Make closures optimizable by Crankshaft compiler.

src/compiler.cc

 // Copyright 2010 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 147 matching lines @@
     info->closure()->PrintName();
     PrintF(" / %" V8PRIxPTR "]\n",
            reinterpret_cast<intptr_t>(*info->closure()));
   }
 }
 
 
 static bool MakeCrankshaftCode(CompilationInfo* info) {
   // Test if we can optimize this function when asked to. We can only
   // do this after the scopes are computed.
   if (!info->AllowOptimize()) info->DisableOptimization();

[fschneider, 2010/12/13 19:00:18]

This checks if the function literal's scope has any heap allocated slots. So I
think this check can go away with your change. 

[antonm, 2010/12/13 22:41:04]

I am not sure: CompilationInfo::AllowOptimize checks if crankshaft is enabled
and if closure_ is not null.  I removed Scope::AllowOptimize as per your
suggestion on IM---thanks a lot for spotting this.

[antonm, 2010/12/13 22:52:47]

BTW, if I understand meaning of Scope::num_heap_slots correctly, I was probably
too quick to remove it---it allowed us to bail out earlier (not in ScopeSetup). 
What do you think?

On 2010/12/13 22:41:04, antonm wrote:

 
   // In case we are not optimizing simply return the code from
   // the full code generator.
   if (!info->IsOptimizing()) {
     return FullCodeGenerator::MakeCode(info);
   }
 
   // We should never arrive here if there is not code object on the
   // shared function object.
   Handle<Code> code(info->shared_info()->code());
@@ skipping 365 matching lines @@
     result = MakeFunctionInfo(&info);
     if (!result.is_null()) {
       CompilationCache::PutEval(source, context, is_global, result);
     }
   }
 
   return result;
 }
 
 
+class PrecompiledScope: public Scope {
+ public:
+  PrecompiledScope(Scope* inner_scope, SerializedScopeInfo* scope_info)
+      : Scope(inner_scope->outer_scope(), Scope::FUNCTION_SCOPE),
+        scope_info_(scope_info) {
+    InsertAfterScope(inner_scope);
+    if (scope_info->HasHeapAllocatedLocals()) {
+      num_heap_slots_ = scope_info->NumberOfContextSlots();
+    }
+    MarkAsResolved();
+  }
+
+  virtual void Initialize(bool inside_with) {
+    UNREACHABLE();
+  }
+
+  virtual Variable* LocalLookup(Handle<String> name) {
+    // Check arguments object lookup.
+    if (*name == *Factory::arguments_symbol()) {
+      return new Variable(this, name, Variable::VAR, true, Variable::ARGUMENTS);
+    }
+
+    // Check context slot lookup.
+    Variable::Mode mode;
+    int index = scope_info_->ContextSlotIndex(*name, &mode);
+    if (index < 0) {
+      return NULL;
+    }
+
+    Variable* var = new Variable(this, name, mode, true, Variable::NORMAL);
+    var->set_rewrite(new Slot(var, Slot::CONTEXT, index));
+    return var;
+  }
+
+  virtual Variable* DeclareLocal(Handle<String> name, Variable::Mode mode) {
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual VariableProxy* NewUnresolved(Handle<String> name, bool inside_with) {
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual Variable* NewTemporary(Handle<String> name) {
+    UNREACHABLE();
+    return NULL;
+  }
+
+ private:
+  SerializedScopeInfo* scope_info_;
+};
+
+
 bool Compiler::CompileLazy(CompilationInfo* info) {
   CompilationZoneScope zone_scope(DELETE_ON_EXIT);
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(COMPILER);
 
   PostponeInterruptsScope postpone;
 
   Handle<SharedFunctionInfo> shared = info->shared_info();
   int compiled_size = shared->end_position() - shared->start_position();
   Counters::total_compile_size.Increment(compiled_size);
 
   // Generate the AST for the lazily compiled function.
   if (ParserApi::Parse(info)) {
     // Measure how long it takes to do the lazy compilation; only take the
     // rest of the function into account to avoid overlap with the lazy
     // parsing statistics.
     HistogramTimerScope timer(&Counters::compile_lazy);
 
+    // If we have scope info, reuse it to build scope for function literal
+    // being compiled.
+    if (!info->closure().is_null()) {
+      SerializedScopeInfo* scope_info = info->closure()->shared()->scope_info();
+      if (scope_info != SerializedScopeInfo::Empty()) {
+        Scope* scope = info->function()->scope();
+        JSFunction* current = *info->closure();
+        do {
+          current = current->context()->closure();
+          SerializedScopeInfo* scope_info = current->shared()->scope_info();
+          if (scope_info != SerializedScopeInfo::Empty()) {
+            scope = new PrecompiledScope(scope, scope_info);
+          } else {
+            ASSERT(current->context()->IsGlobalContext());
+          }
+        } while (!current->context()->IsGlobalContext());
+      }
+    }
+
     // Compile the code.
     if (!MakeCode(info)) {
       Top::StackOverflow();
     } else {
       ASSERT(!info->code().is_null());
       Handle<Code> code = info->code();
       Handle<JSFunction> function = info->closure();
       RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG,
                                 Handle<String>(shared->DebugName()),
                                 shared->start_position(),
@@ skipping 75 matching lines @@
 
   // Generate code
   if (FLAG_lazy && allow_lazy) {
     Handle<Code> code(Builtins::builtin(Builtins::LazyCompile));
     info.SetCode(code);
   } else {
     if (V8::UseCrankshaft()) {
       if (!MakeCrankshaftCode(&info)) {
         return Handle<SharedFunctionInfo>::null();
       }
+      if (!AlwaysFullCompiler()
+          && !info.scope()->outer_scope_calls_eval()
+          && !info.scope()->inside_with()) {
+        ASSERT(info.code()->kind() == Code::FUNCTION);
+        info.code()->set_optimizable(true);
+      }
     } else {
       // The bodies of function literals have not yet been visited by the
       // AST optimizer/analyzer.
       if (!Rewriter::Analyze(&info)) return Handle<SharedFunctionInfo>::null();
 
       bool is_run_once = literal->try_full_codegen();
       bool can_use_full = FLAG_full_compiler && !literal->contains_loops();
 
       if (AlwaysFullCompiler() || (is_run_once && can_use_full)) {
         if (!FullCodeGenerator::MakeCode(&info)) {
@@ skipping 90 matching lines @@
                               *code,
                               *name));
       OPROFILE(CreateNativeCodeRegion(*name,
                                       code->instruction_start(),
                                       code->instruction_size()));
     }
   }
 }
 
 } }  // namespace v8::internal