v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub > Class Reference

Inheritance diagram for v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >:

Collaboration diagram for v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >:

Public Member Functions
	CodeStubGraphBuilder (Isolate *isolate, KeyedLoadGenericStub *stub)
Public Member Functions inherited from v8::internal::CodeStubGraphBuilderBase
	CodeStubGraphBuilderBase (Isolate *isolate, HydrogenCodeStub *stub)
virtual bool	BuildGraph ()
Public Member Functions inherited from v8::internal::HGraphBuilder
	HGraphBuilder (CompilationInfo *info)
virtual	~HGraphBuilder ()
Scope *	scope () const
void	set_scope (Scope *scope)
HBasicBlock *	current_block () const
void	set_current_block (HBasicBlock *block)
HEnvironment *	environment () const
Zone *	zone () const
HGraph *	graph () const
Isolate *	isolate () const
CompilationInfo *	top_info ()
HGraph *	CreateGraph ()
void	Push (HValue *value)
HValue *	Pop ()
HInstruction *	AddInstruction (HInstruction *instr)
void	FinishCurrentBlock (HControlInstruction *last)
void	FinishExitCurrentBlock (HControlInstruction *instruction)
void	Goto (HBasicBlock *from, HBasicBlock *target, FunctionState *state=NULL, bool add_simulate=true)
void	Goto (HBasicBlock *target, FunctionState *state=NULL, bool add_simulate=true)
void	GotoNoSimulate (HBasicBlock *from, HBasicBlock *target)
void	GotoNoSimulate (HBasicBlock *target)
void	AddLeaveInlined (HBasicBlock *block, HValue *return_value, FunctionState *state)
void	AddLeaveInlined (HValue *return_value, FunctionState *state)
template<class I >
HInstruction *	NewUncasted ()
template<class I >
I *	New ()
template<class I >
HInstruction *	AddUncasted ()
template<class I >
I *	Add ()
template<class I , class P1 >
HInstruction *	NewUncasted (P1 p1)
template<class I , class P1 >
I *	New (P1 p1)
template<class I , class P1 >
HInstruction *	AddUncasted (P1 p1)
template<class I , class P1 >
I *	Add (P1 p1)
template<class I , class P1 , class P2 >
HInstruction *	NewUncasted (P1 p1, P2 p2)
template<class I , class P1 , class P2 >
I *	New (P1 p1, P2 p2)
template<class I , class P1 , class P2 >
HInstruction *	AddUncasted (P1 p1, P2 p2)
template<class I , class P1 , class P2 >
I *	Add (P1 p1, P2 p2)
template<class I , class P1 , class P2 , class P3 >
HInstruction *	NewUncasted (P1 p1, P2 p2, P3 p3)
template<class I , class P1 , class P2 , class P3 >
I *	New (P1 p1, P2 p2, P3 p3)
template<class I , class P1 , class P2 , class P3 >
HInstruction *	AddUncasted (P1 p1, P2 p2, P3 p3)
template<class I , class P1 , class P2 , class P3 >
I *	Add (P1 p1, P2 p2, P3 p3)
template<class I , class P1 , class P2 , class P3 , class P4 >
HInstruction *	NewUncasted (P1 p1, P2 p2, P3 p3, P4 p4)
template<class I , class P1 , class P2 , class P3 , class P4 >
I *	New (P1 p1, P2 p2, P3 p3, P4 p4)
template<class I , class P1 , class P2 , class P3 , class P4 >
HInstruction *	AddUncasted (P1 p1, P2 p2, P3 p3, P4 p4)
template<class I , class P1 , class P2 , class P3 , class P4 >
I *	Add (P1 p1, P2 p2, P3 p3, P4 p4)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >
HInstruction *	NewUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >
I *	New (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >
HInstruction *	AddUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >
I *	Add (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >
HInstruction *	NewUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >
I *	New (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >
HInstruction *	AddUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >
I *	Add (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >
HInstruction *	NewUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >
I *	New (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >
HInstruction *	AddUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >
I *	Add (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >
HInstruction *	NewUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >
I *	New (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >
HInstruction *	AddUncasted (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >
I *	Add (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
void	AddSimulate (BailoutId id, RemovableSimulate removable=FIXED_SIMULATE)
template<>
HDeoptimize *	Add (const char *reason, Deoptimizer::BailoutType type)
template<>
HInstruction *	AddUncasted (const char *reason, Deoptimizer::BailoutType type)
template<>
HSimulate *	Add (BailoutId id, RemovableSimulate removable)
template<>
HSimulate *	Add (BailoutId id)
template<>
HInstruction *	AddUncasted (BailoutId id)
template<>
HReturn *	Add (HValue *value)
template<>
HReturn *	Add (HConstant *value)
template<>
HInstruction *	AddUncasted (HValue *value)
template<>
HInstruction *	AddUncasted (HConstant *value)
template<>
HCallRuntime *	Add (Handle< String > name, const Runtime::Function *c_function, int argument_count)
template<>
HInstruction *	AddUncasted (Handle< String > name, const Runtime::Function *c_function, int argument_count)
template<>
HContext *	New ()
template<>
HInstruction *	NewUncasted ()

Protected Member Functions
virtual HValue *	BuildCodeStub ()
void	BuildElementsKindLimitCheck (HGraphBuilder::IfBuilder *if_builder, HValue *bit_field2, ElementsKind kind)
void	BuildFastElementLoad (HGraphBuilder::IfBuilder *if_builder, HValue *receiver, HValue *key, HValue *instance_type, HValue *bit_field2, ElementsKind kind)
void	BuildExternalElementLoad (HGraphBuilder::IfBuilder *if_builder, HValue *receiver, HValue *key, HValue *instance_type, HValue *bit_field2, ElementsKind kind)
KeyedLoadGenericStub *	casted_stub ()
Protected Member Functions inherited from v8::internal::CodeStubGraphBuilderBase
HParameter *	GetParameter (int parameter)
HValue *	GetArgumentsLength ()
CompilationInfo *	info ()
HydrogenCodeStub *	stub ()
HContext *	context ()
Isolate *	isolate ()
HLoadNamedField *	BuildLoadNamedField (HValue *object, FieldIndex index)
void	BuildStoreNamedField (HValue *object, HValue *value, FieldIndex index, Representation representation)
HValue *	UnmappedCase (HValue *elements, HValue *key)
HValue *	BuildArrayConstructor (ElementsKind kind, AllocationSiteOverrideMode override_mode, ArgumentClass argument_class)
HValue *	BuildInternalArrayConstructor (ElementsKind kind, ArgumentClass argument_class)
void	BuildCheckAndInstallOptimizedCode (HValue *js_function, HValue *native_context, IfBuilder *builder, HValue *optimized_map, HValue *map_index)
void	BuildInstallCode (HValue *js_function, HValue *shared_info)
HInstruction *	LoadFromOptimizedCodeMap (HValue *optimized_map, HValue *iterator, int field_offset)
void	BuildInstallFromOptimizedCodeMap (HValue *js_function, HValue *shared_info, HValue *native_context)
Protected Member Functions inherited from v8::internal::HGraphBuilder
HBasicBlock *	CreateBasicBlock (HEnvironment *env)
HBasicBlock *	CreateLoopHeaderBlock ()
template<class BitFieldClass >
HValue *	BuildDecodeField (HValue *encoded_field)
HValue *	BuildGetElementsKind (HValue *object)
HValue *	BuildCheckHeapObject (HValue *object)
HValue *	BuildCheckString (HValue *string)
HValue *	BuildWrapReceiver (HValue *object, HValue *function)
HValue *	BuildCheckForCapacityGrow (HValue *object, HValue *elements, ElementsKind kind, HValue *length, HValue *key, bool is_js_array, PropertyAccessType access_type)
HValue *	BuildCopyElementsOnWrite (HValue *object, HValue *elements, ElementsKind kind, HValue *length)
void	BuildTransitionElementsKind (HValue *object, HValue *map, ElementsKind from_kind, ElementsKind to_kind, bool is_jsarray)
HValue *	BuildNumberToString (HValue *object, Type *type)
void	BuildJSObjectCheck (HValue *receiver, int bit_field_mask)
void	BuildKeyedIndexCheck (HValue *key, HIfContinuation *join_continuation)
void	BuildTestForDictionaryProperties (HValue *object, HIfContinuation *continuation)
void	BuildNonGlobalObjectCheck (HValue *receiver)
HValue *	BuildKeyedLookupCacheHash (HValue *object, HValue *key)
HValue *	BuildUncheckedDictionaryElementLoad (HValue *receiver, HValue *elements, HValue *key, HValue *hash)
HValue *	BuildRegExpConstructResult (HValue *length, HValue *index, HValue *input)
HAllocate *	BuildAllocate (HValue *object_size, HType type, InstanceType instance_type, HAllocationMode allocation_mode)
HValue *	BuildAddStringLengths (HValue *left_length, HValue *right_length)
HValue *	BuildCreateConsString (HValue *length, HValue *left, HValue *right, HAllocationMode allocation_mode)
void	BuildCopySeqStringChars (HValue *src, HValue *src_offset, String::Encoding src_encoding, HValue *dst, HValue *dst_offset, String::Encoding dst_encoding, HValue *length)
HValue *	BuildObjectSizeAlignment (HValue *unaligned_size, int header_size)
HValue *	BuildUncheckedStringAdd (HValue *left, HValue *right, HAllocationMode allocation_mode)
HValue *	BuildStringAdd (HValue *left, HValue *right, HAllocationMode allocation_mode)
HInstruction *	BuildUncheckedMonomorphicElementAccess (HValue *checked_object, HValue *key, HValue *val, bool is_js_array, ElementsKind elements_kind, PropertyAccessType access_type, LoadKeyedHoleMode load_mode, KeyedAccessStoreMode store_mode)
HInstruction *	AddElementAccess (HValue *elements, HValue *checked_key, HValue *val, HValue *dependency, ElementsKind elements_kind, PropertyAccessType access_type, LoadKeyedHoleMode load_mode=NEVER_RETURN_HOLE)
HInstruction *	AddLoadStringInstanceType (HValue *string)
HInstruction *	AddLoadStringLength (HValue *string)
HStoreNamedField *	AddStoreMapConstant (HValue *object, Handle< Map > map)
HLoadNamedField *	AddLoadMap (HValue *object, HValue *dependency=NULL)
HLoadNamedField *	AddLoadElements (HValue *object, HValue *dependency=NULL)
bool	MatchRotateRight (HValue *left, HValue *right, HValue **operand, HValue **shift_amount)
HValue *	BuildBinaryOperation (Token::Value op, HValue *left, HValue *right, Type *left_type, Type *right_type, Type *result_type, Maybe< int > fixed_right_arg, HAllocationMode allocation_mode)
HLoadNamedField *	AddLoadFixedArrayLength (HValue *object, HValue *dependency=NULL)
HLoadNamedField *	AddLoadArrayLength (HValue *object, ElementsKind kind, HValue *dependency=NULL)
HValue *	AddLoadJSBuiltin (Builtins::JavaScript builtin)
HValue *	EnforceNumberType (HValue *number, Type *expected)
HValue *	TruncateToNumber (HValue *value, Type **expected)
void	FinishExitWithHardDeoptimization (const char *reason)
void	AddIncrementCounter (StatsCounter *counter)
HValue *	BuildNewElementsCapacity (HValue *old_capacity)
HValue *	BuildAllocateArrayFromLength (JSArrayBuilder *array_builder, HValue *length_argument)
HValue *	BuildCalculateElementsSize (ElementsKind kind, HValue *capacity)
HAllocate *	AllocateJSArrayObject (AllocationSiteMode mode)
HConstant *	EstablishElementsAllocationSize (ElementsKind kind, int capacity)
HAllocate *	BuildAllocateElements (ElementsKind kind, HValue *size_in_bytes)
void	BuildInitializeElementsHeader (HValue *elements, ElementsKind kind, HValue *capacity)
HValue *	BuildAllocateElementsAndInitializeElementsHeader (ElementsKind kind, HValue *capacity)
void	BuildJSArrayHeader (HValue *array, HValue *array_map, HValue *elements, AllocationSiteMode mode, ElementsKind elements_kind, HValue *allocation_site_payload, HValue *length_field)
HValue *	BuildGrowElementsCapacity (HValue *object, HValue *elements, ElementsKind kind, ElementsKind new_kind, HValue *length, HValue *new_capacity)
void	BuildFillElementsWithValue (HValue *elements, ElementsKind elements_kind, HValue *from, HValue *to, HValue *value)
void	BuildFillElementsWithHole (HValue *elements, ElementsKind elements_kind, HValue *from, HValue *to)
void	BuildCopyElements (HValue *from_elements, ElementsKind from_elements_kind, HValue *to_elements, ElementsKind to_elements_kind, HValue *length, HValue *capacity)
HValue *	BuildCloneShallowArrayCow (HValue *boilerplate, HValue *allocation_site, AllocationSiteMode mode, ElementsKind kind)
HValue *	BuildCloneShallowArrayEmpty (HValue *boilerplate, HValue *allocation_site, AllocationSiteMode mode)
HValue *	BuildCloneShallowArrayNonEmpty (HValue *boilerplate, HValue *allocation_site, AllocationSiteMode mode, ElementsKind kind)
HValue *	BuildElementIndexHash (HValue *index)
void	BuildCompareNil (HValue *value, Type *type, HIfContinuation *continuation)
void	BuildCreateAllocationMemento (HValue *previous_object, HValue *previous_object_size, HValue *payload)
HInstruction *	BuildConstantMapCheck (Handle< JSObject > constant)
HInstruction *	BuildCheckPrototypeMaps (Handle< JSObject > prototype, Handle< JSObject > holder)
HInstruction *	BuildGetNativeContext (HValue *closure)
HInstruction *	BuildGetNativeContext ()
HInstruction *	BuildGetArrayFunction ()
void	SetSourcePosition (int position)
void	EnterInlinedSource (int start_position, int id)
HSourcePosition	ScriptPositionToSourcePosition (int position)
HSourcePosition	source_position ()
void	set_source_position (HSourcePosition position)
template<typename ViewClass >
void	BuildArrayBufferViewInitialization (HValue *obj, HValue *buffer, HValue *byte_offset, HValue *byte_length)

Additional Inherited Members
Static Public Attributes inherited from v8::internal::HGraphBuilder
static const int	kElementLoopUnrollThreshold = 8
Protected Types inherited from v8::internal::CodeStubGraphBuilderBase
enum	ArgumentClass { NONE , SINGLE , MULTIPLE }

Detailed Description

Definition at line 1601 of file code-stubs-hydrogen.cc.

Constructor & Destructor Documentation

CodeStubGraphBuilder()

v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::CodeStubGraphBuilder ( Isolate *  isolate, KeyedLoadGenericStub *  stub  )

inline

Definition at line 1604 of file code-stubs-hydrogen.cc.

      : CodeStubGraphBuilderBase(isolate, stub) {}

Member Function Documentation

BuildCodeStub()

HValue * v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub ( )

protectedvirtual

Implements v8::internal::CodeStubGraphBuilderBase.

Definition at line 1684 of file code-stubs-hydrogen.cc.

                                                                  {
  HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
  HValue* key = GetParameter(LoadDescriptor::kNameIndex);
 
  // Split into a smi/integer case and unique string case.
  HIfContinuation index_name_split_continuation(graph()->CreateBasicBlock(),
                                                graph()->CreateBasicBlock());
 
  BuildKeyedIndexCheck(key, &index_name_split_continuation);
 
  IfBuilder index_name_split(this, &index_name_split_continuation);
  index_name_split.Then();
  {
    // Key is an index (number)
    key = Pop();
 
    int bit_field_mask = (1 << Map::kIsAccessCheckNeeded) |
      (1 << Map::kHasIndexedInterceptor);
    BuildJSObjectCheck(receiver, bit_field_mask);
 
    HValue* map = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
                                       HObjectAccess::ForMap());
 
    HValue* instance_type =
      Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
                           HObjectAccess::ForMapInstanceType());
 
    HValue* bit_field2 = Add<HLoadNamedField>(map,
                                              static_cast<HValue*>(NULL),
                                              HObjectAccess::ForMapBitField2());
 
    IfBuilder kind_if(this);
    BuildFastElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                         FAST_HOLEY_ELEMENTS);
 
    kind_if.Else();
    {
      BuildFastElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                           FAST_HOLEY_DOUBLE_ELEMENTS);
    }
    kind_if.Else();
 
    // The DICTIONARY_ELEMENTS check generates a "kind_if.Then"
    BuildElementsKindLimitCheck(&kind_if, bit_field2, DICTIONARY_ELEMENTS);
    {
      HValue* elements = AddLoadElements(receiver);
 
      HValue* hash = BuildElementIndexHash(key);
 
      Push(BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash));
    }
    kind_if.Else();
 
    // The SLOPPY_ARGUMENTS_ELEMENTS check generates a "kind_if.Then"
    BuildElementsKindLimitCheck(&kind_if, bit_field2,
                                SLOPPY_ARGUMENTS_ELEMENTS);
    // Non-strict elements are not handled.
    Add<HDeoptimize>("non-strict elements in KeyedLoadGenericStub",
                     Deoptimizer::EAGER);
    Push(graph()->GetConstant0());
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_INT8_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_UINT8_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_INT16_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_UINT16_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_INT32_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_UINT32_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_FLOAT32_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_FLOAT64_ELEMENTS);
 
    kind_if.Else();
    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
                             EXTERNAL_UINT8_CLAMPED_ELEMENTS);
 
    kind_if.ElseDeopt("ElementsKind unhandled in KeyedLoadGenericStub");
 
    kind_if.End();
  }
  index_name_split.Else();
  {
    // Key is a unique string.
    key = Pop();
 
    int bit_field_mask = (1 << Map::kIsAccessCheckNeeded) |
        (1 << Map::kHasNamedInterceptor);
    BuildJSObjectCheck(receiver, bit_field_mask);
 
    HIfContinuation continuation;
    BuildTestForDictionaryProperties(receiver, &continuation);
    IfBuilder if_dict_properties(this, &continuation);
    if_dict_properties.Then();
    {
      //  Key is string, properties are dictionary mode
      BuildNonGlobalObjectCheck(receiver);
 
      HValue* properties = Add<HLoadNamedField>(
          receiver, static_cast<HValue*>(NULL),
          HObjectAccess::ForPropertiesPointer());
 
      HValue* hash =
          Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
          HObjectAccess::ForNameHashField());
 
      hash = AddUncasted<HShr>(hash, Add<HConstant>(Name::kHashShift));
 
      HValue* value = BuildUncheckedDictionaryElementLoad(receiver,
                                                          properties,
                                                          key,
                                                          hash);
      Push(value);
    }
    if_dict_properties.Else();
    {
      //  Key is string, properties are fast mode
      HValue* hash = BuildKeyedLookupCacheHash(receiver, key);
 
      ExternalReference cache_keys_ref =
          ExternalReference::keyed_lookup_cache_keys(isolate());
      HValue* cache_keys = Add<HConstant>(cache_keys_ref);
 
      HValue* map = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
                                         HObjectAccess::ForMap());
      HValue* base_index = AddUncasted<HMul>(hash, Add<HConstant>(2));
      base_index->ClearFlag(HValue::kCanOverflow);
 
      HIfContinuation inline_or_runtime_continuation(
          graph()->CreateBasicBlock(), graph()->CreateBasicBlock());
      {
        IfBuilder lookup_ifs[KeyedLookupCache::kEntriesPerBucket];
        for (int probe = 0; probe < KeyedLookupCache::kEntriesPerBucket;
             ++probe) {
          IfBuilder* lookup_if = &lookup_ifs[probe];
          lookup_if->Initialize(this);
          int probe_base = probe * KeyedLookupCache::kEntryLength;
          HValue* map_index = AddUncasted<HAdd>(
              base_index,
              Add<HConstant>(probe_base + KeyedLookupCache::kMapIndex));
          map_index->ClearFlag(HValue::kCanOverflow);
          HValue* key_index = AddUncasted<HAdd>(
              base_index,
              Add<HConstant>(probe_base + KeyedLookupCache::kKeyIndex));
          key_index->ClearFlag(HValue::kCanOverflow);
          HValue* map_to_check =
              Add<HLoadKeyed>(cache_keys, map_index, static_cast<HValue*>(NULL),
                              FAST_ELEMENTS, NEVER_RETURN_HOLE, 0);
          lookup_if->If<HCompareObjectEqAndBranch>(map_to_check, map);
          lookup_if->And();
          HValue* key_to_check =
              Add<HLoadKeyed>(cache_keys, key_index, static_cast<HValue*>(NULL),
                              FAST_ELEMENTS, NEVER_RETURN_HOLE, 0);
          lookup_if->If<HCompareObjectEqAndBranch>(key_to_check, key);
          lookup_if->Then();
          {
            ExternalReference cache_field_offsets_ref =
                ExternalReference::keyed_lookup_cache_field_offsets(isolate());
            HValue* cache_field_offsets =
                Add<HConstant>(cache_field_offsets_ref);
            HValue* index = AddUncasted<HAdd>(hash, Add<HConstant>(probe));
            index->ClearFlag(HValue::kCanOverflow);
            HValue* property_index = Add<HLoadKeyed>(
                cache_field_offsets, index, static_cast<HValue*>(NULL),
                EXTERNAL_INT32_ELEMENTS, NEVER_RETURN_HOLE, 0);
            Push(property_index);
          }
          lookup_if->Else();
        }
        for (int i = 0; i < KeyedLookupCache::kEntriesPerBucket; ++i) {
          lookup_ifs[i].JoinContinuation(&inline_or_runtime_continuation);
        }
      }
 
      IfBuilder inline_or_runtime(this, &inline_or_runtime_continuation);
      inline_or_runtime.Then();
      {
        // Found a cached index, load property inline.
        Push(Add<HLoadFieldByIndex>(receiver, Pop()));
      }
      inline_or_runtime.Else();
      {
        // KeyedLookupCache miss; call runtime.
        Add<HPushArguments>(receiver, key);
        Push(Add<HCallRuntime>(
            isolate()->factory()->empty_string(),
            Runtime::FunctionForId(Runtime::kKeyedGetProperty), 2));
      }
      inline_or_runtime.End();
    }
    if_dict_properties.End();
  }
  index_name_split.End();
 
  return Pop();
}

