[runtime] Object.create(null) creates a slow object

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 109 matching lines @@
       return IntPtrConstant(left_constant - right_constant);
     }
   } else if (is_right_constant) {
     if (right_constant == 0) {
       return left;
     }
   }
   return IntPtrSub(left, right);
 }
 
+void CodeStubAssembler::BranchIfWordIsPowerOfTwo(Node* value, Label* if_true,

[Igor Sheludko, 2016/10/21 07:48:27]

I think this can be written as predicate IsPowerOfTwoWord() if you use Select
instructions...

[Camillo Bruni, 2016/10/21 13:37:15]

Ahhh that's what I've been looking for yesterday! thanks!

+                                                 Label* if_false) {
+  // value && !(value & (value - 1))
+  GotoIf(WordEqual(value, IntPtrConstant(0)), if_false);
+  Branch(
+      WordEqual(WordAnd(value, IntPtrSubWithOverflow(value, IntPtrConstant(1))),
+                IntPtrConstant(0)),
+      if_true, if_false);
+}
+
 Node* CodeStubAssembler::Float64Round(Node* x) {
   Node* one = Float64Constant(1.0);
   Node* one_half = Float64Constant(0.5);
 
   Variable var_x(this, MachineRepresentation::kFloat64);
   Label return_x(this);
 
   // Round up {x} towards Infinity.
   var_x.Bind(Float64Ceil(x));
 
@@ skipping 1513 matching lines @@
       AllocateFixedArray(elements_kind, length_intptr, parameter_mode);
   StoreObjectField(result, JSArray::kElementsOffset, elements);
 
   // Fill in the elements with undefined.
   FillFixedArrayWithValue(elements_kind, elements, zero, length_intptr,
                           Heap::kUndefinedValueRootIndex, parameter_mode);
 
   return result;
 }
 
+Node* CodeStubAssembler::AllocateNameDictionary(int capacity) {
+  return AllocateNameDictionary(IntPtrConstant(capacity));
+}
+
+Node* CodeStubAssembler::AllocateNameDictionary(Node* capacity) {
+  CSA_ASSERT(UintPtrLessThanOrEqual(
+      capacity, IntPtrConstant(NameDictionary::kMaxCapacity)));
+#if defined(DEBUG)
+  Label ok(this), not_ok(this);
+  BranchIfWordIsPowerOfTwo(capacity, &ok, &not_ok);

[Igor Sheludko, 2016/10/21 07:48:27]

... and them this will just be CSA_ASSERT(IsPowerOfTwo(capacity)).

[Camillo Bruni, 2016/10/21 13:37:15]

done.

+  Bind(&not_ok);
+  DebugBreak();
+  Goto(&ok);
+  Bind(&ok);
+#endif
+  Node* length = EntryToIndex<NameDictionary>(capacity);
+  Node* store_size =

[Igor Sheludko, 2016/10/21 07:48:27]

Please follow USE_DEFAULT_MINIMUM_CAPACITY way of calculating size.

USE_CUSTOM_MINIMUM_CAPACITY does not actually work because whenever you add
anything to the dictionary the call to EnsureCapacity() will reallocate it to at
least USE_DEFAULT_MINIMUM_CAPACITY.

[Camillo Bruni, 2016/10/21 13:37:15]

Implemented HashTableComputeCapacity.

+      IntPtrAddFoldConstants(WordShl(length, IntPtrConstant(kPointerSizeLog2)),
+                             IntPtrConstant(NameDictionary::kHeaderSize));
+
+  Node* result = Allocate(store_size);
+  // Initialize FixedArray fields.
+  StoreObjectFieldRoot(result, Internals::kHeapObjectMapOffset,
+                       Heap::kHashTableMapRootIndex);
+  StoreObjectFieldNoWriteBarrier(result, FixedArray::kLengthOffset,
+                                 SmiFromWord(length));
+  // Initialized HashTable fields.
+  Node* zero = SmiConstant(0);

[Igor Sheludko, 2016/10/21 07:48:27]

Smi::kZero

[Camillo Bruni, 2016/10/21 13:37:15]

I added the SmiConstant(int) given the frequent use of
SmiConstant(Smi::FromInt(i)) to add some convenience.

+  StoreObjectFieldNoWriteBarrier(result,
+                                 NameDictionary::kNumberOfElementsOffset, zero);
+  StoreObjectFieldNoWriteBarrier(
+      result, NameDictionary::kNumberOfDeletedElementsOffset, zero);
+  StoreObjectFieldNoWriteBarrier(result, NameDictionary::kCapacityOffset,
+                                 SmiFromWord(capacity));
+  // Initialize Dictionary fields.
+  Node* filler = LoadRoot(Heap::kUndefinedValueRootIndex);
+  StoreObjectFieldNoWriteBarrier(result, NameDictionary::kMaxNumberKeyOffset,
+                                 filler);
+  StoreObjectFieldNoWriteBarrier(result,
+                                 NameDictionary::kNextEnumerationIndexOffset,
+                                 SmiConstant(PropertyDetails::kInitialIndex));
+  // Initialize NameDictionary elements.
+  Node* start_address = IntPtrAdd(
+      result,
+      IntPtrConstant(NameDictionary::kElementsStartOffset - kHeapObjectTag));
+  Node* end_address = IntPtrAdd(
+      result,
+      IntPtrSubFoldConstants(store_size, IntPtrConstant(kHeapObjectTag)));
+  StoreFieldsNoWriteBarrier(start_address, end_address, filler);
+  return result;
+}
+
 Node* CodeStubAssembler::AllocateJSObjectFromMap(Node* map, Node* properties,
                                                  Node* elements) {
   Node* size =
       IntPtrMul(LoadMapInstanceSize(map), IntPtrConstant(kPointerSize));
   CSA_ASSERT(IsRegularHeapObjectSize(size));
   Node* object = Allocate(size);
   StoreMapNoWriteBarrier(object, map);
   InitializeJSObjectFromMap(object, map, size, properties, elements);
   return object;
 }
@@ skipping 6656 matching lines @@
   Node* buffer_bit_field = LoadObjectField(
       buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
   Node* was_neutered_mask = Int32Constant(JSArrayBuffer::WasNeutered::kMask);
 
   return Word32NotEqual(Word32And(buffer_bit_field, was_neutered_mask),
                         Int32Constant(0));
 }
 
 }  // namespace internal
 }  // namespace v8