[Interpreter]: Add support for strict mode load / store ICs.

src/interpreter/bytecode-array-builder.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-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 109 matching lines @@
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 0);
   last_bytecode_start_ = bytecodes()->size();
   bytecodes()->push_back(Bytecodes::ToByte(bytecode));
 }
 
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op,
-                                                            Register reg) {
+BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(
+    Token::Value op, Register reg, LanguageMode language_mode) {
+  if (is_strong(strength(language_mode))) {
+    UNIMPLEMENTED();

[oth, 2015/10/02 15:17:44]

Nitletino - other updates here take a more conservative approach, could change
the test to be is_sloppy||is_strict and UNIMPLEMENTED otherwise.

[rmcilroy, 2015/10/06 13:56:34]

I'd prefer not to do this since it is the language mode strength, not the
language mode itself, which makes the difference. However, changed the signature
to take a strength instead of language mode instead, how's that?

+  }
+
   Output(BytecodeForBinaryOperation(op), reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CompareOperation(
     Token::Value op, Register reg, LanguageMode language_mode) {
-  if (!is_sloppy(language_mode)) {
+  if (is_strong(strength(language_mode))) {

[oth, 2015/10/02 15:17:44]

Nitletino -same here.

[rmcilroy, 2015/10/06 13:56:34]

Acknowledged.

     UNIMPLEMENTED();
   }
 
   Output(BytecodeForCompareOperation(op), reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(
     v8::internal::Smi* smi) {
@@ skipping 69 matching lines @@
   if (FitsInIdxOperand(slot_index)) {
     Output(Bytecode::kLdaGlobal, static_cast<uint8_t>(slot_index));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(
     Register object, int feedback_slot, LanguageMode language_mode) {
-  if (!is_sloppy(language_mode)) {
-    UNIMPLEMENTED();
+  Bytecode bytecode;
+  switch (language_mode) {
+    case SLOPPY:
+      bytecode = Bytecode::kLoadIC;
+      break;
+    case STRICT:
+      bytecode = Bytecode::kLoadICStrict;
+      break;
+    case STRONG:
+    default:
+      UNIMPLEMENTED();

[Michael Starzinger, 2015/10/05 12:04:45]

nit: The strong case is UNIMPLEMENTED but the default case should actually be
UNREACHABLE, correct? Likewise below.

[rmcilroy, 2015/10/06 13:56:34]

Done.

   }
 
   if (FitsInIdxOperand(feedback_slot)) {
-    Output(Bytecode::kLoadIC, object.ToOperand(),
-           static_cast<uint8_t>(feedback_slot));
+    Output(bytecode, object.ToOperand(), static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty(
     Register object, int feedback_slot, LanguageMode language_mode) {
-  if (!is_sloppy(language_mode)) {
-    UNIMPLEMENTED();
+  Bytecode bytecode;
+  switch (language_mode) {
+    case SLOPPY:
+      bytecode = Bytecode::kKeyedLoadIC;
+      break;
+    case STRICT:
+      bytecode = Bytecode::kKeyedLoadICStrict;
+      break;
+    case STRONG:
+    default:
+      UNIMPLEMENTED();
   }
 
   if (FitsInIdxOperand(feedback_slot)) {
-    Output(Bytecode::kKeyedLoadIC, object.ToOperand(),
-           static_cast<uint8_t>(feedback_slot));
+    Output(bytecode, object.ToOperand(), static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(
     Register object, Register name, int feedback_slot,
     LanguageMode language_mode) {
-  if (!is_sloppy(language_mode)) {
-    UNIMPLEMENTED();
+  Bytecode bytecode;
+  switch (language_mode) {
+    case SLOPPY:
+      bytecode = Bytecode::kStoreIC;
+      break;
+    case STRICT:
+      bytecode = Bytecode::kStoreICStrict;
+      break;
+    case STRONG:
+    default:
+      UNIMPLEMENTED();
   }
 
   if (FitsInIdxOperand(feedback_slot)) {
-    Output(Bytecode::kStoreIC, object.ToOperand(), name.ToOperand(),
+    Output(bytecode, object.ToOperand(), name.ToOperand(),
            static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty(
     Register object, Register key, int feedback_slot,
     LanguageMode language_mode) {
-  if (!is_sloppy(language_mode)) {
-    UNIMPLEMENTED();
+  Bytecode bytecode;
+  switch (language_mode) {
+    case SLOPPY:
+      bytecode = Bytecode::kKeyedStoreIC;
+      break;
+    case STRICT:
+      bytecode = Bytecode::kKeyedStoreICStrict;
+      break;
+    case STRONG:
+    default:
+      UNIMPLEMENTED();
   }
 
   if (FitsInIdxOperand(feedback_slot)) {
-    Output(Bytecode::kKeyedStoreIC, object.ToOperand(), key.ToOperand(),
+    Output(bytecode, object.ToOperand(), key.ToOperand(),
            static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToBoolean() {
   if (LastBytecodeInSameBlock()) {
@@ skipping 332 matching lines @@
 
 Register TemporaryRegisterScope::NewRegister() {
   count_++;
   last_register_index_ = builder_->BorrowTemporaryRegister();
   return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8