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

src/interpreter/bytecode-array-builder.cc

Index: src/interpreter/bytecode-array-builder.cc
diff --git a/src/interpreter/bytecode-array-builder.cc b/src/interpreter/bytecode-array-builder.cc
index 9c937d74370d3cde35fcb47caa36239d048b6137..01c5a91a1a4f4953d2d33c8f0821aab01b960b92 100644
--- a/src/interpreter/bytecode-array-builder.cc
+++ b/src/interpreter/bytecode-array-builder.cc
@@ -127,8 +127,12 @@ void BytecodeArrayBuilder::Output(Bytecode 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;
 }
@@ -136,7 +140,7 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op,
 
 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();
   }
 
@@ -226,13 +230,21 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(int slot_index) {
 
 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();
   }
@@ -242,13 +254,21 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(
 
 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();
   }
@@ -259,12 +279,21 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty(
 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();
@@ -276,12 +305,21 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(
 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();