Generate StoreGlobal stubs with Hydrogen

src/stub-cache.cc

Index: src/stub-cache.cc
diff --git a/src/stub-cache.cc b/src/stub-cache.cc
index e0839f13d2b4d33cfe2edbb00994209e2d34e387..aa4c2a571c23305402a440368d7e2df82d30f4bf 100644
--- a/src/stub-cache.cc
+++ b/src/stub-cache.cc
@@ -498,15 +498,30 @@ Handle<Code> StubCache::ComputeStoreNormal(StrictModeFlag strict_mode) {
 Handle<Code> StubCache::ComputeStoreGlobal(Handle<Name> name,
                                            Handle<GlobalObject> receiver,
                                            Handle<PropertyCell> cell,
+                                           Handle<Object> value,
                                            StrictModeFlag strict_mode) {
-  Handle<Code> stub = FindIC(
-      name, Handle<JSObject>::cast(receiver),
-      Code::STORE_IC, Code::NORMAL, strict_mode);
-  if (!stub.is_null()) return stub;
+  Isolate* isolate = cell->GetIsolate();
+  Handle<Type> union_type(cell->UpdateType(*value), isolate);
+  bool is_constant = union_type->IsConstant();
+  StoreGlobalStub stub(strict_mode, is_constant);
 
-  StoreStubCompiler compiler(isolate_, strict_mode);
-  Handle<Code> code = compiler.CompileStoreGlobal(receiver, cell, name);
+  Handle<Code> code = FindIC(
+      name, Handle<JSObject>::cast(receiver),
+      Code::STORE_IC, Code::NORMAL, stub.GetExtraICState());
+  if (!code.is_null()) return code;
+
+  if (is_constant) return stub.GetCode(isolate_);
+
+  // Replace the placeholder cell and global object map with the actual global
+  // cell and receiver map.
+  Handle<Map> cell_map(isolate_->heap()->global_property_cell_map());
+  Handle<Map> meta_map(isolate_->heap()->meta_map());
+  Handle<Object> receiver_map(receiver->map(), isolate_);
+  code = stub.GetCodeCopyFromTemplate(isolate_);
+  code->ReplaceNthObject(1, *meta_map, *receiver_map);
+  code->ReplaceNthObject(1, *cell_map, *cell);

[ulan, 2013/07/01 11:35:03]

I didn't get this part. Where in the generated code does
isolate_->heap()->global_property_cell_map() appear? And shouldn't the second
argument be cell->map()?

[danno, 2013/07/01 12:52:23]

The idea behind code templates is that you create a template with
dummy/placeholder objects with maps that are specific enough to uniquely
distinguish the object from others embedded in the code. When the template is
instantiated, the code is copied, and these placeholder objects get replaced
with the "real" values needed by the specialized code template 

What these two ReplaceNthObject mean is "find the first placeholder map (i.e.
the first object that has the map "meta map") and replace it with the receiver
map, then find the first placeholder cell (i.e. the first object with the
cell_map) and replace it with the real cell we use.

   JSObject::UpdateMapCodeCache(receiver, name, code);
+
   return code;
 }
 
@@ -921,12 +936,8 @@ Handle<Code> StubCache::ComputeCompareNil(Handle<Map> receiver_map,
     if (!cached_ic.is_null()) return cached_ic;
   }
 
-  Handle<Code> ic = stub.GetCode(isolate_);
-
-  // For monomorphic maps, use the code as a template, copying and replacing
-  // the monomorphic map that checks the object's type.
-  ic = isolate_->factory()->CopyCode(ic);
-  ic->ReplaceFirstMap(*receiver_map);
+  Handle<Code> ic = stub.GetCodeCopyFromTemplate(isolate_);
+  ic->ReplaceNthObject(1, isolate_->heap()->meta_map(), *receiver_map);
 
   if (!receiver_map->is_shared()) {
     Map::UpdateCodeCache(receiver_map, name, ic);