[interpreter] Support for ES6 super keyword.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/interpreter/control-flow-builders.h"
@@ skipping 1017 matching lines @@
       RegisterAllocationScope register_scope(this);
       Register value = register_allocator()->NewRegister();
       builder()->StoreAccumulatorInRegister(value);
       Register object = VisitForRegisterValue(property->obj());
       Register key = VisitForRegisterValue(property->key());
       builder()->LoadAccumulatorWithRegister(value);
       builder()->StoreKeyedProperty(object, key, feedback_index(slot),
                                     language_mode());
       break;
     }
-    case NAMED_SUPER_PROPERTY:
-    case KEYED_SUPER_PROPERTY:
-      UNIMPLEMENTED();
+    case NAMED_SUPER_PROPERTY: {
+      RegisterAllocationScope register_scope(this);
+      Register value = register_allocator()->NewRegister();
+      builder()->StoreAccumulatorInRegister(value);
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      Register receiver = VisitForRegisterValue(super_property->this_var());
+      Register home_object =
+          VisitForRegisterValue(super_property->home_object());
+      Handle<Name> name = property->key()->AsLiteral()->AsPropertyName();
+      builder()->LoadAccumulatorWithRegister(value);
+      BuildNamedSuperStore(receiver, home_object, name);

[rmcilroy, 2016/02/11 15:25:49]

Could you adapt this function to expect the home_object in the accumulator and
the value as a register? That way you could avoid the extra LoadAccumulator
above (and probably as StoreAccumulatorInReg for the home object too). 

[oth, 2016/02/12 14:12:53]

I'd wondered about this too. Have added PrepareNamedSuperPropertyArguments and
StoreNamedSuperPropertyArguments that reduces the code here.

+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      RegisterAllocationScope register_scope(this);
+      Register value = register_allocator()->NewRegister();
+      builder()->StoreAccumulatorInRegister(value);
+      Register receiver = VisitForRegisterValue(super_property->this_var());
+      Register home_object =
+          VisitForRegisterValue(super_property->home_object());
+      Register key = VisitForRegisterValue(property->key());
+      builder()->LoadAccumulatorWithRegister(value);
+      BuildKeyedSuperStore(receiver, home_object, key);

[rmcilroy, 2016/02/11 15:25:49]

ditto

[oth, 2016/02/12 14:12:53]

Acknowledged.

+      break;
+    }
   }
 }
 
 
 void BytecodeGenerator::VisitForInStatement(ForInStatement* stmt) {
   if (stmt->subject()->IsNullLiteral() ||
       stmt->subject()->IsUndefinedLiteral(isolate())) {
     // ForIn generates lots of code, skip if it wouldn't produce any effects.
     return;
   }
@@ skipping 421 matching lines @@
         UNREACHABLE();
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:
         DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
       // Fall through.
       case ObjectLiteral::Property::COMPUTED: {
         // It is safe to use [[Put]] here because the boilerplate already
         // contains computed properties with an uninitialized value.
         if (literal_key->value()->IsInternalizedString()) {
           if (property->emit_store()) {
             VisitForAccumulatorValue(property->value());
-            builder()->StoreNamedProperty(
-                literal, literal_key->AsPropertyName(),
-                feedback_index(property->GetSlot(0)), language_mode());
+            if (FunctionLiteral::NeedsHomeObject(property->value())) {
+              RegisterAllocationScope register_scope(this);
+              Register value = register_allocator()->NewRegister();
+              builder()->StoreAccumulatorInRegister(value);
+              builder()->StoreNamedProperty(
+                  literal, literal_key->AsPropertyName(),
+                  feedback_index(property->GetSlot(0)), language_mode());
+              VisitSetHomeObject(value, literal, property, 1);
+            } else {
+              builder()->StoreNamedProperty(
+                  literal, literal_key->AsPropertyName(),
+                  feedback_index(property->GetSlot(0)), language_mode());
+            }
           } else {
             VisitForEffect(property->value());
           }
         } else {
           register_allocator()->PrepareForConsecutiveAllocations(4);
           Register literal_argument =
               register_allocator()->NextConsecutiveRegister();
           Register key = register_allocator()->NextConsecutiveRegister();
           Register value = register_allocator()->NextConsecutiveRegister();
           Register language = register_allocator()->NextConsecutiveRegister();
@@ skipping 267 matching lines @@
 }
 
 
 Register BytecodeGenerator::VisitVariableLoadForRegisterValue(
     Variable* variable, FeedbackVectorSlot slot, TypeofMode typeof_mode) {
   RegisterResultScope register_scope(this);
   VisitVariableLoad(variable, slot, typeof_mode);
   return register_scope.ResultRegister();
 }
 
+void BytecodeGenerator::BuildKeyedSuperLoad(Register receiver,

[rmcilroy, 2016/02/11 15:25:49]

BuildKeyedSuperPropertyLoad  (and the same for the ones below) ?

[oth, 2016/02/12 14:12:53]

Done.

+                                            Register home_object,
+                                            Register key) {
+  RegisterAllocationScope register_scope(this);
+  Register args[4];
+  register_allocator()->PrepareForConsecutiveAllocations(arraysize(args));
+  for (size_t i = 0; i < arraysize(args); i++) {
+    args[i] = register_allocator()->NextConsecutiveRegister();
+  }

[rmcilroy, 2016/02/11 15:25:49]

I'd prefer just to explicitly name each of the registers for clarity (You don't
actually save any lines of code using the args array anyway AFAIKT).

[oth, 2016/02/12 14:12:53]

Keeping this pattern as discussed and incorporated the initialization the array
suggested. WDYT? 

+
+  builder()
+      ->LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
+      .StoreAccumulatorInRegister(args[3])
+      .MoveRegister(key, args[2])
+      .MoveRegister(home_object, args[1])
+      .MoveRegister(receiver, args[0])
+      .CallRuntime(Runtime::kLoadKeyedFromSuper, args[0],
+                   static_cast<int>(arraysize(args)));
+}
+
+void BytecodeGenerator::BuildKeyedSuperStore(Register receiver,
+                                             Register home_object,
+                                             Register key) {
+  RegisterAllocationScope register_scope(this);
+  Register args[4];
+  register_allocator()->PrepareForConsecutiveAllocations(arraysize(args));
+  for (size_t i = 0; i < arraysize(args); i++) {
+    args[i] = register_allocator()->NextConsecutiveRegister();
+  }
+
+  // Prepare arguments. Value to be stored is in the accumulator.
+  builder()
+      ->StoreAccumulatorInRegister(args[3])
+      .MoveRegister(key, args[2])
+      .MoveRegister(home_object, args[1])
+      .MoveRegister(receiver, args[0]);
+
+  // Call runtime to perform store.
+  Runtime::FunctionId function_id = is_strict(language_mode())
+                                        ? Runtime::kStoreKeyedToSuper_Strict
+                                        : Runtime::kStoreKeyedToSuper_Sloppy;
+  builder()->CallRuntime(function_id, args[0],
+                         static_cast<int>(arraysize(args)));
+}
+
+void BytecodeGenerator::BuildNamedSuperLoad(Register receiver,
+                                            Register home_object,
+                                            Handle<Name> name) {
+  RegisterAllocationScope register_scope(this);
+  Register args[4];
+  register_allocator()->PrepareForConsecutiveAllocations(arraysize(args));
+  for (size_t i = 0; i < arraysize(args); i++) {
+    args[i] = register_allocator()->NextConsecutiveRegister();
+  }
+
+  builder()
+      ->LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
+      .StoreAccumulatorInRegister(args[3])
+      .LoadLiteral(name)
+      .StoreAccumulatorInRegister(args[2])
+      .MoveRegister(home_object, args[1])
+      .MoveRegister(receiver, args[0])
+      .CallRuntime(Runtime::kLoadFromSuper, args[0],
+                   static_cast<int>(arraysize(args)));
+}
+
+void BytecodeGenerator::BuildNamedSuperStore(Register receiver,
+                                             Register home_object,
+                                             Handle<Name> name) {
+  RegisterAllocationScope register_scope(this);
+  Register args[4];
+  register_allocator()->PrepareForConsecutiveAllocations(arraysize(args));
+  for (size_t i = 0; i < arraysize(args); i++) {
+    args[i] = register_allocator()->NextConsecutiveRegister();
+  }
+
+  // Prepare arguments. Value to be stored is in the accumulator.
+  builder()
+      ->StoreAccumulatorInRegister(args[3])
+      .LoadLiteral(name)
+      .StoreAccumulatorInRegister(args[2])
+      .MoveRegister(home_object, args[1])
+      .MoveRegister(receiver, args[0]);
+
+  // Call runtime to perform store.
+  Runtime::FunctionId function_id = is_strict(language_mode())
+                                        ? Runtime::kStoreToSuper_Strict
+                                        : Runtime::kStoreToSuper_Sloppy;
+  builder()->CallRuntime(function_id, args[0],
+                         static_cast<int>(arraysize(args)));
+}
+
 void BytecodeGenerator::BuildThrowIfHole(Handle<String> name) {
   Register name_reg = register_allocator()->NewRegister();
   BytecodeLabel end_label;
   // TODO(mythria): This will be replaced by a new bytecode that throws an
   // error if the value is the hole.
   builder()
       ->JumpIfNotHole(&end_label)
       .LoadLiteral(name)
       .StoreAccumulatorInRegister(name_reg)
       .CallRuntime(Runtime::kThrowReferenceError, name_reg, 1)
@@ skipping 188 matching lines @@
       } else {
         builder()->StoreLookupSlot(variable->name(), language_mode());
       }
       break;
     }
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
-  DCHECK(expr->target()->IsValidReferenceExpression());
-  Register object, key;
+  DCHECK(expr->target()->IsValidReferenceExpressionOrThis());
+  Register home_object, object, key;
   Handle<String> name;
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->target()->AsProperty();
   LhsKind assign_type = Property::GetAssignType(property);
 
   // Evaluate LHS expression.
   switch (assign_type) {
     case VARIABLE:
       // Nothing to do to evaluate variable assignment LHS.
       break;
     case NAMED_PROPERTY: {
       object = VisitForRegisterValue(property->obj());
       name = property->key()->AsLiteral()->AsPropertyName();
       break;
     }
     case KEYED_PROPERTY: {
       object = VisitForRegisterValue(property->obj());
       if (expr->is_compound()) {
         // Use VisitForAccumulator and store to register so that the key is
         // still in the accumulator for loading the old value below.
         key = register_allocator()->NewRegister();
         VisitForAccumulatorValue(property->key());
         builder()->StoreAccumulatorInRegister(key);
       } else {
         key = VisitForRegisterValue(property->key());
       }
       break;
     }
-    case NAMED_SUPER_PROPERTY:
-    case KEYED_SUPER_PROPERTY:
-      UNIMPLEMENTED();
+    case NAMED_SUPER_PROPERTY: {
+      object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->this_var());
+      home_object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->home_object());
+      name = property->key()->AsLiteral()->AsPropertyName();
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->this_var());
+      home_object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->home_object());
+      key = VisitForRegisterValue(property->key());
+      break;
+    }
   }
 
   // Evaluate the value and potentially handle compound assignments by loading
   // the left-hand side value and performing a binary operation.
   if (expr->is_compound()) {
     Register old_value;
     switch (assign_type) {
       case VARIABLE: {
         VariableProxy* proxy = expr->target()->AsVariableProxy();
         old_value = VisitVariableLoadForRegisterValue(
@@ skipping 12 matching lines @@
       case KEYED_PROPERTY: {
         // Key is already in accumulator at this point due to evaluating the
         // LHS above.
         FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
         old_value = register_allocator()->NewRegister();
         builder()
             ->LoadKeyedProperty(object, feedback_index(slot), language_mode())
             .StoreAccumulatorInRegister(old_value);
         break;
       }
-      case NAMED_SUPER_PROPERTY:
-      case KEYED_SUPER_PROPERTY:
-        UNIMPLEMENTED();
+      case NAMED_SUPER_PROPERTY: {
+        old_value = register_allocator()->NewRegister();
+        BuildNamedSuperLoad(object, home_object, name);
+        builder()->StoreAccumulatorInRegister(old_value);
         break;
+      }
+      case KEYED_SUPER_PROPERTY: {
+        old_value = register_allocator()->NewRegister();
+        BuildKeyedSuperLoad(object, home_object, key);
+        builder()->StoreAccumulatorInRegister(old_value);
+        break;
+      }
     }
     VisitForAccumulatorValue(expr->value());
     builder()->BinaryOperation(expr->binary_op(), old_value,
                                language_mode_strength());
   } else {
     VisitForAccumulatorValue(expr->value());
   }
 
   // Store the value.
   FeedbackVectorSlot slot = expr->AssignmentSlot();
   switch (assign_type) {
     case VARIABLE: {
       // TODO(oth): The VisitVariableAssignment() call is hard to reason about.
       // Is the value in the accumulator safe? Yes, but scary.
       Variable* variable = expr->target()->AsVariableProxy()->var();
       VisitVariableAssignment(variable, expr->op(), slot);
       break;
     }
     case NAMED_PROPERTY:
       builder()->StoreNamedProperty(object, name, feedback_index(slot),
                                     language_mode());
       break;
     case KEYED_PROPERTY:
       builder()->StoreKeyedProperty(object, key, feedback_index(slot),
                                     language_mode());
       break;
-    case NAMED_SUPER_PROPERTY:
-    case KEYED_SUPER_PROPERTY:
-      UNIMPLEMENTED();
+    case NAMED_SUPER_PROPERTY: {
+      BuildNamedSuperStore(object, home_object, name);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      BuildKeyedSuperStore(object, home_object, key);
+      break;
+    }
   }
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitYield(Yield* expr) { UNIMPLEMENTED(); }
 
 
 void BytecodeGenerator::VisitThrow(Throw* expr) {
   VisitForAccumulatorValue(expr->exception());
@@ skipping 17 matching lines @@
                                    expr->key()->AsLiteral()->AsPropertyName(),
                                    feedback_index(slot), language_mode());
       break;
     }
     case KEYED_PROPERTY: {
       VisitForAccumulatorValue(expr->key());
       builder()->LoadKeyedProperty(obj, feedback_index(slot), language_mode());
       break;
     }
     case NAMED_SUPER_PROPERTY:
+      VisitNamedSuperPropertyLoad(expr, Register::invalid_value());
+      break;
     case KEYED_SUPER_PROPERTY:
-      UNIMPLEMENTED();
+      VisitKeyedSuperPropertyLoad(expr, Register::invalid_value());
+      break;
   }
   execution_result()->SetResultInAccumulator();
 }
 
