TF: Add support for [[HomeObject]]

src/compiler/ast-graph-builder.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/linkage.h"
@@ skipping 1339 matching lines @@
       }
       case ObjectLiteral::Property::SETTER: {
         Node* attr = jsgraph()->Constant(DONT_ENUM);
         const Operator* op = javascript()->CallRuntime(
             Runtime::kDefineSetterPropertyUnchecked, 4);
         NewNode(op, receiver, key, value, attr);
         break;
       }
     }
 
-    // TODO(mstarzinger): This is temporary to make "super" work and replicates
-    // the existing FullCodeGenerator::NeedsHomeObject predicate.
-    if (FunctionLiteral::NeedsHomeObject(property->value())) {
-      Unique<Name> name =
-          MakeUnique(isolate()->factory()->home_object_symbol());
-      Node* store = NewNode(javascript()->StoreNamed(language_mode(), name),
-                            value, receiver);
-      PrepareFrameState(store, BailoutId::None());
-    }
+    AddHomeObjectIfNeeded(property->value(), value, receiver);
   }
 
   // Transform both the class literal and the prototype to fast properties.
   const Operator* op = javascript()->CallRuntime(Runtime::kToFastProperties, 1);
   NewNode(op, environment()->Pop());  // prototype
   NewNode(op, environment()->Pop());  // literal
 
   // Assign to class variable.
   if (expr->scope() != NULL) {
     DCHECK_NOT_NULL(expr->class_variable_proxy());
     Variable* var = expr->class_variable_proxy()->var();
     BuildVariableAssignment(var, literal, Token::INIT_CONST, BailoutId::None());
   }
 
   PrepareFrameState(literal, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(literal);
 }
 
 
+void AstGraphBuilder::AddHomeObjectIfNeeded(Expression* expr, Node* function,
+                                            Node* home_object) {
+  if (FunctionLiteral::NeedsHomeObject(expr)) {
+    Unique<Name> name = MakeUnique(isolate()->factory()->home_object_symbol());
+    Node* store = NewNode(javascript()->StoreNamed(language_mode(), name),
+                          function, home_object);
+    PrepareFrameState(store, BailoutId::None());
+  }
+}
+
+
 void AstGraphBuilder::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
   UNREACHABLE();
 }
 
 
 void AstGraphBuilder::VisitConditional(Conditional* expr) {
   IfBuilder compare_if(this);
   VisitForTest(expr->condition());
   Node* condition = environment()->Pop();
   compare_if.If(condition);
@@ skipping 81 matching lines @@
         // contains computed properties with an uninitialized value.
         if (key->value()->IsInternalizedString()) {
           if (property->emit_store()) {
             VisitForValue(property->value());
             Node* value = environment()->Pop();
             Unique<Name> name = MakeUnique(key->AsPropertyName());
             Node* store =
                 NewNode(javascript()->StoreNamed(language_mode(), name),
                         literal, value);
             PrepareFrameState(store, key->id());
+
+            AddHomeObjectIfNeeded(property->value(), value, literal);
           } else {
             VisitForEffect(property->value());
           }
           break;
         }
         environment()->Push(literal);  // Duplicate receiver.
         VisitForValue(property->key());
         VisitForValue(property->value());
         Node* value = environment()->Pop();
         Node* key = environment()->Pop();
         Node* receiver = environment()->Pop();
         if (property->emit_store()) {
           Node* language = jsgraph()->Constant(SLOPPY);
           const Operator* op =
               javascript()->CallRuntime(Runtime::kSetProperty, 4);
           NewNode(op, receiver, key, value, language);
+
+          AddHomeObjectIfNeeded(property->value(), value, receiver);
         }
         break;
       }
       case ObjectLiteral::Property::PROTOTYPE: {
         environment()->Push(literal);  // Duplicate receiver.
         VisitForValue(property->value());
         Node* value = environment()->Pop();
         Node* receiver = environment()->Pop();
         DCHECK(property->emit_store());
         const Operator* op =
@@ skipping 15 matching lines @@
         break;
     }
   }
 
   // Create nodes to define accessors, using only a single call to the runtime
   // for each pair of corresponding getters and setters.
   for (AccessorTable::Iterator it = accessor_table.begin();
        it != accessor_table.end(); ++it) {
     VisitForValue(it->first);
     VisitForValueOrNull(it->second->getter);
     VisitForValueOrNull(it->second->setter);

[Michael Starzinger, 2015/02/16 18:36:01]

If we ever deoptimize while evaluating the setter then the HomeObject for the
getter won't be set yet, but full-codegen will not set it because the ordering
is different in full-codegen. Not sure if evaluating the FunctionLiteral could
ever cause a deopt though.

     Node* setter = environment()->Pop();
     Node* getter = environment()->Pop();
     Node* name = environment()->Pop();
+    AddHomeObjectIfNeeded(it->second->getter, getter, literal);
+    AddHomeObjectIfNeeded(it->second->setter, setter, literal);
     Node* attr = jsgraph()->Constant(NONE);
     const Operator* op =
         javascript()->CallRuntime(Runtime::kDefineAccessorPropertyUnchecked, 5);
     Node* call = NewNode(op, literal, name, getter, setter, attr);
     // This should not lazy deopt on a new literal.
     PrepareFrameState(call, BailoutId::None());
   }
 
   // Object literals have two parts. The "static" part on the left contains no
   // computed property names, and so we can compute its map ahead of time; see
@@ skipping 12 matching lines @@
     environment()->Push(BuildToName(environment()->Pop(),
                                     expr->GetIdForProperty(property_index)));
     // TODO(mstarzinger): For ObjectLiteral::Property::PROTOTYPE the key should
     // not be on the operand stack while the value is being evaluated. Come up
     // with a repro for this and fix it. Also find a nice way to do so. :)
     VisitForValue(property->value());
     Node* value = environment()->Pop();
     Node* key = environment()->Pop();
     Node* receiver = environment()->Pop();
 
+    AddHomeObjectIfNeeded(property->value(), value, receiver);
+
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
       case ObjectLiteral::Property::COMPUTED:
       case ObjectLiteral::Property::MATERIALIZED_LITERAL: {
         Node* attr = jsgraph()->Constant(NONE);
         const Operator* op =
             javascript()->CallRuntime(Runtime::kDefineDataPropertyUnchecked, 4);
         Node* call = NewNode(op, receiver, key, value, attr);
         PrepareFrameState(call, BailoutId::None());
         break;
@@ skipping 1545 matching lines @@
     Node* dead_node = graph()->NewNode(common()->Dead());
     dead_control_.set(dead_node);
     return dead_node;
   }
   return dead_control_.get();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8