[stubs] Add CSA::IsSymbol() and CSA::IsPrivateSymbol().

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"
 
 namespace v8 {
 namespace internal {
@@ skipping 2897 matching lines @@
 Node* CodeStubAssembler::IsName(Node* object) {
   return Int32LessThanOrEqual(LoadInstanceType(object),
                               Int32Constant(LAST_NAME_TYPE));
 }
 
 Node* CodeStubAssembler::IsString(Node* object) {
   return Int32LessThanOrEqual(LoadInstanceType(object),
                               Int32Constant(FIRST_NONSTRING_TYPE));
 }
 
+Node* CodeStubAssembler::IsSymbol(Node* object) {
+  return HasInstanceType(object, SYMBOL_TYPE);

[Igor Sheludko, 2016/12/13 20:56:28]

IsSymbolMap(LoadMap(object)) does not require loading an instance type field.

[gsathya, 2016/12/13 22:01:03]

Doh ofc. Changed

+}
+
+Node* CodeStubAssembler::IsPrivateSymbol(Node* object) {
+  Label out(this);
+  Variable var_result(this, MachineType::PointerRepresentation());

[Igor Sheludko, 2016/12/13 20:56:28]

CSA expects kWord32 nodes as a condition in Branch, so the result should be a
kWord32. (The CSA graph verification is almost there).

[gsathya, 2016/12/13 22:01:04]

Ah, okay. Changed.

+  var_result.Bind(IntPtrConstant(0));

[Igor Sheludko, 2016/12/13 20:56:28]

Same here: Int32Constant().

[gsathya, 2016/12/13 22:01:03]

Done.

+
+  GotoUnless(IsSymbolMap(LoadMap(object)), &out);

[Igor Sheludko, 2016/12/13 20:56:28]

IsSymbol(object)

[gsathya, 2016/12/13 22:01:04]

Done.

+  Node* const flags =
+      SmiToWord32(LoadObjectField(object, Symbol::kFlagsOffset));
+  const int kPrivateMask = 1 << Symbol::kPrivateBit;
+  var_result.Bind(IsSetWord32(flags, kPrivateMask));
+  Goto(&out);
+
+  Bind(&out);
+  return var_result.value();

[Igor Sheludko, 2016/12/13 20:56:28]

You may want to use Select() for this.

[gsathya, 2016/12/13 22:01:03]

I did initially but didn't look very readable to me. Changed.

+}
+
 Node* CodeStubAssembler::IsNativeContext(Node* object) {
   return WordEqual(LoadMap(object), LoadRoot(Heap::kNativeContextMapRootIndex));
 }
 
 Node* CodeStubAssembler::IsFixedDoubleArray(Node* object) {
   return WordEqual(LoadMap(object), FixedDoubleArrayMapConstant());
 }
 
 Node* CodeStubAssembler::IsHashTable(Node* object) {
   return WordEqual(LoadMap(object), LoadRoot(Heap::kHashTableMapRootIndex));
@@ skipping 1336 matching lines @@
                                   Label* if_bailout) {
   DCHECK_EQ(MachineType::PointerRepresentation(), var_index->rep());
   Comment("TryToName");
 
   Label if_hascachedindex(this), if_keyisnotindex(this);
   // Handle Smi and HeapNumber keys.
   var_index->Bind(TryToIntptr(key, &if_keyisnotindex));
   Goto(if_keyisindex);
 
   Bind(&if_keyisnotindex);
+  // Symbols are unique.
+  GotoIf(IsSymbol(key), if_keyisunique);
   Node* key_instance_type = LoadInstanceType(key);

[Igor Sheludko, 2016/12/13 20:56:28]

On this path we are loading map twice. How about: LoadMap, IsSymbolMap,
LoadMapInstanceType?

[gsathya, 2016/12/13 22:01:04]

Done.

-  // 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);
   GotoUnless(IsStringInstanceType(key_instance_type), if_bailout);
   // |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.
@@ skipping 3974 matching lines @@
                        Heap::kUndefinedValueRootIndex);
   StoreObjectFieldRoot(result, PromiseReactionJobInfo::kDebugNameOffset,
                        Heap::kUndefinedValueRootIndex);
   StoreObjectFieldNoWriteBarrier(result, PromiseReactionJobInfo::kContextOffset,
                                  context);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8