Inheritance diagram for v8::internal::CodeStubGraphBuilderBase:

Collaboration diagram for v8::internal::CodeStubGraphBuilderBase:

Public Member Functions
	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 Types
enum	ArgumentClass { NONE , SINGLE , MULTIPLE }

Protected Member Functions
virtual HValue *	BuildCodeStub ()=0

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)

Private Member Functions
HValue *	BuildArraySingleArgumentConstructor (JSArrayBuilder *builder)

HValue *	BuildArrayNArgumentsConstructor (JSArrayBuilder *builder, ElementsKind kind)

Private Attributes
SmartArrayPointer< HParameter * >	parameters_

HValue *	arguments_length_

CompilationInfoWithZone	info_

CodeStubDescriptor	descriptor_

HContext *	context_

Additional Inherited Members
Static Public Attributes inherited from v8::internal::HGraphBuilder
static const int	kElementLoopUnrollThreshold = 8

Detailed Description

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

Member Enumeration Documentation

◆ ArgumentClass

enum v8::internal::CodeStubGraphBuilderBase::ArgumentClass

protected

Enumerator
NONE
SINGLE
MULTIPLE

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

                      {
     NONE,
     SINGLE,
     MULTIPLE
   };

Constructor & Destructor Documentation

◆ CodeStubGraphBuilderBase()

v8::internal::CodeStubGraphBuilderBase::CodeStubGraphBuilderBase	(	Isolate *	isolate,
		HydrogenCodeStub *	stub
	)

inline

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

       : HGraphBuilder(&info_),
         arguments_length_(NULL),
         info_(stub, isolate),
         descriptor_(stub),
         context_(NULL) {
     int parameter_count = descriptor_.GetEnvironmentParameterCount();
     parameters_.Reset(new HParameter*[parameter_count]);
   }

References descriptor_, v8::internal::CodeStubDescriptor::GetEnvironmentParameterCount(), parameters_, and v8::internal::SmartPointerBase< Deallocator, T >::Reset().

Here is the call graph for this function:

Member Function Documentation

◆ BuildArrayConstructor()

HValue * v8::internal::CodeStubGraphBuilderBase::BuildArrayConstructor	(	ElementsKind	kind,
		AllocationSiteOverrideMode	override_mode,
		ArgumentClass	argument_class
	)

protected

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

                                   {
   HValue* constructor = GetParameter(ArrayConstructorStubBase::kConstructor);
   HValue* alloc_site = GetParameter(ArrayConstructorStubBase::kAllocationSite);
   JSArrayBuilder array_builder(this, kind, alloc_site, constructor,
                                override_mode);
   HValue* result = NULL;
   switch (argument_class) {
     case NONE:
       // This stub is very performance sensitive, the generated code must be
       // tuned so that it doesn't build and eager frame.
       info()->MarkMustNotHaveEagerFrame();
       result = array_builder.AllocateEmptyArray();
       break;
     case SINGLE:
       result = BuildArraySingleArgumentConstructor(&array_builder);
       break;
     case MULTIPLE:
       result = BuildArrayNArgumentsConstructor(&array_builder, kind);
       break;
   }
  
   return result;
 }

References BuildArrayNArgumentsConstructor(), BuildArraySingleArgumentConstructor(), GetParameter(), info(), v8::internal::ArrayConstructorStubBase::kAllocationSite, v8::internal::ArrayConstructorStubBase::kConstructor, v8::internal::CompilationInfo::MarkMustNotHaveEagerFrame(), MULTIPLE, NONE, NULL, and SINGLE.

Here is the call graph for this function:

◆ BuildArrayNArgumentsConstructor()

HValue * v8::internal::CodeStubGraphBuilderBase::BuildArrayNArgumentsConstructor	(	JSArrayBuilder *	builder,
		ElementsKind	kind
	)

