[interpreter] Clean super property handling.

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 399 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 {
- 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),
@@ skipping 487 matching lines @@
       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: {
       RegisterAllocationScope register_scope(this);
-      SuperPropertyArguments super_args;
-      Register value = register_allocator()->NewRegister();
+      register_allocator()->PrepareForConsecutiveAllocations(4);
+      Register receiver = register_allocator()->NextConsecutiveRegister();
+      Register home_object = register_allocator()->NextConsecutiveRegister();
+      Register name = register_allocator()->NextConsecutiveRegister();
+      Register value = register_allocator()->NextConsecutiveRegister();
       builder()->StoreAccumulatorInRegister(value);
-      PrepareNamedSuperPropertyArguments(
-          property->obj()->AsSuperPropertyReference(),
-          property->key()->AsLiteral()->AsPropertyName(), &super_args);
-      builder()->LoadAccumulatorWithRegister(value);
-      BuildNamedSuperPropertyStore(&super_args);
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      VisitForRegisterValue(super_property->this_var(), receiver);
+      VisitForRegisterValue(super_property->home_object(), home_object);
+      builder()
+          ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+          .StoreAccumulatorInRegister(name);
+      BuildNamedSuperPropertyStore(receiver, home_object, name, value);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
       RegisterAllocationScope register_scope(this);
-      SuperPropertyArguments super_args;
-      Register value = register_allocator()->NewRegister();
+      register_allocator()->PrepareForConsecutiveAllocations(4);
+      Register receiver = register_allocator()->NextConsecutiveRegister();
+      Register home_object = register_allocator()->NextConsecutiveRegister();
+      Register key = register_allocator()->NextConsecutiveRegister();
+      Register value = register_allocator()->NextConsecutiveRegister();
       builder()->StoreAccumulatorInRegister(value);
-      PrepareKeyedSuperPropertyArguments(
-          property->obj()->AsSuperPropertyReference(), property->key(),
-          &super_args);
-      builder()->LoadAccumulatorWithRegister(value);
-      BuildKeyedSuperPropertyStore(&super_args);
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      VisitForRegisterValue(super_property->this_var(), receiver);
+      VisitForRegisterValue(super_property->home_object(), home_object);
+      VisitForRegisterValue(property->key(), key);
+      BuildKeyedSuperPropertyStore(receiver, home_object, key, value);
       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.
@@ skipping 720 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::BuildNamedSuperPropertyLoad(Register receiver,
+                                                    Register home_object,
+                                                    Register name) {
+  DCHECK(Register::AreContiguous(receiver, home_object, name));
+  builder()->CallRuntime(Runtime::kLoadFromSuper, receiver, 3);
 }
 
-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::BuildKeyedSuperPropertyLoad(Register receiver,
+                                                    Register home_object,
+                                                    Register key) {
+  DCHECK(Register::AreContiguous(receiver, home_object, key));
+  builder()->CallRuntime(Runtime::kLoadKeyedFromSuper, receiver, 3);
 }
 
-void BytecodeGenerator::BuildNamedSuperPropertyLoad(
-    SuperPropertyArguments* super_args) {
-  // TODO(oth): Abstraction not suitable for 3 args, will over-allocate regs.
-  builder()->CallRuntime(Runtime::kLoadFromSuper, super_args->receiver(), 3);
-}
-
-void BytecodeGenerator::BuildKeyedSuperPropertyLoad(
-    SuperPropertyArguments* super_args) {
-  // TODO(oth): Abstraction not suitable for 3 args, will over-allocate regs.
-  builder()->CallRuntime(Runtime::kLoadKeyedFromSuper, super_args->receiver(),
-                         3);
-}
-
-void BytecodeGenerator::BuildNamedSuperPropertyStore(
-    SuperPropertyArguments* super_args) {
-  builder()->StoreAccumulatorInRegister(super_args->store_value());
+void BytecodeGenerator::BuildNamedSuperPropertyStore(Register receiver,
+                                                     Register home_object,
+                                                     Register name,
+                                                     Register value) {
+  DCHECK(Register::AreContiguous(receiver, home_object, name, 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());
+  builder()->CallRuntime(function_id, receiver, 4);
 }
 
-void BytecodeGenerator::BuildKeyedSuperPropertyStore(
-    SuperPropertyArguments* super_args) {
-  builder()->StoreAccumulatorInRegister(super_args->store_value());
+void BytecodeGenerator::BuildKeyedSuperPropertyStore(Register receiver,
+                                                     Register home_object,
+                                                     Register key,
+                                                     Register value) {
+  DCHECK(Register::AreContiguous(receiver, home_object, key, 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());
+  builder()->CallRuntime(function_id, receiver, 4);
 }
 
 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) {
@@ skipping 190 matching lines @@
         builder()->StoreLookupSlot(variable->name(), language_mode());
       }
       break;
     }
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
   DCHECK(expr->target()->IsValidReferenceExpressionOrThis());
-  Register object, key;
-  SuperPropertyArguments super_args;
+  Register object, key, home_object, value;
   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.
@@ skipping 10 matching lines @@
         // 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: {
-      PrepareNamedSuperPropertyArguments(
-          property->obj()->AsSuperPropertyReference(),
-          property->key()->AsLiteral()->AsPropertyName(), &super_args);
+      register_allocator()->PrepareForConsecutiveAllocations(4);
+      object = register_allocator()->NextConsecutiveRegister();
+      home_object = register_allocator()->NextConsecutiveRegister();
+      key = register_allocator()->NextConsecutiveRegister();
+      value = register_allocator()->NextConsecutiveRegister();
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      VisitForRegisterValue(super_property->this_var(), object);
+      VisitForRegisterValue(super_property->home_object(), home_object);
+      builder()
+          ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+          .StoreAccumulatorInRegister(key);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
-      PrepareKeyedSuperPropertyArguments(
-          property->obj()->AsSuperPropertyReference(), property->key(),
-          &super_args);
+      register_allocator()->PrepareForConsecutiveAllocations(4);
+      object = register_allocator()->NextConsecutiveRegister();
+      home_object = register_allocator()->NextConsecutiveRegister();
+      key = register_allocator()->NextConsecutiveRegister();
+      value = register_allocator()->NextConsecutiveRegister();
+      builder()->StoreAccumulatorInRegister(value);
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      VisitForRegisterValue(super_property->this_var(), object);
+      VisitForRegisterValue(super_property->home_object(), home_object);
+      VisitForRegisterValue(property->key(), 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: {
@@ skipping 15 matching lines @@
         // LHS above.
         FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
         old_value = register_allocator()->NewRegister();
         builder()
             ->LoadKeyedProperty(object, feedback_index(slot))
             .StoreAccumulatorInRegister(old_value);
         break;
       }
       case NAMED_SUPER_PROPERTY: {
         old_value = register_allocator()->NewRegister();
-        BuildNamedSuperPropertyLoad(&super_args);
+        BuildNamedSuperPropertyLoad(object, home_object, key);
         builder()->StoreAccumulatorInRegister(old_value);
         break;
       }
       case KEYED_SUPER_PROPERTY: {
         old_value = register_allocator()->NewRegister();
-        BuildKeyedSuperPropertyLoad(&super_args);
+        BuildKeyedSuperPropertyLoad(object, home_object, key);
         builder()->StoreAccumulatorInRegister(old_value);
         break;
       }
     }
     VisitForAccumulatorValue(expr->value());
     builder()->BinaryOperation(expr->binary_op(), old_value);
   } 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: {
-      BuildNamedSuperPropertyStore(&super_args);
+      builder()->StoreAccumulatorInRegister(value);
+      BuildNamedSuperPropertyStore(object, home_object, key, value);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
-      BuildKeyedSuperPropertyStore(&super_args);
+      builder()->StoreAccumulatorInRegister(value);
+      BuildKeyedSuperPropertyStore(object, home_object, key, value);
       break;
     }
   }
   execution_result()->SetResultInAccumulator();
 }
 
 
 void BytecodeGenerator::VisitYield(Yield* expr) { UNIMPLEMENTED(); }
 
 