-
 void BytecodeGenerator::VisitPropertyLoadForAccumulator(Register obj,
                                                         Property* expr) {
   AccumulatorResultScope result_scope(this);
   VisitPropertyLoad(obj, expr);
 }
 
+void BytecodeGenerator::VisitNamedSuperPropertyLoad(Property* property,
+                                                    Register receiver_out) {
+  RegisterAllocationScope register_scope(this);
+  register_allocator()->PrepareForConsecutiveAllocations(4);
+  Register receiver = register_allocator()->NextConsecutiveRegister();
+  Register home_object = register_allocator()->NextConsecutiveRegister();
+  Register property_name = register_allocator()->NextConsecutiveRegister();
+  Register language = register_allocator()->NextConsecutiveRegister();
+
+  SuperPropertyReference* super_ref =
+      property->obj()->AsSuperPropertyReference();
+  Expression* key = property->key();
+  VisitForAccumulatorValue(super_ref->this_var());
+  builder()->StoreAccumulatorInRegister(receiver);
+
+  VisitForAccumulatorValue(super_ref->home_object());

[rmcilroy, 2016/02/11 15:25:49]

Could you use BuildNamedSuperLoad here?

[oth, 2016/02/12 14:12:53]

Done.

+  builder()
+      ->StoreAccumulatorInRegister(home_object)
+      .LoadLiteral(key->AsLiteral()->AsPropertyName())
+      .StoreAccumulatorInRegister(property_name)
+      .LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
+      .StoreAccumulatorInRegister(language);
+  builder()->CallRuntime(Runtime::kLoadFromSuper, receiver, 4);
+  if (receiver_out.is_valid()) {

[rmcilroy, 2016/02/11 15:25:49]

nit - move this up to be below
"builder()->StoreAccumulatorInRegister(receiver);" so that it is clear that this
visitor returns the load from the runtime call in the accumulator.

[oth, 2016/02/12 14:12:53]

Done.

+    builder()->MoveRegister(receiver, receiver_out);
+  }
+}
+
+void BytecodeGenerator::VisitKeyedSuperPropertyLoad(Property* property,
+                                                    Register receiver_out) {
+  RegisterAllocationScope register_scope(this);

[rmcilroy, 2016/02/11 15:25:49]

Same question here, could this use BuildKeyedSuperPropertyLoad?

[oth, 2016/02/12 14:12:53]

Done.

+  register_allocator()->PrepareForConsecutiveAllocations(4);
+  Register receiver = register_allocator()->NextConsecutiveRegister();
+  Register home = register_allocator()->NextConsecutiveRegister();
+  Register key = register_allocator()->NextConsecutiveRegister();
+  Register language = register_allocator()->NextConsecutiveRegister();
+
+  SuperPropertyReference* super_ref =
+      property->obj()->AsSuperPropertyReference();
+  VisitForAccumulatorValue(super_ref->home_object());
+  builder()->StoreAccumulatorInRegister(home);
+
+  VisitForAccumulatorValue(super_ref->this_var());
+  builder()->StoreAccumulatorInRegister(receiver);
+
+  VisitForAccumulatorValue(property->key());
+  builder()->StoreAccumulatorInRegister(key);
+
+  builder()
+      ->LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
+      .StoreAccumulatorInRegister(language);
+
+  builder()->CallRuntime(Runtime::kLoadKeyedFromSuper, receiver, 4);
+  if (receiver_out.is_valid()) {
+    builder()->MoveRegister(receiver, receiver_out);
+  }
+}
 
 void BytecodeGenerator::VisitProperty(Property* expr) {
-  Register obj = VisitForRegisterValue(expr->obj());
-  VisitPropertyLoad(obj, expr);

[rmcilroy, 2016/02/11 15:25:49]

Could you merge this back please (and make the 
VisitForRegisterValue(expr->obj()); conditional on it not being a super
property.

[oth, 2016/02/12 14:12:53]

Done.

+  LhsKind property_kind = Property::GetAssignType(expr);
+  FeedbackVectorSlot slot = expr->PropertyFeedbackSlot();
+  switch (property_kind) {
+    case VARIABLE:
+      UNREACHABLE();
+    case NAMED_PROPERTY: {
+      Register obj = VisitForRegisterValue(expr->obj());
+      builder()->LoadNamedProperty(obj,
+                                   expr->key()->AsLiteral()->AsPropertyName(),
+                                   feedback_index(slot), language_mode());
+      break;
+    }
+    case KEYED_PROPERTY: {
+      Register obj = VisitForRegisterValue(expr->obj());
+      VisitForAccumulatorValue(expr->key());
+      builder()->LoadKeyedProperty(obj, feedback_index(slot), language_mode());
+      break;
+    }
+    case NAMED_SUPER_PROPERTY:
+      VisitNamedSuperPropertyLoad(expr, Register::invalid_value());
+      break;
+    case KEYED_SUPER_PROPERTY:
+      VisitKeyedSuperPropertyLoad(expr, Register::invalid_value());
+      break;
+  }
+  execution_result()->SetResultInAccumulator();
 }
 
 
 Register BytecodeGenerator::VisitArguments(ZoneList<Expression*>* args) {
   if (args->length() == 0) {
     return Register();
   }
 
   // Visit arguments and place in a contiguous block of temporary
   // registers.  Return the first temporary register corresponding to
@@ skipping 15 matching lines @@
   // Visit remaining arguments
   for (int i = 1; i < static_cast<int>(args->length()); i++) {
     Register ith_arg = register_allocator()->NextConsecutiveRegister();
     VisitForAccumulatorValue(args->at(i));
     builder()->StoreAccumulatorInRegister(ith_arg);
     DCHECK(ith_arg.index() - i == first_arg.index());
   }
   return first_arg;
 }
 
-
 void BytecodeGenerator::VisitCall(Call* expr) {
   Expression* callee_expr = expr->expression();
   Call::CallType call_type = expr->GetCallType(isolate());
 
+  if (call_type == Call::SUPER_CALL) {
+    return VisitCallSuper(expr);
+  }
+
   // Prepare the callee and the receiver to the function call. This depends on
   // the semantics of the underlying call type.
 
   // The receiver and arguments need to be allocated consecutively for
   // Call(). We allocate the callee and receiver consecutively for calls to
   // %LoadLookupSlotForCall. Future optimizations could avoid this there are
   // no arguments or the receiver and arguments are already consecutive.
   ZoneList<Expression*>* args = expr->arguments();
   register_allocator()->PrepareForConsecutiveAllocations(args->length() + 2);
   Register callee = register_allocator()->NextConsecutiveRegister();
@@ skipping 37 matching lines @@
       }
       // Fall through.
       DCHECK_EQ(call_type, Call::POSSIBLY_EVAL_CALL);
     }
     case Call::OTHER_CALL: {
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       VisitForAccumulatorValue(callee_expr);
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
-    case Call::NAMED_SUPER_PROPERTY_CALL:
-    case Call::KEYED_SUPER_PROPERTY_CALL:
+    case Call::NAMED_SUPER_PROPERTY_CALL: {
+      Property* property = callee_expr->AsProperty();
+      VisitNamedSuperPropertyLoad(property, receiver);
+      builder()->StoreAccumulatorInRegister(callee);
+      break;
+    }
+    case Call::KEYED_SUPER_PROPERTY_CALL: {
+      Property* property = callee_expr->AsProperty();
+      VisitKeyedSuperPropertyLoad(property, receiver);
+      builder()->StoreAccumulatorInRegister(callee);
+      break;
+    }
     case Call::SUPER_CALL:
-      UNIMPLEMENTED();
+      UNREACHABLE();
+      break;
   }
 
   // Evaluate all arguments to the function call and store in sequential
   // registers.
   Register arg = VisitArguments(args);
   CHECK(args->length() == 0 || arg.index() == receiver.index() + 1);
 
   // Resolve callee for a potential direct eval call. This block will mutate the
   // callee value.
   if (call_type == Call::POSSIBLY_EVAL_CALL && args->length() > 0) {
@@ skipping 23 matching lines @@
         ->CallRuntime(Runtime::kResolvePossiblyDirectEval, callee_for_eval, 5)
         .StoreAccumulatorInRegister(callee);
   }
 
   builder()->SetExpressionPosition(expr);
   builder()->Call(callee, receiver, 1 + args->length(),
                   feedback_index(expr->CallFeedbackICSlot()));
   execution_result()->SetResultInAccumulator();
 }
 