References v8::internal::HGraphBuilder::AddLoadElements(), v8::internal::HGraphBuilder::BuildElementIndexHash(), v8::internal::HGraphBuilder::BuildJSObjectCheck(), v8::internal::HGraphBuilder::BuildKeyedIndexCheck(), v8::internal::HGraphBuilder::BuildKeyedLookupCacheHash(), v8::internal::HGraphBuilder::BuildNonGlobalObjectCheck(), v8::internal::HGraphBuilder::BuildTestForDictionaryProperties(), v8::internal::HGraphBuilder::BuildUncheckedDictionaryElementLoad(), v8::internal::HValue::ClearFlag(), v8::internal::HGraphBuilder::CreateBasicBlock(), v8::internal::DICTIONARY_ELEMENTS, v8::internal::Deoptimizer::EAGER, v8::internal::EXTERNAL_FLOAT32_ELEMENTS, v8::internal::EXTERNAL_FLOAT64_ELEMENTS, v8::internal::EXTERNAL_INT16_ELEMENTS, v8::internal::EXTERNAL_INT32_ELEMENTS, v8::internal::EXTERNAL_INT8_ELEMENTS, v8::internal::EXTERNAL_UINT16_ELEMENTS, v8::internal::EXTERNAL_UINT32_ELEMENTS, v8::internal::EXTERNAL_UINT8_CLAMPED_ELEMENTS, v8::internal::EXTERNAL_UINT8_ELEMENTS, v8::internal::FAST_ELEMENTS, v8::internal::FAST_HOLEY_DOUBLE_ELEMENTS, v8::internal::FAST_HOLEY_ELEMENTS, v8::internal::Runtime::FunctionForId(), v8::internal::CodeStubGraphBuilderBase::GetParameter(), v8::internal::HGraphBuilder::graph(), v8::internal::CodeStubGraphBuilderBase::isolate(), v8::internal::HValue::kCanOverflow, v8::internal::KeyedLookupCache::kEntriesPerBucket, v8::internal::KeyedLookupCache::kEntryLength, v8::internal::Name::kHashShift, v8::internal::Map::kHasIndexedInterceptor, v8::internal::Map::kHasNamedInterceptor, v8::internal::Map::kIsAccessCheckNeeded, v8::internal::KeyedLookupCache::kKeyIndex, v8::internal::KeyedLookupCache::kMapIndex, v8::internal::LoadDescriptor::kNameIndex, v8::internal::LoadDescriptor::kReceiverIndex, map, v8::internal::NEVER_RETURN_HOLE, NULL, v8::internal::HGraphBuilder::Pop(), v8::internal::HGraphBuilder::Push(), and v8::internal::SLOPPY_ARGUMENTS_ELEMENTS.

