Revert "[stubs] KeyedLoadGeneric: support loading properties from strings"

src/ic/accessor-assembler.cc

 // Copyright 2016 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/ic/accessor-assembler.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
@@ skipping 1138 matching lines @@
                                             Node* instance_type, Node* key,
                                             const LoadICParameters* p,
                                             Label* slow) {
   Comment("key is unique name");
   Label if_found_on_receiver(this), if_property_dictionary(this),
       lookup_prototype_chain(this);
   Variable var_details(this, MachineRepresentation::kWord32);
   Variable var_value(this, MachineRepresentation::kTagged);
 
   // Receivers requiring non-standard accesses (interceptors, access
-  // checks, string wrappers, proxies) are handled in the runtime.
-  // We special-case strings here, to support loading <Symbol.split> etc.
-  Variable var_receiver(this, MachineRepresentation::kTagged);
-  Variable var_receiver_map(this, MachineRepresentation::kTagged);
-  Variable var_instance_type(this, MachineRepresentation::kWord32);
-  var_receiver.Bind(receiver);
-  var_receiver_map.Bind(receiver_map);
-  var_instance_type.Bind(instance_type);
-  Label normal_receiver(this);
-  GotoIf(Int32GreaterThan(instance_type,
-                          Int32Constant(LAST_SPECIAL_RECEIVER_TYPE)),
-         &normal_receiver);
-  GotoIf(Int32GreaterThanOrEqual(instance_type,
-                                 Int32Constant(FIRST_NONSTRING_TYPE)),
+  // checks, strings and string wrappers, proxies) are handled in the runtime.
+  GotoIf(Int32LessThanOrEqual(instance_type,
+                              Int32Constant(LAST_SPECIAL_RECEIVER_TYPE)),
          slow);
-  CSA_ASSERT(this, WordEqual(LoadMapConstructorFunctionIndex(receiver_map),
-                             IntPtrConstant(Context::STRING_FUNCTION_INDEX)));
-  Node* native_context = LoadNativeContext(p->context);
-  Node* constructor_function =
-      LoadContextElement(native_context, Context::STRING_FUNCTION_INDEX);
-  Node* initial_map = LoadObjectField(constructor_function,
-                                      JSFunction::kPrototypeOrInitialMapOffset);
-  var_receiver.Bind(LoadMapPrototype(initial_map));
-  var_receiver_map.Bind(LoadMap(var_receiver.value()));
-  var_instance_type.Bind(LoadMapInstanceType(var_receiver_map.value()));
-  Goto(&normal_receiver);
 
-  Bind(&normal_receiver);
-  receiver = var_receiver.value();
-  receiver_map = var_receiver_map.value();
-  instance_type = var_instance_type.value();
   // Check if the receiver has fast or slow properties.
   Node* properties = LoadProperties(receiver);
   Node* properties_map = LoadMap(properties);
   GotoIf(WordEqual(properties_map, LoadRoot(Heap::kHashTableMapRootIndex)),
          &if_property_dictionary);
 
   // Try looking up the property on the receiver; if unsuccessful, look
   // for a handler in the stub cache.
   Comment("DescriptorArray lookup");
 
   // Skip linear search if there are too many descriptors.
   // TODO(jkummerow): Consider implementing binary search.
   // See also TryLookupProperty() which has the same limitation.
   const int32_t kMaxLinear = 210;
   Label stub_cache(this);
-  Node* bitfield3 = LoadMapBitField3(var_receiver_map.value());
+  Node* bitfield3 = LoadMapBitField3(receiver_map);
   Node* nof = DecodeWordFromWord32<Map::NumberOfOwnDescriptorsBits>(bitfield3);
   GotoIf(UintPtrLessThan(IntPtrConstant(kMaxLinear), nof), &stub_cache);
-  Node* descriptors = LoadMapDescriptors(var_receiver_map.value());
+  Node* descriptors = LoadMapDescriptors(receiver_map);
   Variable var_name_index(this, MachineType::PointerRepresentation());
   Label if_descriptor_found(this);
   DescriptorLookupLinear(key, descriptors, nof, &if_descriptor_found,
                          &var_name_index, &stub_cache);
 
   Bind(&if_descriptor_found);
   {
-    LoadPropertyFromFastObject(receiver, var_receiver_map.value(), descriptors,
+    LoadPropertyFromFastObject(receiver, receiver_map, descriptors,
                                var_name_index.value(), &var_details,
                                &var_value);
     Goto(&if_found_on_receiver);
   }
 
   Bind(&stub_cache);
   {
     Comment("stub cache probe for fast property load");
     Variable var_handler(this, MachineRepresentation::kTagged);
     Label found_handler(this, &var_handler), stub_cache_miss(this);
@@ skipping 27 matching lines @@
     {
       LoadPropertyFromNameDictionary(properties, var_name_index.value(),
                                      &var_details, &var_value);
       Goto(&if_found_on_receiver);
     }
   }
 
   Bind(&if_found_on_receiver);
   {
     Node* value = CallGetterIfAccessor(var_value.value(), var_details.value(),
-                                       p->context, var_receiver.value(), slow);
+                                       p->context, receiver, slow);
     IncrementCounter(isolate()->counters()->ic_keyed_load_generic_symbol(), 1);
     Return(value);
   }
 
   Bind(&lookup_prototype_chain);
   {
     Variable var_holder_map(this, MachineRepresentation::kTagged);
     Variable var_holder_instance_type(this, MachineRepresentation::kWord32);
     Label return_undefined(this);
     Variable* merged_variables[] = {&var_holder_map, &var_holder_instance_type};
     Label loop(this, arraysize(merged_variables), merged_variables);
 
-    var_holder_map.Bind(var_receiver_map.value());
-    var_holder_instance_type.Bind(var_instance_type.value());
+    var_holder_map.Bind(receiver_map);
+    var_holder_instance_type.Bind(instance_type);
     // Private symbols must not be looked up on the prototype chain.
     GotoIf(IsPrivateSymbol(key), &return_undefined);
     Goto(&loop);
     Bind(&loop);
     {
       // Bailout if it can be an integer indexed exotic case.
       GotoIf(Word32Equal(var_holder_instance_type.value(),
                          Int32Constant(JS_TYPED_ARRAY_TYPE)),
              slow);
       Node* proto = LoadMapPrototype(var_holder_map.value());
       GotoIf(WordEqual(proto, NullConstant()), &return_undefined);
       Node* proto_map = LoadMap(proto);
       Node* proto_instance_type = LoadMapInstanceType(proto_map);
       var_holder_map.Bind(proto_map);
       var_holder_instance_type.Bind(proto_instance_type);
       Label next_proto(this), return_value(this, &var_value), goto_slow(this);
-      TryGetOwnProperty(p->context, var_receiver.value(), proto, proto_map,
+      TryGetOwnProperty(p->context, receiver, proto, proto_map,
                         proto_instance_type, key, &return_value, &var_value,
                         &next_proto, &goto_slow);
 
       // This trampoline and the next are required to appease Turbofan's
       // variable merging.
       Bind(&next_proto);
       Goto(&loop);
 
       Bind(&goto_slow);
       Goto(slow);
@@ skipping 668 matching lines @@
   Node* slot = Parameter(Descriptor::kSlot);
   Node* context = Parameter(Descriptor::kContext);
   Node* vector = LoadTypeFeedbackVectorForStub();
 
   StoreICParameters p(context, receiver, name, value, slot, vector);
   KeyedStoreIC(&p, language_mode);
 }
 
 }  // namespace internal
 }  // namespace v8