Convert FastNewClosureStub into hydrogen.

src/code-stubs-hydrogen.cc

Index: src/code-stubs-hydrogen.cc
diff --git a/src/code-stubs-hydrogen.cc b/src/code-stubs-hydrogen.cc
index 852f7b569727b08939d1c952146699d6ff4999f7..464218735a0c2ecd6fa944c4ff814fa5ac11deda 100644
--- a/src/code-stubs-hydrogen.cc
+++ b/src/code-stubs-hydrogen.cc
@@ -112,6 +112,16 @@ class CodeStubGraphBuilderBase : public HGraphBuilder {
   HValue* BuildInternalArrayConstructor(ElementsKind kind,
                                         ArgumentClass argument_class);
 
+  void InstallCode(HValue* object, HValue* native_context,
+                   HValue* thing);
+  void StoreCodeEntry(HValue* object,
+                      HValue* shared_info,
+                      HValue* undefined_value);
+  void InstallOptimizedClosure(HValue* object,
+                               HValue* shared_info,
+                               HValue* native_context,
+                               HValue* undefined_value);
+
  private:
   HValue* BuildArraySingleArgumentConstructor(JSArrayBuilder* builder);
   HValue* BuildArrayNArgumentsConstructor(JSArrayBuilder* builder,
@@ -903,4 +913,203 @@ Handle<Code> ElementsTransitionAndStoreStub::GenerateCode() {
 }
 
 
+void CodeStubGraphBuilderBase::InstallCode(HValue* object,
+                                           HValue* native_context,
+                                           HValue* first_code_slot) {
+  Counters* counters = isolate()->counters();
+  AddIncrementCounter(counters->fast_new_closure_install_optimized(),
+                      context());
+
+  // TODO(fschneider): Idea: store proper code pointers in the optimized code
+  // map and either unmangle them on marking or do nothing as the whole map is
+  // discarded on major GC anyway.
+  HValue* code_entry = Add<HInnerAllocatedObject>(first_code_slot,
+                                                  Code::kHeaderSize - 1);
+  Add<HStoreNamedField>(object, HObjectAccess::ForCodeEntryPointer(),
+                        code_entry);
+
+  // Now link a function into a list of optimized functions.
+  // No need for write barrier as JSFunction object is in the new space.
+  HValue* optimized_functions_list = Add<HLoadNamedField>(native_context,
+      HObjectAccess::ForContextSlot(Context::OPTIMIZED_FUNCTIONS_LIST));
+  Add<HStoreNamedField>(object, HObjectAccess::ForNextFunctionLinkPointer(),
+           optimized_functions_list);
+
+  // This store is the only one that should have a write barrier.
+  Add<HStoreNamedField>(native_context,
+           HObjectAccess::ForContextSlot(Context::OPTIMIZED_FUNCTIONS_LIST),
+           object);
+}
+
+
+void CodeStubGraphBuilderBase::StoreCodeEntry(HValue* object,
+                                              HValue* shared_info,
+                                              HValue* undefined_value) {
+  Add<HStoreNamedField>(object, HObjectAccess::ForNextFunctionLinkPointer(),
+           undefined_value);
+  HValue* code_offset = Add<HLoadNamedField>(shared_info,
+                                             HObjectAccess::ForCodeOffset());
+  HInnerAllocatedObject* code_entry =
+      Add<HInnerAllocatedObject>(code_offset, Code::kHeaderSize - 1);
+  Add<HStoreNamedField>(object, HObjectAccess::ForCodeEntryPointer(),
+                        code_entry);
+}
+
+
+void CodeStubGraphBuilderBase::InstallOptimizedClosure(
+    HValue* object,
+    HValue* shared_info,
+    HValue* native_context,
+    HValue* undefined_value) {
+  Counters* counters = isolate()->counters();
+  IfBuilder is_optimized(this);
+  HInstruction* optimized_map = Add<HLoadNamedField>(shared_info,
+                                        HObjectAccess::ForOptimizedCodeMap());
+  HValue* null_constant = Add<HConstant>(0);
+  is_optimized.If<HCompareObjectEqAndBranch>(optimized_map, null_constant);
+  is_optimized.Then();

[Sven Panne, 2013/08/08 06:23:34]

"Higher order" programming via funny formatting... o_O :-D

Actually this is quite readable, but having to do such funny things suggests
that our builder interfaces are, well, less than ideal... :-P

+  {
+    StoreCodeEntry(object, shared_info, undefined_value);
+  }
+  is_optimized.Else();
+  {
+    AddIncrementCounter(counters->fast_new_closure_try_optimized(), context());
+    // optimized_map points to fixed array of 3-element entries
+    // (native context, optimized code, literals).
+    // Map must never be empty, so check the first elements.
+    Label install_optimized;
+    HValue* first_code_slot = Add<HLoadNamedField>(optimized_map,
+                                      HObjectAccess::ForFirstCodeSlot());
+    HValue* first_context_slot = Add<HLoadNamedField>(optimized_map,
+                                         HObjectAccess::ForFirstContextSlot());
+    IfBuilder already_in(this);
+    already_in.If<HCompareObjectEqAndBranch>(native_context,
+                                             first_context_slot);
+    already_in.Then();
+    {
+      InstallCode(object, native_context, first_code_slot);
+    }
+    already_in.Else();
+    {
+      HValue* shared_function_entry_length =
+          Add<HConstant>(SharedFunctionInfo::kEntryLength);
+      LoopBuilder loop_builder(this,
+                               context(),
+                               LoopBuilder::kPostDecrement,
+                               shared_function_entry_length);
+      HValue* array_length = Add<HLoadNamedField>(optimized_map,
+          HObjectAccess::ForFixedArrayLength());
+      HValue* key = loop_builder.BeginBody(array_length,
+                                           graph()->GetConstant0(),
+                                           Token::GT);
+      {
+        // Iterate through the rest of map backwards.
+        // Do not double check first entry.
+        HValue* second_entry_index =
+            Add<HConstant>(SharedFunctionInfo::kSecondEntryIndex);
+        IfBuilder restore_check(this);
+        restore_check.If<HCompareNumericAndBranch>(key, second_entry_index,
+                                                   Token::EQ);
+        restore_check.Then();
+        {
+          // Store the unoptimized code
+          StoreCodeEntry(object, shared_info, undefined_value);
+          loop_builder.Break();
+        }
+        restore_check.Else();
+        {
+          HValue* keyed_minus = AddInstruction(HSub::New(zone(), context(), key,
+              shared_function_entry_length));
+          HInstruction* keyed_lookup = Add<HLoadKeyed>(optimized_map,
+              keyed_minus, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+          IfBuilder done_check(this);
+          done_check.If<HCompareObjectEqAndBranch>(native_context,
+                                                   keyed_lookup);
+          done_check.Then();
+          {
+            // Hit: fetch the optimized code.
+            HValue* keyed_plus = AddInstruction(HAdd::New(zone(), context(),
+                keyed_minus, graph()->GetConstant1()));
+            HValue* first_code_slot_reloaded = Add<HLoadKeyed>(optimized_map,
+                keyed_plus, static_cast<HValue*>(NULL), FAST_ELEMENTS);
+            InstallCode(object, native_context, first_code_slot_reloaded);
+
+            // Fall out of the loop
+            loop_builder.Break();
+          }
+          done_check.Else();
+          done_check.End();
+        }
+        restore_check.End();
+      }
+      loop_builder.EndBody();
+    }
+    already_in.End();
+  }
+  is_optimized.End();
+}
+
+
+template<>
+HValue* CodeStubGraphBuilder<FastNewClosureStub>::BuildCodeStub() {
+  Counters* counters = isolate()->counters();
+  Factory* factory = isolate()->factory();
+  HInstruction* empty_fixed_array =
+      Add<HConstant>(factory->empty_fixed_array());
+  HInstruction* undefined_value = Add<HConstant>(factory->undefined_value());
+  HValue* shared_info = GetParameter(0);
+
+  // Create a new closure from the given function info in new space
+  HValue* size = Add<HConstant>(JSFunction::kSize);
+  HInstruction* object = Add<HAllocate>(size, HType::JSObject(), NOT_TENURED,
+                                        JS_FUNCTION_TYPE);
+  AddIncrementCounter(counters->fast_new_closure_total(), context());
+
+  int map_index = Context::FunctionMapIndex(casted_stub()->language_mode(),
+                                            casted_stub()->is_generator());
+
+  // Compute the function map in the current native context and set that
+  // as the map of the allocated object.
+  HInstruction* native_context = BuildGetNativeContext();
+  HInstruction* map_slot_value = Add<HLoadNamedField>(native_context,
+      HObjectAccess::ForContextSlot(map_index));
+  Add<HStoreNamedField>(object, HObjectAccess::ForMap(), map_slot_value);
+
+  // Initialize the rest of the function. We don't have to update the
+  // write barrier because the allocated object is in new space.
+  Add<HStoreNamedField>(object, HObjectAccess::ForPropertiesPointer(),
+                        empty_fixed_array);
+  Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
+                        empty_fixed_array);
+  Add<HStoreNamedField>(object, HObjectAccess::ForLiteralsPointer(),
+                        empty_fixed_array);
+  HInstruction* the_hole = Add<HConstant>(factory->the_hole_value());
+  Add<HStoreNamedField>(object, HObjectAccess::ForPrototypeOrInitialMap(),
+                        the_hole);
+  Add<HStoreNamedField>(object, HObjectAccess::ForSharedFunctionInfoPointer(),
+                        shared_info);
+  Add<HStoreNamedField>(object, HObjectAccess::ForFunctionContextPointer(),
+                        shared_info);
+  Add<HStoreNamedField>(object, HObjectAccess::ForFunctionContextPointer(),
+                        context());
+
+  // Initialize the code pointer in the function to be the one
+  // found in the shared function info object.
+  // But first check if there is an optimized version for our context.
+  if (FLAG_cache_optimized_code) {
+    InstallOptimizedClosure(object, shared_info, native_context,
+                            undefined_value);
+  } else {
+    StoreCodeEntry(object, shared_info, undefined_value);
+  }
+
+  return object;
+}
+
+
+Handle<Code> FastNewClosureStub::GenerateCode() {
+  return DoGenerateCode(this);
+}
+
+
 } }  // namespace v8::internal