private

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

                                                       {
   // Insert a bounds check because the number of arguments might exceed
   // the kInitialMaxFastElementArray limit. This cannot happen for code
   // that was parsed, but calling via Array.apply(thisArg, [...]) might
   // trigger it.
   HValue* length = GetArgumentsLength();
   HConstant* max_alloc_length =
       Add<HConstant>(JSObject::kInitialMaxFastElementArray);
   HValue* checked_length = Add<HBoundsCheck>(length, max_alloc_length);
  
   // We need to fill with the hole if it's a smi array in the multi-argument
   // case because we might have to bail out while copying arguments into
   // the array because they aren't compatible with a smi array.
   // If it's a double array, no problem, and if it's fast then no
   // problem either because doubles are boxed.
   //
   // TODO(mvstanton): consider an instruction to memset fill the array
   // with zero in this case instead.
   JSArrayBuilder::FillMode fill_mode = IsFastSmiElementsKind(kind)
       ? JSArrayBuilder::FILL_WITH_HOLE
       : JSArrayBuilder::DONT_FILL_WITH_HOLE;
   HValue* new_object = array_builder->AllocateArray(checked_length,
                                                     max_alloc_length,
                                                     checked_length,
                                                     fill_mode);
   HValue* elements = array_builder->GetElementsLocation();
   DCHECK(elements != NULL);
  
   // Now populate the elements correctly.
   LoopBuilder builder(this,
                       context(),
                       LoopBuilder::kPostIncrement);
   HValue* start = graph()->GetConstant0();
   HValue* key = builder.BeginBody(start, checked_length, Token::LT);
   HInstruction* argument_elements = Add<HArgumentsElements>(false);
   HInstruction* argument = Add<HAccessArgumentsAt>(
       argument_elements, checked_length, key);
  
   Add<HStoreKeyed>(elements, key, argument, kind);
   builder.EndBody();
   return new_object;
 }

References context(), DCHECK, GetArgumentsLength(), v8::internal::HGraphBuilder::graph(), v8::internal::IsFastSmiElementsKind(), v8::internal::JSObject::kInitialMaxFastElementArray, and NULL.

Referenced by BuildArrayConstructor(), and BuildInternalArrayConstructor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildArraySingleArgumentConstructor()

HValue * v8::internal::CodeStubGraphBuilderBase::BuildArraySingleArgumentConstructor ( JSArrayBuilder * builder )

private

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

                                    {
   // Smi check and range check on the input arg.
   HValue* constant_one = graph()->GetConstant1();
   HValue* constant_zero = graph()->GetConstant0();
  
   HInstruction* elements = Add<HArgumentsElements>(false);
   HInstruction* argument = Add<HAccessArgumentsAt>(
       elements, constant_one, constant_zero);
  
   return BuildAllocateArrayFromLength(array_builder, argument);
 }

References v8::internal::HGraphBuilder::BuildAllocateArrayFromLength(), and v8::internal::HGraphBuilder::graph().

Referenced by BuildArrayConstructor(), and BuildInternalArrayConstructor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildCheckAndInstallOptimizedCode()

void v8::internal::CodeStubGraphBuilderBase::BuildCheckAndInstallOptimizedCode	(	HValue *	js_function,
		HValue *	native_context,
		IfBuilder *	builder,
		HValue *	optimized_map,
		HValue *	map_index
	)

protected

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

                        {
   HValue* osr_ast_id_none = Add<HConstant>(BailoutId::None().ToInt());
   HValue* context_slot = LoadFromOptimizedCodeMap(
       optimized_map, map_index, SharedFunctionInfo::kContextOffset);
   HValue* osr_ast_slot = LoadFromOptimizedCodeMap(
       optimized_map, map_index, SharedFunctionInfo::kOsrAstIdOffset);
   builder->If<HCompareObjectEqAndBranch>(native_context,
                                          context_slot);
   builder->AndIf<HCompareObjectEqAndBranch>(osr_ast_slot, osr_ast_id_none);
   builder->Then();
   HValue* code_object = LoadFromOptimizedCodeMap(optimized_map,
       map_index, SharedFunctionInfo::kCachedCodeOffset);
   // and the literals
   HValue* literals = LoadFromOptimizedCodeMap(optimized_map,
       map_index, SharedFunctionInfo::kLiteralsOffset);
  
   Counters* counters = isolate()->counters();
   AddIncrementCounter(counters->fast_new_closure_install_optimized());
  
   // TODO(fschneider): Idea: store proper code pointers in the optimized code
   // map and either unmangle them on marking or do nothing as the whole map is
   // discarded on major GC anyway.
   Add<HStoreCodeEntry>(js_function, code_object);
   Add<HStoreNamedField>(js_function, HObjectAccess::ForLiteralsPointer(),
                         literals);
  
   // Now link a function into a list of optimized functions.
   HValue* optimized_functions_list = Add<HLoadNamedField>(
       native_context, static_cast<HValue*>(NULL),
       HObjectAccess::ForContextSlot(Context::OPTIMIZED_FUNCTIONS_LIST));
   Add<HStoreNamedField>(js_function,
                         HObjectAccess::ForNextFunctionLinkPointer(),
                         optimized_functions_list);
  
   // This store is the only one that should have a write barrier.
   Add<HStoreNamedField>(native_context,
            HObjectAccess::ForContextSlot(Context::OPTIMIZED_FUNCTIONS_LIST),
            js_function);
  
   // The builder continues in the "then" after this function.
 }

