[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 400 matching lines @@
   }
 
   void PrepareForConsecutiveAllocations(int count) {
     allocator_.PrepareForConsecutiveAllocations(count);
   }
 
   Register NextConsecutiveRegister() {
     return allocator_.NextConsecutiveRegister();
   }
 
+  template <size_t N>
+  void PrepareAndInitializeConsecutiveAllocations(Register (&registers)[N]) {
+    return allocator_.PrepareAndInitializeConsecutiveAllocations(registers, N);
+  }
+
   bool RegisterIsAllocatedInThisScope(Register reg) const {
     return allocator_.RegisterIsAllocatedInThisScope(reg);
   }
 
   RegisterAllocationScope* outer() const { return outer_; }
 
  private:
   BytecodeGenerator* generator() const { return generator_; }
   BytecodeArrayBuilder* builder() const { return generator_->builder(); }
 
@@ skipping 105 matching lines @@
     result_register_ = reg;
     set_result_identified();
   }
 
   Register ResultRegister() const { return result_register_; }
 
  private:
   Register result_register_;
 };
 
+// Class for holding arguments for runtime calls relating to super
+// properties.
+class BytecodeGenerator::SuperPropertyArguments final {

[Michael Starzinger, 2016/02/16 16:53:09]

This assumes that both, the runtime calls for loads and stores always had
exactly 4 arguments. This assumption will not hold for long. In fact I just
broke it today. Not a big fan of this abstraction.

+ public:
+  SuperPropertyArguments() {}
+
+  Register (&registers())[4] { return args_; }
+  Register receiver() const { return args_[0]; }
+  Register home_object() const { return args_[1]; }
+  Register name_or_key() const { return args_[2]; }
+  Register store_value() const { return args_[3]; }
+  Register language_mode() const { return args_[3]; }
+  size_t count() const { return arraysize(args_); }
+
+ private:
+  Register args_[4];
+
+  DISALLOW_COPY_AND_ASSIGN(SuperPropertyArguments);
+};
+
 BytecodeGenerator::BytecodeGenerator(Isolate* isolate, Zone* zone)
     : isolate_(isolate),
       zone_(zone),
       builder_(nullptr),
       info_(nullptr),
       scope_(nullptr),
       globals_(0, zone),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       register_allocator_(nullptr),
       try_catch_nesting_level_(0),
       try_finally_nesting_level_(0) {
   InitializeAstVisitor(isolate);
 }
 
-
 Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
   set_info(info);
   set_scope(info->scope());
 
   // Initialize bytecode array builder.
   set_builder(new (zone()) BytecodeArrayBuilder(
       isolate(), zone(), info->num_parameters_including_this(),
       scope()->MaxNestedContextChainLength(), scope()->num_stack_slots()));
 
   // Initialize the incoming context.