+void BytecodeGenerator::VisitCallSuper(Call* expr) {
+  RegisterAllocationScope register_scope(this);
+  SuperCallReference* super = expr->expression()->AsSuperCallReference();
+  DCHECK_NOT_NULL(super);

[rmcilroy, 2016/02/11 15:25:49]

I don't think this DCHECK is necessary (it will crash 3 lines down if it's
null).

[oth, 2016/02/12 14:12:53]

Done.

+
+  // Prepare the constructor to the super call.
+  Register constructor = register_allocator()->NewRegister();
+  Register this_function = constructor;

[rmcilroy, 2016/02/11 15:25:49]

Could you move this down below the CallRuntime with a comment saying that you
reuse the constructor register since it's no longer used. 

[oth, 2016/02/12 14:12:53]

Done.

+  VisitForAccumulatorValue(super->this_function_var());
+  builder()
+      ->StoreAccumulatorInRegister(this_function)
+      .CallRuntime(Runtime::kInlineGetSuperConstructor, this_function, 1)
+      .StoreAccumulatorInRegister(constructor);
+
+  ZoneList<Expression*>* args = expr->arguments();
+  Register first_arg = VisitArguments(args);
+
+  // The new target is loaded into the accumulator from the
+  // {new.target} variable.
+  VisitForAccumulatorValue(super->new_target_var());
+
+  // Call construct.
+  builder()->SetExpressionPosition(expr);
+  builder()->New(constructor, first_arg, args->length());
+  execution_result()->SetResultInAccumulator();
+}
 
 void BytecodeGenerator::VisitCallNew(CallNew* expr) {
   Register constructor = register_allocator()->NewRegister();
   VisitForAccumulatorValue(expr->expression());
   builder()->StoreAccumulatorInRegister(constructor);
 
   ZoneList<Expression*>* args = expr->arguments();
   Register first_arg = VisitArguments(args);
+
   builder()->SetExpressionPosition(expr);
-  builder()->New(constructor, first_arg, args->length());
+  // The accumulator holds new target which is the same as the
+  // constructor for CallNew.
+  builder()
+      ->LoadAccumulatorWithRegister(constructor)
+      .New(constructor, first_arg, args->length());
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   ZoneList<Expression*>* args = expr->arguments();
   if (expr->is_jsruntime()) {
     // Allocate a register for the receiver and load it with undefined.
     register_allocator()->PrepareForConsecutiveAllocations(1 + args->length());
     Register receiver = register_allocator()->NextConsecutiveRegister();
@@ skipping 129 matching lines @@
   DCHECK(expr->expression()->IsValidReferenceExpressionOrThis());
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->expression()->AsProperty();
   LhsKind assign_type = Property::GetAssignType(property);
 
   // TODO(rmcilroy): Set is_postfix to false if visiting for effect.
   bool is_postfix = expr->is_postfix();
 
   // Evaluate LHS expression and get old value.
-  Register obj, key, old_value;
+  Register object, home_object, key, old_value;
   Handle<String> name;
   switch (assign_type) {
     case VARIABLE: {
       VariableProxy* proxy = expr->expression()->AsVariableProxy();
       VisitVariableLoadForAccumulatorValue(proxy->var(),
                                            proxy->VariableFeedbackSlot());
       break;
     }
     case NAMED_PROPERTY: {
       FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
-      obj = VisitForRegisterValue(property->obj());
+      object = VisitForRegisterValue(property->obj());
       name = property->key()->AsLiteral()->AsPropertyName();
-      builder()->LoadNamedProperty(obj, name, feedback_index(slot),
+      builder()->LoadNamedProperty(object, name, feedback_index(slot),
                                    language_mode());
       break;
     }
     case KEYED_PROPERTY: {
       FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
-      obj = VisitForRegisterValue(property->obj());
+      object = VisitForRegisterValue(property->obj());
       // Use visit for accumulator here since we need the key in the accumulator
       // for the LoadKeyedProperty.
       key = register_allocator()->NewRegister();
       VisitForAccumulatorValue(property->key());
       builder()->StoreAccumulatorInRegister(key).LoadKeyedProperty(
-          obj, feedback_index(slot), language_mode());
+          object, feedback_index(slot), language_mode());
       break;
     }
-    case NAMED_SUPER_PROPERTY:
-    case KEYED_SUPER_PROPERTY:
-      UNIMPLEMENTED();
+    case NAMED_SUPER_PROPERTY: {
+      object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->this_var());
+      home_object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->home_object());
+      name = property->key()->AsLiteral()->AsPropertyName();
+      BuildNamedSuperLoad(object, home_object, name);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->this_var());
+      home_object = VisitForRegisterValue(
+          property->obj()->AsSuperPropertyReference()->home_object());
+      key = VisitForRegisterValue(property->key());
+      BuildKeyedSuperLoad(object, home_object, key);
+      break;
+    }
   }
 
   // Convert old value into a number.
   if (!is_strong(language_mode())) {
     builder()->CastAccumulatorToNumber();
   }
 
   // Save result for postfix expressions.
   if (is_postfix) {
     old_value = register_allocator()->outer()->NewRegister();
     builder()->StoreAccumulatorInRegister(old_value);
   }
 
   // Perform +1/-1 operation.
   builder()->CountOperation(expr->binary_op(), language_mode_strength());
 
   // Store the value.
   FeedbackVectorSlot feedback_slot = expr->CountSlot();
   switch (assign_type) {
     case VARIABLE: {
       Variable* variable = expr->expression()->AsVariableProxy()->var();
       VisitVariableAssignment(variable, expr->op(), feedback_slot);
       break;
     }
     case NAMED_PROPERTY: {
-      builder()->StoreNamedProperty(obj, name, feedback_index(feedback_slot),
+      builder()->StoreNamedProperty(object, name, feedback_index(feedback_slot),
                                     language_mode());
       break;
     }
     case KEYED_PROPERTY: {
-      builder()->StoreKeyedProperty(obj, key, feedback_index(feedback_slot),
+      builder()->StoreKeyedProperty(object, key, feedback_index(feedback_slot),
                                     language_mode());
       break;
     }
-    case NAMED_SUPER_PROPERTY:
-    case KEYED_SUPER_PROPERTY:
-      UNIMPLEMENTED();
+    case NAMED_SUPER_PROPERTY: {
+      BuildNamedSuperStore(object, home_object, name);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      BuildKeyedSuperStore(object, home_object, key);
+      break;
+    }
   }
 
   // Restore old value for postfix expressions.
   if (is_postfix) {
     execution_result()->SetResultInRegister(old_value);
   } else {
     execution_result()->SetResultInAccumulator();
   }
 }
 
@@ skipping 39 matching lines @@
   UNREACHABLE();
 }
 
 
 void BytecodeGenerator::VisitThisFunction(ThisFunction* expr) {
   execution_result()->SetResultInRegister(Register::function_closure());
 }
 
 
 void BytecodeGenerator::VisitSuperCallReference(SuperCallReference* expr) {
-  UNIMPLEMENTED();
+  // Handled by VisitCall().
+  UNREACHABLE();
 }
 
 
 void BytecodeGenerator::VisitSuperPropertyReference(
     SuperPropertyReference* expr) {
-  UNIMPLEMENTED();
+  builder()->CallRuntime(Runtime::kThrowUnsupportedSuperError, Register(0), 0);
+  execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitCommaExpression(BinaryOperation* binop) {
   VisitForEffect(binop->left());
   Visit(binop->right());
 }
 
 
 void BytecodeGenerator::VisitLogicalOrExpression(BinaryOperation* binop) {
@@ skipping 152 matching lines @@
   // TODO(rmcilroy): Replace value_out with VisitForRegister();
   if (property == nullptr) {
     builder()->LoadNull().StoreAccumulatorInRegister(value_out);
   } else {
     VisitForAccumulatorValue(property->value());
     builder()->StoreAccumulatorInRegister(value_out);
     VisitSetHomeObject(value_out, home_object, property);
   }
 }
 
-
 void BytecodeGenerator::VisitSetHomeObject(Register value, Register home_object,
                                            ObjectLiteralProperty* property,
                                            int slot_number) {
   Expression* expr = property->value();
-  if (!FunctionLiteral::NeedsHomeObject(expr)) return;
-
-  UNIMPLEMENTED();
+  if (FunctionLiteral::NeedsHomeObject(expr)) {
+    Handle<Name> name = isolate()->factory()->home_object_symbol();
+    FeedbackVectorSlot slot = property->GetSlot(slot_number);
+    builder()
+        ->LoadAccumulatorWithRegister(home_object)
+        .StoreNamedProperty(value, name, feedback_index(slot), language_mode());
+  }
 }
 
 
 void BytecodeGenerator::VisitArgumentsObject(Variable* variable) {
   if (variable == nullptr) return;
 
   DCHECK(variable->IsContextSlot() || variable->IsStackAllocated());
 
   // Allocate and initialize a new arguments object and assign to the
   // {arguments} variable.
@@ skipping 12 matching lines @@
   // Allocate and initialize a new rest parameter and assign to the {rest}
   // variable.
   builder()->CreateArguments(CreateArgumentsType::kRestParameter);
   DCHECK(rest->IsContextSlot() || rest->IsStackAllocated());
   VisitVariableAssignment(rest, Token::ASSIGN, FeedbackVectorSlot::Invalid());
 }
 
 void BytecodeGenerator::VisitThisFunctionVariable(Variable* variable) {
   if (variable == nullptr) return;
 
-  // TODO(rmcilroy): Remove once we have tests which exercise this code path.
-  UNIMPLEMENTED();
-
   // Store the closure we were called with in the given variable.
   builder()->LoadAccumulatorWithRegister(Register::function_closure());
   VisitVariableAssignment(variable, Token::INIT, FeedbackVectorSlot::Invalid());
 }
 
 
 void BytecodeGenerator::VisitNewTargetVariable(Variable* variable) {
   if (variable == nullptr) return;
 
   // Store the new target we were called with in the given variable.
@@ skipping 76 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8