References v8::internal::HGraphBuilder::AddIncrementCounter(), v8::internal::Isolate::counters(), isolate(), v8::internal::SharedFunctionInfo::kCachedCodeOffset, v8::internal::SharedFunctionInfo::kContextOffset, v8::internal::SharedFunctionInfo::kLiteralsOffset, v8::internal::SharedFunctionInfo::kOsrAstIdOffset, literals(), LoadFromOptimizedCodeMap(), v8::internal::BailoutId::None(), NULL, and v8::internal::Context::OPTIMIZED_FUNCTIONS_LIST.

Referenced by BuildInstallFromOptimizedCodeMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildCodeStub()

virtual HValue* v8::internal::CodeStubGraphBuilderBase::BuildCodeStub ( )

protectedpure virtual

Referenced by BuildGraph().

Here is the caller graph for this function:

◆ BuildGraph()

bool v8::internal::CodeStubGraphBuilderBase::BuildGraph ( )

virtual

Implements v8::internal::HGraphBuilder.

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

                                           {
   // Update the static counter each time a new code stub is generated.
   isolate()->counters()->code_stubs()->Increment();
  
   if (FLAG_trace_hydrogen_stubs) {
     const char* name = CodeStub::MajorName(stub()->MajorKey(), false);
     PrintF("-----------------------------------------------------------\n");
     PrintF("Compiling stub %s using hydrogen\n", name);
     isolate()->GetHTracer()->TraceCompilation(&info_);
   }
  
   int param_count = descriptor_.GetEnvironmentParameterCount();
   HEnvironment* start_environment = graph()->start_environment();
   HBasicBlock* next_block = CreateBasicBlock(start_environment);
   Goto(next_block);
   next_block->SetJoinId(BailoutId::StubEntry());
   set_current_block(next_block);
  
   bool runtime_stack_params = descriptor_.stack_parameter_count().is_valid();
   HInstruction* stack_parameter_count = NULL;
   for (int i = 0; i < param_count; ++i) {
     Representation r = descriptor_.GetEnvironmentParameterRepresentation(i);
     HParameter* param = Add<HParameter>(i,
                                         HParameter::REGISTER_PARAMETER, r);
     start_environment->Bind(i, param);
     parameters_[i] = param;
     if (descriptor_.IsEnvironmentParameterCountRegister(i)) {
       param->set_type(HType::Smi());
       stack_parameter_count = param;
       arguments_length_ = stack_parameter_count;
     }
   }
  
   DCHECK(!runtime_stack_params || arguments_length_ != NULL);
   if (!runtime_stack_params) {
     stack_parameter_count = graph()->GetConstantMinus1();
     arguments_length_ = graph()->GetConstant0();
   }
  
   context_ = Add<HContext>();
   start_environment->BindContext(context_);
  
   Add<HSimulate>(BailoutId::StubEntry());
  
   NoObservableSideEffectsScope no_effects(this);
  
   HValue* return_value = BuildCodeStub();
  
   // We might have extra expressions to pop from the stack in addition to the
   // arguments above.
   HInstruction* stack_pop_count = stack_parameter_count;
   if (descriptor_.function_mode() == JS_FUNCTION_STUB_MODE) {
     if (!stack_parameter_count->IsConstant() &&
         descriptor_.hint_stack_parameter_count() < 0) {
       HInstruction* constant_one = graph()->GetConstant1();
       stack_pop_count = AddUncasted<HAdd>(stack_parameter_count, constant_one);
       stack_pop_count->ClearFlag(HValue::kCanOverflow);
       // TODO(mvstanton): verify that stack_parameter_count+1 really fits in a
       // smi.
     } else {
       int count = descriptor_.hint_stack_parameter_count();
       stack_pop_count = Add<HConstant>(count);
     }
   }
  
   if (current_block() != NULL) {
     HReturn* hreturn_instruction = New<HReturn>(return_value,
                                                 stack_pop_count);
     FinishCurrentBlock(hreturn_instruction);
   }
   return true;
 }