Here is the call graph for this function:

BuildElementsKindLimitCheck()

void v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildElementsKindLimitCheck ( HGraphBuilder::IfBuilder *  if_builder, HValue *  bit_field2, ElementsKind  kind  )

protected

Definition at line 1634 of file code-stubs-hydrogen.cc.

                       {
  ElementsKind next_kind = static_cast<ElementsKind>(kind + 1);
  HValue* kind_limit = Add<HConstant>(
      static_cast<int>(Map::ElementsKindBits::encode(next_kind)));
 
  if_builder->If<HCompareNumericAndBranch>(bit_field2, kind_limit, Token::LT);
  if_builder->Then();
}

References v8::internal::BitFieldBase< T, shift, size, U >::encode().

Here is the call graph for this function:

BuildExternalElementLoad()

void v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildExternalElementLoad ( HGraphBuilder::IfBuilder *  if_builder, HValue *  receiver, HValue *  key, HValue *  instance_type, HValue *  bit_field2, ElementsKind  kind  )

protected

Definition at line 1670 of file code-stubs-hydrogen.cc.

                                                                  {
  DCHECK(IsExternalArrayElementsKind(kind));
 
  BuildElementsKindLimitCheck(if_builder, bit_field2, kind);
 
  Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                              false, kind,
                                              LOAD, NEVER_RETURN_HOLE,
                                              STANDARD_STORE));
}

