[builtins] HasOwnProperty: handle non-internalized string keys

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/counters.h"
 #include "src/ic/handler-configuration.h"
@@ skipping 2094 matching lines @@
     GenericElementLoad(receiver, receiver_map, instance_type, var_index.value(),
                        &slow);
   }
 
   BIND(&if_unique_name);
   {
     GenericPropertyLoad(receiver, receiver_map, instance_type,
                         var_unique.value(), p, &slow);
   }
 
+  // TODO(jkummerow): The code below internalizes strings on the fly, but
+  // it currently adds too much load on the stub cache. Find a solution
+  // for stub cache overload issues and enable this!
+  /* {

[Igor Sheludko, 2017/04/13 11:38:54]

I'd suggest to add a read-only bool option and do
  if (FLAG_internalize_on_the_fly) {

instead of commenting a block. This way we can at least be sure that the code
compiles.

Or even better, if you move this code to CSA::TryLookupInternalizedString(Node*
string, Label* if_index, Label* if_internalized, Label* if_never_internalized,
Label* if_bailout)

then you can reuse in "if_notunique_name" case of ObjectHasOwnProperty.

[Jakob Kummerow, 2017/04/13 14:01:52]

Done.

+    Node* function = ExternalConstant(
+        ExternalReference::try_internalize_string_function(isolate()));
+    Node* result = CallCFunction1(MachineType::AnyTagged(),
+                                  MachineType::AnyTagged(), function, p->name);
+    // If internalization failed, then the string did not exist in the string
+    // table yet, which implies that no existing object has a property with
+    // that name.
+    Label internalized(this), not_found(this);
+    GotoIf(TaggedIsNotSmi(result), &internalized);
+    Node* int_result = SmiUntag(result);

[Igor Sheludko, 2017/04/13 11:38:53]

s/int_result/word_result/ ?

[Jakob Kummerow, 2017/04/13 14:01:52]

Done.

+    GotoIf(WordEqual(int_result, IntPtrConstant(ResultSentinel::kNotFound)),
+           &not_found);
+    GotoIf(WordEqual(int_result, IntPtrConstant(ResultSentinel::kUnsupported)),
+           &slow);
+    var_index.Bind(int_result);
+    Goto(&if_index);
+
+    BIND(&internalized);
+    var_unique.Bind(result);
+    Goto(&if_unique_name);
+
+    BIND(&not_found);
+    Return(UndefinedConstant());
+  } */
+
   BIND(&slow);
   {
     Comment("KeyedLoadGeneric_slow");
     IncrementCounter(isolate()->counters()->ic_keyed_load_generic_slow(), 1);
     // TODO(jkummerow): Should we use the GetProperty TF stub instead?
     TailCallRuntime(Runtime::kKeyedGetProperty, p->context, p->receiver,
                     p->name);
   }
 }
 
@@ skipping 348 matching lines @@
   Node* context = Parameter(Descriptor::kContext);
   Node* vector = LoadFeedbackVectorForStub();
 
   Callable callable =
       CodeFactory::KeyedStoreICInOptimizedCode(isolate(), language_mode);
   TailCallStub(callable, context, receiver, name, value, slot, vector);
 }
 
 }  // namespace internal
 }  // namespace v8