Only treat possible eval calls going through 'with' as special.

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/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 2338 matching lines @@
                                        size_t first_argument_register) {
   // Visit arguments.
   for (int i = 0; i < static_cast<int>(args->length()); i++) {
     VisitForRegisterValue(args->at(i), arg_regs[first_argument_register + i]);
   }
 }
 
 void BytecodeGenerator::VisitCall(Call* expr) {
   Expression* callee_expr = expr->expression();
   Call::CallType call_type = expr->GetCallType();
+  bool possibly_eval = call_type == Call::POSSIBLY_EVAL_THROUGH_WITH_CALL ||
+                       call_type == Call::POSSIBLY_EVAL_CALL;
 
   if (call_type == Call::SUPER_CALL) {
     return VisitCallSuper(expr);
   }
 
   Register callee = register_allocator()->NewRegister();
 
   // Add an argument register for the receiver.
   RegisterList args =
       register_allocator()->NewRegisterList(expr->arguments()->length() + 1);
@@ skipping 16 matching lines @@
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       // Load callee as a global variable.
       VariableProxy* proxy = callee_expr->AsVariableProxy();
       BuildVariableLoadForAccumulatorValue(proxy->var(),
                                            proxy->VariableFeedbackSlot(),
                                            proxy->hole_check_mode());
       builder()->StoreAccumulatorInRegister(callee);
       break;
     }
     case Call::WITH_CALL:
-    case Call::POSSIBLY_EVAL_CALL: {
-      if (callee_expr->AsVariableProxy()->var()->IsLookupSlot()) {
-        RegisterAllocationScope inner_register_scope(this);
-        Register name = register_allocator()->NewRegister();
+    case Call::POSSIBLY_EVAL_THROUGH_WITH_CALL: {
+      DCHECK(callee_expr->AsVariableProxy()->var()->IsLookupSlot());
+      RegisterAllocationScope inner_register_scope(this);
+      Register name = register_allocator()->NewRegister();
 
-        // Call %LoadLookupSlotForCall to get the callee and receiver.
-        DCHECK(Register::AreContiguous(callee, receiver));
-        RegisterList result_pair(callee.index(), 2);
-        Variable* variable = callee_expr->AsVariableProxy()->var();
-        builder()
-            ->LoadLiteral(variable->name())
-            .StoreAccumulatorInRegister(name)
-            .CallRuntimeForPair(Runtime::kLoadLookupSlotForCall, name,
-                                result_pair);
-        break;
-      }
-      // Fall through.
-      DCHECK_EQ(call_type, Call::POSSIBLY_EVAL_CALL);
+      // Call %LoadLookupSlotForCall to get the callee and receiver.
+      DCHECK(Register::AreContiguous(callee, receiver));
+      RegisterList result_pair(callee.index(), 2);
+      Variable* variable = callee_expr->AsVariableProxy()->var();
+      builder()
+          ->LoadLiteral(variable->name())
+          .StoreAccumulatorInRegister(name)
+          .CallRuntimeForPair(Runtime::kLoadLookupSlotForCall, name,
+                              result_pair);
+      break;
     }
+    case Call::POSSIBLY_EVAL_CALL:
     case Call::OTHER_CALL: {
       builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
       VisitForRegisterValue(callee_expr, callee);
       break;
     }
     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:
       UNREACHABLE();
       break;
   }
 
   // Evaluate all arguments to the function call and store in sequential args
   // registers.
   VisitArguments(expr->arguments(), args, 1);
 
   // Resolve callee for a potential direct eval call. This block will mutate the
   // callee value.
-  if (call_type == Call::POSSIBLY_EVAL_CALL &&
-      expr->arguments()->length() > 0) {
+  if (possibly_eval && expr->arguments()->length() > 0) {
     RegisterAllocationScope inner_register_scope(this);
     // Set up arguments for ResolvePossiblyDirectEval by copying callee, source
     // strings and function closure, and loading language and
     // position.
     RegisterList runtime_call_args = register_allocator()->NewRegisterList(6);
     builder()
         ->MoveRegister(callee, runtime_call_args[0])
         .MoveRegister(args[1], runtime_call_args[1])
         .MoveRegister(Register::function_closure(), runtime_call_args[2])
         .LoadLiteral(Smi::FromInt(language_mode()))
@@ skipping 738 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8