[stubs] Add String and JSReceiver instance type predicates

src/code-stub-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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
@@ skipping 742 matching lines @@
     // The {value} is a HeapObject, load its map.
     Node* value_map = LoadMap(value);
 
     // Load the {value}s instance type.
     Node* value_instance_type = LoadMapInstanceType(value_map);
 
     // Dispatch based on the instance type; we distinguish all String instance
     // types, the HeapNumber type and everything else.
     GotoIf(Word32Equal(value_instance_type, Int32Constant(HEAP_NUMBER_TYPE)),
            &if_valueisheapnumber);
-    Branch(
-        Int32LessThan(value_instance_type, Int32Constant(FIRST_NONSTRING_TYPE)),
-        &if_valueisstring, &if_valueisother);
+    Branch(IsStringInstanceType(value_instance_type), &if_valueisstring,
+           &if_valueisother);
 
     Bind(&if_valueisstring);
     {
       // Load the string length field of the {value}.
       Node* value_length = LoadObjectField(value, String::kLengthOffset);
 
       // Check if the {value} is the empty string.
       BranchIfSmiEqual(value_length, SmiConstant(0), if_false, if_true);
     }
 
@@ skipping 1300 matching lines @@
   Label if_valueissmi(this, Label::kDeferred), if_valueisnotsmi(this),
       if_valueisstring(this);
   Branch(WordIsSmi(value), &if_valueissmi, &if_valueisnotsmi);
   Bind(&if_valueisnotsmi);
   {
     // Load the instance type of the {value}.
     Node* value_instance_type = LoadInstanceType(value);
 
     // Check if the {value} is already String.
     Label if_valueisnotstring(this, Label::kDeferred);
-    Branch(
-        Int32LessThan(value_instance_type, Int32Constant(FIRST_NONSTRING_TYPE)),
-        &if_valueisstring, &if_valueisnotstring);
+    Branch(IsStringInstanceType(value_instance_type), &if_valueisstring,
+           &if_valueisnotstring);
     Bind(&if_valueisnotstring);
     {
       // Check if the {value} is null.
       Label if_valueisnullorundefined(this, Label::kDeferred),
           if_valueisnotnullorundefined(this, Label::kDeferred),
           if_valueisnotnull(this, Label::kDeferred);
       Branch(WordEqual(value, NullConstant()), &if_valueisnullorundefined,
              &if_valueisnotnull);
       Bind(&if_valueisnotnull);
       {
@@ skipping 72 matching lines @@
       switch (primitive_type) {
         case PrimitiveType::kBoolean:
           GotoIf(WordEqual(value_map, BooleanMapConstant()), &done_loop);
           break;
         case PrimitiveType::kNumber:
           GotoIf(
               Word32Equal(value_instance_type, Int32Constant(HEAP_NUMBER_TYPE)),
               &done_loop);
           break;
         case PrimitiveType::kString:
-          GotoIf(Int32LessThan(value_instance_type,
-                               Int32Constant(FIRST_NONSTRING_TYPE)),
-                 &done_loop);
+          GotoIf(IsStringInstanceType(value_instance_type), &done_loop);
           break;
         case PrimitiveType::kSymbol:
           GotoIf(Word32Equal(value_instance_type, Int32Constant(SYMBOL_TYPE)),
                  &done_loop);
           break;
       }
       Goto(&done_throw);
     }
   }
 
@@ skipping 31 matching lines @@
       Runtime::kThrowIncompatibleMethodReceiver, context,
       HeapConstant(factory()->NewStringFromAsciiChecked(method_name, TENURED)),
       value);
   var_value_map.Bind(UndefinedConstant());
   Goto(&out);  // Never reached.
 
   Bind(&out);
   return var_value_map.value();
 }
 
