Remove strong mode support from property loads.

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 1294 matching lines @@
   VisitClassLiteralForRuntimeDefinition(expr);
 
   // Load the "prototype" from the constructor.
   register_allocator()->PrepareForConsecutiveAllocations(2);
   Register literal = register_allocator()->NextConsecutiveRegister();
   Register prototype = register_allocator()->NextConsecutiveRegister();
   Handle<String> name = isolate()->factory()->prototype_string();
   FeedbackVectorSlot slot = expr->PrototypeSlot();
   builder()
       ->StoreAccumulatorInRegister(literal)
-      .LoadNamedProperty(literal, name, feedback_index(slot), language_mode())
+      .LoadNamedProperty(literal, name, feedback_index(slot))
       .StoreAccumulatorInRegister(prototype);
 
   VisitClassLiteralProperties(expr, literal, prototype);
   builder()->CallRuntime(Runtime::kFinalizeClassDefinition, literal, 2);
   // Assign to class variable.
   if (expr->class_variable_proxy() != nullptr) {
     Variable* var = expr->class_variable_proxy()->var();
     FeedbackVectorSlot slot = expr->NeedsProxySlot()
                                   ? expr->ProxySlot()
                                   : FeedbackVectorSlot::Invalid();
@@ skipping 448 matching lines @@
       // index -1 but is parameter index 0 in BytecodeArrayBuilder).
       Register source = builder()->Parameter(variable->index() + 1);
       builder()->LoadAccumulatorWithRegister(source);
       BuildHoleCheckForVariableLoad(mode, variable->name());
       execution_result()->SetResultInAccumulator();
       break;
     }
     case VariableLocation::GLOBAL:
     case VariableLocation::UNALLOCATED: {
       builder()->LoadGlobal(variable->name(), feedback_index(slot),
-                            language_mode(), typeof_mode);
+                            typeof_mode);
       execution_result()->SetResultInAccumulator();
       break;
     }
     case VariableLocation::CONTEXT: {
       int depth = execution_context()->ContextChainDepth(variable->scope());
       ContextScope* context = execution_context()->Previous(depth);
       Register context_reg;
       if (context) {
         context_reg = context->reg();
       } else {
@@ skipping 62 matching lines @@
   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());
+  // 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) {
-  builder()
-      ->LoadLiteral(Smi::FromInt(static_cast<int>(language_mode())))
-      .StoreAccumulatorInRegister(super_args->language_mode());
+  // TODO(oth): Abstraction not suitable for 3 args, will over-allocate regs.
   builder()->CallRuntime(Runtime::kLoadKeyedFromSuper, super_args->receiver(),
-                         super_args->count());
+                         3);
 }
 
 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());
@@ skipping 270 matching lines @@
       case VARIABLE: {
         VariableProxy* proxy = expr->target()->AsVariableProxy();
         old_value = VisitVariableLoadForRegisterValue(
             proxy->var(), proxy->VariableFeedbackSlot());
         break;
       }
       case NAMED_PROPERTY: {
         FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
         old_value = register_allocator()->NewRegister();
         builder()
-            ->LoadNamedProperty(object, name, feedback_index(slot),
-                                language_mode())
+            ->LoadNamedProperty(object, name, feedback_index(slot))
             .StoreAccumulatorInRegister(old_value);
         break;
       }
       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())
+            ->LoadKeyedProperty(object, feedback_index(slot))
             .StoreAccumulatorInRegister(old_value);
         break;
       }
       case NAMED_SUPER_PROPERTY: {
         old_value = register_allocator()->NewRegister();
         BuildNamedSuperPropertyLoad(&super_args);
         builder()->StoreAccumulatorInRegister(old_value);
         break;
       }
       case KEYED_SUPER_PROPERTY: {
@@ skipping 56 matching lines @@
 
 void BytecodeGenerator::VisitPropertyLoad(Register obj, Property* expr) {
   LhsKind property_kind = Property::GetAssignType(expr);
   FeedbackVectorSlot slot = expr->PropertyFeedbackSlot();
   switch (property_kind) {
     case VARIABLE:
       UNREACHABLE();
     case NAMED_PROPERTY: {
       builder()->LoadNamedProperty(obj,
                                    expr->key()->AsLiteral()->AsPropertyName(),
-                                   feedback_index(slot), language_mode());
+                                   feedback_index(slot));
       break;
     }
     case KEYED_PROPERTY: {
       VisitForAccumulatorValue(expr->key());
-      builder()->LoadKeyedProperty(obj, feedback_index(slot), language_mode());
+      builder()->LoadKeyedProperty(obj, feedback_index(slot));
       break;
     }
     case NAMED_SUPER_PROPERTY:
       VisitNamedSuperPropertyLoad(expr, Register::invalid_value());
       break;
     case KEYED_SUPER_PROPERTY:
       VisitKeyedSuperPropertyLoad(expr, Register::invalid_value());
       break;
   }
   execution_result()->SetResultInAccumulator();
@@ skipping 398 matching lines @@
     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),
-                                   language_mode());
+      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), language_mode());
+          object, feedback_index(slot));
       break;
     }
     case NAMED_SUPER_PROPERTY: {
       PrepareNamedSuperPropertyArguments(
           property->obj()->AsSuperPropertyReference(),
           property->key()->AsLiteral()->AsPropertyName(), &super_args);
       BuildNamedSuperPropertyLoad(&super_args);
       break;
     }
     case KEYED_SUPER_PROPERTY: {
@@ skipping 412 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8