@@ skipping 470 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);
+      SuperPropertyArguments super_args;
+      Register value = register_allocator()->NewRegister();
+      builder()->StoreAccumulatorInRegister(value);
+      PrepareNamedSuperPropertyArguments(
+          property->obj()->AsSuperPropertyReference(),
+          property->key()->AsLiteral()->AsPropertyName(), &super_args);
+      builder()->LoadAccumulatorWithRegister(value);
+      BuildNamedSuperPropertyStore(&super_args);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      RegisterAllocationScope register_scope(this);
+      SuperPropertyArguments super_args;
+      Register value = register_allocator()->NewRegister();
+      builder()->StoreAccumulatorInRegister(value);
+      PrepareKeyedSuperPropertyArguments(
+          property->obj()->AsSuperPropertyReference(), property->key(),
+          &super_args);
+      builder()->LoadAccumulatorWithRegister(value);
+      BuildKeyedSuperPropertyStore(&super_args);
+      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 422 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 263 matching lines @@
   VisitVariableLoad(variable, slot, typeof_mode);
 }
 
 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::PrepareNamedSuperPropertyArguments(
+    SuperPropertyReference* super_property, Handle<Name> name,
+    SuperPropertyArguments* super_args) {
+  register_allocator()->PrepareAndInitializeConsecutiveAllocations(
+      super_args->registers());
+
+  VisitForAccumulatorValue(super_property->this_var());
+  builder()->StoreAccumulatorInRegister(super_args->receiver());
+  VisitForAccumulatorValue(super_property->home_object());
+  builder()->StoreAccumulatorInRegister(super_args->home_object());
+  builder()->LoadLiteral(name).StoreAccumulatorInRegister(
+      super_args->name_or_key());
+}
+
+void BytecodeGenerator::PrepareKeyedSuperPropertyArguments(
+    SuperPropertyReference* super_property, Expression* key,
+    SuperPropertyArguments* super_args) {
+  register_allocator()->PrepareAndInitializeConsecutiveAllocations(
+      super_args->registers());
+
+  VisitForAccumulatorValue(super_property->this_var());
+  builder()->StoreAccumulatorInRegister(super_args->receiver());
+  VisitForAccumulatorValue(super_property->home_object());
+  builder()->StoreAccumulatorInRegister(super_args->home_object());
+  VisitForAccumulatorValue(key);
+  builder()->StoreAccumulatorInRegister(super_args->name_or_key());
+}
+
+void BytecodeGenerator::BuildNamedSuperPropertyLoad(
+    SuperPropertyArguments* super_args) {
+  builder()
+      ->LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
+      .StoreAccumulatorInRegister(super_args->language_mode());
+  builder()->CallRuntime(Runtime::kLoadFromSuper, super_args->receiver(),
+                         super_args->count());
+}
+
+void BytecodeGenerator::BuildKeyedSuperPropertyLoad(
+    SuperPropertyArguments* super_args) {
+  builder()
+      ->LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
+      .StoreAccumulatorInRegister(super_args->language_mode());
+  builder()->CallRuntime(Runtime::kLoadKeyedFromSuper, super_args->receiver(),
+                         super_args->count());
+}
+
+void BytecodeGenerator::BuildNamedSuperPropertyStore(
+    SuperPropertyArguments* super_args) {
+  builder()->StoreAccumulatorInRegister(super_args->store_value());
+  Runtime::FunctionId function_id = is_strict(language_mode())
+                                        ? Runtime::kStoreToSuper_Strict
+                                        : Runtime::kStoreToSuper_Sloppy;
+  builder()->CallRuntime(function_id, super_args->receiver(),
+                         super_args->count());
+}
+
+void BytecodeGenerator::BuildKeyedSuperPropertyStore(
+    SuperPropertyArguments* super_args) {
+  builder()->StoreAccumulatorInRegister(super_args->store_value());
+  Runtime::FunctionId function_id = is_strict(language_mode())
+                                        ? Runtime::kStoreKeyedToSuper_Strict
+                                        : Runtime::kStoreKeyedToSuper_Sloppy;
+  builder()->CallRuntime(function_id, super_args->receiver(),
+                         super_args->count());
+}
+
 void BytecodeGenerator::BuildThrowReferenceError(Handle<String> name) {
   RegisterAllocationScope register_scope(this);
   Register name_reg = register_allocator()->NewRegister();
   builder()->LoadLiteral(name).StoreAccumulatorInRegister(name_reg).CallRuntime(
       Runtime::kThrowReferenceError, name_reg, 1);
 }
 
 void BytecodeGenerator::BuildThrowIfHole(Handle<String> name) {
   // TODO(interpreter): Can the parser reduce the number of checks
   // performed? Or should there be a ThrowIfHole bytecode.
@@ skipping 35 matching lines @@
     BuildThrowReassignConstant(variable->name());
   } else if (mode == LET && op != Token::INIT) {
     // Perform an initialization check for let declared variables.
     // E.g. let x = (x = 20); is not allowed.
     BuildThrowIfHole(variable->name());
   } else {
     DCHECK(variable->is_this() && mode == CONST && op == Token::INIT);
     // Perform an initialization check for 'this'. 'this' variable is the
     // only variable able to trigger bind operations outside the TDZ
     // via 'super' calls.
-    BuildThrowIfHole(variable->name());
+    BuildThrowIfNotHole(variable->name());
   }
 }
 
 void BytecodeGenerator::VisitVariableAssignment(Variable* variable,
                                                 Token::Value op,
                                                 FeedbackVectorSlot slot) {
   VariableMode mode = variable->mode();
   RegisterAllocationScope assignment_register_scope(this);
   BytecodeLabel end_label;
   bool hole_check_required =
@@ skipping 131 matching lines @@
       } else {
         builder()->StoreLookupSlot(variable->name(), language_mode());
       }
       break;
     }
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
-  DCHECK(expr->target()->IsValidReferenceExpression());
+  DCHECK(expr->target()->IsValidReferenceExpressionOrThis());
   Register object, key;
