[turbofan] Make global variable loads and stores explicit.

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/types.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/types-fuzz.h"
@@ skipping 1002 matching lines @@
     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.Object, T.Receiver);
     CheckSub(T.Proxy, T.Receiver);
     CheckSub(T.OtherObject, T.Object);
     CheckSub(T.Undetectable, T.Object);
-    CheckSub(T.DetectableObject, T.Object);
-    CheckSub(T.GlobalObject, T.DetectableObject);
-    CheckSub(T.OtherObject, T.DetectableObject);
-    CheckSub(T.GlobalObject, T.Object);
-    CheckSub(T.GlobalObject, T.Receiver);
+    CheckSub(T.OtherObject, T.Object);
 
     CheckUnordered(T.Object, T.Proxy);
-    CheckUnordered(T.GlobalObject, T.OtherObject);
-    CheckUnordered(T.DetectableObject, T.Undetectable);
+    CheckUnordered(T.OtherObject, T.Undetectable);
 
     // Subtyping between concrete structural types
 
     CheckSub(T.ObjectClass, T.Object);
     CheckSub(T.ArrayClass, T.OtherObject);
     CheckSub(T.UninitializedClass, T.Internal);
     CheckUnordered(T.ObjectClass, T.ArrayClass);
     CheckUnordered(T.UninitializedClass, T.Null);
     CheckUnordered(T.UninitializedClass, T.Undefined);
 
@@ skipping 301 matching lines @@
     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.Object, T.Receiver);
     CheckOverlap(T.OtherObject, T.Object);
-    CheckOverlap(T.GlobalObject, T.Object);
     CheckOverlap(T.Proxy, T.Receiver);
     CheckDisjoint(T.Object, T.Proxy);
 
     // Structural types
     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.SignedSmall);
@@ skipping 592 matching lines @@
     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;
         HType htype1 = HType::FromType<Type>(type1);
         HType htype2 = HType::FromType<Type>(type2);
         CHECK(!type1->Is(type2) || htype1.IsSubtypeOf(htype2));
       }
     }
   }
-
-  void GlobalObjectType() {
-    i::Handle<i::Context> context1 = v8::Utils::OpenHandle(
-        *v8::Context::New(reinterpret_cast<v8::Isolate*>(isolate)));
-    Handle<i::GlobalObject> global_object1(context1->global_object());
-    TypeHandle GlobalObjectConstant1 =
-        Type::Constant(global_object1, Rep::ToRegion(&zone, isolate));
-
-    i::Handle<i::Context> context2 = v8::Utils::OpenHandle(
-        *v8::Context::New(reinterpret_cast<v8::Isolate*>(isolate)));
-    Handle<i::GlobalObject> global_object2(context2->global_object());
-    TypeHandle GlobalObjectConstant2 =
-        Type::Constant(global_object2, Rep::ToRegion(&zone, isolate));
-
-    CheckSub(GlobalObjectConstant1, T.DetectableObject);
-    CheckSub(GlobalObjectConstant2, T.DetectableObject);
-    CheckSub(GlobalObjectConstant1, T.GlobalObject);
-    CheckSub(GlobalObjectConstant2, T.GlobalObject);
-    CheckSub(GlobalObjectConstant1, T.Object);
-    CheckSub(GlobalObjectConstant2, T.Object);
-
-    CheckUnordered(T.GlobalObject, T.OtherObject);
-    CheckUnordered(GlobalObjectConstant1, T.OtherObject);
-    CheckUnordered(GlobalObjectConstant2, T.OtherObject);
-    CheckUnordered(GlobalObjectConstant1, GlobalObjectConstant2);
-
-    CheckDisjoint(T.GlobalObject, T.ObjectClass);
-    CheckDisjoint(GlobalObjectConstant1, T.ObjectClass);
-    CheckDisjoint(GlobalObjectConstant2, T.ArrayClass);
-
-    CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.GlobalObject);
-    CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), GlobalObjectConstant1);
-    CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), GlobalObjectConstant2);
-
-    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.GlobalObject);
-    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass),
-                   GlobalObjectConstant1);
-    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass),
-                   GlobalObjectConstant2);
-
-    CheckUnordered(T.Union(T.ObjectClass, T.String), T.GlobalObject);
-
-    CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass),
-             T.Union(T.GlobalObject, T.Object));
-
-    CheckDisjoint(T.Union(GlobalObjectConstant1, T.ArrayClass),
-                  GlobalObjectConstant2);
-
-    CheckEqual(T.Union(T.Union(T.Number, GlobalObjectConstant1),
-                       T.Union(T.SignedSmall, T.GlobalObject)),
-               T.Union(T.Number, T.GlobalObject));
-
-    CheckEqual(T.Semantic(T.Intersect(T.ObjectClass, T.GlobalObject)), T.None);
-
-    CHECK(!T.Intersect(T.ArrayClass, GlobalObjectConstant2)->IsInhabited());
-
-    CheckEqual(T.Intersect(T.Union(T.Number, T.OtherObject),
-                           T.Union(T.Signed32, T.GlobalObject)),
-               T.Signed32);
-  }
 };
 
 typedef Tests<Type, Type*, Zone, ZoneRep> ZoneTests;
 typedef Tests<HeapType, Handle<HeapType>, Isolate, HeapRep> HeapTests;
 
 
 TEST(IsSomeType_zone) { ZoneTests().IsSomeType(); }
 
 
 TEST(IsSomeType_heap) { HeapTests().IsSomeType(); }
@@ skipping 154 matching lines @@
 }
 
 
 TEST(Convert_heap) { HeapTests().Convert<Type, Type*, Zone, ZoneRep>(); }
 
 
 TEST(HTypeFromType_zone) { ZoneTests().HTypeFromType(); }
 
 
 TEST(HTypeFromType_heap) { HeapTests().HTypeFromType(); }
-
-
-TEST(GlobalObjectType_zone) { ZoneTests().GlobalObjectType(); }
-
-
-TEST(GlobalObjectType_heap) { HeapTests().GlobalObjectType(); }