@@ skipping 37 matching lines @@
 
 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);
+  register_allocator()->PrepareForConsecutiveAllocations(3);
+
+  Register receiver, home_object, name;
+  receiver = register_allocator()->NextConsecutiveRegister();
+  home_object = register_allocator()->NextConsecutiveRegister();
+  name = register_allocator()->NextConsecutiveRegister();
+  SuperPropertyReference* super_property =
+      property->obj()->AsSuperPropertyReference();
+  VisitForRegisterValue(super_property->this_var(), receiver);
+  VisitForRegisterValue(super_property->home_object(), home_object);
+  builder()
+      ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+      .StoreAccumulatorInRegister(name);
+  BuildNamedSuperPropertyLoad(receiver, home_object, name);
+
   if (opt_receiver_out.is_valid()) {
-    builder()->MoveRegister(super_args.receiver(), opt_receiver_out);
+    builder()->MoveRegister(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);
+  register_allocator()->PrepareForConsecutiveAllocations(3);
+
+  Register receiver, home_object, key;
+  receiver = register_allocator()->NextConsecutiveRegister();
+  home_object = register_allocator()->NextConsecutiveRegister();
+  key = register_allocator()->NextConsecutiveRegister();
+  SuperPropertyReference* super_property =
+      property->obj()->AsSuperPropertyReference();
+  VisitForRegisterValue(super_property->this_var(), receiver);
+  VisitForRegisterValue(super_property->home_object(), home_object);
+  VisitForRegisterValue(property->key(), key);
+  BuildKeyedSuperPropertyLoad(receiver, home_object, key);
+
   if (opt_receiver_out.is_valid()) {
-    builder()->MoveRegister(super_args.receiver(), opt_receiver_out);
+    builder()->MoveRegister(receiver, opt_receiver_out);
   }
-  BuildKeyedSuperPropertyLoad(&super_args);
 }
 
 void BytecodeGenerator::VisitProperty(Property* 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);
@@ skipping 343 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 object, key, old_value;
-  SuperPropertyArguments super_args;
+  Register object, home_object, key, old_value, 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();
       object = VisitForRegisterValue(property->obj());
       name = property->key()->AsLiteral()->AsPropertyName();
       builder()->LoadNamedProperty(object, name, feedback_index(slot));
       break;
     }
     case KEYED_PROPERTY: {
       FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
       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(
           object, feedback_index(slot));
       break;
     }
     case NAMED_SUPER_PROPERTY: {
-      PrepareNamedSuperPropertyArguments(
-          property->obj()->AsSuperPropertyReference(),
-          property->key()->AsLiteral()->AsPropertyName(), &super_args);
-      BuildNamedSuperPropertyLoad(&super_args);
+      register_allocator()->PrepareForConsecutiveAllocations(4);
+      object = register_allocator()->NextConsecutiveRegister();
+      home_object = register_allocator()->NextConsecutiveRegister();
+      key = register_allocator()->NextConsecutiveRegister();
+      value = register_allocator()->NextConsecutiveRegister();
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      VisitForRegisterValue(super_property->this_var(), object);
+      VisitForRegisterValue(super_property->home_object(), home_object);
+      builder()
+          ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+          .StoreAccumulatorInRegister(key);
+      BuildNamedSuperPropertyLoad(object, home_object, key);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
-      PrepareKeyedSuperPropertyArguments(
-          property->obj()->AsSuperPropertyReference(), property->key(),
-          &super_args);
-      BuildKeyedSuperPropertyLoad(&super_args);
+      register_allocator()->PrepareForConsecutiveAllocations(4);
+      object = register_allocator()->NextConsecutiveRegister();
+      home_object = register_allocator()->NextConsecutiveRegister();
+      key = register_allocator()->NextConsecutiveRegister();
+      value = register_allocator()->NextConsecutiveRegister();
+      builder()->StoreAccumulatorInRegister(value);
+      SuperPropertyReference* super_property =
+          property->obj()->AsSuperPropertyReference();
+      VisitForRegisterValue(super_property->this_var(), object);
+      VisitForRegisterValue(super_property->home_object(), home_object);
+      VisitForRegisterValue(property->key(), key);
+      BuildKeyedSuperPropertyLoad(object, home_object, key);
       break;
     }
   }
 
   // Convert old value into a number.
   if (!is_strong(language_mode())) {
     builder()->CastAccumulatorToNumber();
   }
 
   // Save result for postfix expressions.
@@ skipping 17 matching lines @@
       builder()->StoreNamedProperty(object, name, feedback_index(feedback_slot),
                                     language_mode());
       break;
     }
     case KEYED_PROPERTY: {
       builder()->StoreKeyedProperty(object, key, feedback_index(feedback_slot),
                                     language_mode());
       break;
     }
     case NAMED_SUPER_PROPERTY: {
-      BuildNamedSuperPropertyStore(&super_args);
+      builder()->StoreAccumulatorInRegister(value);
+      BuildNamedSuperPropertyStore(object, home_object, key, value);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
-      BuildKeyedSuperPropertyStore(&super_args);
+      builder()->StoreAccumulatorInRegister(value);
+      BuildKeyedSuperPropertyStore(object, home_object, key, value);
       break;
     }
   }
 
   // Restore old value for postfix expressions.
   if (is_postfix) {
     execution_result()->SetResultInRegister(old_value);
   } else {
     execution_result()->SetResultInAccumulator();
   }
@@ skipping 335 matching lines @@
 
 
 // Visits the expression |expr| and returns the register containing
 // the expression result.
 Register BytecodeGenerator::VisitForRegisterValue(Expression* expr) {
   RegisterResultScope register_scope(this);
   Visit(expr);
   return register_scope.ResultRegister();
 }
 
+// Visits the expression |expr| and stores the expression result in
+// |destination|.
+void BytecodeGenerator::VisitForRegisterValue(Expression* expr,
+                                              Register destination) {
+  AccumulatorResultScope register_scope(this);
+  Visit(expr);
+  builder()->StoreAccumulatorInRegister(destination);
+}
 
 void BytecodeGenerator::VisitInScope(Statement* stmt, Scope* scope) {
   ContextScope context_scope(this, scope);
   DCHECK(scope->declarations()->is_empty());
   Visit(stmt);
 }
 
 
 LanguageMode BytecodeGenerator::language_mode() const {
   return info()->language_mode();
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8