Migrate Compare ICs to new type rep

test/cctest/test-types.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 33 matching lines @@
 class HandlifiedTypes {
  public:
   explicit HandlifiedTypes(Isolate* isolate) :
       None(Type::None(), isolate),
       Any(Type::Any(), isolate),
       Oddball(Type::Oddball(), isolate),
       Boolean(Type::Boolean(), isolate),
       Null(Type::Null(), isolate),
       Undefined(Type::Undefined(), isolate),
       Number(Type::Number(), isolate),
-      Smi(Type::Smi(), isolate),
+      Integer31(Type::Integer31(), isolate),
+      Integer32(Type::Integer32(), isolate),
       Double(Type::Double(), isolate),
       Name(Type::Name(), isolate),
       UniqueName(Type::UniqueName(), isolate),
       String(Type::String(), isolate),
       InternalizedString(Type::InternalizedString(), isolate),
       Symbol(Type::Symbol(), isolate),
       Receiver(Type::Receiver(), isolate),
       Object(Type::Object(), isolate),
       Array(Type::Array(), isolate),
       Function(Type::Function(), isolate),
       Proxy(Type::Proxy(), isolate),
       object_map(isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 * kPointerSize)),
       array_map(isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 * kPointerSize)),
       isolate_(isolate) {
     smi = handle(Smi::FromInt(666), isolate);
     object1 = isolate->factory()->NewJSObjectFromMap(object_map);
     object2 = isolate->factory()->NewJSObjectFromMap(object_map);
     array = isolate->factory()->NewJSArray(20);
     ObjectClass = handle(Type::Class(object_map), isolate);
     ArrayClass = handle(Type::Class(array_map), isolate);
-    SmiConstant = handle(Type::Constant(smi, isolate), isolate);
+    Integer31Constant = handle(Type::Constant(smi, isolate), isolate);
     ObjectConstant1 = handle(Type::Constant(object1), isolate);
     ObjectConstant2 = handle(Type::Constant(object2), isolate);
     ArrayConstant = handle(Type::Constant(array), isolate);
   }
 
   Handle<Type> None;
   Handle<Type> Any;
   Handle<Type> Oddball;
   Handle<Type> Boolean;
   Handle<Type> Null;
   Handle<Type> Undefined;
   Handle<Type> Number;
-  Handle<Type> Smi;
+  Handle<Type> Integer31;
+  Handle<Type> Integer32;
   Handle<Type> Double;
   Handle<Type> Name;
   Handle<Type> UniqueName;
   Handle<Type> String;
   Handle<Type> InternalizedString;
   Handle<Type> Symbol;
   Handle<Type> Receiver;
   Handle<Type> Object;
   Handle<Type> Array;
   Handle<Type> Function;
   Handle<Type> Proxy;
 
   Handle<Type> ObjectClass;
   Handle<Type> ArrayClass;
 
-  Handle<Type> SmiConstant;
+  Handle<Type> Integer31Constant;
   Handle<Type> ObjectConstant1;
   Handle<Type> ObjectConstant2;
   Handle<Type> ArrayConstant;
 
   Handle<Map> object_map;
   Handle<Map> array_map;
 
   Handle<v8::internal::Smi> smi;
   Handle<JSObject> object1;
   Handle<JSObject> object2;