References arguments_length_, BuildCodeStub(), v8::internal::HValue::ClearFlag(), context_, v8::internal::Isolate::counters(), v8::internal::HGraphBuilder::CreateBasicBlock(), v8::internal::HGraphBuilder::current_block(), DCHECK, descriptor_, v8::internal::HGraphBuilder::FinishCurrentBlock(), v8::internal::CodeStubDescriptor::function_mode(), v8::internal::CodeStubDescriptor::GetEnvironmentParameterCount(), v8::internal::CodeStubDescriptor::GetEnvironmentParameterRepresentation(), v8::internal::Isolate::GetHTracer(), v8::internal::HGraphBuilder::Goto(), v8::internal::HGraphBuilder::graph(), v8::internal::CodeStubDescriptor::hint_stack_parameter_count(), info_, v8::internal::Register::is_valid(), v8::internal::CodeStubDescriptor::IsEnvironmentParameterCountRegister(), isolate(), v8::internal::JS_FUNCTION_STUB_MODE, v8::internal::HValue::kCanOverflow, name, NULL, parameters_, v8::internal::PrintF(), v8::internal::HGraphBuilder::set_current_block(), v8::internal::CodeStubDescriptor::stack_parameter_count(), stub(), and v8::internal::BailoutId::StubEntry().

Here is the call graph for this function:

◆ BuildInstallCode()

void v8::internal::CodeStubGraphBuilderBase::BuildInstallCode	(	HValue *	js_function,
		HValue *	shared_info
	)

protected

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

                                                                      {
   Add<HStoreNamedField>(js_function,
                         HObjectAccess::ForNextFunctionLinkPointer(),
                         graph()->GetConstantUndefined());
   HValue* code_object = Add<HLoadNamedField>(
       shared_info, static_cast<HValue*>(NULL), HObjectAccess::ForCodeOffset());
   Add<HStoreCodeEntry>(js_function, code_object);
 }

References v8::internal::HGraphBuilder::graph(), and NULL.

Referenced by BuildInstallFromOptimizedCodeMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildInstallFromOptimizedCodeMap()

void v8::internal::CodeStubGraphBuilderBase::BuildInstallFromOptimizedCodeMap	(	HValue *	js_function,
		HValue *	shared_info,
		HValue *	native_context
	)

