[strong] Implement strong mode restrictions on property access

src/hydrogen.cc

 // Copyright 2013 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/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 665 matching lines @@
 HConstant* HGraph::GetConstant1() {
   return GetConstant(&constant_1_, 1);
 }
 
 
 HConstant* HGraph::GetConstantMinus1() {
   return GetConstant(&constant_minus1_, -1);
 }
 
 
+HConstant* HGraph::GetConstantBool(bool value) {
+  return value ? GetConstantTrue() : GetConstantFalse();
+}
+
+
 #define DEFINE_GET_CONSTANT(Name, name, type, htype, boolean_value)            \
 HConstant* HGraph::GetConstant##Name() {                                       \
   if (!constant_##name##_.is_set()) {                                          \
     HConstant* constant = new(zone()) HConstant(                               \
         Unique<Object>::CreateImmovable(isolate()->factory()->name##_value()), \
         Unique<Map>::CreateImmovable(isolate()->factory()->type##_map()),      \
         false,                                                                 \
         Representation::Tagged(),                                              \
         htype,                                                                 \
         true,                                                                  \
@@ skipping 967 matching lines @@
 
   // hash = hash ^ (hash >> 16);
   shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(16));
   return AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 }
 
 
 HValue* HGraphBuilder::BuildUncheckedDictionaryElementLoad(HValue* receiver,
                                                            HValue* elements,
                                                            HValue* key,
-                                                           HValue* hash) {
+                                                           HValue* hash,
+                                                           Strength strength) {
   HValue* capacity =
       Add<HLoadKeyed>(elements, Add<HConstant>(NameDictionary::kCapacityIndex),
                       nullptr, FAST_ELEMENTS);
 
   HValue* mask = AddUncasted<HSub>(capacity, graph()->GetConstant1());
   mask->ChangeRepresentation(Representation::Integer32());
   mask->ClearFlag(HValue::kCanOverflow);
 
   HValue* entry = hash;
   HValue* count = graph()->GetConstant1();
@@ skipping 21 matching lines @@
 
   HValue* candidate_key =
       Add<HLoadKeyed>(elements, key_index, nullptr, FAST_ELEMENTS);
   IfBuilder if_undefined(this);
   if_undefined.If<HCompareObjectEqAndBranch>(candidate_key,
                                              graph()->GetConstantUndefined());
   if_undefined.Then();
   {
     // element == undefined means "not found". Call the runtime.
     // TODO(jkummerow): walk the prototype chain instead.
-    Add<HPushArguments>(receiver, key);
+    Add<HPushArguments>(receiver, key,
+                        graph()->GetConstantBool(static_cast<bool>(strength)));
     Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
                            Runtime::FunctionForId(Runtime::kKeyedGetProperty),
-                           2));
+                           3));
   }
   if_undefined.Else();
   {
     IfBuilder if_match(this);
     if_match.If<HCompareObjectEqAndBranch>(candidate_key, key);
     if_match.Then();
     if_match.Else();
 
     // Update non-internalized string in the dictionary with internalized key?
     IfBuilder if_update_with_internalized(this);
@@ skipping 36 matching lines @@
                                     Add<HConstant>(details_mask));
     IfBuilder details_compare(this);
     details_compare.If<HCompareNumericAndBranch>(
         details, graph()->GetConstant0(), Token::EQ);
     details_compare.Then();
     HValue* result_index =
         AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset + 1));
     result_index->ClearFlag(HValue::kCanOverflow);
     Push(Add<HLoadKeyed>(elements, result_index, nullptr, FAST_ELEMENTS));
     details_compare.Else();
-    Add<HPushArguments>(receiver, key);
+    Add<HPushArguments>(receiver, key,
+                        graph()->GetConstantBool(static_cast<bool>(strength)));
     Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
                            Runtime::FunctionForId(Runtime::kKeyedGetProperty),
