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

test/cctest/interpreter/test-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/v8.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 467 matching lines @@
            B(LdaConstant), U8(0),                              //
            B(LoadIC), R(1), U8(vector->GetIndex(slot1)),       //
            B(Star), R(0),                                      //
            B(Ldar), R(helper.kLastParamIndex),                 //
            B(Star), R(1),                                      //
            B(LdaSmi8), U8(-124),                               //
            B(KeyedLoadIC), R(1), U8(vector->GetIndex(slot2)),  //
            B(Return)                                           //
        },
        1,
-       {"name"}}};
+       {"name"}},
+      {"function f(a) { \"use strict\"; return a.name; }\nf({name : \"test\"})",
+       1 * kPointerSize,
+       2,
+       12,
+       {
+           // TODO(rmcilroy) Avoid unnecessary LdaConstant for "use strict"
+           // expression, or any other unused literal expression.
+           B(LdaConstant), U8(0),                               //
+           B(Ldar), R(helper.kLastParamIndex),                  //
+           B(Star), R(0),                                       //
+           B(LdaConstant), U8(1),                               //
+           B(LoadICStrict), R(0), U8(vector->GetIndex(slot1)),  //
+           B(Return)                                            //
+       },
+       2,
+       {"use strict", "name"}},
+      {"function f(a, b) { \"use strict\"; return a[b]; }\n"
+       "f({arg : \"test\"}, \"arg\")",
+       1 * kPointerSize,
+       3,
+       12,
+       {
+           // TODO(rmcilroy) Avoid unnecessary LdaConstant for "use strict"
+           // expression, or any other unused literal expression.
+           B(LdaConstant), U8(0),                                    //
+           B(Ldar), R(helper.kLastParamIndex - 1),                   //
+           B(Star), R(0),                                            //
+           B(Ldar), R(helper.kLastParamIndex),                       //
+           B(KeyedLoadICStrict), R(0), U8(vector->GetIndex(slot1)),  //
+           B(Return)                                                 //
+       },
+       1,
+       {"use strict"}}};
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(PropertyStores) {
   InitializedHandleScope handle_scope;
@@ skipping 84 matching lines @@
            B(Star), R(1),                                        //
            B(Ldar), R(helper.kLastParamIndex),                   //
            B(Star), R(2),                                        //
            B(LdaSmi8), U8(-124),                                 //
            B(KeyedLoadIC), R(2), U8(vector->GetIndex(slot1)),    //
            B(StoreIC), R(0), R(1), U8(vector->GetIndex(slot2)),  //
            B(LdaUndefined),                                      //
            B(Return)                                             //
        },
        1,
-       {"name"}}};
+       {"name"}},
+      {"function f(a) { \"use strict\"; a.name = \"val\"; }\n"
+       "f({name : \"test\"})",
+       2 * kPointerSize,
+       2,
+       18,
+       {
+           // TODO(rmcilroy) Avoid unnecessary LdaConstant for "use strict"
+           // expression, or any other unused literal expression.
+           B(LdaConstant), U8(0),                                      //
+           B(Ldar), R(helper.kLastParamIndex),                         //
+           B(Star), R(0),                                              //
+           B(LdaConstant), U8(1),                                      //
+           B(Star), R(1),                                              //
+           B(LdaConstant), U8(2),                                      //
+           B(StoreICStrict), R(0), R(1), U8(vector->GetIndex(slot1)),  //
+           B(LdaUndefined),                                            //
+           B(Return)                                                   //
+       },
+       3,
+       {"use strict", "name", "val"}},
+      {"function f(a, b) { \"use strict\"; a[b] = \"val\"; }\n"
+       "f({arg : \"test\"}, \"arg\")",
+       2 * kPointerSize,
+       3,
+       18,
+       {
+           // TODO(rmcilroy) Avoid unnecessary LdaConstant for "use strict"
+           // expression, or any other unused literal expression.
+           B(LdaConstant), U8(0),                                           //
+           B(Ldar), R(helper.kLastParamIndex - 1),                          //
+           B(Star), R(0),                                                   //
+           B(Ldar), R(helper.kLastParamIndex),                              //
+           B(Star), R(1),                                                   //
+           B(LdaConstant), U8(1),                                           //
+           B(KeyedStoreICStrict), R(0), R(1), U8(vector->GetIndex(slot1)),  //
+           B(LdaUndefined),                                                 //
+           B(Return)                                                        //
+       },
+       2,
+       {"use strict", "val"}}};
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 #define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
 
@@ skipping 577 matching lines @@
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8