protected

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

                             {
   Counters* counters = isolate()->counters();
   IfBuilder is_optimized(this);
   HInstruction* optimized_map = Add<HLoadNamedField>(
       shared_info, static_cast<HValue*>(NULL),
       HObjectAccess::ForOptimizedCodeMap());
   HValue* null_constant = Add<HConstant>(0);
   is_optimized.If<HCompareObjectEqAndBranch>(optimized_map, null_constant);
   is_optimized.Then();
   {
     BuildInstallCode(js_function, shared_info);
   }
   is_optimized.Else();
   {
     AddIncrementCounter(counters->fast_new_closure_try_optimized());
     // optimized_map points to fixed array of 3-element entries
     // (native context, optimized code, literals).
     // Map must never be empty, so check the first elements.
     HValue* first_entry_index =
         Add<HConstant>(SharedFunctionInfo::kEntriesStart);
     IfBuilder already_in(this);
     BuildCheckAndInstallOptimizedCode(js_function, native_context, &already_in,
                                       optimized_map, first_entry_index);
     already_in.Else();
     {
       // Iterate through the rest of map backwards. Do not double check first
       // entry. After the loop, if no matching optimized code was found,
       // install unoptimized code.
       // for(i = map.length() - SharedFunctionInfo::kEntryLength;
       //     i > SharedFunctionInfo::kEntriesStart;
       //     i -= SharedFunctionInfo::kEntryLength) { .. }
       HValue* shared_function_entry_length =
           Add<HConstant>(SharedFunctionInfo::kEntryLength);
       LoopBuilder loop_builder(this,
                                context(),
                                LoopBuilder::kPostDecrement,
                                shared_function_entry_length);
       HValue* array_length = Add<HLoadNamedField>(
           optimized_map, static_cast<HValue*>(NULL),
           HObjectAccess::ForFixedArrayLength());
       HValue* start_pos = AddUncasted<HSub>(array_length,
                                             shared_function_entry_length);
       HValue* slot_iterator = loop_builder.BeginBody(start_pos,
                                                      first_entry_index,
                                                      Token::GT);
       {
         IfBuilder done_check(this);
         BuildCheckAndInstallOptimizedCode(js_function, native_context,
                                           &done_check,
                                           optimized_map,
                                           slot_iterator);
         // Fall out of the loop
         loop_builder.Break();
       }
       loop_builder.EndBody();
  
       // If slot_iterator equals first entry index, then we failed to find and
       // install optimized code
       IfBuilder no_optimized_code_check(this);
       no_optimized_code_check.If<HCompareNumericAndBranch>(
           slot_iterator, first_entry_index, Token::EQ);
       no_optimized_code_check.Then();
       {
         // Store the unoptimized code
         BuildInstallCode(js_function, shared_info);
       }
     }
   }
 }

References v8::internal::HGraphBuilder::AddIncrementCounter(), BuildCheckAndInstallOptimizedCode(), BuildInstallCode(), context(), v8::internal::Isolate::counters(), v8::internal::EQ, isolate(), v8::internal::SharedFunctionInfo::kEntriesStart, v8::internal::SharedFunctionInfo::kEntryLength, and NULL.

Here is the call graph for this function:

◆ BuildInternalArrayConstructor()

HValue * v8::internal::CodeStubGraphBuilderBase::BuildInternalArrayConstructor	(	ElementsKind	kind,
		ArgumentClass	argument_class
	)

protected

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

                                                      {
   HValue* constructor = GetParameter(
       InternalArrayConstructorStubBase::kConstructor);
   JSArrayBuilder array_builder(this, kind, constructor);
  
   HValue* result = NULL;
   switch (argument_class) {
     case NONE:
       // This stub is very performance sensitive, the generated code must be
       // tuned so that it doesn't build and eager frame.
       info()->MarkMustNotHaveEagerFrame();
       result = array_builder.AllocateEmptyArray();
       break;
     case SINGLE:
       result = BuildArraySingleArgumentConstructor(&array_builder);
       break;
     case MULTIPLE:
       result = BuildArrayNArgumentsConstructor(&array_builder, kind);
       break;
   }
   return result;
 }

References BuildArrayNArgumentsConstructor(), BuildArraySingleArgumentConstructor(), GetParameter(), info(), v8::internal::InternalArrayConstructorStubBase::kConstructor, v8::internal::CompilationInfo::MarkMustNotHaveEagerFrame(), MULTIPLE, NONE, NULL, and SINGLE.

Here is the call graph for this function:

◆ BuildLoadNamedField()

HLoadNamedField * v8::internal::CodeStubGraphBuilderBase::BuildLoadNamedField	(	HValue *	object,
		FieldIndex	index
	)

protected

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

                                       {
   Representation representation = index.is_double()
       ? Representation::Double()
       : Representation::Tagged();
   int offset = index.offset();
   HObjectAccess access = index.is_inobject()
       ? HObjectAccess::ForObservableJSObjectOffset(offset, representation)
       : HObjectAccess::ForBackingStoreOffset(offset, representation);
   if (index.is_double()) {
     // Load the heap number.
     object = Add<HLoadNamedField>(
         object, static_cast<HValue*>(NULL),
         access.WithRepresentation(Representation::Tagged()));
     // Load the double value from it.
     access = HObjectAccess::ForHeapNumberValue();
   }
   return Add<HLoadNamedField>(object, static_cast<HValue*>(NULL), access);
 }

References v8::internal::Representation::Double(), NULL, and v8::internal::Representation::Tagged().

Here is the call graph for this function:

◆ BuildStoreNamedField()

void v8::internal::CodeStubGraphBuilderBase::BuildStoreNamedField	(	HValue *	object,
		HValue *	value,
		FieldIndex	index,
		Representation	representation
	)

protected

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

                                    {
   DCHECK(!index.is_double() || representation.IsDouble());
   int offset = index.offset();
   HObjectAccess access =
       index.is_inobject()
           ? HObjectAccess::ForObservableJSObjectOffset(offset, representation)
           : HObjectAccess::ForBackingStoreOffset(offset, representation);
  
   if (representation.IsDouble()) {
     // Load the heap number.
     object = Add<HLoadNamedField>(
         object, static_cast<HValue*>(NULL),
         access.WithRepresentation(Representation::Tagged()));
     // Store the double value into it.
     access = HObjectAccess::ForHeapNumberValue();
   } else if (representation.IsHeapObject()) {
     BuildCheckHeapObject(value);
   }
  
   Add<HStoreNamedField>(object, access, value, INITIALIZING_STORE);
 }

References v8::internal::HGraphBuilder::BuildCheckHeapObject(), DCHECK, v8::internal::INITIALIZING_STORE, v8::internal::Representation::IsDouble(), v8::internal::Representation::IsHeapObject(), NULL, and v8::internal::Representation::Tagged().

Here is the call graph for this function:

◆ context()

HContext* v8::internal::CodeStubGraphBuilderBase::context ( )

inlineprotectedvirtual

Implements v8::internal::HGraphBuilder.

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

61 { return context_; }

References context_.

Referenced by BuildArrayNArgumentsConstructor(), and BuildInstallFromOptimizedCodeMap().

Here is the caller graph for this function:

◆ GetArgumentsLength()

HValue* v8::internal::CodeStubGraphBuilderBase::GetArgumentsLength ( )

inlineprotected

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

                                {
     // This is initialized in BuildGraph()
     DCHECK(arguments_length_ != NULL);
     return arguments_length_;
   }

References arguments_length_, DCHECK, and NULL.

Referenced by BuildArrayNArgumentsConstructor().

Here is the caller graph for this function:

◆ GetParameter()

HParameter* v8::internal::CodeStubGraphBuilderBase::GetParameter ( int parameter )

inlineprotected

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

                                           {
     DCHECK(parameter < descriptor_.GetEnvironmentParameterCount());
     return parameters_[parameter];
   }

References DCHECK, descriptor_, v8::internal::CodeStubDescriptor::GetEnvironmentParameterCount(), and parameters_.

Referenced by BuildArrayConstructor(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), and BuildInternalArrayConstructor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ info()

CompilationInfo* v8::internal::CodeStubGraphBuilderBase::info ( )

inlineprotected

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

59 { return &info_; }

References info_.

Referenced by BuildArrayConstructor(), and BuildInternalArrayConstructor().

Here is the caller graph for this function:

◆ isolate()

Isolate* v8::internal::CodeStubGraphBuilderBase::isolate ( )

inlineprotected

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

62 { return info_.isolate(); }

v8::internal::CompilationInfo::isolate

Isolate * isolate() const

Definition: compiler.h:96

References info_, and v8::internal::CompilationInfo::isolate().

Referenced by BuildCheckAndInstallOptimizedCode(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), BuildGraph(), BuildInstallFromOptimizedCodeMap(), and UnmappedCase().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadFromOptimizedCodeMap()

HInstruction * v8::internal::CodeStubGraphBuilderBase::LoadFromOptimizedCodeMap	(	HValue *	optimized_map,
		HValue *	iterator,
		int	field_offset
	)

protected

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

                       {
   // By making sure to express these loads in the form [<hvalue> + constant]
   // the keyed load can be hoisted.
   DCHECK(field_offset >= 0 && field_offset < SharedFunctionInfo::kEntryLength);
   HValue* field_slot = iterator;
   if (field_offset > 0) {
     HValue* field_offset_value = Add<HConstant>(field_offset);
     field_slot = AddUncasted<HAdd>(iterator, field_offset_value);
   }
   HInstruction* field_entry = Add<HLoadKeyed>(optimized_map, field_slot,
       static_cast<HValue*>(NULL), FAST_ELEMENTS);
   return field_entry;
 }

