Partially revert "Optimize function across closures."

BUG=chromium:434447

Review URL: https://codereview.chromium.org/755173002

Cr-Commit-Position: refs/heads/master@{#25500}

diff --git a/src/code-stubs-hydrogen.cc b/src/code-stubs-hydrogen.cc
index f66670b..fca1e29 100644 (file)
--- a/src/code-stubs-hydrogen.cc
+++ b/src/code-stubs-hydrogen.cc
@@ -1555,67 +1555,46 @@ HValue* CodeStubGraphBuilder<FastNewClosureStub>::BuildCodeStub() {
 
   AddIncrementCounter(counters->fast_new_closure_total());
 
-  IfBuilder optimize_now(this);
-  HInstruction* compile_hint = Add<HLoadNamedField>(
-      shared_info, static_cast<HValue*>(NULL), HObjectAccess::ForCompileHint());
-  HValue* hint_mask = Add<HConstant>(
-      static_cast<int32_t>(1 << SharedFunctionInfo::kOptimizeNextClosure));
-  HInstruction* optimize =
-      AddUncasted<HBitwise>(Token::BIT_AND, compile_hint, hint_mask);
-  optimize_now.If<HCompareNumericAndBranch>(optimize, hint_mask, Token::EQ);
-  optimize_now.Then();
-  {
-    Add<HPushArguments>(context(), shared_info, graph()->GetConstantFalse());
-    Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
-                           Runtime::FunctionForId(Runtime::kNewClosure), 3));
-  }
-  optimize_now.Else();
-  {
-    // Create a new closure from the given function info in new space
-    HValue* size = Add<HConstant>(JSFunction::kSize);
-    HInstruction* js_function =
-        Add<HAllocate>(size, HType::JSObject(), NOT_TENURED, JS_FUNCTION_TYPE);
-
-    int map_index = Context::FunctionMapIndex(casted_stub()->strict_mode(),
-                                              casted_stub()->kind());
-
-    // 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, static_cast<HValue*>(NULL),
-                             HObjectAccess::ForContextSlot(map_index));
-    Add<HStoreNamedField>(js_function, HObjectAccess::ForMap(), map_slot_value);
-
-    // Initialize the rest of the function.
-    Add<HStoreNamedField>(js_function, HObjectAccess::ForPropertiesPointer(),
-                          empty_fixed_array);
-    Add<HStoreNamedField>(js_function, HObjectAccess::ForElementsPointer(),
-                          empty_fixed_array);
-    Add<HStoreNamedField>(js_function, HObjectAccess::ForLiteralsPointer(),
-                          empty_fixed_array);
-    Add<HStoreNamedField>(js_function,
-                          HObjectAccess::ForPrototypeOrInitialMap(),
-                          graph()->GetConstantHole());
-    Add<HStoreNamedField>(js_function,
-                          HObjectAccess::ForSharedFunctionInfoPointer(),
-                          shared_info);
-    Add<HStoreNamedField>(
-        js_function, 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) {
-      BuildInstallFromOptimizedCodeMap(js_function, shared_info,
-                                       native_context);
-    } else {
-      BuildInstallCode(js_function, shared_info);
-    }
-    Push(js_function);
+  // Create a new closure from the given function info in new space
+  HValue* size = Add<HConstant>(JSFunction::kSize);
+  HInstruction* js_function =
+      Add<HAllocate>(size, HType::JSObject(), NOT_TENURED, JS_FUNCTION_TYPE);
+
+  int map_index = Context::FunctionMapIndex(casted_stub()->strict_mode(),
+                                            casted_stub()->kind());
+
+  // 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, static_cast<HValue*>(NULL),
+                           HObjectAccess::ForContextSlot(map_index));
+  Add<HStoreNamedField>(js_function, HObjectAccess::ForMap(), map_slot_value);
+
+  // Initialize the rest of the function.
+  Add<HStoreNamedField>(js_function, HObjectAccess::ForPropertiesPointer(),
+                        empty_fixed_array);
+  Add<HStoreNamedField>(js_function, HObjectAccess::ForElementsPointer(),
+                        empty_fixed_array);
+  Add<HStoreNamedField>(js_function, HObjectAccess::ForLiteralsPointer(),
+                        empty_fixed_array);
+  Add<HStoreNamedField>(js_function, HObjectAccess::ForPrototypeOrInitialMap(),
+                        graph()->GetConstantHole());
+  Add<HStoreNamedField>(
+      js_function, HObjectAccess::ForSharedFunctionInfoPointer(), shared_info);
+  Add<HStoreNamedField>(js_function, 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) {
+    BuildInstallFromOptimizedCodeMap(js_function, shared_info, native_context);
+  } else {
+    BuildInstallCode(js_function, shared_info);
   }
