using namespace v8::internal;
// Testing auxiliaries (breaking the Type abstraction).
+typedef uintptr_t bitset;
+
struct ZoneRep {
typedef void* Struct;
static bool IsStruct(Type* t, int tag) {
return !IsBitset(t) && reinterpret_cast<intptr_t>(AsStruct(t)[0]) == tag;
}
- static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) & 1; }
+ static bool IsBitset(Type* t) { return reinterpret_cast<bitset>(t) & 1; }
static bool IsUnion(Type* t) { return IsStruct(t, 6); }
static Struct* AsStruct(Type* t) {
return reinterpret_cast<Struct*>(t);
}
- static int AsBitset(Type* t) {
- return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
+ static bitset AsBitset(Type* t) {
+ return reinterpret_cast<bitset>(t) ^ 1u;
}
static Struct* AsUnion(Type* t) {
return AsStruct(t);
static bool IsUnion(Handle<HeapType> t) { return IsStruct(t, 6); }
static Struct* AsStruct(Handle<HeapType> t) { return FixedArray::cast(*t); }
- static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value(); }
+ static bitset AsBitset(Handle<HeapType> t) {
+ return reinterpret_cast<bitset>(*t);
+ }
static Struct* AsUnion(Handle<HeapType> t) { return AsStruct(t); }
static int Length(Struct* structured) { return structured->length() - 1; }
using HeapType::BitsetType::Glb;
using HeapType::BitsetType::Lub;
using HeapType::BitsetType::InherentLub;
- static int Glb(Handle<HeapType> type) { return Glb(*type); }
- static int Lub(Handle<HeapType> type) { return Lub(*type); }
- static int InherentLub(Handle<HeapType> type) { return InherentLub(*type); }
+ static bitset Glb(Handle<HeapType> type) { return Glb(*type); }
+ static bitset Lub(Handle<HeapType> type) { return Lub(*type); }
+ static bitset InherentLub(Handle<HeapType> type) {
+ return InherentLub(*type);
+ }
};
};
CHECK(type1->Is(type2));
CHECK(!type2->Is(type1));
if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
- CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
+ CHECK(Rep::AsBitset(type1) != Rep::AsBitset(type2));
}
}
CHECK(!type1->Is(type2));
CHECK(!type2->Is(type1));
if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
- CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
+ CHECK(Rep::AsBitset(type1) != Rep::AsBitset(type2));
}
}
CHECK(type1->Maybe(type2));
CHECK(type2->Maybe(type1));
if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
- CHECK_NE(0,
- Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask));
+ CHECK(0 !=
+ (Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask)));
}
}
CHECK(!type1->Maybe(type2));
CHECK(!type2->Maybe(type1));
if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
- CHECK_EQ(0,
- Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask));
+ CHECK(0 ==
+ (Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask)));
}
}
CHECK(this->IsBitset(T.None));
CHECK(this->IsBitset(T.Any));
- CHECK_EQ(0, this->AsBitset(T.None));
- CHECK_EQ(-1, this->AsBitset(T.Any));
+ CHECK(0 == this->AsBitset(T.None));
+ CHECK(0xfffffffeu == this->AsBitset(T.Any));
// Union(T1, T2) is bitset for bitsets T1,T2
for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
TypeHandle type2 = *it2;
TypeHandle union12 = T.Union(type1, type2);
if (this->IsBitset(type1) && this->IsBitset(type2)) {
- CHECK_EQ(
- this->AsBitset(type1) | this->AsBitset(type2),
+ CHECK(
+ (this->AsBitset(type1) | this->AsBitset(type2)) ==
this->AsBitset(union12));
}
}
TypeHandle type2 = *it2;
TypeHandle intersect12 = T.Intersect(type1, type2);
if (this->IsBitset(type1) && this->IsBitset(type2)) {
- CHECK_EQ(
- this->AsBitset(type1) & this->AsBitset(type2),
+ CHECK(
+ (this->AsBitset(type1) & this->AsBitset(type2)) ==
this->AsBitset(intersect12));
}
}