[stubs] Consolidate TryToName implementation

test/cctest/test-code-stub-assembler.cc

 // Copyright 2015 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/base/utils/random-number-generator.h"
 #include "src/ic/stub-cache.h"
 #include "src/isolate.h"
 #include "test/cctest/compiler/code-assembler-tester.h"
 #include "test/cctest/compiler/function-tester.h"
 
@@ skipping 114 matching lines @@
   CodeStubAssemblerTester m(isolate, kNumParams);
 
   enum Result { kKeyIsIndex, kKeyIsUnique, kBailout };
   {
     Node* key = m.Parameter(0);
     Node* expected_result = m.Parameter(1);
     Node* expected_arg = m.Parameter(2);
 
     Label passed(&m), failed(&m);
     Label if_keyisindex(&m), if_keyisunique(&m), if_bailout(&m);
-    Variable var_index(&m, MachineRepresentation::kWord32);
+    Variable var_index(&m, MachineType::PointerRepresentation());
 
     m.TryToName(key, &if_keyisindex, &var_index, &if_keyisunique, &if_bailout);
 
     m.Bind(&if_keyisindex);
     m.GotoUnless(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kKeyIsIndex))),
         &failed);
-    m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_index.value()),
-             &passed, &failed);
+    m.Branch(m.WordEqual(m.SmiUntag(expected_arg), var_index.value()), &passed,
+             &failed);
 
     m.Bind(&if_keyisunique);
     m.GotoUnless(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kKeyIsUnique))),
         &failed);
     m.Branch(m.WordEqual(expected_arg, key), &passed, &failed);
 
     m.Bind(&if_bailout);
     m.Branch(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
@@ skipping 19 matching lines @@
     ft.CheckTrue(key, expect_index, key);
   }
 
   {
     // TryToName(<positive smi>) => if_keyisindex: smi value.
     Handle<Object> key(Smi::FromInt(153), isolate);
     ft.CheckTrue(key, expect_index, key);
   }
 
   {
-    // TryToName(<negative smi>) => bailout.
+    // TryToName(<negative smi>) => if_keyisindex: smi value.
+    // A subsequent bounds check needs to take care of this case.
     Handle<Object> key(Smi::FromInt(-1), isolate);
-    ft.CheckTrue(key, expect_bailout);
+    ft.CheckTrue(key, expect_index, key);
   }
 
   {
+    // TryToName(<heap number with int value>) => if_keyisindex: number.
+    Handle<Object> key(isolate->factory()->NewHeapNumber(153));
+    Handle<Object> index(Smi::FromInt(153), isolate);
+    ft.CheckTrue(key, expect_index, index);
+  }
+
+  {
     // TryToName(<symbol>) => if_keyisunique: <symbol>.
     Handle<Object> key = isolate->factory()->NewSymbol();
     ft.CheckTrue(key, expect_unique, key);
   }
 
   {
     // TryToName(<internalized string>) => if_keyisunique: <internalized string>
     Handle<Object> key = isolate->factory()->InternalizeUtf8String("test");
     ft.CheckTrue(key, expect_unique, key);
   }
 
   {
     // TryToName(<internalized number string>) => if_keyisindex: number.
     Handle<Object> key = isolate->factory()->InternalizeUtf8String("153");
     Handle<Object> index(Smi::FromInt(153), isolate);
     ft.CheckTrue(key, expect_index, index);
   }
 
   {
+    // TryToName(<non-internalized number string>) => if_keyisindex: number.
+    Handle<String> key = isolate->factory()->NewStringFromAsciiChecked("153");
+    uint32_t dummy;
+    key->AsArrayIndex(&dummy);

[Igor Sheludko, 2016/09/01 14:31:31]

CHECK(...)?

[Jakob Kummerow, 2016/09/05 13:15:54]

Done.

+    DCHECK(key->HasHashCode());

[Igor Sheludko, 2016/09/01 14:31:31]

DCHECK -> CHECK

[Jakob Kummerow, 2016/09/05 13:15:54]

Done. (I don't see the necessity, as that's not the point of the test, it just
verifies that the test tests what it intends to test, which IMHO is sufficient
to verify in Debug mode, but fine, whatever :-) .)

+    DCHECK(!key->IsInternalizedString());

[Igor Sheludko, 2016/09/01 14:31:31]

Same here.

[Jakob Kummerow, 2016/09/05 13:15:54]

Done.

+    Handle<Object> index(Smi::FromInt(153), isolate);
+    ft.CheckTrue(key, expect_index, index);
+  }
+
+  {
     // TryToName(<non-internalized string>) => bailout.
     Handle<Object> key = isolate->factory()->NewStringFromAsciiChecked("test");
     ft.CheckTrue(key, expect_bailout);
   }
 }
 
 namespace {
 
 template <typename Dictionary>
 void TestNameDictionaryLookup() {
@@ skipping 1116 matching lines @@
 
     Handle<Code> expected_handler(handler, isolate);
     ft.CheckTrue(receiver, name, expected_handler);
   }
   // Ensure we performed both kind of queries.
   CHECK(queried_existing && queried_non_existing);
 }
 
 }  // namespace internal
 }  // namespace v8