-  optimize_now.End();
-  return Pop();
+
+  return js_function;
 }
 
 

diff --git a/src/compiler.cc b/src/compiler.cc
index 3d81219..0540d96 100644 (file)
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -1387,7 +1387,6 @@ MaybeHandle<Code> Compiler::GetOptimizedCode(Handle<JSFunction> function,
   PostponeInterruptsScope postpone(isolate);
 
   Handle<SharedFunctionInfo> shared = info->shared_info();
-  shared->set_optimize_next_closure(false);
   if (shared->code()->kind() != Code::FUNCTION ||
       ScopeInfo::Empty(isolate) == shared->scope_info()) {
     // The function was never compiled. Compile it unoptimized first.

diff --git a/src/factory.cc b/src/factory.cc
index 4de2407..9bda713 100644 (file)
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -1419,9 +1419,6 @@ Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
 
   if (FLAG_always_opt && ShouldOptimizeNewClosure(isolate(), info)) {
     result->MarkForOptimization();
-  } else if (info->optimize_next_closure() &&
-             ShouldOptimizeNewClosure(isolate(), info)) {
-    result->AttemptConcurrentOptimization();
   }
   return result;
 }

diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h
index 3e16f97..1752c44 100644 (file)
--- a/src/hydrogen-instructions.h
+++ b/src/hydrogen-instructions.h
@@ -6171,18 +6171,6 @@ class HObjectAccess FINAL {
                          SharedFunctionInfo::kOptimizedCodeMapOffset);
   }
 
-  static HObjectAccess ForCompileHint() {
-// Compile hints are stored in the upper half of a pseudo-smi, which for
-// 64-bit means that the representation is an integer.
-#if V8_HOST_ARCH_32_BIT
-    Representation repr = Representation::Smi();
-#else
-    Representation repr = Representation::Integer32();
-#endif
-    return HObjectAccess(kInobject, SharedFunctionInfo::kCompilerHintsOffset,
-                         repr);
-  }
-
   static HObjectAccess ForFunctionContextPointer() {
     return HObjectAccess(kInobject, JSFunction::kContextOffset);
   }

diff --git a/src/objects-inl.h b/src/objects-inl.h
index 0a85a13..9a65e16 100644 (file)
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -5612,8 +5612,6 @@ BOOL_ACCESSORS(SharedFunctionInfo, start_position_and_type, is_expression,
 BOOL_ACCESSORS(SharedFunctionInfo, start_position_and_type, is_toplevel,
                kIsTopLevelBit)
 
-BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, optimize_next_closure,
-               kOptimizeNextClosure)
 BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, allows_lazy_compilation,
                kAllowLazyCompilation)
 BOOL_ACCESSORS(SharedFunctionInfo,

diff --git a/src/objects.h b/src/objects.h
index 80a6985..502d263 100644 (file)
--- a/src/objects.h
+++ b/src/objects.h
@@ -6802,8 +6802,6 @@ class SharedFunctionInfo: public HeapObject {
   inline int ic_age();
   inline void set_ic_age(int age);
 
-  DECL_BOOLEAN_ACCESSORS(optimize_next_closure)
-
   // Indicates if this function can be lazy compiled.
   // This is used to determine if we can safely flush code from a function
   // when doing GC if we expect that the function will no longer be used.
@@ -7106,7 +7104,6 @@ class SharedFunctionInfo: public HeapObject {
   enum CompilerHints {
     kAllowLazyCompilation,
     kAllowLazyCompilationWithoutContext,
-    kOptimizeNextClosure,
     kOptimizationDisabled,
     kStrictModeFunction,
     kUsesArguments,

diff --git a/src/runtime-profiler.cc b/src/runtime-profiler.cc
index db9d76a..6c99714 100644 (file)
--- a/src/runtime-profiler.cc
+++ b/src/runtime-profiler.cc
@@ -106,7 +106,6 @@ void RuntimeProfiler::Optimize(JSFunction* function, const char* reason) {
     PrintF("]\n");
   }
 
-  function->shared()->set_optimize_next_closure(true);
   function->AttemptConcurrentOptimization();
 }