References DCHECK, v8::internal::FAST_ELEMENTS, v8::internal::SharedFunctionInfo::kEntryLength, and NULL.

Referenced by BuildCheckAndInstallOptimizedCode().

Here is the caller graph for this function:

◆ stub()

HydrogenCodeStub* v8::internal::CodeStubGraphBuilderBase::stub ( )

inlineprotected

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

60 { return info_.code_stub(); }

v8::internal::CompilationInfo::code_stub

HydrogenCodeStub * code_stub() const

Definition: compiler.h:115

References v8::internal::CompilationInfo::code_stub(), and info_.

Referenced by BuildGraph(), v8::internal::CodeStubGraphBuilder< Stub >::casted_stub(), and v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::casted_stub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UnmappedCase()

HValue * v8::internal::CodeStubGraphBuilderBase::UnmappedCase	(	HValue *	elements,
		HValue *	key
	)

protected

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

                                                                             {
   HValue* result;
   HInstruction* backing_store = Add<HLoadKeyed>(
       elements, graph()->GetConstant1(), static_cast<HValue*>(NULL),
       FAST_ELEMENTS, ALLOW_RETURN_HOLE);
   Add<HCheckMaps>(backing_store, isolate()->factory()->fixed_array_map());
   HValue* backing_store_length =
       Add<HLoadNamedField>(backing_store, static_cast<HValue*>(NULL),
                            HObjectAccess::ForFixedArrayLength());
   IfBuilder in_unmapped_range(this);
   in_unmapped_range.If<HCompareNumericAndBranch>(key, backing_store_length,
                                                  Token::LT);
   in_unmapped_range.Then();
   {
     result = Add<HLoadKeyed>(backing_store, key, static_cast<HValue*>(NULL),
                              FAST_HOLEY_ELEMENTS, NEVER_RETURN_HOLE);
   }
   in_unmapped_range.ElseDeopt("Outside of range");
   in_unmapped_range.End();
   return result;
 }

References v8::internal::ALLOW_RETURN_HOLE, v8::internal::FAST_ELEMENTS, v8::internal::FAST_HOLEY_ELEMENTS, v8::internal::HGraphBuilder::graph(), isolate(), v8::internal::NEVER_RETURN_HOLE, and NULL.

Here is the call graph for this function:

Member Data Documentation

◆ arguments_length_

HValue* v8::internal::CodeStubGraphBuilderBase::arguments_length_

private

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

Referenced by BuildGraph(), and GetArgumentsLength().

◆ context_

HContext* v8::internal::CodeStubGraphBuilderBase::context_

private

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

Referenced by BuildGraph(), and context().

◆ descriptor_

CodeStubDescriptor v8::internal::CodeStubGraphBuilderBase::descriptor_

private

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

Referenced by BuildGraph(), CodeStubGraphBuilderBase(), and GetParameter().

◆ info_

CompilationInfoWithZone v8::internal::CodeStubGraphBuilderBase::info_

private

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

Referenced by BuildGraph(), info(), isolate(), and stub().

◆ parameters_

SmartArrayPointer<HParameter*> v8::internal::CodeStubGraphBuilderBase::parameters_

private

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

Referenced by BuildGraph(), CodeStubGraphBuilderBase(), and GetParameter().

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

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

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ ArgumentClass

Constructor & Destructor Documentation

◆ CodeStubGraphBuilderBase()

Member Function Documentation

◆ BuildArrayConstructor()

◆ BuildArrayNArgumentsConstructor()

◆ BuildArraySingleArgumentConstructor()

◆ BuildCheckAndInstallOptimizedCode()

◆ BuildCodeStub()

◆ BuildGraph()

◆ BuildInstallCode()

◆ BuildInstallFromOptimizedCodeMap()

◆ BuildInternalArrayConstructor()

◆ BuildLoadNamedField()

◆ BuildStoreNamedField()

◆ context()

◆ GetArgumentsLength()

◆ GetParameter()

◆ info()

◆ isolate()

◆ LoadFromOptimizedCodeMap()

◆ stub()

◆ UnmappedCase()

Member Data Documentation

◆ arguments_length_

◆ context_

◆ descriptor_

◆ info_

◆ parameters_