[stubs] Extend HasProperty stub with dictionary-mode and double-elements objects support.

src/code-stub-assembler.h

 // 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.
 
 #ifndef V8_CODE_STUB_ASSEMBLER_H_
 #define V8_CODE_STUB_ASSEMBLER_H_
 
 #include "src/compiler/code-assembler.h"
 #include "src/objects.h"
 
@@ skipping 20 matching lines @@
   // Create with JSCall linkage.
   CodeStubAssembler(Isolate* isolate, Zone* zone, int parameter_count,
                     Code::Flags flags, const char* name);
 
   compiler::Node* BooleanMapConstant();
   compiler::Node* EmptyStringConstant();
   compiler::Node* HeapNumberMapConstant();
   compiler::Node* NoContextConstant();
   compiler::Node* NullConstant();
   compiler::Node* UndefinedConstant();
+  compiler::Node* TheHoleConstant();
+  compiler::Node* HashSeed();
   compiler::Node* StaleRegisterConstant();
 
   // Float64 operations.
   compiler::Node* Float64Ceil(compiler::Node* x);
   compiler::Node* Float64Floor(compiler::Node* x);
   compiler::Node* Float64Round(compiler::Node* x);
   compiler::Node* Float64Trunc(compiler::Node* x);
 
   // Tag a Word as a Smi value.
   compiler::Node* SmiTag(compiler::Node* value);
@@ skipping 49 matching lines @@
                                    MachineType rep = MachineType::AnyTagged());
   // Load a field from an object on the heap.
   compiler::Node* LoadObjectField(compiler::Node* object, int offset,
                                   MachineType rep = MachineType::AnyTagged());
   // Load the floating point value of a HeapNumber.
   compiler::Node* LoadHeapNumberValue(compiler::Node* object);
   // Load the Map of an HeapObject.
   compiler::Node* LoadMap(compiler::Node* object);
   // Load the instance type of an HeapObject.
   compiler::Node* LoadInstanceType(compiler::Node* object);
+  // Load the properties backing store of a JSObject.
+  compiler::Node* LoadProperties(compiler::Node* object);
   // Load the elements backing store of a JSObject.
   compiler::Node* LoadElements(compiler::Node* object);
   // Load the length of a fixed array base instance.
   compiler::Node* LoadFixedArrayBaseLength(compiler::Node* array);
   // Load the bit field of a Map.
   compiler::Node* LoadMapBitField(compiler::Node* map);
   // Load bit field 2 of a map.
   compiler::Node* LoadMapBitField2(compiler::Node* map);
   // Load bit field 3 of a map.
   compiler::Node* LoadMapBitField3(compiler::Node* map);
   // Load the instance type of a map.
   compiler::Node* LoadMapInstanceType(compiler::Node* map);
   // Load the instance descriptors of a map.
   compiler::Node* LoadMapDescriptors(compiler::Node* map);
   // Load the prototype of a map.
   compiler::Node* LoadMapPrototype(compiler::Node* map);
 
   // Load the hash field of a name.
-  compiler::Node* LoadNameHash(compiler::Node* name);
+  compiler::Node* LoadNameHashField(compiler::Node* name);
+  // Load the hash value of a name. If {if_hash_not_computed} label
+  // is specified then it also checks if hash is actually computed.
+  compiler::Node* LoadNameHash(compiler::Node* name,
+                               Label* if_hash_not_computed = nullptr);
   // Load the instance size of a Map.
   compiler::Node* LoadMapInstanceSize(compiler::Node* map);
 
   compiler::Node* AllocateUninitializedFixedArray(compiler::Node* length);
 
   // Load an array element from a FixedArray.
   compiler::Node* LoadFixedArrayElementInt32Index(compiler::Node* object,
                                                   compiler::Node* int32_index,
                                                   int additional_offset = 0);
   compiler::Node* LoadFixedArrayElementSmiIndex(compiler::Node* object,
                                                 compiler::Node* smi_index,
                                                 int additional_offset = 0);
   compiler::Node* LoadFixedArrayElementConstantIndex(compiler::Node* object,
                                                      int index);
+  // Load an array element from a FixedDoubleArray.
+  compiler::Node* OffsetOfFixedDoubleArrayElementInt32Index(
+      compiler::Node* int32_index, int additional_offset = 0);
+  compiler::Node* LoadFixedDoubleArrayElementInt32Index(
+      compiler::Node* object, compiler::Node* int32_index,
+      MachineType machine_type, int additional_offset = 0);
 
   // Context manipulation
   compiler::Node* LoadNativeContext(compiler::Node* context);
 
   compiler::Node* LoadJSArrayElementsMap(ElementsKind kind,
                                          compiler::Node* native_context);
 
   // Store the floating point value of a HeapNumber.
   compiler::Node* StoreHeapNumberValue(compiler::Node* object,
                                        compiler::Node* value);
@@ skipping 75 matching lines @@
     return BitFieldDecode(word32, T::kShift, T::kMask);
   }
 
   compiler::Node* BitFieldDecode(compiler::Node* word32, uint32_t shift,
                                  uint32_t mask);
 
   // Various building blocks for stubs doing property lookups.
   void TryToName(compiler::Node* key, Label* if_keyisindex, Variable* var_index,
                  Label* if_keyisunique, Label* call_runtime);
 
+  static const int kInlinedDictionaryProbes = 4;
+  template <typename Dictionary>
+  void NameDictionaryLookup(compiler::Node* dictionary,
+                            compiler::Node* unique_name, Label* if_found,
+                            Label* if_not_found, Label* call_runtime,
+                            int inlined_probes = kInlinedDictionaryProbes);
+
+  compiler::Node* ComputeIntegerHash(compiler::Node* key, compiler::Node* seed);
+
+  template <typename Dictionary>
+  void NumberDictionaryLookup(compiler::Node* dictionary, compiler::Node* key,
+                              Label* if_found, Label* if_not_found,
+                              Label* call_runtime);
+
   void TryLookupProperty(compiler::Node* object, compiler::Node* map,
-                         compiler::Node* instance_type, compiler::Node* name,
-                         Label* if_found, Label* if_not_found,
-                         Label* call_runtime);
+                         compiler::Node* instance_type,
+                         compiler::Node* unique_name, Label* if_found,
+                         Label* if_not_found, Label* call_runtime);
 
   void TryLookupElement(compiler::Node* object, compiler::Node* map,
                         compiler::Node* instance_type, compiler::Node* index,
                         Label* if_found, Label* if_not_found,
                         Label* call_runtime);
 
   // Instanceof helpers.
   // ES6 section 7.3.19 OrdinaryHasInstance (C, O)
   compiler::Node* OrdinaryHasInstance(compiler::Node* context,
                                       compiler::Node* callable,
                                       compiler::Node* object);
 
  private:
   compiler::Node* AllocateRawAligned(compiler::Node* size_in_bytes,
                                      AllocationFlags flags,
                                      compiler::Node* top_address,
                                      compiler::Node* limit_address);
   compiler::Node* AllocateRawUnaligned(compiler::Node* size_in_bytes,
                                        AllocationFlags flags,
                                        compiler::Node* top_adddress,
                                        compiler::Node* limit_address);
 
   static const int kElementLoopUnrollThreshold = 8;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CODE_STUB_ASSEMBLER_H_