@@ skipping 46 matching lines @@
   CHECK(*T.array_map == AsClass(*T.ArrayClass));
 }
 
 
 TEST(Constant) {
   CcTest::InitializeVM();
   Isolate* isolate = Isolate::Current();
   HandleScope scope(isolate);
   HandlifiedTypes T(isolate);
 
-  CHECK(IsConstant(*T.SmiConstant));
+  CHECK(IsConstant(*T.Integer31Constant));
   CHECK(IsConstant(*T.ObjectConstant1));
   CHECK(IsConstant(*T.ObjectConstant2));
   CHECK(IsConstant(*T.ArrayConstant));
 
-  CHECK(*T.smi == AsConstant(*T.SmiConstant));
+  CHECK(*T.smi == AsConstant(*T.Integer31Constant));
   CHECK(*T.object1 == AsConstant(*T.ObjectConstant1));
   CHECK(*T.object2 == AsConstant(*T.ObjectConstant2));
   CHECK(*T.object1 != AsConstant(*T.ObjectConstant2));
   CHECK(*T.array == AsConstant(*T.ArrayConstant));
 }
 
 
 static void CheckSub(Handle<Type> type1, Handle<Type> type2) {
   CHECK(type1->Is(type2));
   CHECK(!type2->Is(type1));
@@ skipping 30 matching lines @@
 
   CheckSub(T.Oddball, T.Any);
   CheckSub(T.Boolean, T.Oddball);
   CheckSub(T.Null, T.Oddball);
   CheckSub(T.Undefined, T.Oddball);
   CheckUnordered(T.Boolean, T.Null);
   CheckUnordered(T.Undefined, T.Null);
   CheckUnordered(T.Boolean, T.Undefined);
 
   CheckSub(T.Number, T.Any);
-  CheckSub(T.Smi, T.Number);
+  CheckSub(T.Integer31, T.Number);
+  CheckSub(T.Integer32, T.Number);
   CheckSub(T.Double, T.Number);
-  CheckUnordered(T.Smi, T.Double);
+  CheckSub(T.Integer31, T.Integer32);
+  CheckUnordered(T.Integer31, T.Double);
+  CheckUnordered(T.Integer32, T.Double);
 
   CheckSub(T.Name, T.Any);
   CheckSub(T.UniqueName, T.Any);
   CheckSub(T.UniqueName, T.Name);
   CheckSub(T.String, T.Name);
   CheckSub(T.InternalizedString, T.String);
   CheckSub(T.InternalizedString, T.UniqueName);
   CheckSub(T.InternalizedString, T.Name);
   CheckSub(T.Symbol, T.UniqueName);
   CheckSub(T.Symbol, T.Name);
   CheckUnordered(T.String, T.UniqueName);
   CheckUnordered(T.String, T.Symbol);
   CheckUnordered(T.InternalizedString, T.Symbol);
 
   CheckSub(T.Receiver, T.Any);
   CheckSub(T.Object, T.Any);
   CheckSub(T.Object, T.Receiver);
   CheckSub(T.Array, T.Object);
   CheckSub(T.Function, T.Object);
   CheckSub(T.Proxy, T.Receiver);
   CheckUnordered(T.Object, T.Proxy);
   CheckUnordered(T.Array, T.Function);
 
   // Structured subtyping
   CheckSub(T.ObjectClass, T.Object);
   CheckSub(T.ArrayClass, T.Object);
   CheckUnordered(T.ObjectClass, T.ArrayClass);
 
-  CheckSub(T.SmiConstant, T.Smi);
-  CheckSub(T.SmiConstant, T.Number);
+  CheckSub(T.Integer31Constant, T.Integer31);
+  CheckSub(T.Integer31Constant, T.Integer32);
+  CheckSub(T.Integer31Constant, T.Number);
   CheckSub(T.ObjectConstant1, T.Object);
   CheckSub(T.ObjectConstant2, T.Object);
   CheckSub(T.ArrayConstant, T.Object);
   CheckSub(T.ArrayConstant, T.Array);
   CheckUnordered(T.ObjectConstant1, T.ObjectConstant2);
   CheckUnordered(T.ObjectConstant1, T.ArrayConstant);
 
   CheckUnordered(T.ObjectConstant1, T.ObjectClass);
   CheckUnordered(T.ObjectConstant2, T.ObjectClass);
   CheckUnordered(T.ObjectConstant1, T.ArrayClass);
@@ skipping 31 matching lines @@
 
   CheckOverlap(T.Oddball, T.Any);
   CheckOverlap(T.Boolean, T.Oddball);
   CheckOverlap(T.Null, T.Oddball);
   CheckOverlap(T.Undefined, T.Oddball);
   CheckDisjoint(T.Boolean, T.Null);
   CheckDisjoint(T.Undefined, T.Null);
   CheckDisjoint(T.Boolean, T.Undefined);
 
   CheckOverlap(T.Number, T.Any);
-  CheckOverlap(T.Smi, T.Number);
+  CheckOverlap(T.Integer31, T.Number);
   CheckOverlap(T.Double, T.Number);
-  CheckDisjoint(T.Smi, T.Double);
+  CheckDisjoint(T.Integer32, T.Double);
 
   CheckOverlap(T.Name, T.Any);
   CheckOverlap(T.UniqueName, T.Any);
   CheckOverlap(T.UniqueName, T.Name);
   CheckOverlap(T.String, T.Name);
   CheckOverlap(T.InternalizedString, T.String);
   CheckOverlap(T.InternalizedString, T.UniqueName);
   CheckOverlap(T.InternalizedString, T.Name);
   CheckOverlap(T.Symbol, T.UniqueName);
   CheckOverlap(T.Symbol, T.Name);
   CheckOverlap(T.String, T.UniqueName);
   CheckDisjoint(T.String, T.Symbol);
   CheckDisjoint(T.InternalizedString, T.Symbol);
 
   CheckOverlap(T.Receiver, T.Any);
   CheckOverlap(T.Object, T.Any);
   CheckOverlap(T.Object, T.Receiver);
   CheckOverlap(T.Array, T.Object);
   CheckOverlap(T.Function, T.Object);
   CheckOverlap(T.Proxy, T.Receiver);
   CheckDisjoint(T.Object, T.Proxy);
   CheckDisjoint(T.Array, T.Function);
 
   CheckOverlap(T.ObjectClass, T.Object);
   CheckOverlap(T.ArrayClass, T.Object);
   CheckOverlap(T.ObjectClass, T.ObjectClass);
   CheckOverlap(T.ArrayClass, T.ArrayClass);
   CheckDisjoint(T.ObjectClass, T.ArrayClass);
 
-  CheckOverlap(T.SmiConstant, T.Smi);
-  CheckOverlap(T.SmiConstant, T.Number);
-  CheckDisjoint(T.SmiConstant, T.Double);
+  CheckOverlap(T.Integer31Constant, T.Integer31);
+  CheckOverlap(T.Integer31Constant, T.Integer32);
+  CheckOverlap(T.Integer31Constant, T.Number);
+  CheckDisjoint(T.Integer31Constant, T.Double);
   CheckOverlap(T.ObjectConstant1, T.Object);
   CheckOverlap(T.ObjectConstant2, T.Object);
   CheckOverlap(T.ArrayConstant, T.Object);
   CheckOverlap(T.ArrayConstant, T.Array);
   CheckOverlap(T.ObjectConstant1, T.ObjectConstant1);
   CheckDisjoint(T.ObjectConstant1, T.ObjectConstant2);
   CheckDisjoint(T.ObjectConstant1, T.ArrayConstant);
 
   CheckDisjoint(T.ObjectConstant1, T.ObjectClass);
   CheckDisjoint(T.ObjectConstant2, T.ObjectClass);
@@ skipping 62 matching lines @@
   CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant), T.Array);
   CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant), T.Number);
   CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant), T.ObjectClass);
 
   // Bitset-class
   CHECK(IsBitset(Type::Union(T.ObjectClass, T.Object)));
   CHECK(IsUnion(Type::Union(T.ObjectClass, T.Number)));
 
   CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object);
   CheckSub(T.Union(T.ObjectClass, T.Number), T.Any);