-                           2));
+                           3));
     details_compare.End();
 
     found_key_match.Else();
     found_key_match.JoinContinuation(&return_or_loop_continuation);
   }
   if_undefined.JoinContinuation(&return_or_loop_continuation);
 
   IfBuilder return_or_loop(this, &return_or_loop_continuation);
   return_or_loop.Then();
   probe_loop.Break();
@@ skipping 4424 matching lines @@
   if (IsJSObjectFieldAccessor()) return IsLoad();
   if (IsJSArrayBufferViewFieldAccessor()) return IsLoad();
   if (map_->function_with_prototype() && !map_->has_non_instance_prototype() &&
       name_.is_identical_to(isolate()->factory()->prototype_string())) {
     return IsLoad();
   }
   if (!LookupDescriptor()) return false;
   if (IsFound()) return IsLoad() || !IsReadOnly();
   if (IsIntegerIndexedExotic()) return false;
   if (!LookupInPrototypes()) return false;
-  if (IsLoad()) return true;
+  if (IsLoad()) return !is_strong(builder_->function_language_mode());
 
   if (IsAccessorConstant()) return true;
   LookupTransition(*map_, *name_, NONE);
   if (IsTransitionToData() && map_->unused_property_fields() > 0) {
     // Construct the object field access.
     int descriptor = transition()->LastAdded();
     int index =
         transition()->instance_descriptors()->GetFieldIndex(descriptor) -
         map_->inobject_properties();
     PropertyDetails details =
@@ skipping 797 matching lines @@
     Handle<TypeFeedbackVector> vector =
         handle(current_feedback_vector(), isolate());
     FeedbackVectorICSlot slot = expr->AsProperty()->PropertyFeedbackSlot();
 
     if (!expr->AsProperty()->key()->IsPropertyName()) {
       // It's possible that a keyed load of a constant string was converted
       // to a named load. Here, at the last minute, we need to make sure to
       // use a generic Keyed Load if we are using the type vector, because
       // it has to share information with full code.
       HConstant* key = Add<HConstant>(name);
-      HLoadKeyedGeneric* result =
-          New<HLoadKeyedGeneric>(object, key, PREMONOMORPHIC);
+      HLoadKeyedGeneric* result = New<HLoadKeyedGeneric>(
+          object, key, function_language_mode(), PREMONOMORPHIC);
       result->SetVectorAndSlot(vector, slot);
       return result;
     }
 
-    HLoadNamedGeneric* result =
-        New<HLoadNamedGeneric>(object, name, PREMONOMORPHIC);
+    HLoadNamedGeneric* result = New<HLoadNamedGeneric>(
+        object, name, function_language_mode(), PREMONOMORPHIC);
     result->SetVectorAndSlot(vector, slot);
     return result;
   } else {
     return New<HStoreNamedGeneric>(object, name, value,
                                    function_language_mode(), PREMONOMORPHIC);
   }
 }
 
 
 
 HInstruction* HOptimizedGraphBuilder::BuildKeyedGeneric(
     PropertyAccessType access_type,
     Expression* expr,
     HValue* object,
     HValue* key,
     HValue* value) {
   if (access_type == LOAD) {
     InlineCacheState initial_state = expr->AsProperty()->GetInlineCacheState();
-    HLoadKeyedGeneric* result =
-        New<HLoadKeyedGeneric>(object, key, initial_state);
+    HLoadKeyedGeneric* result = New<HLoadKeyedGeneric>(
+        object, key, function_language_mode(), initial_state);
     // HLoadKeyedGeneric with vector ics benefits from being encoded as
     // MEGAMORPHIC because the vector/slot combo becomes unnecessary.
     if (initial_state != MEGAMORPHIC) {
       // We need to pass vector information.
       Handle<TypeFeedbackVector> vector =
           handle(current_feedback_vector(), isolate());
       FeedbackVectorICSlot slot = expr->AsProperty()->PropertyFeedbackSlot();
       result->SetVectorAndSlot(vector, slot);
     }
     return result;
@@ skipping 6096 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8