+Node* CodeStubAssembler::IsStringInstanceType(Node* instance_type) {
+  STATIC_ASSERT(INTERNALIZED_STRING_TYPE == FIRST_TYPE);
+  return Int32LessThan(instance_type, Int32Constant(FIRST_NONSTRING_TYPE));
+}
+
+Node* CodeStubAssembler::IsJSReceiverInstanceType(Node* instance_type) {
+  STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
+  return Int32GreaterThanOrEqual(instance_type,
+                                 Int32Constant(FIRST_JS_RECEIVER_TYPE));
+}
+
 Node* CodeStubAssembler::StringCharCodeAt(Node* string, Node* index) {
   // Translate the {index} into a Word.
   index = SmiToWord(index);
 
   // We may need to loop in case of cons or sliced strings.
   Variable var_index(this, MachineType::PointerRepresentation());
   Variable var_result(this, MachineRepresentation::kWord32);
   Variable var_string(this, MachineRepresentation::kTagged);
   Variable* loop_vars[] = {&var_index, &var_string};
   Label done_loop(this, &var_result), loop(this, 2, loop_vars);
@@ skipping 285 matching lines @@
   // Make sure first argument is a string.
 
   // Bailout if receiver is a Smi.
   GotoIf(WordIsSmi(string), &runtime);
 
   // Load the instance type of the {string}.
   Node* const instance_type = LoadInstanceType(string);
   var_instance_type.Bind(instance_type);
 
   // Check if {string} is a String.
-  GotoIf(Int32GreaterThanOrEqual(instance_type,
-                                 Int32Constant(FIRST_NONSTRING_TYPE)),
-         &runtime);
+  GotoUnless(IsStringInstanceType(instance_type), &runtime);
 
   // Make sure that both from and to are non-negative smis.
 
   GotoUnless(WordIsPositiveSmi(from), &runtime);
   GotoUnless(WordIsPositiveSmi(to), &runtime);
 
   Node* const substr_length = SmiSub(to, from);
   Node* const string_length = LoadStringLength(string);
 
   // Begin dispatching based on substring length.
@@ skipping 325 matching lines @@
   Bind(&loop);
   {
     // Load the current {input} value (known to be a HeapObject).
     Node* input = var_input.value();
 
     // Dispatch on the {input} instance type.
     Node* input_instance_type = LoadInstanceType(input);
     Label if_inputisstring(this), if_inputisoddball(this),
         if_inputisreceiver(this, Label::kDeferred),
         if_inputisother(this, Label::kDeferred);
-    GotoIf(
-        Int32LessThan(input_instance_type, Int32Constant(FIRST_NONSTRING_TYPE)),
-        &if_inputisstring);
+    GotoIf(IsStringInstanceType(input_instance_type), &if_inputisstring);
     GotoIf(Word32Equal(input_instance_type, Int32Constant(ODDBALL_TYPE)),
            &if_inputisoddball);
-    STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
-    Branch(Int32GreaterThanOrEqual(input_instance_type,
-                                   Int32Constant(FIRST_JS_RECEIVER_TYPE)),
-           &if_inputisreceiver, &if_inputisother);
+    Branch(IsJSReceiverInstanceType(input_instance_type), &if_inputisreceiver,
+           &if_inputisother);
 
     Bind(&if_inputisstring);
     {
       // The {input} is a String, use the fast stub to convert it to a Number.
       var_result.Bind(StringToNumber(context, input));
       Goto(&end);
     }
 
     Bind(&if_inputisoddball);
     {
@@ skipping 188 matching lines @@
   // Handle Smi and HeapNumber keys.
   var_index->Bind(TryToIntptr(key, &if_keyisnotindex));
   Goto(if_keyisindex);
 
   Bind(&if_keyisnotindex);
   Node* key_instance_type = LoadInstanceType(key);
   // Symbols are unique.
   GotoIf(Word32Equal(key_instance_type, Int32Constant(SYMBOL_TYPE)),
          if_keyisunique);
   // Miss if |key| is not a String.
   STATIC_ASSERT(FIRST_NAME_TYPE == FIRST_TYPE);

[Igor Sheludko, 2016/10/05 08:02:27]

You can now remove this assert from here.

-  GotoIf(
-      Int32GreaterThan(key_instance_type, Int32Constant(FIRST_NONSTRING_TYPE)),
-      if_bailout);
+  GotoUnless(IsStringInstanceType(key_instance_type), if_bailout);

[jgruber, 2016/10/04 13:35:54]

Igor: I'm assuming the original code was bugged (since it did not jump for
FIRST_NONSTRING_TYPE itself), but please double-check.

[Igor Sheludko, 2016/10/05 08:02:27]

FIRST_NONSTRING_TYPE is actually a SYMBOL_TYPE which was already handled above,
so the old code is ok and your change too.

   // |key| is a String. Check if it has a cached array index.
   Node* hash = LoadNameHashField(key);
   Node* contains_index =
       Word32And(hash, Int32Constant(Name::kContainsCachedArrayIndexMask));
   GotoIf(Word32Equal(contains_index, Int32Constant(0)), &if_hascachedindex);
   // No cached array index. If the string knows that it contains an index,
   // then it must be an uncacheable index. Handle this case in the runtime.
   Node* not_an_index =
       Word32And(hash, Int32Constant(Name::kIsNotArrayIndexMask));
   GotoIf(Word32Equal(not_an_index, Int32Constant(0)), if_bailout);
@@ skipping 626 matching lines @@
   {
     Variable var_entry(this, MachineType::PointerRepresentation());
     Node* elements = LoadElements(object);
     NumberDictionaryLookup<SeededNumberDictionary>(
         elements, intptr_index, if_found, &var_entry, if_not_found);
   }
   Bind(&if_isfaststringwrapper);
   {
     AssertInstanceType(object, JS_VALUE_TYPE);
     Node* string = LoadJSValueValue(object);
-    Assert(Int32LessThan(LoadInstanceType(string),
-                         Int32Constant(FIRST_NONSTRING_TYPE)));
+    Assert(IsStringInstanceType(LoadInstanceType(string)));
     Node* length = LoadStringLength(string);
     GotoIf(UintPtrLessThan(intptr_index, SmiUntag(length)), if_found);
     Goto(&if_isobjectorsmi);
   }
   Bind(&if_isslowstringwrapper);
   {
     AssertInstanceType(object, JS_VALUE_TYPE);
     Node* string = LoadJSValueValue(object);
-    Assert(Int32LessThan(LoadInstanceType(string),
-                         Int32Constant(FIRST_NONSTRING_TYPE)));
+    Assert(IsStringInstanceType(LoadInstanceType(string)));
     Node* length = LoadStringLength(string);
     GotoIf(UintPtrLessThan(intptr_index, SmiUntag(length)), if_found);
     Goto(&if_isdictionary);
   }
   Bind(&if_oob);
   {
     // Positive OOB indices mean "not found", negative indices must be
     // converted to property names.
     GotoIf(IntPtrLessThan(intptr_index, IntPtrConstant(0)), if_bailout);
     Goto(if_not_found);
@@ skipping 1918 matching lines @@
                        Heap::kTheHoleValueRootIndex);
 
   // Store the WeakCell in the feedback vector.
   StoreFixedArrayElement(feedback_vector, slot, cell, UPDATE_WRITE_BARRIER,
                          CodeStubAssembler::SMI_PARAMETERS);
   return cell;
 }
 
 }  // namespace internal
 }  // namespace v8