Make closures optimizable by Crankshaft compiler.

src/hydrogen.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 2351 matching lines @@
     AddInstruction(call->PushArgumentAt(i));
   }
 }
 
 
 void HGraphBuilder::SetupScope(Scope* scope) {
   // We don't yet handle the function name for named function expressions.
   if (scope->function() != NULL) BAILOUT("named function expression");
 
   // We can't handle heap-allocated locals.
   if (scope->num_heap_slots() > 0) BAILOUT("heap allocated locals");

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

I think this bailout can go away, too.

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

I am not sure.  Apparently it makes us bail out of the function being compiled
needs to store some local variables in heap allocated slots, not when the
function accesses heap allocated slot of some other function.  That is:

function foo() {
  var heap_slot = 1;
  return function bar() {
    return heap_slot;
  }
}

This check bails out for foo, not for bar, if I understand it correctly.

 
   HConstant* undefined_constant =
       new HConstant(Factory::undefined_value(), Representation::Tagged());
   AddInstruction(undefined_constant);
   graph_->set_undefined_constant(undefined_constant);
 
   // Set the initial values of parameters including "this".  "This" has
   // parameter index 0.
   int count = scope->num_parameters() + 1;
   for (int i = 0; i < count; ++i) {
@@ skipping 540 matching lines @@
 
 void HGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
   Variable* variable = expr->AsVariable();
   if (variable == NULL) {
     BAILOUT("reference to rewritten variable");
   } else if (variable->IsStackAllocated()) {
     if (environment()->Lookup(variable)->CheckFlag(HValue::kIsArguments)) {
       BAILOUT("unsupported context for arguments object");
     }
     ast_context()->ReturnValue(environment()->Lookup(variable));
+  } else if (variable->AsSlot() != NULL &&
+      variable->AsSlot()->type() == Slot::CONTEXT) {

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

Indentation.

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

Done.

+    if (variable->mode() == Variable::CONST) {
+      BAILOUT("reference to const context slot");
+    }
+    Slot* slot = variable->AsSlot();
+    CompilationInfo* info = graph()->info();
+    int context_chain_length = info->function()->scope()->
+        ContextChainLength(slot->var()->scope());
+    ASSERT(context_chain_length >= 0);
+    Handle<JSFunction> closure = info->closure();
+    Context* context = closure->context();
+    for (int i = 0; i < context_chain_length; i++) {
+      context = context->closure()->context();
+    }
+    // TODO(antonm): if slot's value is not modified by closures, instead
+    // of reading it out of context, we could just embed the value as
+    // a constant.
+    HLoadContextSlot* instr =
+        new HLoadContextSlot(Handle<Context>(context), slot->index());
+    ast_context()->ReturnInstruction(instr, expr->id());
   } else if (variable->is_global()) {
     LookupResult lookup;
     LookupGlobalPropertyCell(variable, &lookup, false);
     CHECK_BAILOUT;
 
     Handle<GlobalObject> global(graph()->info()->global_object());
     // TODO(3039103): Handle global property load through an IC call when access
     // checks are enabled.
     if (global->IsAccessCheckNeeded()) {
       BAILOUT("global object requires access check");
@@ skipping 491 matching lines @@
 
   if (expr->is_compound()) {
     HandleCompoundAssignment(expr);
     return;
   }
 
   if (var != NULL) {
     if (proxy->IsArguments()) BAILOUT("assignment to arguments");
 
     // Handle the assignment.
+    if (var->AsSlot() != NULL && var->AsSlot()->type() == Slot::CONTEXT) {
+      BAILOUT("context slot assignment");
+    }
     if (var->is_global()) {
       VISIT_FOR_VALUE(expr->value());
       HandleGlobalVariableAssignment(var, Top(), expr->position(), expr->id());
     } else {
       // We allow reference to the arguments object only in assignemtns
       // to local variables to make sure that the arguments object does
       // not escape and is not modified.
       VariableProxy* rhs = expr->value()->AsVariableProxy();
       if (rhs != NULL &&
           rhs->var()->IsStackAllocated() &&
@@ skipping 2211 matching lines @@
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (chunk_ != NULL) chunk_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal