[async-functions] support await expressions in finally statements

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/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-stubs.h"
@@ skipping 583 matching lines @@
       function_literals_(0, info->zone()),
       native_function_literals_(0, info->zone()),
       object_literals_(0, info->zone()),
       array_literals_(0, info->zone()),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       generator_resume_points_(info->literal()->yield_count(), info->zone()),
       generator_state_(),
       loop_depth_(0),
+      catch_prediction_(HandlerTable::UNCAUGHT),
       home_object_symbol_(info->isolate()->factory()->home_object_symbol()),
       iterator_symbol_(info->isolate()->factory()->iterator_symbol()),
       prototype_string_(info->isolate()->factory()->prototype_string()),
       empty_fixed_array_(info->isolate()->factory()->empty_fixed_array()),
       undefined_string_(
           info->isolate()->ast_string_constants()->undefined_string()) {}
 
 Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(Isolate* isolate) {
   AllocateDeferredConstants(isolate);
   if (HasStackOverflow()) return Handle<BytecodeArray>();
@@ skipping 59 matching lines @@
 
   InitializeAstVisitor(stack_limit);
 
   // Initialize the incoming context.
   ContextScope incoming_context(this, scope(), false);
 
   // Initialize control scope.
   ControlScopeForTopLevel control(this);
 
   RegisterAllocationScope register_scope(this);
-
-  if (IsResumableFunction(info()->literal()->kind())) {
+  if (IsResumableFunction(info()->literal()->kind()) ||
+      scope()->is_module_scope()) {
+    generator_object_ = register_allocator()->NewRegister();
     generator_state_ = register_allocator()->NewRegister();
+    if (IsAsyncFunction(info()->literal()->kind())) {
+      promise_ = register_allocator()->NewRegister();
+    }
     VisitGeneratorPrologue();
   }
 
   if (scope()->NeedsContext()) {
     // Push a new inner context scope for the function.
     BuildNewLocalActivationContext();
     ContextScope local_function_context(this, scope(), false);
     BuildLocalActivationContextInitialization();
     GenerateBytecodeBody();
   } else {
@@ skipping 11 matching lines @@
   // Emit an implicit return instruction in case control flow can fall off the
   // end of the function without an explicit return being present on all paths.
   if (builder()->RequiresImplicitReturn()) {
     builder()->LoadUndefined();
     BuildReturn();
   }
   DCHECK(!builder()->RequiresImplicitReturn());
 }
 
 void BytecodeGenerator::GenerateBytecodeBody() {
+  const bool kIsModule = scope()->is_module_scope();
+  const bool kIsGeneratorFunction =
+      IsGeneratorFunction(info()->literal()->kind());
+  const bool kIsResumableFunction =
+      IsResumableFunction(info()->literal()->kind());
+
   // Build the arguments object if it is used.
   VisitArgumentsObject(scope()->arguments());
 
   // Build rest arguments array if it is used.
   Variable* rest_parameter = scope()->rest_parameter();
   VisitRestArgumentsArray(rest_parameter);
 
   // Build assignment to {.this_function} variable if it is used.
   VisitThisFunctionVariable(scope()->this_function_var());
 
   // Build assignment to {new.target} variable if it is used.
   VisitNewTargetVariable(scope()->new_target_var());
 
   // Emit tracing call if requested to do so.
   if (FLAG_trace) builder()->CallRuntime(Runtime::kTraceEnter);
 
   // Visit declarations within the function scope.
   VisitDeclarations(scope()->declarations());
 
   // Emit initializing assignments for module namespace imports (if any).
   VisitModuleNamespaceImports();
 
   // Perform a stack-check before the body.
   builder()->StackCheck(info()->literal()->start_position());
 
+  // Build assignment to variable <function name> if function is a named
+  // expression and the variable is used.
+  if (info()->literal()->is_named_expression()) {
+    Variable* function_var = scope()->function_var();
+    if (function_var != nullptr && !function_var->IsUnallocated()) {
+      builder()->LoadAccumulatorWithRegister(Register::function_closure());
+      BuildVariableAssignment(function_var, Token::INIT,
+                              FeedbackVectorSlot::Invalid(),
+                              HoleCheckMode::kElided);
+    }
+  }
+
+  Block* parameter_init_block = info()->literal()->parameter_init_block();
+
+  if (kIsResumableFunction || kIsModule) {
+    if (kIsResumableFunction) {
+      // No need to store `undefined` in the generator register for Modules,
+      // as there is no finally block.
+      builder()->LoadUndefined().StoreAccumulatorInRegister(generator_object_);
+    }
+
+    auto try_block = [=]() {
+      // Try ...
+      if (parameter_init_block != nullptr) {
+        // Initialize non-simple parameters before initial yield.
+        VisitBlock(parameter_init_block);
+      }
+      // Allocate generator object
+      RegisterAllocationScope register_scope(this);
+      RegisterList args = register_allocator()->NewRegisterList(2);
+      builder()->MoveRegister(Register::function_closure(), args[0]);
+
+      int yield_position = info()->literal()->position();
+      builder()->SetExpressionPosition(yield_position);
+
+      if (IsArrowFunction(info()->literal()->kind())) {
+        builder()->LoadUndefined().StoreAccumulatorInRegister(args[1]);
+      } else {
+        builder()->MoveRegister(builder()->Receiver(), args[1]);
+      }
+      builder()
+          ->CallRuntime(Runtime::kCreateJSGeneratorObject, args)
+          .StoreAccumulatorInRegister(generator_object_);
+
+      if (kIsGeneratorFunction || kIsModule) {
+        BuildYield(0, Yield::kOnExceptionThrow, Yield::kNormal,
+                   generator_object_, yield_position);
+      }
+      VisitStatements(info()->literal()->body());
+
+      if (builder()->RequiresImplicitReturn()) {
+        if (IsGeneratorFunction(info()->literal()->kind())) {
+          // Add implicit `return { value: undefined, done: true }`
+          builder()
+              ->LoadUndefined()
+              .StoreAccumulatorInRegister(args[0])
+              .LoadTrue()
+              .StoreAccumulatorInRegister(args[1])
+              .CallRuntime(Runtime::kInlineCreateIterResultObject, args);
+          execution_control()->ReturnAccumulator();
+        }
+      }
+    };
+
+    auto catch_block = [=](Register context) {
+      // Catch ...
+      if (IsAsyncFunction(info()->literal()->kind())) {
+        RegisterAllocationScope register_scope(this);
+        RegisterList args = register_allocator()->NewRegisterList(4);
+        Register exception = args[2];
+
+        builder()
+            ->StoreAccumulatorInRegister(exception)
+            .LoadTheHole()
+            .SetPendingMessage()
+            .LoadUndefined()
+            .StoreAccumulatorInRegister(args[0])
+            .MoveRegister(promise_, args[1])
+            .LoadFalse()
+            .StoreAccumulatorInRegister(args[3])
+            .CallJSRuntime(Context::PROMISE_INTERNAL_REJECT_INDEX, args)
+            .LoadAccumulatorWithRegister(promise_)
+            .Return();  // No need to close the generator for async functions
+      }
+    };
+
+    auto finally_block = [=]() {
+      // Finally ...
+      if (kIsGeneratorFunction) {
+        BytecodeLabel if_generatorundefined;
+        builder()->LoadAccumulatorWithRegister(generator_object_);
+        builder()->JumpIfUndefined(&if_generatorundefined);
+        builder()->CallRuntime(Runtime::kInlineGeneratorClose,
+                               generator_object_);
+        builder()->Bind(&if_generatorundefined);
+      }
+    };
+
+    const bool kNeedsTryCatch = IsAsyncFunction(info()->literal()->kind());
+    if (kNeedsTryCatch) {
+      // Currently, only async functions need a special behaviour for top-level
+      // exceptions
+      HandlerTable::CatchPrediction catch_prediction =
+          HandlerTable::ASYNC_AWAIT;
+      BuildTryCatchFinally(HandlerTable::UNCAUGHT, catch_prediction, try_block,
+                           catch_block, finally_block);
+    } else if (kIsGeneratorFunction) {
+      BuildTryFinally(HandlerTable::UNCAUGHT, try_block, finally_block);
+    } else {
+      DCHECK(kIsModule);
+      try_block();
+    }
+    return;
+  }
+
   // Visit statements in the function body.
+  if (parameter_init_block != nullptr) {
+    VisitBlock(parameter_init_block);
+  }
   VisitStatements(info()->literal()->body());
 }
 
 void BytecodeGenerator::BuildIndexedJump(Register index, size_t start_index,
                                          size_t size,
                                          ZoneVector<BytecodeLabel>& targets) {
   // TODO(neis): Optimize this by using a proper jump table.
   DCHECK_LE(start_index + size, targets.size());
   for (size_t i = start_index; i < start_index + size; i++) {
     builder()
@@ skipping 59 matching lines @@
       .PushContext(dummy)
       .ResumeGenerator(generator_object)
       .StoreAccumulatorInRegister(generator_state_);
   BuildIndexedJump(generator_state_, 0, generator_resume_points_.size(),
                    generator_resume_points_);
 
   builder()
       ->Bind(&regular_call)
       .LoadLiteral(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting))
       .StoreAccumulatorInRegister(generator_state_);
+
+  if (IsAsyncFunction(info()->literal()->kind())) {
+    // Create initial async function promise
+    RegisterAllocationScope register_scope(this);
+    RegisterList args = register_allocator()->NewRegisterList(1);
+    builder()
+        ->LoadUndefined()
+        .StoreAccumulatorInRegister(args[0])
+        .CallJSRuntime(Context::ASYNC_FUNCTION_PROMISE_CREATE_INDEX, args)
+        .StoreAccumulatorInRegister(promise_);
+  }
+
   // This is a regular call. Fall through to the ordinary function prologue,
   // after which we will run into the generator object creation and other extra
   // code inserted by the parser.
 }
 
 void BytecodeGenerator::VisitBlock(Block* stmt) {
   // Visit declarations and statements.
   if (stmt->scope() != nullptr && stmt->scope()->NeedsContext()) {
     BuildNewLocalBlockContext(stmt->scope());
     ContextScope scope(this, stmt->scope());
@@ skipping 495 matching lines @@
   VisitForEffect(stmt->next_result());
   VisitForAccumulatorValue(stmt->result_done());
   loop_builder.BreakIfTrue();
 
   VisitForEffect(stmt->assign_each());
   VisitIterationBody(stmt, &loop_builder);
   loop_builder.JumpToHeader(loop_depth_);
   loop_builder.EndLoop();
 }
 
-void BytecodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
-  TryCatchBuilder try_control_builder(builder(), stmt->catch_prediction());
+void BytecodeGenerator::BuildTryCatch(
+    HandlerTable::CatchPrediction catch_prediction,
+    std::function<void()> build_try,
+    std::function<void(Register)> build_catch) {
+  TryCatchBuilder try_control_builder(builder(), catch_prediction);
 
   // Preserve the context in a dedicated register, so that it can be restored
   // when the handler is entered by the stack-unwinding machinery.
   // TODO(mstarzinger): Be smarter about register allocation.
   Register context = register_allocator()->NewRegister();
   builder()->MoveRegister(Register::current_context(), context);
 
   // Evaluate the try-block inside a control scope. This simulates a handler
   // that is intercepting 'throw' control commands.
   try_control_builder.BeginTry(context);
   {
     ControlScopeForTryCatch scope(this, &try_control_builder);
-    Visit(stmt->try_block());
+    ScopedAssignment<HandlerTable::CatchPrediction> prediction(
+        catch_prediction_, catch_prediction);
+    build_try();
   }
   try_control_builder.EndTry();
 
-  // Create a catch scope that binds the exception.
-  BuildNewLocalCatchContext(stmt->variable(), stmt->scope());
-  builder()->StoreAccumulatorInRegister(context);
-
-  // If requested, clear message object as we enter the catch block.
-  if (stmt->clear_pending_message()) {
-    builder()->LoadTheHole().SetPendingMessage();
-  }
-
-  // Load the catch context into the accumulator.
-  builder()->LoadAccumulatorWithRegister(context);
-
   // Evaluate the catch-block.
-  VisitInScope(stmt->catch_block(), stmt->scope());
+  build_catch(context);
   try_control_builder.EndCatch();
 }
 
-void BytecodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
-  TryFinallyBuilder try_control_builder(builder(), stmt->catch_prediction());
+void BytecodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
+  BuildTryCatch(stmt->catch_prediction(), [=]() { Visit(stmt->try_block()); },
+                [=](Register context) {
+                  // Create a catch scope that binds the exception.
+                  BuildNewLocalCatchContext(stmt->variable(), stmt->scope());
+                  builder()->StoreAccumulatorInRegister(context);
+
+                  // If requested, clear message object as we enter the catch
+                  // block.
+                  if (stmt->clear_pending_message()) {
+                    builder()->LoadTheHole().SetPendingMessage();
+                  }
+
+                  // Load the catch context into the accumulator.
+                  builder()->LoadAccumulatorWithRegister(context);
+
+                  VisitInScope(stmt->catch_block(), stmt->scope());
+                });
+}
+
+void BytecodeGenerator::BuildTryFinally(
+    HandlerTable::CatchPrediction catch_prediction,
+    std::function<void()> build_try, std::function<void()> build_finally) {
+  TryFinallyBuilder try_control_builder(builder(), catch_prediction);
 
   // We keep a record of all paths that enter the finally-block to be able to
   // dispatch to the correct continuation point after the statements in the
   // finally-block have been evaluated.
   //
   // The try-finally construct can enter the finally-block in three ways:
   // 1. By exiting the try-block normally, falling through at the end.
   // 2. By exiting the try-block with a function-local control flow transfer
   //    (i.e. through break/continue/return statements).
   // 3. By exiting the try-block with a thrown exception.
@@ skipping 11 matching lines @@
   // when the handler is entered by the stack-unwinding machinery.
   // TODO(mstarzinger): Be smarter about register allocation.
   Register context = register_allocator()->NewRegister();
   builder()->MoveRegister(Register::current_context(), context);
 
   // Evaluate the try-block inside a control scope. This simulates a handler
   // that is intercepting all control commands.
   try_control_builder.BeginTry(context);
   {
     ControlScopeForTryFinally scope(this, &try_control_builder, &commands);
-    Visit(stmt->try_block());
+    build_try();
   }
   try_control_builder.EndTry();
 
   // Record fall-through and exception cases.
   commands.RecordFallThroughPath();
   try_control_builder.LeaveTry();
   try_control_builder.BeginHandler();
   commands.RecordHandlerReThrowPath();
 
   // Pending message object is saved on entry.
   try_control_builder.BeginFinally();
   Register message = context;  // Reuse register.
 
   // Clear message object as we enter the finally block.
   builder()->LoadTheHole().SetPendingMessage().StoreAccumulatorInRegister(
       message);
 
   // Evaluate the finally-block.
-  Visit(stmt->finally_block());
+  build_finally();
   try_control_builder.EndFinally();
 
   // Pending message object is restored on exit.
   builder()->LoadAccumulatorWithRegister(message).SetPendingMessage();
 
   // Dynamic dispatch after the finally-block.
   commands.ApplyDeferredCommands();
 }
 
+void BytecodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
+  BuildTryFinally(stmt->catch_prediction(), [=]() { Visit(stmt->try_block()); },
+                  [=]() { Visit(stmt->finally_block()); });
+}
+
+void BytecodeGenerator::BuildTryCatchFinally(
+    HandlerTable::CatchPrediction outer_catch_prediction,
+    HandlerTable::CatchPrediction inner_catch_prediction,
+    std::function<void()> build_try, std::function<void(Register)> build_catch,
+    std::function<void()> build_finally) {
+  BuildTryFinally(
+      outer_catch_prediction,
+      [=]() { BuildTryCatch(inner_catch_prediction, build_try, build_catch); },
+      build_finally);
+}
+
 void BytecodeGenerator::VisitDebuggerStatement(DebuggerStatement* stmt) {
   builder()->SetStatementPosition(stmt);
   builder()->Debugger();
 }
 
 void BytecodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   uint8_t flags = CreateClosureFlags::Encode(expr->pretenure(),
                                              scope()->is_function_scope());
   size_t entry = builder()->AllocateConstantPoolEntry();
   int slot_index = feedback_index(expr->LiteralFeedbackSlot());
@@ skipping 538 matching lines @@
 }
 
 void BytecodeGenerator::BuildVariableLoadForAccumulatorValue(
     Variable* variable, FeedbackVectorSlot slot, HoleCheckMode hole_check_mode,
     TypeofMode typeof_mode) {
   ValueResultScope accumulator_result(this);
   BuildVariableLoad(variable, slot, hole_check_mode, typeof_mode);
 }
 
 void BytecodeGenerator::BuildReturn() {
-  if (FLAG_trace) {
-    RegisterAllocationScope register_scope(this);
-    Register result = register_allocator()->NewRegister();
-    // Runtime returns {result} value, preserving accumulator.
-    builder()->StoreAccumulatorInRegister(result).CallRuntime(
-        Runtime::kTraceExit, result);
+  if (IsAsyncFunction(info()->literal()->kind())) {
+    RegisterList args = register_allocator()->NewRegisterList(3);
+    Register receiver = args[0];
+    Register promise = args[1];
+    Register return_value = args[2];
+
+    builder()
+        ->StoreAccumulatorInRegister(return_value)
+        .LoadUndefined()
+        .StoreAccumulatorInRegister(receiver)
+        .MoveRegister(promise_, promise)
+        .CallJSRuntime(Context::PROMISE_RESOLVE_INDEX, args)
+        .LoadAccumulatorWithRegister(promise);
   }
+
+  BuildTraceExit();
   builder()->Return();
 }
 
+void BytecodeGenerator::BuildTraceExit() {
+  if (!FLAG_trace) return;
+  RegisterAllocationScope register_scope(this);
+  Register result = register_allocator()->NewRegister();
+  // Runtime returns {result} value, preserving accumulator.
+  builder()->StoreAccumulatorInRegister(result).CallRuntime(Runtime::kTraceExit,
+                                                            result);
+}
+
 void BytecodeGenerator::BuildReThrow() { builder()->ReThrow(); }
 
 void BytecodeGenerator::BuildAbort(BailoutReason bailout_reason) {
   RegisterAllocationScope register_scope(this);
   Register reason = register_allocator()->NewRegister();
   builder()
       ->LoadLiteral(Smi::FromInt(static_cast<int>(bailout_reason)))
       .StoreAccumulatorInRegister(reason)
       .CallRuntime(Runtime::kAbort, reason);
 }
@@ skipping 266 matching lines @@
     }
     case KEYED_SUPER_PROPERTY: {
       builder()
           ->StoreAccumulatorInRegister(super_property_args[3])
           .CallRuntime(StoreKeyedToSuperRuntimeId(), super_property_args);
       break;
     }
   }
 }
 
-void BytecodeGenerator::VisitYield(Yield* expr) {
-  builder()->SetExpressionPosition(expr);
-  Register value = VisitForRegisterValue(expr->expression());
+void BytecodeGenerator::BuildYield(int yield_id,
+                                   Yield::OnException on_exception,
+                                   Yield::YieldType yield_type, Register value,
+                                   int position) {
+  DCHECK_GE(yield_id, 0);
+  DCHECK_LT(yield_id, generator_resume_points_.size());
 
-  Register generator = VisitForRegisterValue(expr->generator_object());
+  Register generator = generator_object_;
+  DCHECK(generator.is_valid());
 
-  // Save context, registers, and state. Then return.
-  builder()
-      ->LoadLiteral(Smi::FromInt(expr->yield_id()))
-      .SuspendGenerator(generator)
-      .LoadAccumulatorWithRegister(value)
-      .Return();  // Hard return (ignore any finally blocks).
+  if (IsAsyncFunction(info()->literal()->kind()) &&
+      yield_type == Yield::kAwait) {
+    RegisterAllocationScope register_scope(this);
+    RegisterList args = register_allocator()->NewRegisterList(4);
 
-  builder()->Bind(&(generator_resume_points_[expr->yield_id()]));
+    int context_index = Context::ASYNC_FUNCTION_AWAIT_CAUGHT_INDEX;
+    if (catch_prediction_ == HandlerTable::ASYNC_AWAIT)
+      context_index = Context::ASYNC_FUNCTION_AWAIT_UNCAUGHT_INDEX;
+
+    builder()
+        ->LoadUndefined()
+        .StoreAccumulatorInRegister(args[0])
+        .MoveRegister(generator, args[1])
+        .MoveRegister(value, args[2])
+        .MoveRegister(promise_, args[3])
+        .CallJSRuntime(context_index, args)
+        .LoadLiteral(Smi::FromInt(yield_id))
+        .SuspendGenerator(generator)
+        .LoadAccumulatorWithRegister(promise_)
+        .Return();  // Hard return (ignore any finally blocks)
+  } else {
+    // Save context, registers, and state. Then return.
+    builder()
+        ->LoadLiteral(Smi::FromInt(yield_id))
+        .SuspendGenerator(generator)
+        .LoadAccumulatorWithRegister(value)
+        .Return();  // Hard return (ignore any finally blocks).
+  }
+
+  builder()->Bind(&(generator_resume_points_[yield_id]));
   // Upon resume, we continue here.
 
   {
     RegisterAllocationScope register_scope(this);
 
     // Update state to indicate that we have finished resuming. Loop headers
     // rely on this.
     builder()
         ->LoadLiteral(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting))
         .StoreAccumulatorInRegister(generator_state_);
@@ skipping 28 matching lines @@
       RegisterList args = register_allocator()->NewRegisterList(2);
       builder()
           ->MoveRegister(input, args[0])
           .LoadTrue()
           .StoreAccumulatorInRegister(args[1])
           .CallRuntime(Runtime::kInlineCreateIterResultObject, args);
       execution_control()->ReturnAccumulator();
     }
 
     builder()->Bind(&resume_with_throw);
-    builder()->SetExpressionPosition(expr);
+    builder()->SetExpressionPosition(position);
     builder()->LoadAccumulatorWithRegister(input);
-    if (expr->rethrow_on_exception()) {
+    if (on_exception == Yield::kOnExceptionRethrow) {
       builder()->ReThrow();
     } else {
       builder()->Throw();
     }
 
     builder()->Bind(&resume_with_next);
     builder()->LoadAccumulatorWithRegister(input);
   }
 }
 