References v8::internal::HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), DCHECK, v8::internal::IsExternalArrayElementsKind(), v8::internal::LOAD, v8::internal::NEVER_RETURN_HOLE, NULL, v8::internal::HGraphBuilder::Push(), and v8::internal::STANDARD_STORE.

Here is the call graph for this function:

BuildFastElementLoad()

void v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildFastElementLoad ( HGraphBuilder::IfBuilder *  if_builder, HValue *  receiver, HValue *  key, HValue *  instance_type, HValue *  bit_field2, ElementsKind  kind  )

protected

Definition at line 1646 of file code-stubs-hydrogen.cc.

                                                                  {
  DCHECK(!IsExternalArrayElementsKind(kind));
 
  BuildElementsKindLimitCheck(if_builder, bit_field2, kind);
 
  IfBuilder js_array_check(this);
  js_array_check.If<HCompareNumericAndBranch>(
      instance_type, Add<HConstant>(JS_ARRAY_TYPE), Token::EQ);
  js_array_check.Then();
  Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                              true, kind,
                                              LOAD, NEVER_RETURN_HOLE,
                                              STANDARD_STORE));
  js_array_check.Else();
  Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                              false, kind,
                                              LOAD, NEVER_RETURN_HOLE,
                                              STANDARD_STORE));
  js_array_check.End();
}

References v8::internal::HGraphBuilder::BuildUncheckedMonomorphicElementAccess(), DCHECK, v8::internal::EQ, v8::internal::IsExternalArrayElementsKind(), v8::internal::JS_ARRAY_TYPE, v8::internal::LOAD, v8::internal::NEVER_RETURN_HOLE, NULL, v8::internal::HGraphBuilder::Push(), and v8::internal::STANDARD_STORE.

Here is the call graph for this function:

casted_stub()

KeyedLoadGenericStub* v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::casted_stub ( )

inlineprotected

Definition at line 1628 of file code-stubs-hydrogen.cc.

                                      {
    return static_cast<KeyedLoadGenericStub*>(stub());
  }

References v8::internal::CodeStubGraphBuilderBase::stub().

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/code-stubs-hydrogen.cc