+  SuperPropertyArguments super_args;
   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: {
+      PrepareNamedSuperPropertyArguments(
+          property->obj()->AsSuperPropertyReference(),
+          property->key()->AsLiteral()->AsPropertyName(), &super_args);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      PrepareKeyedSuperPropertyArguments(
+          property->obj()->AsSuperPropertyReference(), property->key(),
+          &super_args);
+      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();
+        BuildNamedSuperPropertyLoad(&super_args);
+        builder()->StoreAccumulatorInRegister(old_value);
         break;
+      }
+      case KEYED_SUPER_PROPERTY: {
+        old_value = register_allocator()->NewRegister();
+        BuildKeyedSuperPropertyLoad(&super_args);
+        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: {
+      BuildNamedSuperPropertyStore(&super_args);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      BuildKeyedSuperPropertyStore(&super_args);
+      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 opt_receiver_out) {
+  RegisterAllocationScope register_scope(this);
+  SuperPropertyArguments super_args;
+  PrepareNamedSuperPropertyArguments(
+      property->obj()->AsSuperPropertyReference(),
+      property->key()->AsLiteral()->AsPropertyName(), &super_args);
+  if (opt_receiver_out.is_valid()) {
+    builder()->MoveRegister(super_args.receiver(), opt_receiver_out);
+  }
+  BuildNamedSuperPropertyLoad(&super_args);
+}
+
+void BytecodeGenerator::VisitKeyedSuperPropertyLoad(Property* property,
+                                                    Register opt_receiver_out) {
+  RegisterAllocationScope register_scope(this);
+  SuperPropertyArguments super_args;
+  PrepareKeyedSuperPropertyArguments(
+      property->obj()->AsSuperPropertyReference(), property->key(),
+      &super_args);
+  if (opt_receiver_out.is_valid()) {
+    builder()->MoveRegister(super_args.receiver(), opt_receiver_out);
+  }
+  BuildKeyedSuperPropertyLoad(&super_args);
+}
 
 void BytecodeGenerator::VisitProperty(Property* expr) {
-  Register obj = VisitForRegisterValue(expr->obj());
-  VisitPropertyLoad(obj, expr);
+  LhsKind property_kind = Property::GetAssignType(expr);
+  if (property_kind != NAMED_SUPER_PROPERTY &&
+      property_kind != KEYED_SUPER_PROPERTY) {
+    Register obj = VisitForRegisterValue(expr->obj());
+    VisitPropertyLoad(obj, expr);
+  } else {
+    VisitPropertyLoad(Register::invalid_value(), expr);
+  }
 }
 
-
 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
   // the first argument.
   //
   // NB the caller may have already called
@@ skipping 12 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();
+
+  // Prepare the constructor to the super call.
+  Register this_function = register_allocator()->NewRegister();
+  VisitForAccumulatorValue(super->this_function_var());
+  builder()
+      ->StoreAccumulatorInRegister(this_function)
+      .CallRuntime(Runtime::kInlineGetSuperConstructor, this_function, 1);
+
+  Register constructor = this_function;  // Re-use dead this_function register.
+  builder()->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 133 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, key, old_value;
+  SuperPropertyArguments super_args;
   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: {
+      PrepareNamedSuperPropertyArguments(
+          property->obj()->AsSuperPropertyReference(),
+          property->key()->AsLiteral()->AsPropertyName(), &super_args);
+      BuildNamedSuperPropertyLoad(&super_args);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      PrepareKeyedSuperPropertyArguments(
+          property->obj()->AsSuperPropertyReference(), property->key(),
+          &super_args);
+      BuildKeyedSuperPropertyLoad(&super_args);
+      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: {
+      BuildNamedSuperPropertyStore(&super_args);
+      break;
+    }
+    case KEYED_SUPER_PROPERTY: {
+      BuildKeyedSuperPropertyStore(&super_args);
+      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