+void BytecodeGenerator::VisitYield(Yield* expr) {
+  builder()->SetExpressionPosition(expr);
+  Register value = VisitForRegisterValue(expr->expression());
+
+  BuildYield(expr->yield_id(), expr->on_exception(), expr->yield_type(), value,
+             expr->position());
+}
+
 void BytecodeGenerator::VisitThrow(Throw* expr) {
   VisitForAccumulatorValue(expr->exception());
   builder()->SetExpressionPosition(expr);
   builder()->Throw();
 }
 
 void BytecodeGenerator::VisitPropertyLoad(Register obj, Property* expr) {
   LhsKind property_kind = Property::GetAssignType(expr);
   FeedbackVectorSlot slot = expr->PropertyFeedbackSlot();
   builder()->SetExpressionPosition(expr);
@@ skipping 552 matching lines @@
   builder()->SetExpressionPosition(expr);
   builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
 }
 
 void BytecodeGenerator::VisitSpread(Spread* expr) { Visit(expr->expression()); }
 
 void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
   UNREACHABLE();
 }
 
+void BytecodeGenerator::VisitInternalVariable(InternalVariable* expr) {
+  switch (expr->type()) {
+    case InternalVariable::kGeneratorObject:
+      DCHECK(IsGeneratorFunction(info()->literal()->kind()));
+      builder()->LoadAccumulatorWithRegister(generator_object_);
+      return;
+
+    default:
+      break;
+  }
+
+  UNREACHABLE();
+}
+
 void BytecodeGenerator::VisitGetIterator(GetIterator* expr) {
   FeedbackVectorSlot load_slot = expr->IteratorPropertyFeedbackSlot();
   FeedbackVectorSlot call_slot = expr->IteratorCallFeedbackSlot();
 
   RegisterList args = register_allocator()->NewRegisterList(1);
   Register method = register_allocator()->NewRegister();
   Register obj = args[0];
 
   VisitForAccumulatorValue(expr->iterable());
 
@@ skipping 430 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8