Revert r23916, r23917 for breaking 64-bit tests.

test/cctest/test-types.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "src/hydrogen-types.h"
 #include "src/isolate-inl.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
 
 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<bitset>(t) & 1; }
+  static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) & 1; }
   static bool IsUnion(Type* t) { return IsStruct(t, 6); }
 
   static Struct* AsStruct(Type* t) {
     return reinterpret_cast<Struct*>(t);
   }
-  static bitset AsBitset(Type* t) {
-    return reinterpret_cast<bitset>(t) ^ 1u;
+  static int AsBitset(Type* t) {
+    return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
   }
   static Struct* AsUnion(Type* t) {
     return AsStruct(t);
   }
   static int Length(Struct* structured) {
     return static_cast<int>(reinterpret_cast<intptr_t>(structured[1]));
   }
 
   static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; }
 
   struct BitsetType : Type::BitsetType {
     using Type::BitsetType::New;
     using Type::BitsetType::Glb;
     using Type::BitsetType::Lub;
     using Type::BitsetType::InherentLub;
   };
 };
 
 
 struct HeapRep {
   typedef FixedArray Struct;
 
   static bool IsStruct(Handle<HeapType> t, int tag) {
     return t->IsFixedArray() && Smi::cast(AsStruct(t)->get(0))->value() == tag;
   }
   static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
   static bool IsUnion(Handle<HeapType> t) { return IsStruct(t, 6); }
 
   static Struct* AsStruct(Handle<HeapType> t) { return FixedArray::cast(*t); }
-  static bitset AsBitset(Handle<HeapType> t) {
-    return reinterpret_cast<bitset>(*t);
-  }
+  static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value(); }
   static Struct* AsUnion(Handle<HeapType> t) { return AsStruct(t); }
   static int Length(Struct* structured) { return structured->length() - 1; }
 
   static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; }
 
   struct BitsetType : HeapType::BitsetType {
     using HeapType::BitsetType::New;
     using HeapType::BitsetType::Glb;
     using HeapType::BitsetType::Lub;
     using HeapType::BitsetType::InherentLub;
-    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);
-    }
+    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); }
   };
 };
 
 
 template<class Type, class TypeHandle, class Region>
 class Types {
  public:
   Types(Region* region, Isolate* isolate)
       : region_(region), rng_(isolate->random_number_generator()) {
     #define DECLARE_TYPE(name, value) \
@@ skipping 276 matching lines @@
   }
 
   void CheckEqual(TypeHandle type1, TypeHandle type2) {
     CHECK(Equal(type1, type2));
   }
 
   void CheckSub(TypeHandle type1, TypeHandle type2) {
     CHECK(type1->Is(type2));
     CHECK(!type2->Is(type1));
     if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
-      CHECK(Rep::AsBitset(type1) != Rep::AsBitset(type2));
+      CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
     }
   }
 
   void CheckUnordered(TypeHandle type1, TypeHandle type2) {
     CHECK(!type1->Is(type2));
     CHECK(!type2->Is(type1));
     if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
-      CHECK(Rep::AsBitset(type1) != Rep::AsBitset(type2));
+      CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
     }
   }
 
   void CheckOverlap(TypeHandle type1, TypeHandle type2, TypeHandle mask) {
     CHECK(type1->Maybe(type2));
     CHECK(type2->Maybe(type1));
     if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
-      CHECK(0 !=
-          (Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask)));
+      CHECK_NE(0,
+          Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask));
     }
   }
 
   void CheckDisjoint(TypeHandle type1, TypeHandle type2, TypeHandle mask) {
     CHECK(!type1->Is(type2));
     CHECK(!type2->Is(type1));
     CHECK(!type1->Maybe(type2));
     CHECK(!type2->Maybe(type1));
     if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
-      CHECK(0 ==
-          (Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask)));
+      CHECK_EQ(0,
+          Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask));
     }
   }
 
   void Bitset() {
     // None and Any are bitsets.
     CHECK(this->IsBitset(T.None));
     CHECK(this->IsBitset(T.Any));
 
-    CHECK(0 == this->AsBitset(T.None));
-    CHECK(0xfffffffeu == this->AsBitset(T.Any));
+    CHECK_EQ(0, this->AsBitset(T.None));
+    CHECK_EQ(-1, this->AsBitset(T.Any));
 
     // Union(T1, T2) is bitset for bitsets T1,T2
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
       for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
         TypeHandle type1 = *it1;
         TypeHandle type2 = *it2;
         TypeHandle union12 = T.Union(type1, type2);
         CHECK(!(this->IsBitset(type1) && this->IsBitset(type2)) ||
               this->IsBitset(union12));
       }
@@ skipping 21 matching lines @@
       }
     }
 
     // Union(T1, T2) is bitwise disjunction for bitsets T1,T2
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
       for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
         TypeHandle type1 = *it1;
         TypeHandle type2 = *it2;
         TypeHandle union12 = T.Union(type1, type2);
         if (this->IsBitset(type1) && this->IsBitset(type2)) {
-          CHECK(
-              (this->AsBitset(type1) | this->AsBitset(type2)) ==
+          CHECK_EQ(
+              this->AsBitset(type1) | this->AsBitset(type2),
               this->AsBitset(union12));
         }
       }
     }
 
     // Intersect(T1, T2) is bitwise conjunction for bitsets T1,T2
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
       for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
         TypeHandle type1 = *it1;
         TypeHandle type2 = *it2;
         TypeHandle intersect12 = T.Intersect(type1, type2);
         if (this->IsBitset(type1) && this->IsBitset(type2)) {
-          CHECK(
-              (this->AsBitset(type1) & this->AsBitset(type2)) ==
+          CHECK_EQ(
+              this->AsBitset(type1) & this->AsBitset(type2),
               this->AsBitset(intersect12));
         }
       }
     }
   }
 
   void Class() {
     // Constructor
     for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
       Handle<i::Map> map = *mt;
@@ skipping 1488 matching lines @@
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }
 
 
 TEST(HTypeFromType) {
   CcTest::InitializeVM();
   ZoneTests().HTypeFromType();
   HeapTests().HTypeFromType();
 }