Revert of Revert of [strong] Implement strong mode restrictions on property access

src/code-stubs-hydrogen.cc

 // Copyright 2012 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/bailout-reason.h"
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
@@ skipping 44 matching lines @@
   HValue* GetArgumentsLength() {
     // This is initialized in BuildGraph()
     DCHECK(arguments_length_ != NULL);
     return arguments_length_;
   }
   CompilationInfo* info() { return info_; }
   CodeStub* stub() { return info_->code_stub(); }
   HContext* context() { return context_; }
   Isolate* isolate() { return info_->isolate(); }
 
-  HLoadNamedField* BuildLoadNamedField(HValue* object,
-                                       FieldIndex index);
+  HLoadNamedField* BuildLoadNamedField(HValue* object, FieldIndex index);
   void BuildStoreNamedField(HValue* object, HValue* value, FieldIndex index,
                             Representation representation,
                             bool transition_to_field);
 
   enum ArgumentClass {
     NONE,
     SINGLE,
     MULTIPLE
   };
 
@@ skipping 1817 matching lines @@
 HValue* CodeStubGraphBuilder<LoadDictionaryElementStub>::BuildCodeStub() {
   HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
   HValue* key = GetParameter(LoadDescriptor::kNameIndex);
 
   Add<HCheckSmi>(key);
 
   HValue* elements = AddLoadElements(receiver);
 
   HValue* hash = BuildElementIndexHash(key);
 
-  return BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash);
+  return BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash,
+                                             casted_stub()->language_mode());
 }
 
 
 Handle<Code> LoadDictionaryElementStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template<>
 HValue* CodeStubGraphBuilder<RegExpConstructResultStub>::BuildCodeStub() {
@@ skipping 93 matching lines @@
   Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                               false, kind,
                                               LOAD, NEVER_RETURN_HOLE,
                                               STANDARD_STORE));
 }
 
 
 HValue* CodeStubGraphBuilder<KeyedLoadGenericStub>::BuildCodeStub() {
   HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
   HValue* key = GetParameter(LoadDescriptor::kNameIndex);
-
   // Split into a smi/integer case and unique string case.
   HIfContinuation index_name_split_continuation(graph()->CreateBasicBlock(),
                                                 graph()->CreateBasicBlock());
 
   BuildKeyedIndexCheck(key, &index_name_split_continuation);
 
   IfBuilder index_name_split(this, &index_name_split_continuation);
   index_name_split.Then();
   {
     // Key is an index (number)
@@ skipping 23 matching lines @@
     }
     kind_if.Else();
 
     // The DICTIONARY_ELEMENTS check generates a "kind_if.Then"
     BuildElementsKindLimitCheck(&kind_if, bit_field2, DICTIONARY_ELEMENTS);
     {
       HValue* elements = AddLoadElements(receiver);
 
       HValue* hash = BuildElementIndexHash(key);
 
-      Push(BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash));
+      Push(BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash,
+                                               casted_stub()->language_mode()));
     }
     kind_if.Else();
 
     // The SLOPPY_ARGUMENTS_ELEMENTS check generates a "kind_if.Then"
     BuildElementsKindLimitCheck(&kind_if, bit_field2,
                                 SLOPPY_ARGUMENTS_ELEMENTS);
     // Non-strict elements are not handled.
     Add<HDeoptimize>(Deoptimizer::kNonStrictElementsInKeyedLoadGenericStub,
                      Deoptimizer::EAGER);
     Push(graph()->GetConstant0());
@@ skipping 57 matching lines @@
       BuildNonGlobalObjectCheck(receiver);
 
       HValue* properties = Add<HLoadNamedField>(
           receiver, nullptr, HObjectAccess::ForPropertiesPointer());
 
       HValue* hash =
           Add<HLoadNamedField>(key, nullptr, HObjectAccess::ForNameHashField());
 
       hash = AddUncasted<HShr>(hash, Add<HConstant>(Name::kHashShift));
 
-      HValue* value = BuildUncheckedDictionaryElementLoad(receiver,
-                                                          properties,
-                                                          key,
-                                                          hash);
+      HValue* value = BuildUncheckedDictionaryElementLoad(
+          receiver, properties, key, hash, casted_stub()->language_mode());
       Push(value);
     }
     if_dict_properties.Else();
     {
       // TODO(dcarney): don't use keyed lookup cache, but convert to use
       // megamorphic stub cache.
       UNREACHABLE();
       //  Key is string, properties are fast mode
       HValue* hash = BuildKeyedLookupCacheHash(receiver, key);
 
@@ skipping 54 matching lines @@
 
       IfBuilder inline_or_runtime(this, &inline_or_runtime_continuation);
       inline_or_runtime.Then();
       {
         // Found a cached index, load property inline.
         Push(Add<HLoadFieldByIndex>(receiver, Pop()));
       }
       inline_or_runtime.Else();
       {
         // KeyedLookupCache miss; call runtime.
-        Add<HPushArguments>(receiver, key);
+        Add<HPushArguments>(receiver, key,
+                            Add<HConstant>(casted_stub()->language_mode()));
         Push(Add<HCallRuntime>(
             isolate()->factory()->empty_string(),
-            Runtime::FunctionForId(Runtime::kKeyedGetProperty), 2));
+            Runtime::FunctionForId(Runtime::kKeyedGetProperty), 3));
       }
       inline_or_runtime.End();
     }
     if_dict_properties.End();
   }
   index_name_split.End();
 
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8