-  CheckSub(T.Union(T.ObjectClass, T.Smi), T.Union(T.Object, T.Number));
+  CheckSub(T.Union(T.ObjectClass, T.Integer31), T.Union(T.Object, T.Number));
   CheckSub(T.Union(T.ObjectClass, T.Array), T.Object);
   CheckUnordered(T.Union(T.ObjectClass, T.String), T.Array);
   CheckOverlap(T.Union(T.ObjectClass, T.String), T.Object);
   CheckDisjoint(T.Union(T.ObjectClass, T.String), T.Number);
 
   // Bitset-constant
-  CHECK(IsBitset(Type::Union(T.SmiConstant, T.Number)));
+  CHECK(IsBitset(Type::Union(T.Integer31Constant, T.Number)));
   CHECK(IsBitset(Type::Union(T.ObjectConstant1, T.Object)));
   CHECK(IsUnion(Type::Union(T.ObjectConstant2, T.Number)));
 
-  CheckEqual(T.Union(T.SmiConstant, T.Number), T.Number);
+  CheckEqual(T.Union(T.Integer31Constant, T.Number), T.Number);
   CheckEqual(T.Union(T.ObjectConstant1, T.Object), T.Object);
   CheckSub(T.Union(T.ObjectConstant1, T.Number), T.Any);
-  CheckSub(T.Union(T.ObjectConstant1, T.Smi), T.Union(T.Object, T.Number));
+  CheckSub(
+      T.Union(T.ObjectConstant1, T.Integer32), T.Union(T.Object, T.Number));
   CheckSub(T.Union(T.ObjectConstant1, T.Array), T.Object);
   CheckUnordered(T.Union(T.ObjectConstant1, T.String), T.Array);
   CheckOverlap(T.Union(T.ObjectConstant1, T.String), T.Object);
   CheckDisjoint(T.Union(T.ObjectConstant1, T.String), T.Number);
 
   // Class-constant
   CHECK(IsUnion(Type::Union(T.ObjectConstant1, T.ObjectClass)));
   CHECK(IsUnion(Type::Union(T.ArrayClass, T.ObjectConstant2)));
 
   CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object);
@@ skipping 56 matching lines @@
       T.Union(T.ArrayConstant, T.ObjectConstant2), T.ObjectConstant1)));
 
   CheckEqual(
       T.Union(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
       T.Union(T.ObjectConstant2, T.ObjectConstant1));
   CheckEqual(
       T.Union(T.Union(T.ArrayConstant, T.ObjectConstant2), T.ObjectConstant1),
       T.Union(T.ObjectConstant2, T.Union(T.ArrayConstant, T.ObjectConstant1)));
 
   // Union-union
-  CHECK(IsBitset(
-      Type::Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Smi, T.Array))));
+  CHECK(IsBitset(Type::Union(
+      T.Union(T.Number, T.ArrayClass), T.Union(T.Integer32, T.Array))));
 
   CheckEqual(
       T.Union(T.Union(T.ObjectConstant2, T.ObjectConstant1),
               T.Union(T.ObjectConstant1, T.ObjectConstant2)),
       T.Union(T.ObjectConstant2, T.ObjectConstant1));
   CheckEqual(
       T.Union(T.Union(T.ObjectConstant2, T.ArrayConstant),
               T.Union(T.ObjectConstant1, T.ArrayConstant)),
       T.Union(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ArrayConstant));
   CheckEqual(
-      T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Smi, T.Array)),
+      T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Integer31, T.Array)),
       T.Union(T.Number, T.Array));
 }