v8::internal::HGraphBuilder Class Reference

#include <hydrogen.h>

Inheritance diagram for v8::internal::HGraphBuilder:

Collaboration diagram for v8::internal::HGraphBuilder:

Classes
class	FINAL

Public Member Functions
	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 ()
virtual HValue *	context ()=0
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 ()

Static Public Attributes
static const int	kElementLoopUnrollThreshold = 8

Protected Member Functions
virtual bool	BuildGraph ()=0
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
	HGraphBuilder ()
template<class I >
I *	AddInstructionTyped (I *instr)

Private Attributes
CompilationInfo *	info_
HGraph *	graph_
HBasicBlock *	current_block_
Scope *	scope_
HSourcePosition	position_
int	start_position_

Detailed Description

Definition at line 1043 of file hydrogen.h.

Constructor & Destructor Documentation

HGraphBuilder() [1/2]

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

inlineexplicit

Definition at line 1045 of file hydrogen.h.

      : info_(info),
        graph_(NULL),
        current_block_(NULL),
        scope_(info->scope()),
        position_(HSourcePosition::Unknown()),
        start_position_(0) {}

~HGraphBuilder()

virtual v8::internal::HGraphBuilder::~HGraphBuilder ( )

inlinevirtual

Definition at line 1052 of file hydrogen.h.

{}

HGraphBuilder() [2/2]

v8::internal::HGraphBuilder::HGraphBuilder ( )

private

Member Function Documentation

Add() [1/15]

template<class I >

I* v8::internal::HGraphBuilder::Add ( )

inline

Definition at line 1116 of file hydrogen.h.

{ return AddInstructionTyped(New<I>());}

References AddInstructionTyped().

Referenced by v8::internal::HOsrBuilder::BuildOsrLoopEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

Add() [2/15]

template<>

HSimulate* v8::internal::HGraphBuilder::Add ( BailoutId  id )

inline

Definition at line 1969 of file hydrogen.h.

                  {
  return Add<HSimulate>(id, FIXED_SIMULATE);
}

References v8::internal::FIXED_SIMULATE.

Add() [3/15]

template<>

HSimulate* v8::internal::HGraphBuilder::Add ( BailoutId  id, RemovableSimulate  removable  )

inline

Definition at line 1959 of file hydrogen.h.

                                 {
  HSimulate* instr = current_block()->CreateSimulate(id, removable);
  AddInstruction(instr);
  return instr;
}

References AddInstruction(), and current_block().

Here is the call graph for this function:

Add() [4/15]

template<>

HDeoptimize* v8::internal::HGraphBuilder::Add ( const char *  reason, Deoptimizer::BailoutType  type  )

inline

Definition at line 1932 of file hydrogen.h.

                                                     {
  if (type == Deoptimizer::SOFT) {
    isolate()->counters()->soft_deopts_requested()->Increment();
    if (FLAG_always_opt) return NULL;
  }
  if (current_block()->IsDeoptimizing()) return NULL;
  HBasicBlock* after_deopt_block = CreateBasicBlock(
      current_block()->last_environment());
  HDeoptimize* instr = New<HDeoptimize>(reason, type, after_deopt_block);
  if (type == Deoptimizer::SOFT) {
    isolate()->counters()->soft_deopts_inserted()->Increment();
  }
  FinishCurrentBlock(instr);
  set_current_block(after_deopt_block);
  return instr;
}

References v8::internal::Isolate::counters(), CreateBasicBlock(), current_block(), FinishCurrentBlock(), isolate(), NULL, set_current_block(), and v8::internal::Deoptimizer::SOFT.

Here is the call graph for this function:

Add() [5/15]

template<>

HCallRuntime* v8::internal::HGraphBuilder::Add ( Handle< String >  name, const Runtime::Function *  c_function, int  argument_count  )

inline

Definition at line 2009 of file hydrogen.h.

                        {
  HCallRuntime* instr = New<HCallRuntime>(name, c_function, argument_count);
  if (graph()->info()->IsStub()) {
    // When compiling code stubs, we don't want to save all double registers
    // upon entry to the stub, but instead have the call runtime instruction
    // save the double registers only on-demand (in the fallback case).
    instr->set_save_doubles(kSaveFPRegs);
  }
  AddInstruction(instr);
  return instr;
}

References AddInstruction(), graph(), v8::internal::kSaveFPRegs, and name.

Here is the call graph for this function:

Add() [6/15]

template<>

HReturn* v8::internal::HGraphBuilder::Add ( HConstant *  value )

inline

Definition at line 1992 of file hydrogen.h.

                                                            {
  return Add<HReturn>(static_cast<HValue*>(value));
}

Add() [7/15]

template<>

HReturn* v8::internal::HGraphBuilder::Add ( HValue *  value )

inline

Definition at line 1982 of file hydrogen.h.

                                                         {
  int num_parameters = graph()->info()->num_parameters();
  HValue* params = AddUncasted<HConstant>(num_parameters);
  HReturn* return_instruction = New<HReturn>(value, params);
  FinishExitCurrentBlock(return_instruction);
  return return_instruction;
}

References FinishExitCurrentBlock(), and graph().

Here is the call graph for this function:

Add() [8/15]

template<class I , class P1 >

I* v8::internal::HGraphBuilder::Add ( P1  p1 )

inline

Definition at line 1137 of file hydrogen.h.

                {
    I* result = AddInstructionTyped(New<I>(p1));
    // Specializations must have their parameters properly casted
    // to avoid landing here.
    DCHECK(!result->IsReturn() && !result->IsSimulate() &&
           !result->IsDeoptimize());
    return result;
  }

References AddInstructionTyped(), DCHECK, v8::internal::I, and v8::internal::p1.

Here is the call graph for this function:

Add() [9/15]

template<class I , class P1 , class P2 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2  )

inline

Definition at line 1166 of file hydrogen.h.

                       {
    I* result = AddInstructionTyped(New<I>(p1, p2));
    // Specializations must have their parameters properly casted
    // to avoid landing here.
    DCHECK(!result->IsSimulate());
    return result;
  }

References AddInstructionTyped(), DCHECK, v8::internal::I, v8::internal::p1, and v8::internal::p2.

Here is the call graph for this function:

Add() [10/15]

template<class I , class P1 , class P2 , class P3 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2, P3  p3  )

inline

Definition at line 1190 of file hydrogen.h.

                              {
    return AddInstructionTyped(New<I>(p1, p2, p3));
  }

References AddInstructionTyped(), v8::internal::p1, v8::internal::p2, and v8::internal::p3.

Here is the call graph for this function:

Add() [11/15]

template<class I , class P1 , class P2 , class P3 , class P4 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2, P3  p3, P4  p4  )

inline

Definition at line 1210 of file hydrogen.h.

                                     {
    return AddInstructionTyped(New<I>(p1, p2, p3, p4));
  }

References AddInstructionTyped(), v8::internal::p1, v8::internal::p2, v8::internal::p3, and v8::internal::p4.

Here is the call graph for this function:

Add() [12/15]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5  )

inline

Definition at line 1230 of file hydrogen.h.

                                            {
    return AddInstructionTyped(New<I>(p1, p2, p3, p4, p5));
  }

References AddInstructionTyped(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, and v8::internal::p5.

Here is the call graph for this function:

Add() [13/15]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6  )

inline

Definition at line 1250 of file hydrogen.h.

                                                   {
    return AddInstructionTyped(New<I>(p1, p2, p3, p4, p5, p6));
  }

References AddInstructionTyped(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, and v8::internal::p6.

Here is the call graph for this function:

Add() [14/15]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7  )

inline

Definition at line 1274 of file hydrogen.h.

                                                          {
    return AddInstructionTyped(New<I>(p1, p2, p3, p4, p5, p6, p7));
  }

References AddInstructionTyped(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, and v8::internal::p7.

Here is the call graph for this function:

Add() [15/15]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >

I* v8::internal::HGraphBuilder::Add ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7, P8  p8  )

inline

Definition at line 1300 of file hydrogen.h.

                                                                 {
    return AddInstructionTyped(New<I>(p1, p2, p3, p4, p5, p6, p7, p8));
  }

References AddInstructionTyped(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, v8::internal::p7, and v8::internal::p8.

Here is the call graph for this function:

AddElementAccess()

HInstruction * v8::internal::HGraphBuilder::AddElementAccess ( HValue *  elements, HValue *  checked_key, HValue *  val, HValue *  dependency, ElementsKind  elements_kind, PropertyAccessType  access_type, LoadKeyedHoleMode  load_mode = NEVER_RETURN_HOLE  )

protected

Definition at line 2671 of file hydrogen.cc.

                                 {
  if (access_type == STORE) {
    DCHECK(val != NULL);
    if (elements_kind == EXTERNAL_UINT8_CLAMPED_ELEMENTS ||
        elements_kind == UINT8_CLAMPED_ELEMENTS) {
      val = Add<HClampToUint8>(val);
    }
    return Add<HStoreKeyed>(elements, checked_key, val, elements_kind,
                            STORE_TO_INITIALIZED_ENTRY);
  }
 
  DCHECK(access_type == LOAD);
  DCHECK(val == NULL);
  HLoadKeyed* load = Add<HLoadKeyed>(
      elements, checked_key, dependency, elements_kind, load_mode);
  if (FLAG_opt_safe_uint32_operations &&
      (elements_kind == EXTERNAL_UINT32_ELEMENTS ||
       elements_kind == UINT32_ELEMENTS)) {
    graph()->RecordUint32Instruction(load);
  }
  return load;
}

References DCHECK, v8::internal::EXTERNAL_UINT32_ELEMENTS, v8::internal::EXTERNAL_UINT8_CLAMPED_ELEMENTS, LOAD, NULL, STORE, v8::internal::STORE_TO_INITIALIZED_ENTRY, v8::internal::UINT32_ELEMENTS, and v8::internal::UINT8_CLAMPED_ELEMENTS.

Referenced by v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the caller graph for this function:

AddIncrementCounter()

void v8::internal::HGraphBuilder::AddIncrementCounter ( StatsCounter *  counter )

protected

Definition at line 1219 of file hydrogen.cc.

                                                             {
  if (FLAG_native_code_counters && counter->Enabled()) {
    HValue* reference = Add<HConstant>(ExternalReference(counter));
    HValue* old_value = Add<HLoadNamedField>(
        reference, static_cast<HValue*>(NULL), HObjectAccess::ForCounter());
    HValue* new_value = AddUncasted<HAdd>(old_value, graph()->GetConstant1());
    new_value->ClearFlag(HValue::kCanOverflow);  // Ignore counter overflow
    Add<HStoreNamedField>(reference, HObjectAccess::ForCounter(),
                          new_value, STORE_TO_INITIALIZED_ENTRY);
  }
}

References v8::internal::HValue::ClearFlag(), v8::internal::StatsCounter::Enabled(), NULL, and v8::internal::STORE_TO_INITIALIZED_ENTRY.

Referenced by v8::internal::CodeStubGraphBuilderBase::BuildCheckAndInstallOptimizedCode(), and v8::internal::CodeStubGraphBuilderBase::BuildInstallFromOptimizedCodeMap().

Here is the call graph for this function:

Here is the caller graph for this function:

AddInstruction()

HInstruction * v8::internal::HGraphBuilder::AddInstruction

(

HInstruction *

instr

)

Definition at line 1185 of file hydrogen.cc.

                                                               {
  DCHECK(current_block() != NULL);
  DCHECK(!FLAG_hydrogen_track_positions ||
         !position_.IsUnknown() ||
         !info_->IsOptimizing());
  current_block()->AddInstruction(instr, source_position());
  if (graph()->IsInsideNoSideEffectsScope()) {
    instr->SetFlag(HValue::kHasNoObservableSideEffects);
  }
  return instr;
}

References DCHECK, NULL, and v8::internal::HValue::SetFlag().

Referenced by Add(), AddInstructionTyped(), AddUncasted(), v8::internal::HOptimizedGraphBuilder::BuildLoad(), v8::internal::HOptimizedGraphBuilder::BuildStore(), v8::internal::HOptimizedGraphBuilder::HandleKeyedElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::PushArgumentsFromEnvironment(), v8::internal::HOptimizedGraphBuilder::SetUpScope(), TruncateToNumber(), and v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the call graph for this function:

Here is the caller graph for this function:

AddInstructionTyped()

template<class I >

I* v8::internal::HGraphBuilder::AddInstructionTyped ( I *  instr )

inlineprivate

Definition at line 1918 of file hydrogen.h.

                                   {
    return I::cast(AddInstruction(instr));
  }

References AddInstruction().

Referenced by Add().

Here is the call graph for this function:

Here is the caller graph for this function:

AddLeaveInlined() [1/2]

void v8::internal::HGraphBuilder::AddLeaveInlined ( HBasicBlock *  block, HValue *  return_value, FunctionState *  state  )

inline

Definition at line 1097 of file hydrogen.h.

                                             {
    block->AddLeaveInlined(return_value, state, source_position());
  }

References source_position().

Referenced by AddLeaveInlined(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

AddLeaveInlined() [2/2]

void v8::internal::HGraphBuilder::AddLeaveInlined ( HValue *  return_value, FunctionState *  state  )

inline

Definition at line 1102 of file hydrogen.h.

                                                                   {
    return AddLeaveInlined(current_block(), return_value, state);
  }

References AddLeaveInlined(), and current_block().

Here is the call graph for this function:

AddLoadArrayLength()

HLoadNamedField * v8::internal::HGraphBuilder::AddLoadArrayLength ( HValue *  object, ElementsKind  kind, HValue *  dependency = NULL  )

protected

Definition at line 2723 of file hydrogen.cc.

                                                                       {
  return Add<HLoadNamedField>(
      array, dependency, HObjectAccess::ForArrayLength(kind));
}

Referenced by v8::internal::HOptimizedGraphBuilder::BuildArrayIndexOf().

Here is the caller graph for this function:

AddLoadElements()

HLoadNamedField * v8::internal::HGraphBuilder::AddLoadElements ( HValue *  object, HValue *  dependency = NULL  )

protected

Definition at line 2708 of file hydrogen.cc.

                                                                    {
  return Add<HLoadNamedField>(
      object, dependency, HObjectAccess::ForElementsPointer());
}

Referenced by v8::internal::HOptimizedGraphBuilder::BuildArrayIndexOf(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), and v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the caller graph for this function:

AddLoadFixedArrayLength()

HLoadNamedField * v8::internal::HGraphBuilder::AddLoadFixedArrayLength ( HValue *  object, HValue *  dependency = NULL  )

protected

Definition at line 2715 of file hydrogen.cc.

                        {
  return Add<HLoadNamedField>(
      array, dependency, HObjectAccess::ForFixedArrayLength());
}

AddLoadJSBuiltin()

HValue * v8::internal::HGraphBuilder::AddLoadJSBuiltin ( Builtins::JavaScript  builtin )

protected

Definition at line 3306 of file hydrogen.cc.

                                                                  {
  HValue* global_object = Add<HLoadNamedField>(
      context(), static_cast<HValue*>(NULL),
      HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
  HObjectAccess access = HObjectAccess::ForObservableJSObjectOffset(
      GlobalObject::kBuiltinsOffset);
  HValue* builtins = Add<HLoadNamedField>(
      global_object, static_cast<HValue*>(NULL), access);
  HObjectAccess function_access = HObjectAccess::ForObservableJSObjectOffset(
          JSBuiltinsObject::OffsetOfFunctionWithId(builtin));
  return Add<HLoadNamedField>(
      builtins, static_cast<HValue*>(NULL), function_access);
}

References context(), v8::internal::Context::GLOBAL_OBJECT_INDEX, v8::internal::GlobalObject::kBuiltinsOffset, NULL, and v8::internal::JSBuiltinsObject::OffsetOfFunctionWithId().

Referenced by BuildBinaryOperation(), and v8::internal::HOptimizedGraphBuilder::VisitDelete().

Here is the call graph for this function:

Here is the caller graph for this function:

AddLoadMap()

HLoadNamedField * v8::internal::HGraphBuilder::AddLoadMap ( HValue *  object, HValue *  dependency = NULL  )

protected

Definition at line 2702 of file hydrogen.cc.

                                                               {
  return Add<HLoadNamedField>(object, dependency, HObjectAccess::ForMap());
}

AddLoadStringInstanceType()

HInstruction * v8::internal::HGraphBuilder::AddLoadStringInstanceType ( HValue *  string )

protected

Definition at line 6793 of file hydrogen.cc.

                                                                     {
  if (string->IsConstant()) {
    HConstant* c_string = HConstant::cast(string);
    if (c_string->HasStringValue()) {
      return Add<HConstant>(c_string->StringValue()->map()->instance_type());
    }
  }
  return Add<HLoadNamedField>(
      Add<HLoadNamedField>(string, static_cast<HValue*>(NULL),
                           HObjectAccess::ForMap()),
      static_cast<HValue*>(NULL), HObjectAccess::ForMapInstanceType());
}

References NULL.

AddLoadStringLength()

HInstruction * v8::internal::HGraphBuilder::AddLoadStringLength ( HValue *  string )

protected

Definition at line 6807 of file hydrogen.cc.

                                                               {
  if (string->IsConstant()) {
    HConstant* c_string = HConstant::cast(string);
    if (c_string->HasStringValue()) {
      return Add<HConstant>(c_string->StringValue()->length());
    }
  }
  return Add<HLoadNamedField>(string, static_cast<HValue*>(NULL),
                              HObjectAccess::ForStringLength());
}

References NULL.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildStringCharCodeAt().

Here is the caller graph for this function:

AddSimulate()

void v8::internal::HGraphBuilder::AddSimulate	(	BailoutId	id,
		RemovableSimulate	removable = FIXED_SIMULATE
	)

Definition at line 1232 of file hydrogen.cc.

                                                             {
  DCHECK(current_block() != NULL);
  DCHECK(!graph()->IsInsideNoSideEffectsScope());
  current_block()->AddNewSimulate(id, source_position(), removable);
}

References DCHECK, and NULL.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildCompareInstruction(), and v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed().

Here is the caller graph for this function:

AddStoreMapConstant()

HStoreNamedField* v8::internal::HGraphBuilder::AddStoreMapConstant ( HValue *  object, Handle< Map >  map  )

inlineprotected

Definition at line 1438 of file hydrogen.h.

                                                                         {
    return Add<HStoreNamedField>(object, HObjectAccess::ForMap(),
                                 Add<HConstant>(map));
  }

References map.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildAllocateExternalElements(), v8::internal::HOptimizedGraphBuilder::BuildAllocateFixedTypedArray(), v8::internal::HOptimizedGraphBuilder::BuildEmitInObjectProperties(), v8::internal::HOptimizedGraphBuilder::BuildEmitObjectHeader(), and v8::internal::HOptimizedGraphBuilder::BuildStoreNamedField().

Here is the caller graph for this function:

AddUncasted() [1/14]

template<class I >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( )

inline

Definition at line 1113 of file hydrogen.h.

{ return AddInstruction(NewUncasted<I>());}

References AddInstruction().

Here is the call graph for this function:

AddUncasted() [2/14]

template<>

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( BailoutId  id )

inline

Definition at line 1976 of file hydrogen.h.

                                                                       {
  return Add<HSimulate>(id, FIXED_SIMULATE);
}

References v8::internal::FIXED_SIMULATE.

AddUncasted() [3/14]

template<>

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( const char *  reason, Deoptimizer::BailoutType  type  )

inline

Definition at line 1952 of file hydrogen.h.

                                                     {
  return Add<HDeoptimize>(reason, type);
}

AddUncasted() [4/14]

template<>

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( Handle< String >  name, const Runtime::Function *  c_function, int  argument_count  )

inline

Definition at line 2026 of file hydrogen.h.

                        {
  return Add<HCallRuntime>(name, c_function, argument_count);
}

References name.

AddUncasted() [5/14]

template<>

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( HConstant *  value )

inline

Definition at line 2003 of file hydrogen.h.

                                                                         {
  return Add<HReturn>(value);
}

AddUncasted() [6/14]

template<>

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( HValue *  value )

inline

Definition at line 1997 of file hydrogen.h.

                                                                      {
  return Add<HReturn>(value);
}

AddUncasted() [7/14]

template<class I , class P1 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1 )

inline

Definition at line 1127 of file hydrogen.h.

                                   {
    HInstruction* result = AddInstruction(NewUncasted<I>(p1));
    // Specializations must have their parameters properly casted
    // to avoid landing here.
    DCHECK(!result->IsReturn() && !result->IsSimulate() &&
           !result->IsDeoptimize());
    return result;
  }

References AddInstruction(), DCHECK, and v8::internal::p1.

Here is the call graph for this function:

AddUncasted() [8/14]

template<class I , class P1 , class P2 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2  )

inline

Definition at line 1157 of file hydrogen.h.

                                          {
    HInstruction* result = AddInstruction(NewUncasted<I>(p1, p2));
    // Specializations must have their parameters properly casted
    // to avoid landing here.
    DCHECK(!result->IsSimulate());
    return result;
  }

References AddInstruction(), DCHECK, v8::internal::p1, and v8::internal::p2.

Here is the call graph for this function:

AddUncasted() [9/14]

template<class I , class P1 , class P2 , class P3 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2, P3  p3  )

inline

Definition at line 1185 of file hydrogen.h.

                                                 {
    return AddInstruction(NewUncasted<I>(p1, p2, p3));
  }

References AddInstruction(), v8::internal::p1, v8::internal::p2, and v8::internal::p3.

Here is the call graph for this function:

AddUncasted() [10/14]

template<class I , class P1 , class P2 , class P3 , class P4 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2, P3  p3, P4  p4  )

inline

Definition at line 1205 of file hydrogen.h.

                                                        {
    return AddInstruction(NewUncasted<I>(p1, p2, p3, p4));
  }

References AddInstruction(), v8::internal::p1, v8::internal::p2, v8::internal::p3, and v8::internal::p4.

Here is the call graph for this function:

AddUncasted() [11/14]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5  )

inline

Definition at line 1225 of file hydrogen.h.

                                                               {
    return AddInstruction(NewUncasted<I>(p1, p2, p3, p4, p5));
  }

References AddInstruction(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, and v8::internal::p5.

Here is the call graph for this function:

AddUncasted() [12/14]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6  )

inline

Definition at line 1245 of file hydrogen.h.

                                                                      {
    return AddInstruction(NewUncasted<I>(p1, p2, p3, p4, p5, p6));
  }

References AddInstruction(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, and v8::internal::p6.

Here is the call graph for this function:

AddUncasted() [13/14]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7  )

inline

Definition at line 1268 of file hydrogen.h.

                                                                             {
    return AddInstruction(NewUncasted<I>(p1, p2, p3, p4, p5, p6, p7));
  }

References AddInstruction(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, and v8::internal::p7.

Here is the call graph for this function:

AddUncasted() [14/14]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >

HInstruction* v8::internal::HGraphBuilder::AddUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7, P8  p8  )

inline

Definition at line 1293 of file hydrogen.h.

                                                        {
    return AddInstruction(NewUncasted<I>(p1, p2, p3, p4, p5, p6, p7, p8));
  }

References AddInstruction(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, v8::internal::p7, and v8::internal::p8.

Here is the call graph for this function:

AllocateJSArrayObject()

HAllocate * v8::internal::HGraphBuilder::AllocateJSArrayObject ( AllocationSiteMode  mode )

protected

Definition at line 2582 of file hydrogen.cc.

                                                                       {
  int base_size = JSArray::kSize;
  if (mode == TRACK_ALLOCATION_SITE) {
    base_size += AllocationMemento::kSize;
  }
  HConstant* size_in_bytes = Add<HConstant>(base_size);
  return Add<HAllocate>(
      size_in_bytes, HType::JSArray(), NOT_TENURED, JS_OBJECT_TYPE);
}

References v8::internal::JS_OBJECT_TYPE, mode(), v8::internal::NOT_TENURED, and v8::internal::TRACK_ALLOCATION_SITE.

Here is the call graph for this function:

BuildAddStringLengths()

HValue * v8::internal::HGraphBuilder::BuildAddStringLengths ( HValue *  left_length, HValue *  right_length  )

protected

Definition at line 2050 of file hydrogen.cc.

                                                                   {
  // Compute the combined string length and check against max string length.
  HValue* length = AddUncasted<HAdd>(left_length, right_length);
  // Check that length <= kMaxLength <=> length < MaxLength + 1.
  HValue* max_length = Add<HConstant>(String::kMaxLength + 1);
  Add<HBoundsCheck>(length, max_length);
  return length;
}

BuildAllocate()

HAllocate * v8::internal::HGraphBuilder::BuildAllocate ( HValue *  object_size, HType  type, InstanceType  instance_type, HAllocationMode  allocation_mode  )

protected

Definition at line 2023 of file hydrogen.cc.

                                     {
  // Compute the effective allocation size.
  HValue* size = object_size;
  if (allocation_mode.CreateAllocationMementos()) {
    size = AddUncasted<HAdd>(size, Add<HConstant>(AllocationMemento::kSize));
    size->ClearFlag(HValue::kCanOverflow);
  }
 
  // Perform the actual allocation.
  HAllocate* object = Add<HAllocate>(
      size, type, allocation_mode.GetPretenureMode(),
      instance_type, allocation_mode.feedback_site());
 
  // Setup the allocation memento.
  if (allocation_mode.CreateAllocationMementos()) {
    BuildCreateAllocationMemento(
        object, object_size, allocation_mode.current_site());
  }
 
  return object;
}

References size.

BuildAllocateArrayFromLength()

HValue * v8::internal::HGraphBuilder::BuildAllocateArrayFromLength ( JSArrayBuilder *  array_builder, HValue *  length_argument  )

protected

Definition at line 2514 of file hydrogen.cc.

                             {
  if (length_argument->IsConstant() &&
      HConstant::cast(length_argument)->HasSmiValue()) {
    int array_length = HConstant::cast(length_argument)->Integer32Value();
    if (array_length == 0) {
      return array_builder->AllocateEmptyArray();
    } else {
      return array_builder->AllocateArray(length_argument,
                                          array_length,
                                          length_argument);
    }
  }
 
  HValue* constant_zero = graph()->GetConstant0();
  HConstant* max_alloc_length =
      Add<HConstant>(JSObject::kInitialMaxFastElementArray);
  HInstruction* checked_length = Add<HBoundsCheck>(length_argument,
                                                   max_alloc_length);
  IfBuilder if_builder(this);
  if_builder.If<HCompareNumericAndBranch>(checked_length, constant_zero,
                                          Token::EQ);
  if_builder.Then();
  const int initial_capacity = JSArray::kPreallocatedArrayElements;
  HConstant* initial_capacity_node = Add<HConstant>(initial_capacity);
  Push(initial_capacity_node);  // capacity
  Push(constant_zero);          // length
  if_builder.Else();
  if (!(top_info()->IsStub()) &&
      IsFastPackedElementsKind(array_builder->kind())) {
    // We'll come back later with better (holey) feedback.
    if_builder.Deopt("Holey array despite packed elements_kind feedback");
  } else {
    Push(checked_length);         // capacity
    Push(checked_length);         // length
  }
  if_builder.End();
 
  // Figure out total size
  HValue* length = Pop();
  HValue* capacity = Pop();
  return array_builder->AllocateArray(capacity, max_alloc_length, length);
}

References v8::internal::EQ, v8::internal::IsFastPackedElementsKind(), and v8::internal::compiler::Push().

Referenced by v8::internal::CodeStubGraphBuilderBase::BuildArraySingleArgumentConstructor(), and v8::internal::HOptimizedGraphBuilder::BuildInlinedCallArray().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildAllocateElements()

HAllocate * v8::internal::HGraphBuilder::BuildAllocateElements ( ElementsKind  kind, HValue *  size_in_bytes  )

protected

Definition at line 2604 of file hydrogen.cc.

                                                                       {
  InstanceType instance_type = IsFastDoubleElementsKind(kind)
      ? FIXED_DOUBLE_ARRAY_TYPE
      : FIXED_ARRAY_TYPE;
 
  return Add<HAllocate>(size_in_bytes, HType::HeapObject(), NOT_TENURED,
                        instance_type);
}

References v8::internal::FIXED_ARRAY_TYPE, v8::internal::FIXED_DOUBLE_ARRAY_TYPE, v8::internal::IsFastDoubleElementsKind(), and v8::internal::NOT_TENURED.

Here is the call graph for this function:

BuildAllocateElementsAndInitializeElementsHeader()

HValue * v8::internal::HGraphBuilder::BuildAllocateElementsAndInitializeElementsHeader ( ElementsKind  kind, HValue *  capacity  )

protected

Definition at line 2629 of file hydrogen.cc.

                      {
  // The HForceRepresentation is to prevent possible deopt on int-smi
  // conversion after allocation but before the new object fields are set.
  capacity = AddUncasted<HForceRepresentation>(capacity, Representation::Smi());
  HValue* size_in_bytes = BuildCalculateElementsSize(kind, capacity);
  HValue* new_elements = BuildAllocateElements(kind, size_in_bytes);
  BuildInitializeElementsHeader(new_elements, kind, capacity);
  return new_elements;
}

BuildArrayBufferViewInitialization()

template<class ViewClass >

void v8::internal::HGraphBuilder::BuildArrayBufferViewInitialization ( HValue *  obj, HValue *  buffer, HValue *  byte_offset, HValue *  byte_length  )

protected

Definition at line 9398 of file hydrogen.cc.

                         {
 
  for (int offset = ViewClass::kSize;
       offset < ViewClass::kSizeWithInternalFields;
       offset += kPointerSize) {
    Add<HStoreNamedField>(obj,
        HObjectAccess::ForObservableJSObjectOffset(offset),
        graph()->GetConstant0());
  }
 
  Add<HStoreNamedField>(
      obj,
      HObjectAccess::ForJSArrayBufferViewByteOffset(),
      byte_offset);
  Add<HStoreNamedField>(
      obj,
      HObjectAccess::ForJSArrayBufferViewByteLength(),
      byte_length);
 
  if (buffer != NULL) {
    Add<HStoreNamedField>(
        obj,
        HObjectAccess::ForJSArrayBufferViewBuffer(), buffer);
    HObjectAccess weak_first_view_access =
        HObjectAccess::ForJSArrayBufferWeakFirstView();
    Add<HStoreNamedField>(obj,
        HObjectAccess::ForJSArrayBufferViewWeakNext(),
        Add<HLoadNamedField>(buffer,
                             static_cast<HValue*>(NULL),
                             weak_first_view_access));
    Add<HStoreNamedField>(buffer, weak_first_view_access, obj);
  } else {
    Add<HStoreNamedField>(
        obj,
        HObjectAccess::ForJSArrayBufferViewBuffer(),
        Add<HConstant>(static_cast<int32_t>(0)));
    Add<HStoreNamedField>(obj,
        HObjectAccess::ForJSArrayBufferViewWeakNext(),
        graph()->GetConstantUndefined());
  }
}

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

Here is the call graph for this function:

BuildBinaryOperation()

HValue * v8::internal::HGraphBuilder::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  )

protected

Definition at line 10259 of file hydrogen.cc.

                                     {
 
  Representation left_rep = Representation::FromType(left_type);
  Representation right_rep = Representation::FromType(right_type);
 
  bool maybe_string_add = op == Token::ADD &&
                          (left_type->Maybe(Type::String()) ||
                           left_type->Maybe(Type::Receiver()) ||
                           right_type->Maybe(Type::String()) ||
                           right_type->Maybe(Type::Receiver()));
 
  if (!left_type->IsInhabited()) {
    Add<HDeoptimize>("Insufficient type feedback for LHS of binary operation",
                     Deoptimizer::SOFT);
    // TODO(rossberg): we should be able to get rid of non-continuous
    // defaults.
    left_type = Type::Any(zone());
  } else {
    if (!maybe_string_add) left = TruncateToNumber(left, &left_type);
    left_rep = Representation::FromType(left_type);
  }
 
  if (!right_type->IsInhabited()) {
    Add<HDeoptimize>("Insufficient type feedback for RHS of binary operation",
                     Deoptimizer::SOFT);
    right_type = Type::Any(zone());
  } else {
    if (!maybe_string_add) right = TruncateToNumber(right, &right_type);
    right_rep = Representation::FromType(right_type);
  }
 
  // Special case for string addition here.
  if (op == Token::ADD &&
      (left_type->Is(Type::String()) || right_type->Is(Type::String()))) {
    // Validate type feedback for left argument.
    if (left_type->Is(Type::String())) {
      left = BuildCheckString(left);
    }
 
    // Validate type feedback for right argument.
    if (right_type->Is(Type::String())) {
      right = BuildCheckString(right);
    }
 
    // Convert left argument as necessary.
    if (left_type->Is(Type::Number())) {
      DCHECK(right_type->Is(Type::String()));
      left = BuildNumberToString(left, left_type);
    } else if (!left_type->Is(Type::String())) {
      DCHECK(right_type->Is(Type::String()));
      HValue* function = AddLoadJSBuiltin(Builtins::STRING_ADD_RIGHT);
      Add<HPushArguments>(left, right);
      return AddUncasted<HInvokeFunction>(function, 2);
    }
 
    // Convert right argument as necessary.
    if (right_type->Is(Type::Number())) {
      DCHECK(left_type->Is(Type::String()));
      right = BuildNumberToString(right, right_type);
    } else if (!right_type->Is(Type::String())) {
      DCHECK(left_type->Is(Type::String()));
      HValue* function = AddLoadJSBuiltin(Builtins::STRING_ADD_LEFT);
      Add<HPushArguments>(left, right);
      return AddUncasted<HInvokeFunction>(function, 2);
    }
 
    // Fast path for empty constant strings.
    if (left->IsConstant() &&
        HConstant::cast(left)->HasStringValue() &&
        HConstant::cast(left)->StringValue()->length() == 0) {
      return right;
    }
    if (right->IsConstant() &&
        HConstant::cast(right)->HasStringValue() &&
        HConstant::cast(right)->StringValue()->length() == 0) {
      return left;
    }
 
    // Register the dependent code with the allocation site.
    if (!allocation_mode.feedback_site().is_null()) {
      DCHECK(!graph()->info()->IsStub());
      Handle<AllocationSite> site(allocation_mode.feedback_site());
      AllocationSite::AddDependentCompilationInfo(
          site, AllocationSite::TENURING, top_info());
    }
 
    // Inline the string addition into the stub when creating allocation
    // mementos to gather allocation site feedback, or if we can statically
    // infer that we're going to create a cons string.
    if ((graph()->info()->IsStub() &&
         allocation_mode.CreateAllocationMementos()) ||
        (left->IsConstant() &&
         HConstant::cast(left)->HasStringValue() &&
         HConstant::cast(left)->StringValue()->length() + 1 >=
           ConsString::kMinLength) ||
        (right->IsConstant() &&
         HConstant::cast(right)->HasStringValue() &&
         HConstant::cast(right)->StringValue()->length() + 1 >=
           ConsString::kMinLength)) {
      return BuildStringAdd(left, right, allocation_mode);
    }
 
    // Fallback to using the string add stub.
    return AddUncasted<HStringAdd>(
        left, right, allocation_mode.GetPretenureMode(),
        STRING_ADD_CHECK_NONE, allocation_mode.feedback_site());
  }
 
  if (graph()->info()->IsStub()) {
    left = EnforceNumberType(left, left_type);
    right = EnforceNumberType(right, right_type);
  }
 
  Representation result_rep = Representation::FromType(result_type);
 
  bool is_non_primitive = (left_rep.IsTagged() && !left_rep.IsSmi()) ||
                          (right_rep.IsTagged() && !right_rep.IsSmi());
 
  HInstruction* instr = NULL;
  // Only the stub is allowed to call into the runtime, since otherwise we would
  // inline several instructions (including the two pushes) for every tagged
  // operation in optimized code, which is more expensive, than a stub call.
  if (graph()->info()->IsStub() && is_non_primitive) {
    HValue* function = AddLoadJSBuiltin(BinaryOpIC::TokenToJSBuiltin(op));
    Add<HPushArguments>(left, right);
    instr = AddUncasted<HInvokeFunction>(function, 2);
  } else {
    switch (op) {
      case Token::ADD:
        instr = AddUncasted<HAdd>(left, right);
        break;
      case Token::SUB:
        instr = AddUncasted<HSub>(left, right);
        break;
      case Token::MUL:
        instr = AddUncasted<HMul>(left, right);
        break;
      case Token::MOD: {
        if (fixed_right_arg.has_value &&
            !right->EqualsInteger32Constant(fixed_right_arg.value)) {
          HConstant* fixed_right = Add<HConstant>(
              static_cast<int>(fixed_right_arg.value));
          IfBuilder if_same(this);
          if_same.If<HCompareNumericAndBranch>(right, fixed_right, Token::EQ);
          if_same.Then();
          if_same.ElseDeopt("Unexpected RHS of binary operation");
          right = fixed_right;
        }
        instr = AddUncasted<HMod>(left, right);
        break;
      }
      case Token::DIV:
        instr = AddUncasted<HDiv>(left, right);
        break;
      case Token::BIT_XOR:
      case Token::BIT_AND:
        instr = AddUncasted<HBitwise>(op, left, right);
        break;
      case Token::BIT_OR: {
        HValue* operand, *shift_amount;
        if (left_type->Is(Type::Signed32()) &&
            right_type->Is(Type::Signed32()) &&
            MatchRotateRight(left, right, &operand, &shift_amount)) {
          instr = AddUncasted<HRor>(operand, shift_amount);
        } else {
          instr = AddUncasted<HBitwise>(op, left, right);
        }
        break;
      }
      case Token::SAR:
        instr = AddUncasted<HSar>(left, right);
        break;
      case Token::SHR:
        instr = AddUncasted<HShr>(left, right);
        if (FLAG_opt_safe_uint32_operations && instr->IsShr() &&
            CanBeZero(right)) {
          graph()->RecordUint32Instruction(instr);
        }
        break;
      case Token::SHL:
        instr = AddUncasted<HShl>(left, right);
        break;
      default:
        UNREACHABLE();
    }
  }
 
  if (instr->IsBinaryOperation()) {
    HBinaryOperation* binop = HBinaryOperation::cast(instr);
    binop->set_observed_input_representation(1, left_rep);
    binop->set_observed_input_representation(2, right_rep);
    binop->initialize_output_representation(result_rep);
    if (graph()->info()->IsStub()) {
      // Stub should not call into stub.
      instr->SetFlag(HValue::kCannotBeTagged);
      // And should truncate on HForceRepresentation already.
      if (left->IsForceRepresentation()) {
        left->CopyFlag(HValue::kTruncatingToSmi, instr);
        left->CopyFlag(HValue::kTruncatingToInt32, instr);
      }
      if (right->IsForceRepresentation()) {
        right->CopyFlag(HValue::kTruncatingToSmi, instr);
        right->CopyFlag(HValue::kTruncatingToInt32, instr);
      }
    }
  }
  return instr;
}

References v8::internal::ADD, v8::internal::AllocationSite::AddDependentCompilationInfo(), AddLoadJSBuiltin(), BuildCheckString(), BuildNumberToString(), BuildStringAdd(), v8::internal::CanBeZero(), v8::internal::HValue::cast(), v8::internal::HValue::CopyFlag(), DCHECK, v8::internal::DIV, EnforceNumberType(), v8::internal::EQ, v8::internal::HValue::EqualsInteger32Constant(), v8::internal::Representation::FromType(), graph(), v8::Maybe< T >::has_value, v8::internal::HBinaryOperation::initialize_output_representation(), v8::internal::TypeImpl< Config >::Is(), v8::internal::TypeImpl< Config >::IsInhabited(), v8::internal::Representation::IsSmi(), v8::internal::Representation::IsTagged(), v8::internal::HValue::kCannotBeTagged, v8::internal::ConsString::kMinLength, v8::internal::HValue::kTruncatingToInt32, v8::internal::HValue::kTruncatingToSmi, MatchRotateRight(), v8::internal::TypeImpl< Config >::Maybe(), v8::internal::MUL, NULL, v8::internal::HBinaryOperation::set_observed_input_representation(), v8::internal::HValue::SetFlag(), v8::internal::Deoptimizer::SOFT, v8::internal::STRING_ADD_CHECK_NONE, v8::internal::SUB, v8::internal::AllocationSite::TENURING, v8::internal::BinaryOpIC::TokenToJSBuiltin(), top_info(), TruncateToNumber(), UNREACHABLE, v8::Maybe< T >::value, and zone().

Referenced by v8::internal::HOptimizedGraphBuilder::BuildBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCalculateElementsSize()

HValue * v8::internal::HGraphBuilder::BuildCalculateElementsSize ( ElementsKind  kind, HValue *  capacity  )

protected

Definition at line 2560 of file hydrogen.cc.

                                                                    {
  int elements_size = IsFastDoubleElementsKind(kind)
      ? kDoubleSize
      : kPointerSize;
 
  HConstant* elements_size_value = Add<HConstant>(elements_size);
  HInstruction* mul = HMul::NewImul(zone(), context(),
                                    capacity->ActualValue(),
                                    elements_size_value);
  AddInstruction(mul);
  mul->ClearFlag(HValue::kCanOverflow);
 
  STATIC_ASSERT(FixedDoubleArray::kHeaderSize == FixedArray::kHeaderSize);
 
  HConstant* header_size = Add<HConstant>(FixedArray::kHeaderSize);
  HValue* total_size = AddUncasted<HAdd>(mul, header_size);
  total_size->ClearFlag(HValue::kCanOverflow);
  return total_size;
}

References v8::internal::HValue::ActualValue(), v8::internal::HValue::ClearFlag(), v8::internal::IsFastDoubleElementsKind(), v8::internal::kDoubleSize, v8::internal::kPointerSize, and STATIC_ASSERT.

Here is the call graph for this function:

BuildCheckForCapacityGrow()

HValue * v8::internal::HGraphBuilder::BuildCheckForCapacityGrow ( HValue *  object, HValue *  elements, ElementsKind  kind, HValue *  length, HValue *  key, bool  is_js_array, PropertyAccessType  access_type  )

protected

Definition at line 1302 of file hydrogen.cc.

                                    {
  IfBuilder length_checker(this);
 
  Token::Value token = IsHoleyElementsKind(kind) ? Token::GTE : Token::EQ;
  length_checker.If<HCompareNumericAndBranch>(key, length, token);
 
  length_checker.Then();
 
  HValue* current_capacity = AddLoadFixedArrayLength(elements);
 
  IfBuilder capacity_checker(this);
 
  capacity_checker.If<HCompareNumericAndBranch>(key, current_capacity,
                                                Token::GTE);
  capacity_checker.Then();
 
  HValue* max_gap = Add<HConstant>(static_cast<int32_t>(JSObject::kMaxGap));
  HValue* max_capacity = AddUncasted<HAdd>(current_capacity, max_gap);
 
  Add<HBoundsCheck>(key, max_capacity);
 
  HValue* new_capacity = BuildNewElementsCapacity(key);
  HValue* new_elements = BuildGrowElementsCapacity(object, elements,
                                                   kind, kind, length,
                                                   new_capacity);
 
  environment()->Push(new_elements);
  capacity_checker.Else();
 
  environment()->Push(elements);
  capacity_checker.End();
 
  if (is_js_array) {
    HValue* new_length = AddUncasted<HAdd>(key, graph_->GetConstant1());
    new_length->ClearFlag(HValue::kCanOverflow);
 
    Add<HStoreNamedField>(object, HObjectAccess::ForArrayLength(kind),
                          new_length);
  }
 
  if (access_type == STORE && kind == FAST_SMI_ELEMENTS) {
    HValue* checked_elements = environment()->Top();
 
    // Write zero to ensure that the new element is initialized with some smi.
    Add<HStoreKeyed>(checked_elements, key, graph()->GetConstant0(), kind);
  }
 
  length_checker.Else();
  Add<HBoundsCheck>(key, length);
 
  environment()->Push(elements);
  length_checker.End();
 
  return environment()->Pop();
}

References v8::internal::HValue::ClearFlag(), v8::internal::EQ, v8::internal::FAST_SMI_ELEMENTS, v8::internal::IsHoleyElementsKind(), and STORE.

Here is the call graph for this function:

BuildCheckHeapObject()

HValue * v8::internal::HGraphBuilder::BuildCheckHeapObject ( HValue *  object )

protected

Definition at line 1266 of file hydrogen.cc.

                                                       {
  if (obj->type().IsHeapObject()) return obj;
  return Add<HCheckHeapObject>(obj);
}

References v8::internal::HValue::type().

Referenced by v8::internal::HOptimizedGraphBuilder::AddCheckMap(), v8::internal::HOptimizedGraphBuilder::BuildCompareInstruction(), v8::internal::HOptimizedGraphBuilder::BuildNamedAccess(), v8::internal::CodeStubGraphBuilderBase::BuildStoreNamedField(), v8::internal::HOptimizedGraphBuilder::BuildStoreNamedField(), v8::internal::HOptimizedGraphBuilder::HandleKeyedElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), and v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCheckPrototypeMaps()

HInstruction * v8::internal::HGraphBuilder::BuildCheckPrototypeMaps ( Handle< JSObject >  prototype, Handle< JSObject >  holder  )

protected

Definition at line 7403 of file hydrogen.cc.

                                                                              {
  PrototypeIterator iter(isolate(), prototype,
                         PrototypeIterator::START_AT_RECEIVER);
  while (holder.is_null() ||
         !PrototypeIterator::GetCurrent(iter).is_identical_to(holder)) {
    BuildConstantMapCheck(
        Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)));
    iter.Advance();
    if (iter.IsAtEnd()) {
      return NULL;
    }
  }
  return BuildConstantMapCheck(
      Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)));
}

References v8::internal::PrototypeIterator::Advance(), BuildConstantMapCheck(), v8::internal::PrototypeIterator::GetCurrent(), v8::internal::Handle< T >::is_null(), v8::internal::PrototypeIterator::IsAtEnd(), isolate(), NULL, and v8::internal::PrototypeIterator::START_AT_RECEIVER.

Referenced by v8::internal::HOptimizedGraphBuilder::AddCheckPrototypeMaps(), v8::internal::HOptimizedGraphBuilder::BuildKeyedHoleMode(), v8::internal::HOptimizedGraphBuilder::BuildMonomorphicAccess(), v8::internal::HOptimizedGraphBuilder::BuildMonomorphicElementAccess(), and v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCheckString()

HValue * v8::internal::HGraphBuilder::BuildCheckString ( HValue *  string )

protected

Definition at line 1278 of file hydrogen.cc.

                                                      {
  if (!string->type().IsString()) {
    DCHECK(!string->IsConstant() ||
           !HConstant::cast(string)->HasStringValue());
    BuildCheckHeapObject(string);
    return Add<HCheckInstanceType>(string, HCheckInstanceType::IS_STRING);
  }
  return string;
}

References DCHECK, and v8::internal::HValue::type().

Referenced by BuildBinaryOperation(), and v8::internal::HOptimizedGraphBuilder::BuildStringCharCodeAt().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCloneShallowArrayCow()

HValue * v8::internal::HGraphBuilder::BuildCloneShallowArrayCow ( HValue *  boilerplate, HValue *  allocation_site, AllocationSiteMode  mode, ElementsKind  kind  )

protected

Definition at line 2929 of file hydrogen.cc.

                                                                    {
  HAllocate* array = AllocateJSArrayObject(mode);
 
  HValue* map = AddLoadMap(boilerplate);
  HValue* elements = AddLoadElements(boilerplate);
  HValue* length = AddLoadArrayLength(boilerplate, kind);
 
  BuildJSArrayHeader(array,
                     map,
                     elements,
                     mode,
                     FAST_ELEMENTS,
                     allocation_site,
                     length);
  return array;
}

References v8::internal::FAST_ELEMENTS, map, and mode().

Here is the call graph for this function:

BuildCloneShallowArrayEmpty()

HValue * v8::internal::HGraphBuilder::BuildCloneShallowArrayEmpty ( HValue *  boilerplate, HValue *  allocation_site, AllocationSiteMode  mode  )

protected

Definition at line 2950 of file hydrogen.cc.

                                                                            {
  HAllocate* array = AllocateJSArrayObject(mode);
 
  HValue* map = AddLoadMap(boilerplate);
 
  BuildJSArrayHeader(array,
                     map,
                     NULL,  // set elements to empty fixed array
                     mode,
                     FAST_ELEMENTS,
                     allocation_site,
                     graph()->GetConstant0());
  return array;
}

References v8::internal::FAST_ELEMENTS, map, mode(), and NULL.

Here is the call graph for this function:

BuildCloneShallowArrayNonEmpty()

HValue * v8::internal::HGraphBuilder::BuildCloneShallowArrayNonEmpty ( HValue *  boilerplate, HValue *  allocation_site, AllocationSiteMode  mode, ElementsKind  kind  )

protected

Definition at line 2968 of file hydrogen.cc.

                                                                         {
  HValue* boilerplate_elements = AddLoadElements(boilerplate);
  HValue* capacity = AddLoadFixedArrayLength(boilerplate_elements);
 
  // Generate size calculation code here in order to make it dominate
  // the JSArray allocation.
  HValue* elements_size = BuildCalculateElementsSize(kind, capacity);
 
  // Create empty JSArray object for now, store elimination should remove
  // redundant initialization of elements and length fields and at the same
  // time the object will be fully prepared for GC if it happens during
  // elements allocation.
  HValue* result = BuildCloneShallowArrayEmpty(
      boilerplate, allocation_site, mode);
 
  HAllocate* elements = BuildAllocateElements(kind, elements_size);
 
  // This function implicitly relies on the fact that the
  // FastCloneShallowArrayStub is called only for literals shorter than
  // JSObject::kInitialMaxFastElementArray.
  // Can't add HBoundsCheck here because otherwise the stub will eager a frame.
  HConstant* size_upper_bound = EstablishElementsAllocationSize(
      kind, JSObject::kInitialMaxFastElementArray);
  elements->set_size_upper_bound(size_upper_bound);
 
  Add<HStoreNamedField>(result, HObjectAccess::ForElementsPointer(), elements);
 
  // The allocation for the cloned array above causes register pressure on
  // machines with low register counts. Force a reload of the boilerplate
  // elements here to free up a register for the allocation to avoid unnecessary
  // spillage.
  boilerplate_elements = AddLoadElements(boilerplate);
  boilerplate_elements->SetFlag(HValue::kCantBeReplaced);
 
  // Copy the elements array header.
  for (int i = 0; i < FixedArrayBase::kHeaderSize; i += kPointerSize) {
    HObjectAccess access = HObjectAccess::ForFixedArrayHeader(i);
    Add<HStoreNamedField>(elements, access,
        Add<HLoadNamedField>(boilerplate_elements,
                             static_cast<HValue*>(NULL), access));
  }
 
  // And the result of the length
  HValue* length = AddLoadArrayLength(boilerplate, kind);
  Add<HStoreNamedField>(result, HObjectAccess::ForArrayLength(kind), length);
 
  BuildCopyElements(boilerplate_elements, kind, elements,
                    kind, length, NULL);
  return result;
}

References v8::internal::kPointerSize, mode(), NULL, and v8::internal::HValue::SetFlag().

Here is the call graph for this function:

BuildCompareNil()

void v8::internal::HGraphBuilder::BuildCompareNil ( HValue *  value, Type *  type, HIfContinuation *  continuation  )

protected

Definition at line 3023 of file hydrogen.cc.

                                   {
  IfBuilder if_nil(this);
  bool some_case_handled = false;
  bool some_case_missing = false;
 
  if (type->Maybe(Type::Null())) {
    if (some_case_handled) if_nil.Or();
    if_nil.If<HCompareObjectEqAndBranch>(value, graph()->GetConstantNull());
    some_case_handled = true;
  } else {
    some_case_missing = true;
  }
 
  if (type->Maybe(Type::Undefined())) {
    if (some_case_handled) if_nil.Or();
    if_nil.If<HCompareObjectEqAndBranch>(value,
                                         graph()->GetConstantUndefined());
    some_case_handled = true;
  } else {
    some_case_missing = true;
  }
 
  if (type->Maybe(Type::Undetectable())) {
    if (some_case_handled) if_nil.Or();
    if_nil.If<HIsUndetectableAndBranch>(value);
    some_case_handled = true;
  } else {
    some_case_missing = true;
  }
 
  if (some_case_missing) {
    if_nil.Then();
    if_nil.Else();
    if (type->NumClasses() == 1) {
      BuildCheckHeapObject(value);
      // For ICs, the map checked below is a sentinel map that gets replaced by
      // the monomorphic map when the code is used as a template to generate a
      // new IC. For optimized functions, there is no sentinel map, the map
      // emitted below is the actual monomorphic map.
      Add<HCheckMaps>(value, type->Classes().Current());
    } else {
      if_nil.Deopt("Too many undetectable types");
    }
  }
 
  if_nil.CaptureContinuation(continuation);
}

References v8::internal::TypeImpl< Config >::Classes(), v8::internal::TypeImpl< Config >::Maybe(), v8::Null(), v8::internal::TypeImpl< Config >::NumClasses(), and v8::Undefined().

Referenced by v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareNil().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildConstantMapCheck()

HInstruction * v8::internal::HGraphBuilder::BuildConstantMapCheck ( Handle< JSObject >  constant )

protected

Definition at line 7395 of file hydrogen.cc.

                                                                            {
  HCheckMaps* check = Add<HCheckMaps>(
      Add<HConstant>(constant), handle(constant->map()));
  check->ClearDependsOnFlag(kElementsKind);
  return check;
}

References v8::internal::handle().

Referenced by BuildCheckPrototypeMaps().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCopyElements()

void v8::internal::HGraphBuilder::BuildCopyElements ( HValue *  from_elements, ElementsKind  from_elements_kind, HValue *  to_elements, ElementsKind  to_elements_kind, HValue *  length, HValue *  capacity  )

protected

Definition at line 2839 of file hydrogen.cc.

                                                        {
  int constant_capacity = -1;
  if (capacity != NULL &&
      capacity->IsConstant() &&
      HConstant::cast(capacity)->HasInteger32Value()) {
    int constant_candidate = HConstant::cast(capacity)->Integer32Value();
    if (constant_candidate <= kElementLoopUnrollThreshold) {
      constant_capacity = constant_candidate;
    }
  }
 
  bool pre_fill_with_holes =
    IsFastDoubleElementsKind(from_elements_kind) &&
    IsFastObjectElementsKind(to_elements_kind);
  if (pre_fill_with_holes) {
    // If the copy might trigger a GC, make sure that the FixedArray is
    // pre-initialized with holes to make sure that it's always in a
    // consistent state.
    BuildFillElementsWithHole(to_elements, to_elements_kind,
                              graph()->GetConstant0(), NULL);
  }
 
  if (constant_capacity != -1) {
    // Unroll the loop for small elements kinds.
    for (int i = 0; i < constant_capacity; i++) {
      HValue* key_constant = Add<HConstant>(i);
      HInstruction* value = Add<HLoadKeyed>(from_elements, key_constant,
                                            static_cast<HValue*>(NULL),
                                            from_elements_kind);
      Add<HStoreKeyed>(to_elements, key_constant, value, to_elements_kind);
    }
  } else {
    if (!pre_fill_with_holes &&
        (capacity == NULL || !length->Equals(capacity))) {
      BuildFillElementsWithHole(to_elements, to_elements_kind,
                                length, NULL);
    }
 
    if (capacity == NULL) {
      capacity = AddLoadFixedArrayLength(to_elements);
    }
 
    LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
 
    HValue* key = builder.BeginBody(length, graph()->GetConstant0(),
                                    Token::GT);
 
    key = AddUncasted<HSub>(key, graph()->GetConstant1());
    key->ClearFlag(HValue::kCanOverflow);
 
    HValue* element = Add<HLoadKeyed>(from_elements, key,
                                      static_cast<HValue*>(NULL),
                                      from_elements_kind,
                                      ALLOW_RETURN_HOLE);
 
    ElementsKind kind = (IsHoleyElementsKind(from_elements_kind) &&
                         IsFastSmiElementsKind(to_elements_kind))
      ? FAST_HOLEY_ELEMENTS : to_elements_kind;
 
    if (IsHoleyElementsKind(from_elements_kind) &&
        from_elements_kind != to_elements_kind) {
      IfBuilder if_hole(this);
      if_hole.If<HCompareHoleAndBranch>(element);
      if_hole.Then();
      HConstant* hole_constant = IsFastDoubleElementsKind(to_elements_kind)
        ? Add<HConstant>(FixedDoubleArray::hole_nan_as_double())
        : graph()->GetConstantHole();
      Add<HStoreKeyed>(to_elements, key, hole_constant, kind);
      if_hole.Else();
      HStoreKeyed* store = Add<HStoreKeyed>(to_elements, key, element, kind);
      store->SetFlag(HValue::kAllowUndefinedAsNaN);
      if_hole.End();
    } else {
      HStoreKeyed* store = Add<HStoreKeyed>(to_elements, key, element, kind);
      store->SetFlag(HValue::kAllowUndefinedAsNaN);
    }
 
    builder.EndBody();
  }
 
  Counters* counters = isolate()->counters();
  AddIncrementCounter(counters->inlined_copied_elements());
}

References v8::internal::ALLOW_RETURN_HOLE, v8::internal::HValue::ClearFlag(), v8::internal::HValue::Equals(), v8::internal::FAST_HOLEY_ELEMENTS, v8::internal::IsFastDoubleElementsKind(), v8::internal::IsFastObjectElementsKind(), v8::internal::IsFastSmiElementsKind(), v8::internal::IsHoleyElementsKind(), and NULL.

Here is the call graph for this function:

BuildCopyElementsOnWrite()

HValue * v8::internal::HGraphBuilder::BuildCopyElementsOnWrite ( HValue *  object, HValue *  elements, ElementsKind  kind, HValue *  length  )

protected

Definition at line 1366 of file hydrogen.cc.

                                                                {
  Factory* factory = isolate()->factory();
 
  IfBuilder cow_checker(this);
 
  cow_checker.If<HCompareMap>(elements, factory->fixed_cow_array_map());
  cow_checker.Then();
 
  HValue* capacity = AddLoadFixedArrayLength(elements);
 
  HValue* new_elements = BuildGrowElementsCapacity(object, elements, kind,
                                                   kind, length, capacity);
 
  environment()->Push(new_elements);
 
  cow_checker.Else();
 
  environment()->Push(elements);
 
  cow_checker.End();
 
  return environment()->Pop();
}

Referenced by v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the caller graph for this function:

BuildCopySeqStringChars()

void v8::internal::HGraphBuilder::BuildCopySeqStringChars ( HValue *  src, HValue *  src_offset, String::Encoding  src_encoding, HValue *  dst, HValue *  dst_offset, String::Encoding  dst_encoding, HValue *  length  )

protected

Definition at line 2145 of file hydrogen.cc.

                                                            {
  DCHECK(dst_encoding != String::ONE_BYTE_ENCODING ||
         src_encoding == String::ONE_BYTE_ENCODING);
  LoopBuilder loop(this, context(), LoopBuilder::kPostIncrement);
  HValue* index = loop.BeginBody(graph()->GetConstant0(), length, Token::LT);
  {
    HValue* src_index = AddUncasted<HAdd>(src_offset, index);
    HValue* value =
        AddUncasted<HSeqStringGetChar>(src_encoding, src, src_index);
    HValue* dst_index = AddUncasted<HAdd>(dst_offset, index);
    Add<HSeqStringSetChar>(dst_encoding, dst, dst_index, value);
  }
  loop.EndBody();
}

References DCHECK.

BuildCreateAllocationMemento()

void v8::internal::HGraphBuilder::BuildCreateAllocationMemento ( HValue *  previous_object, HValue *  previous_object_size, HValue *  payload  )

protected

Definition at line 3075 of file hydrogen.cc.

                             {
  DCHECK(allocation_site != NULL);
  HInnerAllocatedObject* allocation_memento = Add<HInnerAllocatedObject>(
      previous_object, previous_object_size, HType::HeapObject());
  AddStoreMapConstant(
      allocation_memento, isolate()->factory()->allocation_memento_map());
  Add<HStoreNamedField>(
      allocation_memento,
      HObjectAccess::ForAllocationMementoSite(),
      allocation_site);
  if (FLAG_allocation_site_pretenuring) {
    HValue* memento_create_count = Add<HLoadNamedField>(
        allocation_site, static_cast<HValue*>(NULL),
        HObjectAccess::ForAllocationSiteOffset(
            AllocationSite::kPretenureCreateCountOffset));
    memento_create_count = AddUncasted<HAdd>(
        memento_create_count, graph()->GetConstant1());
    // This smi value is reset to zero after every gc, overflow isn't a problem
    // since the counter is bounded by the new space size.
    memento_create_count->ClearFlag(HValue::kCanOverflow);
    Add<HStoreNamedField>(
        allocation_site, HObjectAccess::ForAllocationSiteOffset(
            AllocationSite::kPretenureCreateCountOffset), memento_create_count);
  }
}

References v8::internal::HValue::ClearFlag(), DCHECK, and NULL.

Here is the call graph for this function:

BuildCreateConsString()

HValue * v8::internal::HGraphBuilder::BuildCreateConsString ( HValue *  length, HValue *  left, HValue *  right, HAllocationMode  allocation_mode  )

protected

Definition at line 2061 of file hydrogen.cc.

                                     {
  // Determine the string instance types.
  HInstruction* left_instance_type = AddLoadStringInstanceType(left);
  HInstruction* right_instance_type = AddLoadStringInstanceType(right);
 
  // Allocate the cons string object. HAllocate does not care whether we
  // pass CONS_STRING_TYPE or CONS_ONE_BYTE_STRING_TYPE here, so we just use
  // CONS_STRING_TYPE here. Below we decide whether the cons string is
  // one-byte or two-byte and set the appropriate map.
  DCHECK(HAllocate::CompatibleInstanceTypes(CONS_STRING_TYPE,
                                            CONS_ONE_BYTE_STRING_TYPE));
  HAllocate* result = BuildAllocate(Add<HConstant>(ConsString::kSize),
                                    HType::String(), CONS_STRING_TYPE,
                                    allocation_mode);
 
  // Compute intersection and difference of instance types.
  HValue* anded_instance_types = AddUncasted<HBitwise>(
      Token::BIT_AND, left_instance_type, right_instance_type);
  HValue* xored_instance_types = AddUncasted<HBitwise>(
      Token::BIT_XOR, left_instance_type, right_instance_type);
 
  // We create a one-byte cons string if
  // 1. both strings are one-byte, or
  // 2. at least one of the strings is two-byte, but happens to contain only
  //    one-byte characters.
  // To do this, we check
  // 1. if both strings are one-byte, or if the one-byte data hint is set in
  //    both strings, or
  // 2. if one of the strings has the one-byte data hint set and the other
  //    string is one-byte.
  IfBuilder if_onebyte(this);
  STATIC_ASSERT(kOneByteStringTag != 0);
  STATIC_ASSERT(kOneByteDataHintMask != 0);
  if_onebyte.If<HCompareNumericAndBranch>(
      AddUncasted<HBitwise>(
          Token::BIT_AND, anded_instance_types,
          Add<HConstant>(static_cast<int32_t>(
                  kStringEncodingMask | kOneByteDataHintMask))),
      graph()->GetConstant0(), Token::NE);
  if_onebyte.Or();
  STATIC_ASSERT(kOneByteStringTag != 0 &&
                kOneByteDataHintTag != 0 &&
                kOneByteDataHintTag != kOneByteStringTag);
  if_onebyte.If<HCompareNumericAndBranch>(
      AddUncasted<HBitwise>(
          Token::BIT_AND, xored_instance_types,
          Add<HConstant>(static_cast<int32_t>(
                  kOneByteStringTag | kOneByteDataHintTag))),
      Add<HConstant>(static_cast<int32_t>(
              kOneByteStringTag | kOneByteDataHintTag)), Token::EQ);
  if_onebyte.Then();
  {
    // We can safely skip the write barrier for storing the map here.
    Add<HStoreNamedField>(
        result, HObjectAccess::ForMap(),
        Add<HConstant>(isolate()->factory()->cons_one_byte_string_map()));
  }
  if_onebyte.Else();
  {
    // We can safely skip the write barrier for storing the map here.
    Add<HStoreNamedField>(
        result, HObjectAccess::ForMap(),
        Add<HConstant>(isolate()->factory()->cons_string_map()));
  }
  if_onebyte.End();
 
  // Initialize the cons string fields.
  Add<HStoreNamedField>(result, HObjectAccess::ForStringHashField(),
                        Add<HConstant>(String::kEmptyHashField));
  Add<HStoreNamedField>(result, HObjectAccess::ForStringLength(), length);
  Add<HStoreNamedField>(result, HObjectAccess::ForConsStringFirst(), left);
  Add<HStoreNamedField>(result, HObjectAccess::ForConsStringSecond(), right);
 
  // Count the native string addition.
  AddIncrementCounter(isolate()->counters()->string_add_native());
 
  return result;
}

References v8::internal::CONS_ONE_BYTE_STRING_TYPE, v8::internal::CONS_STRING_TYPE, DCHECK, v8::internal::EQ, v8::internal::kOneByteDataHintMask, v8::internal::kOneByteDataHintTag, v8::internal::kOneByteStringTag, v8::internal::kStringEncodingMask, and STATIC_ASSERT.

BuildDecodeField()

template<class BitFieldClass >

HValue* v8::internal::HGraphBuilder::BuildDecodeField ( HValue *  encoded_field )

inlineprotected

Definition at line 1317 of file hydrogen.h.

                                                  {
    HValue* mask_value = Add<HConstant>(static_cast<int>(BitFieldClass::kMask));
    HValue* masked_field =
        AddUncasted<HBitwise>(Token::BIT_AND, encoded_field, mask_value);
    return AddUncasted<HShr>(masked_field,
        Add<HConstant>(static_cast<int>(BitFieldClass::kShift)));
  }

BuildElementIndexHash()

HValue * v8::internal::HGraphBuilder::BuildElementIndexHash ( HValue *  index )

protected

Definition at line 1634 of file hydrogen.cc.

                                                          {
  int32_t seed_value = static_cast<uint32_t>(isolate()->heap()->HashSeed());
  HValue* seed = Add<HConstant>(seed_value);
  HValue* hash = AddUncasted<HBitwise>(Token::BIT_XOR, index, seed);
 
  // hash = ~hash + (hash << 15);
  HValue* shifted_hash = AddUncasted<HShl>(hash, Add<HConstant>(15));
  HValue* not_hash = AddUncasted<HBitwise>(Token::BIT_XOR, hash,
                                           graph()->GetConstantMinus1());
  hash = AddUncasted<HAdd>(shifted_hash, not_hash);
 
  // hash = hash ^ (hash >> 12);
  shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(12));
  hash = AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 
  // hash = hash + (hash << 2);
  shifted_hash = AddUncasted<HShl>(hash, Add<HConstant>(2));
  hash = AddUncasted<HAdd>(hash, shifted_hash);
 
  // hash = hash ^ (hash >> 4);
  shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(4));
  hash = AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 
  // hash = hash * 2057;
  hash = AddUncasted<HMul>(hash, Add<HConstant>(2057));
  hash->ClearFlag(HValue::kCanOverflow);
 
  // hash = hash ^ (hash >> 16);
  shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(16));
  return AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
}

References v8::internal::HValue::ClearFlag().

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildFillElementsWithHole()

void v8::internal::HGraphBuilder::BuildFillElementsWithHole ( HValue *  elements, ElementsKind  elements_kind, HValue *  from, HValue *  to  )

protected

Definition at line 2822 of file hydrogen.cc.

                                                          {
  // Fast elements kinds need to be initialized in case statements below cause a
  // garbage collection.
  Factory* factory = isolate()->factory();
 
  double nan_double = FixedDoubleArray::hole_nan_as_double();
  HValue* hole = IsFastSmiOrObjectElementsKind(elements_kind)
      ? Add<HConstant>(factory->the_hole_value())
      : Add<HConstant>(nan_double);
 
  BuildFillElementsWithValue(elements, elements_kind, from, to, hole);
}

References v8::internal::IsFastSmiOrObjectElementsKind(), and to().

Here is the call graph for this function:

BuildFillElementsWithValue()

void v8::internal::HGraphBuilder::BuildFillElementsWithValue ( HValue *  elements, ElementsKind  elements_kind, HValue *  from, HValue *  to, HValue *  value  )

protected

Definition at line 2770 of file hydrogen.cc.

                                                              {
  if (to == NULL) {
    to = AddLoadFixedArrayLength(elements);
  }
 
  // Special loop unfolding case
  STATIC_ASSERT(JSArray::kPreallocatedArrayElements <=
                kElementLoopUnrollThreshold);
  int initial_capacity = -1;
  if (from->IsInteger32Constant() && to->IsInteger32Constant()) {
    int constant_from = from->GetInteger32Constant();
    int constant_to = to->GetInteger32Constant();
 
    if (constant_from == 0 && constant_to <= kElementLoopUnrollThreshold) {
      initial_capacity = constant_to;
    }
  }
 
  // Since we're about to store a hole value, the store instruction below must
  // assume an elements kind that supports heap object values.
  if (IsFastSmiOrObjectElementsKind(elements_kind)) {
    elements_kind = FAST_HOLEY_ELEMENTS;
  }
 
  if (initial_capacity >= 0) {
    for (int i = 0; i < initial_capacity; i++) {
      HInstruction* key = Add<HConstant>(i);
      Add<HStoreKeyed>(elements, key, value, elements_kind);
    }
  } else {
    // Carefully loop backwards so that the "from" remains live through the loop
    // rather than the to. This often corresponds to keeping length live rather
    // then capacity, which helps register allocation, since length is used more
    // other than capacity after filling with holes.
    LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
 
    HValue* key = builder.BeginBody(to, from, Token::GT);
 
    HValue* adjusted_key = AddUncasted<HSub>(key, graph()->GetConstant1());
    adjusted_key->ClearFlag(HValue::kCanOverflow);
 
    Add<HStoreKeyed>(elements, adjusted_key, value, elements_kind);
 
    builder.EndBody();
  }
}

References v8::internal::HValue::ClearFlag(), v8::internal::FAST_HOLEY_ELEMENTS, v8::internal::HValue::GetInteger32Constant(), v8::internal::IsFastSmiOrObjectElementsKind(), v8::internal::HValue::IsInteger32Constant(), NULL, STATIC_ASSERT, and to().

Here is the call graph for this function:

BuildGetArrayFunction()

HInstruction * v8::internal::HGraphBuilder::BuildGetArrayFunction ( )

protected

Definition at line 3132 of file hydrogen.cc.

                                                   {
  HInstruction* native_context = BuildGetNativeContext();
  HInstruction* index =
      Add<HConstant>(static_cast<int32_t>(Context::ARRAY_FUNCTION_INDEX));
  return Add<HLoadKeyed>(
      native_context, index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
}

References v8::internal::FAST_ELEMENTS, and NULL.

BuildGetElementsKind()

HValue * v8::internal::HGraphBuilder::BuildGetElementsKind ( HValue *  object )

protected

Definition at line 1256 of file hydrogen.cc.

                                                          {
  HValue* map = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
                                     HObjectAccess::ForMap());
 
  HValue* bit_field2 = Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
                                            HObjectAccess::ForMapBitField2());
  return BuildDecodeField<Map::ElementsKindBits>(bit_field2);
}

References map, and NULL.

BuildGetNativeContext() [1/2]

HInstruction * v8::internal::HGraphBuilder::BuildGetNativeContext ( )

protected

Definition at line 3120 of file hydrogen.cc.

                                                   {
  // Get the global context, then the native context
  HValue* global_object = Add<HLoadNamedField>(
      context(), static_cast<HValue*>(NULL),
      HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
  return Add<HLoadNamedField>(
      global_object, static_cast<HValue*>(NULL),
      HObjectAccess::ForObservableJSObjectOffset(
          GlobalObject::kNativeContextOffset));
}

References NULL.

BuildGetNativeContext() [2/2]

HInstruction * v8::internal::HGraphBuilder::BuildGetNativeContext ( HValue *  closure )

protected

Definition at line 3105 of file hydrogen.cc.

                                                                  {
  // Get the global context, then the native context
  HInstruction* context =
      Add<HLoadNamedField>(closure, static_cast<HValue*>(NULL),
                           HObjectAccess::ForFunctionContextPointer());
  HInstruction* global_object = Add<HLoadNamedField>(
      context, static_cast<HValue*>(NULL),
      HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
  HObjectAccess access = HObjectAccess::ForObservableJSObjectOffset(
      GlobalObject::kNativeContextOffset);
  return Add<HLoadNamedField>(
      global_object, static_cast<HValue*>(NULL), access);
}

References NULL.

BuildGraph()

virtual bool v8::internal::HGraphBuilder::BuildGraph ( )

protectedpure virtual

Implemented in v8::internal::HOptimizedGraphBuilder, and v8::internal::CodeStubGraphBuilderBase.

BuildGrowElementsCapacity()

HValue * v8::internal::HGraphBuilder::BuildGrowElementsCapacity ( HValue *  object, HValue *  elements, ElementsKind  kind, ElementsKind  new_kind, HValue *  length, HValue *  new_capacity  )

protected

Definition at line 2747 of file hydrogen.cc.

                                                                       {
  Add<HBoundsCheck>(new_capacity, Add<HConstant>(
          (Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) >>
          ElementsKindToShiftSize(new_kind)));
 
  HValue* new_elements = BuildAllocateElementsAndInitializeElementsHeader(
      new_kind, new_capacity);
 
  BuildCopyElements(elements, kind, new_elements,
                    new_kind, length, new_capacity);
 
  Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
                        new_elements);
 
  return new_elements;
}

References v8::internal::ElementsKindToShiftSize().

Here is the call graph for this function:

BuildInitializeElementsHeader()

void v8::internal::HGraphBuilder::BuildInitializeElementsHeader ( HValue *  elements, ElementsKind  kind, HValue *  capacity  )

protected

Definition at line 2615 of file hydrogen.cc.

                                                                    {
  Factory* factory = isolate()->factory();
  Handle<Map> map = IsFastDoubleElementsKind(kind)
      ? factory->fixed_double_array_map()
      : factory->fixed_array_map();
 
  Add<HStoreNamedField>(elements, HObjectAccess::ForMap(), Add<HConstant>(map));
  Add<HStoreNamedField>(elements, HObjectAccess::ForFixedArrayLength(),
                        capacity);
}

References v8::internal::IsFastDoubleElementsKind(), and map.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildEmitElements().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildJSArrayHeader()

void v8::internal::HGraphBuilder::BuildJSArrayHeader ( HValue *  array, HValue *  array_map, HValue *  elements, AllocationSiteMode  mode, ElementsKind  elements_kind, HValue *  allocation_site_payload, HValue *  length_field  )

protected

Definition at line 2642 of file hydrogen.cc.

                                                             {
  Add<HStoreNamedField>(array, HObjectAccess::ForMap(), array_map);
 
  HConstant* empty_fixed_array =
    Add<HConstant>(isolate()->factory()->empty_fixed_array());
 
  Add<HStoreNamedField>(
      array, HObjectAccess::ForPropertiesPointer(), empty_fixed_array);
 
  Add<HStoreNamedField>(
      array, HObjectAccess::ForElementsPointer(),
      elements != NULL ? elements : empty_fixed_array);
 
  Add<HStoreNamedField>(
      array, HObjectAccess::ForArrayLength(elements_kind), length_field);
 
  if (mode == TRACK_ALLOCATION_SITE) {
    BuildCreateAllocationMemento(
        array, Add<HConstant>(JSArray::kSize), allocation_site_payload);
  }
}

References mode(), NULL, and v8::internal::TRACK_ALLOCATION_SITE.

Here is the call graph for this function:

BuildJSObjectCheck()

void v8::internal::HGraphBuilder::BuildJSObjectCheck ( HValue *  receiver, int  bit_field_mask  )

protected

Definition at line 1435 of file hydrogen.cc.

                                                           {
  // Check that the object isn't a smi.
  Add<HCheckHeapObject>(receiver);
 
  // Get the map of the receiver.
  HValue* map = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
                                     HObjectAccess::ForMap());
 
  // Check the instance type and if an access check is needed, this can be
  // done with a single load, since both bytes are adjacent in the map.
  HObjectAccess access(HObjectAccess::ForMapInstanceTypeAndBitField());
  HValue* instance_type_and_bit_field =
      Add<HLoadNamedField>(map, static_cast<HValue*>(NULL), access);
 
  HValue* mask = Add<HConstant>(0x00FF | (bit_field_mask << 8));
  HValue* and_result = AddUncasted<HBitwise>(Token::BIT_AND,
                                             instance_type_and_bit_field,
                                             mask);
  HValue* sub_result = AddUncasted<HSub>(and_result,
                                         Add<HConstant>(JS_OBJECT_TYPE));
  Add<HBoundsCheck>(sub_result,
                    Add<HConstant>(LAST_JS_OBJECT_TYPE + 1 - JS_OBJECT_TYPE));
}

References v8::internal::JS_OBJECT_TYPE, v8::internal::LAST_JS_OBJECT_TYPE, map, and NULL.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the caller graph for this function:

BuildKeyedIndexCheck()

void v8::internal::HGraphBuilder::BuildKeyedIndexCheck ( HValue *  key, HIfContinuation *  join_continuation  )

protected

Definition at line 1461 of file hydrogen.cc.

                                                                             {
  // The sometimes unintuitively backward ordering of the ifs below is
  // convoluted, but necessary.  All of the paths must guarantee that the
  // if-true of the continuation returns a smi element index and the if-false of
  // the continuation returns either a symbol or a unique string key. All other
  // object types cause a deopt to fall back to the runtime.
 
  IfBuilder key_smi_if(this);
  key_smi_if.If<HIsSmiAndBranch>(key);
  key_smi_if.Then();
  {
    Push(key);  // Nothing to do, just continue to true of continuation.
  }
  key_smi_if.Else();
  {
    HValue* map = Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
                                       HObjectAccess::ForMap());
    HValue* instance_type =
        Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
                             HObjectAccess::ForMapInstanceType());
 
    // Non-unique string, check for a string with a hash code that is actually
    // an index.
    STATIC_ASSERT(LAST_UNIQUE_NAME_TYPE == FIRST_NONSTRING_TYPE);
    IfBuilder not_string_or_name_if(this);
    not_string_or_name_if.If<HCompareNumericAndBranch>(
        instance_type,
        Add<HConstant>(LAST_UNIQUE_NAME_TYPE),
        Token::GT);
 
    not_string_or_name_if.Then();
    {
      // Non-smi, non-Name, non-String: Try to convert to smi in case of
      // HeapNumber.
      // TODO(danno): This could call some variant of ToString
      Push(AddUncasted<HForceRepresentation>(key, Representation::Smi()));
    }
    not_string_or_name_if.Else();
    {
      // String or Name: check explicitly for Name, they can short-circuit
      // directly to unique non-index key path.
      IfBuilder not_symbol_if(this);
      not_symbol_if.If<HCompareNumericAndBranch>(
          instance_type,
          Add<HConstant>(SYMBOL_TYPE),
          Token::NE);
 
      not_symbol_if.Then();
      {
        // String: check whether the String is a String of an index. If it is,
        // extract the index value from the hash.
        HValue* hash =
            Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
                                 HObjectAccess::ForNameHashField());
        HValue* not_index_mask = Add<HConstant>(static_cast<int>(
            String::kContainsCachedArrayIndexMask));
 
        HValue* not_index_test = AddUncasted<HBitwise>(
            Token::BIT_AND, hash, not_index_mask);
 
        IfBuilder string_index_if(this);
        string_index_if.If<HCompareNumericAndBranch>(not_index_test,
                                                     graph()->GetConstant0(),
                                                     Token::EQ);
        string_index_if.Then();
        {
          // String with index in hash: extract string and merge to index path.
          Push(BuildDecodeField<String::ArrayIndexValueBits>(hash));
        }
        string_index_if.Else();
        {
          // Key is a non-index String, check for uniqueness/internalization.
          // If it's not internalized yet, internalize it now.
          HValue* not_internalized_bit = AddUncasted<HBitwise>(
              Token::BIT_AND,
              instance_type,
              Add<HConstant>(static_cast<int>(kIsNotInternalizedMask)));
 
          IfBuilder internalized(this);
          internalized.If<HCompareNumericAndBranch>(not_internalized_bit,
                                                    graph()->GetConstant0(),
                                                    Token::EQ);
          internalized.Then();
          Push(key);
 
          internalized.Else();
          Add<HPushArguments>(key);
          HValue* intern_key = Add<HCallRuntime>(
              isolate()->factory()->empty_string(),
              Runtime::FunctionForId(Runtime::kInternalizeString), 1);
          Push(intern_key);
 
          internalized.End();
          // Key guaranteed to be a unique string
        }
        string_index_if.JoinContinuation(join_continuation);
      }
      not_symbol_if.Else();
      {
        Push(key);  // Key is symbol
      }
      not_symbol_if.JoinContinuation(join_continuation);
    }
    not_string_or_name_if.JoinContinuation(join_continuation);
  }
  key_smi_if.JoinContinuation(join_continuation);
}

References v8::internal::EQ, v8::internal::FIRST_NONSTRING_TYPE, v8::internal::kIsNotInternalizedMask, v8::internal::LAST_UNIQUE_NAME_TYPE, map, NULL, v8::internal::compiler::Push(), STATIC_ASSERT, and v8::internal::SYMBOL_TYPE.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildKeyedLookupCacheHash()

HValue * v8::internal::HGraphBuilder::BuildKeyedLookupCacheHash ( HValue *  object, HValue *  key  )

protected

Definition at line 1612 of file hydrogen.cc.

                                                              {
  // Load the map of the receiver, compute the keyed lookup cache hash
  // based on 32 bits of the map pointer and the string hash.
  HValue* object_map =
      Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
                           HObjectAccess::ForMapAsInteger32());
  HValue* shifted_map = AddUncasted<HShr>(
      object_map, Add<HConstant>(KeyedLookupCache::kMapHashShift));
  HValue* string_hash =
      Add<HLoadNamedField>(key, static_cast<HValue*>(NULL),
                           HObjectAccess::ForStringHashField());
  HValue* shifted_hash = AddUncasted<HShr>(
      string_hash, Add<HConstant>(String::kHashShift));
  HValue* xor_result = AddUncasted<HBitwise>(Token::BIT_XOR, shifted_map,
                                             shifted_hash);
  int mask = (KeyedLookupCache::kCapacityMask & KeyedLookupCache::kHashMask);
  return AddUncasted<HBitwise>(Token::BIT_AND, xor_result,
                               Add<HConstant>(mask));
}

References NULL.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the caller graph for this function:

BuildNewElementsCapacity()

HValue * v8::internal::HGraphBuilder::BuildNewElementsCapacity ( HValue *  old_capacity )

protected

Definition at line 2731 of file hydrogen.cc.

                                                                    {
  HValue* half_old_capacity = AddUncasted<HShr>(old_capacity,
                                                graph_->GetConstant1());
 
  HValue* new_capacity = AddUncasted<HAdd>(half_old_capacity, old_capacity);
  new_capacity->ClearFlag(HValue::kCanOverflow);
 
  HValue* min_growth = Add<HConstant>(16);
 
  new_capacity = AddUncasted<HAdd>(new_capacity, min_growth);
  new_capacity->ClearFlag(HValue::kCanOverflow);
 
  return new_capacity;
}

References v8::internal::HValue::ClearFlag().

Here is the call graph for this function:

BuildNonGlobalObjectCheck()

void v8::internal::HGraphBuilder::BuildNonGlobalObjectCheck ( HValue *  receiver )

protected

Definition at line 1571 of file hydrogen.cc.

                                                              {
  // Get the the instance type of the receiver, and make sure that it is
  // not one of the global object types.
  HValue* map = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
                                     HObjectAccess::ForMap());
  HValue* instance_type =
    Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
                         HObjectAccess::ForMapInstanceType());
  STATIC_ASSERT(JS_BUILTINS_OBJECT_TYPE == JS_GLOBAL_OBJECT_TYPE + 1);
  HValue* min_global_type = Add<HConstant>(JS_GLOBAL_OBJECT_TYPE);
  HValue* max_global_type = Add<HConstant>(JS_BUILTINS_OBJECT_TYPE);
 
  IfBuilder if_global_object(this);
  if_global_object.If<HCompareNumericAndBranch>(instance_type,
                                                max_global_type,
                                                Token::LTE);
  if_global_object.And();
  if_global_object.If<HCompareNumericAndBranch>(instance_type,
                                                min_global_type,
                                                Token::GTE);
  if_global_object.ThenDeopt("receiver was a global object");
  if_global_object.End();
}

References v8::internal::JS_BUILTINS_OBJECT_TYPE, v8::internal::JS_GLOBAL_OBJECT_TYPE, map, NULL, and STATIC_ASSERT.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the caller graph for this function:

BuildNumberToString()

HValue * v8::internal::HGraphBuilder::BuildNumberToString ( HValue *  object, Type *  type  )

protected

Definition at line 1878 of file hydrogen.cc.

                                                                     {
  NoObservableSideEffectsScope scope(this);
 
  // Convert constant numbers at compile time.
  if (object->IsConstant() && HConstant::cast(object)->HasNumberValue()) {
    Handle<Object> number = HConstant::cast(object)->handle(isolate());
    Handle<String> result = isolate()->factory()->NumberToString(number);
    return Add<HConstant>(result);
  }
 
  // Create a joinable continuation.
  HIfContinuation found(graph()->CreateBasicBlock(),
                        graph()->CreateBasicBlock());
 
  // Load the number string cache.
  HValue* number_string_cache =
      Add<HLoadRoot>(Heap::kNumberStringCacheRootIndex);
 
  // Make the hash mask from the length of the number string cache. It
  // contains two elements (number and string) for each cache entry.
  HValue* mask = AddLoadFixedArrayLength(number_string_cache);
  mask->set_type(HType::Smi());
  mask = AddUncasted<HSar>(mask, graph()->GetConstant1());
  mask = AddUncasted<HSub>(mask, graph()->GetConstant1());
 
  // Check whether object is a smi.
  IfBuilder if_objectissmi(this);
  if_objectissmi.If<HIsSmiAndBranch>(object);
  if_objectissmi.Then();
  {
    // Compute hash for smi similar to smi_get_hash().
    HValue* hash = AddUncasted<HBitwise>(Token::BIT_AND, object, mask);
 
    // Load the key.
    HValue* key_index = AddUncasted<HShl>(hash, graph()->GetConstant1());
    HValue* key = Add<HLoadKeyed>(number_string_cache, key_index,
                                  static_cast<HValue*>(NULL),
                                  FAST_ELEMENTS, ALLOW_RETURN_HOLE);
 
    // Check if object == key.
    IfBuilder if_objectiskey(this);
    if_objectiskey.If<HCompareObjectEqAndBranch>(object, key);
    if_objectiskey.Then();
    {
      // Make the key_index available.
      Push(key_index);
    }
    if_objectiskey.JoinContinuation(&found);
  }
  if_objectissmi.Else();
  {
    if (type->Is(Type::SignedSmall())) {
      if_objectissmi.Deopt("Expected smi");
    } else {
      // Check if the object is a heap number.
      IfBuilder if_objectisnumber(this);
      HValue* objectisnumber = if_objectisnumber.If<HCompareMap>(
          object, isolate()->factory()->heap_number_map());
      if_objectisnumber.Then();
      {
        // Compute hash for heap number similar to double_get_hash().
        HValue* low = Add<HLoadNamedField>(
            object, objectisnumber,
            HObjectAccess::ForHeapNumberValueLowestBits());
        HValue* high = Add<HLoadNamedField>(
            object, objectisnumber,
            HObjectAccess::ForHeapNumberValueHighestBits());
        HValue* hash = AddUncasted<HBitwise>(Token::BIT_XOR, low, high);
        hash = AddUncasted<HBitwise>(Token::BIT_AND, hash, mask);
 
        // Load the key.
        HValue* key_index = AddUncasted<HShl>(hash, graph()->GetConstant1());
        HValue* key = Add<HLoadKeyed>(number_string_cache, key_index,
                                      static_cast<HValue*>(NULL),
                                      FAST_ELEMENTS, ALLOW_RETURN_HOLE);
 
        // Check if the key is a heap number and compare it with the object.
        IfBuilder if_keyisnotsmi(this);
        HValue* keyisnotsmi = if_keyisnotsmi.IfNot<HIsSmiAndBranch>(key);
        if_keyisnotsmi.Then();
        {
          IfBuilder if_keyisheapnumber(this);
          if_keyisheapnumber.If<HCompareMap>(
              key, isolate()->factory()->heap_number_map());
          if_keyisheapnumber.Then();
          {
            // Check if values of key and object match.
            IfBuilder if_keyeqobject(this);
            if_keyeqobject.If<HCompareNumericAndBranch>(
                Add<HLoadNamedField>(key, keyisnotsmi,
                                     HObjectAccess::ForHeapNumberValue()),
                Add<HLoadNamedField>(object, objectisnumber,
                                     HObjectAccess::ForHeapNumberValue()),
                Token::EQ);
            if_keyeqobject.Then();
            {
              // Make the key_index available.
              Push(key_index);
            }
            if_keyeqobject.JoinContinuation(&found);
          }
          if_keyisheapnumber.JoinContinuation(&found);
        }
        if_keyisnotsmi.JoinContinuation(&found);
      }
      if_objectisnumber.Else();
      {
        if (type->Is(Type::Number())) {
          if_objectisnumber.Deopt("Expected heap number");
        }
      }
      if_objectisnumber.JoinContinuation(&found);
    }
  }
  if_objectissmi.JoinContinuation(&found);
 
  // Check for cache hit.
  IfBuilder if_found(this, &found);
  if_found.Then();
  {
    // Count number to string operation in native code.
    AddIncrementCounter(isolate()->counters()->number_to_string_native());
 
    // Load the value in case of cache hit.
    HValue* key_index = Pop();
    HValue* value_index = AddUncasted<HAdd>(key_index, graph()->GetConstant1());
    Push(Add<HLoadKeyed>(number_string_cache, value_index,
                         static_cast<HValue*>(NULL),
                         FAST_ELEMENTS, ALLOW_RETURN_HOLE));
  }
  if_found.Else();
  {
    // Cache miss, fallback to runtime.
    Add<HPushArguments>(object);
    Push(Add<HCallRuntime>(
            isolate()->factory()->empty_string(),
            Runtime::FunctionForId(Runtime::kNumberToStringSkipCache),
            1));
  }
  if_found.End();
 
  return Pop();
}

References v8::internal::ALLOW_RETURN_HOLE, v8::internal::EQ, v8::internal::FAST_ELEMENTS, v8::internal::TypeImpl< Config >::Is(), NULL, v8::internal::compiler::Push(), and v8::internal::HValue::set_type().

Referenced by BuildBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildObjectSizeAlignment()

HValue * v8::internal::HGraphBuilder::BuildObjectSizeAlignment ( HValue *  unaligned_size, int  header_size  )

protected

Definition at line 2167 of file hydrogen.cc.

                                             {
  DCHECK((header_size & kObjectAlignmentMask) == 0);
  HValue* size = AddUncasted<HAdd>(
      unaligned_size, Add<HConstant>(static_cast<int32_t>(
          header_size + kObjectAlignmentMask)));
  size->ClearFlag(HValue::kCanOverflow);
  return AddUncasted<HBitwise>(
      Token::BIT_AND, size, Add<HConstant>(static_cast<int32_t>(
          ~kObjectAlignmentMask)));
}

References DCHECK, v8::internal::kObjectAlignmentMask, and size.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildAllocateFixedTypedArray().

Here is the caller graph for this function:

BuildRegExpConstructResult()

HValue * v8::internal::HGraphBuilder::BuildRegExpConstructResult ( HValue *  length, HValue *  index, HValue *  input  )

protected

Definition at line 1807 of file hydrogen.cc.

                                                                 {
  NoObservableSideEffectsScope scope(this);
  HConstant* max_length = Add<HConstant>(JSObject::kInitialMaxFastElementArray);
  Add<HBoundsCheck>(length, max_length);
 
  // Generate size calculation code here in order to make it dominate
  // the JSRegExpResult allocation.
  ElementsKind elements_kind = FAST_ELEMENTS;
  HValue* size = BuildCalculateElementsSize(elements_kind, length);
 
  // Allocate the JSRegExpResult and the FixedArray in one step.
  HValue* result = Add<HAllocate>(
      Add<HConstant>(JSRegExpResult::kSize), HType::JSArray(),
      NOT_TENURED, JS_ARRAY_TYPE);
 
  // Initialize the JSRegExpResult header.
  HValue* global_object = Add<HLoadNamedField>(
      context(), static_cast<HValue*>(NULL),
      HObjectAccess::ForContextSlot(Context::GLOBAL_OBJECT_INDEX));
  HValue* native_context = Add<HLoadNamedField>(
      global_object, static_cast<HValue*>(NULL),
      HObjectAccess::ForGlobalObjectNativeContext());
  Add<HStoreNamedField>(
      result, HObjectAccess::ForMap(),
      Add<HLoadNamedField>(
          native_context, static_cast<HValue*>(NULL),
          HObjectAccess::ForContextSlot(Context::REGEXP_RESULT_MAP_INDEX)));
  HConstant* empty_fixed_array =
      Add<HConstant>(isolate()->factory()->empty_fixed_array());
  Add<HStoreNamedField>(
      result, HObjectAccess::ForJSArrayOffset(JSArray::kPropertiesOffset),
      empty_fixed_array);
  Add<HStoreNamedField>(
      result, HObjectAccess::ForJSArrayOffset(JSArray::kElementsOffset),
      empty_fixed_array);
  Add<HStoreNamedField>(
      result, HObjectAccess::ForJSArrayOffset(JSArray::kLengthOffset), length);
 
  // Initialize the additional fields.
  Add<HStoreNamedField>(
      result, HObjectAccess::ForJSArrayOffset(JSRegExpResult::kIndexOffset),
      index);
  Add<HStoreNamedField>(
      result, HObjectAccess::ForJSArrayOffset(JSRegExpResult::kInputOffset),
      input);
 
  // Allocate and initialize the elements header.
  HAllocate* elements = BuildAllocateElements(elements_kind, size);
  BuildInitializeElementsHeader(elements, elements_kind, length);
 
  if (!elements->has_size_upper_bound()) {
    HConstant* size_in_bytes_upper_bound = EstablishElementsAllocationSize(
        elements_kind, max_length->Integer32Value());
    elements->set_size_upper_bound(size_in_bytes_upper_bound);
  }
 
  Add<HStoreNamedField>(
      result, HObjectAccess::ForJSArrayOffset(JSArray::kElementsOffset),
      elements);
 
  // Initialize the elements contents with undefined.
  BuildFillElementsWithValue(
      elements, elements_kind, graph()->GetConstant0(), length,
      graph()->GetConstantUndefined());
 
  return result;
}

References v8::internal::FAST_ELEMENTS, v8::internal::JS_ARRAY_TYPE, v8::internal::NOT_TENURED, NULL, and size.

BuildStringAdd()

HValue * v8::internal::HGraphBuilder::BuildStringAdd ( HValue *  left, HValue *  right, HAllocationMode  allocation_mode  )

protected

Definition at line 2349 of file hydrogen.cc.

                                     {
  NoObservableSideEffectsScope no_effects(this);
 
  // Determine string lengths.
  HValue* left_length = AddLoadStringLength(left);
  HValue* right_length = AddLoadStringLength(right);
 
  // Check if left string is empty.
  IfBuilder if_leftempty(this);
  if_leftempty.If<HCompareNumericAndBranch>(
      left_length, graph()->GetConstant0(), Token::EQ);
  if_leftempty.Then();
  {
    // Count the native string addition.
    AddIncrementCounter(isolate()->counters()->string_add_native());
 
    // Just return the right string.
    Push(right);
  }
  if_leftempty.Else();
  {
    // Check if right string is empty.
    IfBuilder if_rightempty(this);
    if_rightempty.If<HCompareNumericAndBranch>(
        right_length, graph()->GetConstant0(), Token::EQ);
    if_rightempty.Then();
    {
      // Count the native string addition.
      AddIncrementCounter(isolate()->counters()->string_add_native());
 
      // Just return the left string.
      Push(left);
    }
    if_rightempty.Else();
    {
      // Add the two non-empty strings.
      Push(BuildUncheckedStringAdd(left, right, allocation_mode));
    }
    if_rightempty.End();
  }
  if_leftempty.End();
 
  return Pop();
}

References v8::internal::EQ, and v8::internal::compiler::Push().

Referenced by BuildBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildTestForDictionaryProperties()

void v8::internal::HGraphBuilder::BuildTestForDictionaryProperties ( HValue *  object, HIfContinuation *  continuation  )

protected

Definition at line 1596 of file hydrogen.cc.

                                   {
  HValue* properties = Add<HLoadNamedField>(
      object, static_cast<HValue*>(NULL),
      HObjectAccess::ForPropertiesPointer());
  HValue* properties_map =
      Add<HLoadNamedField>(properties, static_cast<HValue*>(NULL),
                           HObjectAccess::ForMap());
  HValue* hash_map = Add<HLoadRoot>(Heap::kHashTableMapRootIndex);
  IfBuilder builder(this);
  builder.If<HCompareObjectEqAndBranch>(properties_map, hash_map);
  builder.CaptureContinuation(continuation);
}

References NULL.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the caller graph for this function:

BuildTransitionElementsKind()

void v8::internal::HGraphBuilder::BuildTransitionElementsKind ( HValue *  object, HValue *  map, ElementsKind  from_kind, ElementsKind  to_kind, bool  is_jsarray  )

protected

Definition at line 1394 of file hydrogen.cc.

                                                                 {
  DCHECK(!IsFastHoleyElementsKind(from_kind) ||
         IsFastHoleyElementsKind(to_kind));
 
  if (AllocationSite::GetMode(from_kind, to_kind) == TRACK_ALLOCATION_SITE) {
    Add<HTrapAllocationMemento>(object);
  }
 
  if (!IsSimpleMapChangeTransition(from_kind, to_kind)) {
    HInstruction* elements = AddLoadElements(object);
 
    HInstruction* empty_fixed_array = Add<HConstant>(
        isolate()->factory()->empty_fixed_array());
 
    IfBuilder if_builder(this);
 
    if_builder.IfNot<HCompareObjectEqAndBranch>(elements, empty_fixed_array);
 
    if_builder.Then();
 
    HInstruction* elements_length = AddLoadFixedArrayLength(elements);
 
    HInstruction* array_length = is_jsarray
        ? Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
                               HObjectAccess::ForArrayLength(from_kind))
        : elements_length;
 
    BuildGrowElementsCapacity(object, elements, from_kind, to_kind,
                              array_length, elements_length);
 
    if_builder.End();
  }
 
  Add<HStoreNamedField>(object, HObjectAccess::ForMap(), map);
}

References DCHECK, v8::internal::IsFastHoleyElementsKind(), v8::internal::IsSimpleMapChangeTransition(), map, NULL, and v8::internal::TRACK_ALLOCATION_SITE.

Here is the call graph for this function:

BuildUncheckedDictionaryElementLoad()

HValue * v8::internal::HGraphBuilder::BuildUncheckedDictionaryElementLoad ( HValue *  receiver, HValue *  elements, HValue *  key, HValue *  hash  )

protected

Definition at line 1667 of file hydrogen.cc.

                                                                         {
  HValue* capacity = Add<HLoadKeyed>(
      elements,
      Add<HConstant>(NameDictionary::kCapacityIndex),
      static_cast<HValue*>(NULL),
      FAST_ELEMENTS);
 
  HValue* mask = AddUncasted<HSub>(capacity, graph()->GetConstant1());
  mask->ChangeRepresentation(Representation::Integer32());
  mask->ClearFlag(HValue::kCanOverflow);
 
  HValue* entry = hash;
  HValue* count = graph()->GetConstant1();
  Push(entry);
  Push(count);
 
  HIfContinuation return_or_loop_continuation(graph()->CreateBasicBlock(),
                                              graph()->CreateBasicBlock());
  HIfContinuation found_key_match_continuation(graph()->CreateBasicBlock(),
                                               graph()->CreateBasicBlock());
  LoopBuilder probe_loop(this);
  probe_loop.BeginBody(2);  // Drop entry, count from last environment to
                            // appease live range building without simulates.
 
  count = Pop();
  entry = Pop();
  entry = AddUncasted<HBitwise>(Token::BIT_AND, entry, mask);
  int entry_size = SeededNumberDictionary::kEntrySize;
  HValue* base_index = AddUncasted<HMul>(entry, Add<HConstant>(entry_size));
  base_index->ClearFlag(HValue::kCanOverflow);
  int start_offset = SeededNumberDictionary::kElementsStartIndex;
  HValue* key_index =
      AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset));
  key_index->ClearFlag(HValue::kCanOverflow);
 
  HValue* candidate_key = Add<HLoadKeyed>(
      elements, key_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
  IfBuilder if_undefined(this);
  if_undefined.If<HCompareObjectEqAndBranch>(candidate_key,
                                             graph()->GetConstantUndefined());
  if_undefined.Then();
  {
    // element == undefined means "not found". Call the runtime.
    // TODO(jkummerow): walk the prototype chain instead.
    Add<HPushArguments>(receiver, key);
    Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
                           Runtime::FunctionForId(Runtime::kKeyedGetProperty),
                           2));
  }
  if_undefined.Else();
  {
    IfBuilder if_match(this);
    if_match.If<HCompareObjectEqAndBranch>(candidate_key, key);
    if_match.Then();
    if_match.Else();
 
    // Update non-internalized string in the dictionary with internalized key?
    IfBuilder if_update_with_internalized(this);
    HValue* smi_check =
        if_update_with_internalized.IfNot<HIsSmiAndBranch>(candidate_key);
    if_update_with_internalized.And();
    HValue* map = AddLoadMap(candidate_key, smi_check);
    HValue* instance_type = Add<HLoadNamedField>(
        map, static_cast<HValue*>(NULL), HObjectAccess::ForMapInstanceType());
    HValue* not_internalized_bit = AddUncasted<HBitwise>(
        Token::BIT_AND, instance_type,
        Add<HConstant>(static_cast<int>(kIsNotInternalizedMask)));
    if_update_with_internalized.If<HCompareNumericAndBranch>(
        not_internalized_bit, graph()->GetConstant0(), Token::NE);
    if_update_with_internalized.And();
    if_update_with_internalized.IfNot<HCompareObjectEqAndBranch>(
        candidate_key, graph()->GetConstantHole());
    if_update_with_internalized.AndIf<HStringCompareAndBranch>(candidate_key,
                                                               key, Token::EQ);
    if_update_with_internalized.Then();
    // Replace a key that is a non-internalized string by the equivalent
    // internalized string for faster further lookups.
    Add<HStoreKeyed>(elements, key_index, key, FAST_ELEMENTS);
    if_update_with_internalized.Else();
 
    if_update_with_internalized.JoinContinuation(&found_key_match_continuation);
    if_match.JoinContinuation(&found_key_match_continuation);
 
    IfBuilder found_key_match(this, &found_key_match_continuation);
    found_key_match.Then();
    // Key at current probe matches. Relevant bits in the |details| field must
    // be zero, otherwise the dictionary element requires special handling.
    HValue* details_index =
        AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset + 2));
    details_index->ClearFlag(HValue::kCanOverflow);
    HValue* details = Add<HLoadKeyed>(
        elements, details_index, static_cast<HValue*>(NULL), FAST_ELEMENTS);
    int details_mask = PropertyDetails::TypeField::kMask |
                       PropertyDetails::DeletedField::kMask;
    details = AddUncasted<HBitwise>(Token::BIT_AND, details,
                                    Add<HConstant>(details_mask));
    IfBuilder details_compare(this);
    details_compare.If<HCompareNumericAndBranch>(
        details, graph()->GetConstant0(), Token::EQ);
    details_compare.Then();
    HValue* result_index =
        AddUncasted<HAdd>(base_index, Add<HConstant>(start_offset + 1));
    result_index->ClearFlag(HValue::kCanOverflow);
    Push(Add<HLoadKeyed>(elements, result_index, static_cast<HValue*>(NULL),
                         FAST_ELEMENTS));
    details_compare.Else();
    Add<HPushArguments>(receiver, key);
    Push(Add<HCallRuntime>(isolate()->factory()->empty_string(),
                           Runtime::FunctionForId(Runtime::kKeyedGetProperty),
                           2));
    details_compare.End();
 
    found_key_match.Else();
    found_key_match.JoinContinuation(&return_or_loop_continuation);
  }
  if_undefined.JoinContinuation(&return_or_loop_continuation);
 
  IfBuilder return_or_loop(this, &return_or_loop_continuation);
  return_or_loop.Then();
  probe_loop.Break();
 
  return_or_loop.Else();
  entry = AddUncasted<HAdd>(entry, count);
  entry->ClearFlag(HValue::kCanOverflow);
  count = AddUncasted<HAdd>(count, graph()->GetConstant1());
  count->ClearFlag(HValue::kCanOverflow);
  Push(entry);
  Push(count);
 
  probe_loop.EndBody();
 
  return_or_loop.End();
 
  return Pop();
}

References v8::internal::HValue::ChangeRepresentation(), v8::internal::HValue::ClearFlag(), v8::internal::EQ, v8::internal::FAST_ELEMENTS, v8::internal::kIsNotInternalizedMask, map, NULL, and v8::internal::compiler::Push().

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildUncheckedMonomorphicElementAccess()

HInstruction * v8::internal::HGraphBuilder::BuildUncheckedMonomorphicElementAccess ( HValue *  checked_object, HValue *  key, HValue *  val, bool  is_js_array, ElementsKind  elements_kind, PropertyAccessType  access_type, LoadKeyedHoleMode  load_mode, KeyedAccessStoreMode  store_mode  )

protected

Definition at line 2398 of file hydrogen.cc.

                                     {
  DCHECK((!IsExternalArrayElementsKind(elements_kind) &&
              !IsFixedTypedArrayElementsKind(elements_kind)) ||
         !is_js_array);
  // No GVNFlag is necessary for ElementsKind if there is an explicit dependency
  // on a HElementsTransition instruction. The flag can also be removed if the
  // map to check has FAST_HOLEY_ELEMENTS, since there can be no further
  // ElementsKind transitions. Finally, the dependency can be removed for stores
  // for FAST_ELEMENTS, since a transition to HOLEY elements won't change the
  // generated store code.
  if ((elements_kind == FAST_HOLEY_ELEMENTS) ||
      (elements_kind == FAST_ELEMENTS && access_type == STORE)) {
    checked_object->ClearDependsOnFlag(kElementsKind);
  }
 
  bool fast_smi_only_elements = IsFastSmiElementsKind(elements_kind);
  bool fast_elements = IsFastObjectElementsKind(elements_kind);
  HValue* elements = AddLoadElements(checked_object);
  if (access_type == STORE && (fast_elements || fast_smi_only_elements) &&
      store_mode != STORE_NO_TRANSITION_HANDLE_COW) {
    HCheckMaps* check_cow_map = Add<HCheckMaps>(
        elements, isolate()->factory()->fixed_array_map());
    check_cow_map->ClearDependsOnFlag(kElementsKind);
  }
  HInstruction* length = NULL;
  if (is_js_array) {
    length = Add<HLoadNamedField>(
        checked_object->ActualValue(), checked_object,
        HObjectAccess::ForArrayLength(elements_kind));
  } else {
    length = AddLoadFixedArrayLength(elements);
  }
  length->set_type(HType::Smi());
  HValue* checked_key = NULL;
  if (IsExternalArrayElementsKind(elements_kind) ||
      IsFixedTypedArrayElementsKind(elements_kind)) {
    HValue* backing_store;
    if (IsExternalArrayElementsKind(elements_kind)) {
      backing_store = Add<HLoadNamedField>(
          elements, static_cast<HValue*>(NULL),
          HObjectAccess::ForExternalArrayExternalPointer());
    } else {
      backing_store = elements;
    }
    if (store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS) {
      NoObservableSideEffectsScope no_effects(this);
      IfBuilder length_checker(this);
      length_checker.If<HCompareNumericAndBranch>(key, length, Token::LT);
      length_checker.Then();
      IfBuilder negative_checker(this);
      HValue* bounds_check = negative_checker.If<HCompareNumericAndBranch>(
          key, graph()->GetConstant0(), Token::GTE);
      negative_checker.Then();
      HInstruction* result = AddElementAccess(
          backing_store, key, val, bounds_check, elements_kind, access_type);
      negative_checker.ElseDeopt("Negative key encountered");
      negative_checker.End();
      length_checker.End();
      return result;
    } else {
      DCHECK(store_mode == STANDARD_STORE);
      checked_key = Add<HBoundsCheck>(key, length);
      return AddElementAccess(
          backing_store, checked_key, val,
          checked_object, elements_kind, access_type);
    }
  }
  DCHECK(fast_smi_only_elements ||
         fast_elements ||
         IsFastDoubleElementsKind(elements_kind));
 
  // In case val is stored into a fast smi array, assure that the value is a smi
  // before manipulating the backing store. Otherwise the actual store may
  // deopt, leaving the backing store in an invalid state.
  if (access_type == STORE && IsFastSmiElementsKind(elements_kind) &&
      !val->type().IsSmi()) {
    val = AddUncasted<HForceRepresentation>(val, Representation::Smi());
  }
 
  if (IsGrowStoreMode(store_mode)) {
    NoObservableSideEffectsScope no_effects(this);
    Representation representation = HStoreKeyed::RequiredValueRepresentation(
        elements_kind, STORE_TO_INITIALIZED_ENTRY);
    val = AddUncasted<HForceRepresentation>(val, representation);
    elements = BuildCheckForCapacityGrow(checked_object, elements,
                                         elements_kind, length, key,
                                         is_js_array, access_type);
    checked_key = key;
  } else {
    checked_key = Add<HBoundsCheck>(key, length);
 
    if (access_type == STORE && (fast_elements || fast_smi_only_elements)) {
      if (store_mode == STORE_NO_TRANSITION_HANDLE_COW) {
        NoObservableSideEffectsScope no_effects(this);
        elements = BuildCopyElementsOnWrite(checked_object, elements,
                                            elements_kind, length);
      } else {
        HCheckMaps* check_cow_map = Add<HCheckMaps>(
            elements, isolate()->factory()->fixed_array_map());
        check_cow_map->ClearDependsOnFlag(kElementsKind);
      }
    }
  }
  return AddElementAccess(elements, checked_key, val, checked_object,
                          elements_kind, access_type, load_mode);
}

References v8::internal::HValue::ActualValue(), v8::internal::HValue::ClearDependsOnFlag(), DCHECK, v8::internal::FAST_ELEMENTS, v8::internal::FAST_HOLEY_ELEMENTS, v8::internal::IsExternalArrayElementsKind(), v8::internal::IsFastDoubleElementsKind(), v8::internal::IsFastObjectElementsKind(), v8::internal::IsFastSmiElementsKind(), v8::internal::IsFixedTypedArrayElementsKind(), v8::internal::IsGrowStoreMode(), NULL, v8::internal::HValue::set_type(), v8::internal::STANDARD_STORE, STORE, v8::internal::STORE_NO_TRANSITION_HANDLE_COW, v8::internal::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, v8::internal::STORE_TO_INITIALIZED_ENTRY, and v8::internal::HValue::type().

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildExternalElementLoad(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildFastElementLoad(), v8::internal::HOptimizedGraphBuilder::BuildMonomorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::TryBuildConsolidatedElementLoad(), and v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildUncheckedStringAdd()

HValue * v8::internal::HGraphBuilder::BuildUncheckedStringAdd ( HValue *  left, HValue *  right, HAllocationMode  allocation_mode  )

protected

Definition at line 2180 of file hydrogen.cc.

                                     {
  // Determine the string lengths.
  HValue* left_length = AddLoadStringLength(left);
  HValue* right_length = AddLoadStringLength(right);
 
  // Compute the combined string length.
  HValue* length = BuildAddStringLengths(left_length, right_length);
 
  // Do some manual constant folding here.
  if (left_length->IsConstant()) {
    HConstant* c_left_length = HConstant::cast(left_length);
    DCHECK_NE(0, c_left_length->Integer32Value());
    if (c_left_length->Integer32Value() + 1 >= ConsString::kMinLength) {
      // The right string contains at least one character.
      return BuildCreateConsString(length, left, right, allocation_mode);
    }
  } else if (right_length->IsConstant()) {
    HConstant* c_right_length = HConstant::cast(right_length);
    DCHECK_NE(0, c_right_length->Integer32Value());
    if (c_right_length->Integer32Value() + 1 >= ConsString::kMinLength) {
      // The left string contains at least one character.
      return BuildCreateConsString(length, left, right, allocation_mode);
    }
  }
 
  // Check if we should create a cons string.
  IfBuilder if_createcons(this);
  if_createcons.If<HCompareNumericAndBranch>(
      length, Add<HConstant>(ConsString::kMinLength), Token::GTE);
  if_createcons.Then();
  {
    // Create a cons string.
    Push(BuildCreateConsString(length, left, right, allocation_mode));
  }
  if_createcons.Else();
  {
    // Determine the string instance types.
    HValue* left_instance_type = AddLoadStringInstanceType(left);
    HValue* right_instance_type = AddLoadStringInstanceType(right);
 
    // Compute union and difference of instance types.
    HValue* ored_instance_types = AddUncasted<HBitwise>(
        Token::BIT_OR, left_instance_type, right_instance_type);
    HValue* xored_instance_types = AddUncasted<HBitwise>(
        Token::BIT_XOR, left_instance_type, right_instance_type);
 
    // Check if both strings have the same encoding and both are
    // sequential.
    IfBuilder if_sameencodingandsequential(this);
    if_sameencodingandsequential.If<HCompareNumericAndBranch>(
        AddUncasted<HBitwise>(
            Token::BIT_AND, xored_instance_types,
            Add<HConstant>(static_cast<int32_t>(kStringEncodingMask))),
        graph()->GetConstant0(), Token::EQ);
    if_sameencodingandsequential.And();
    STATIC_ASSERT(kSeqStringTag == 0);
    if_sameencodingandsequential.If<HCompareNumericAndBranch>(
        AddUncasted<HBitwise>(
            Token::BIT_AND, ored_instance_types,
            Add<HConstant>(static_cast<int32_t>(kStringRepresentationMask))),
        graph()->GetConstant0(), Token::EQ);
    if_sameencodingandsequential.Then();
    {
      HConstant* string_map =
          Add<HConstant>(isolate()->factory()->string_map());
      HConstant* one_byte_string_map =
          Add<HConstant>(isolate()->factory()->one_byte_string_map());
 
      // Determine map and size depending on whether result is one-byte string.
      IfBuilder if_onebyte(this);
      STATIC_ASSERT(kOneByteStringTag != 0);
      if_onebyte.If<HCompareNumericAndBranch>(
          AddUncasted<HBitwise>(
              Token::BIT_AND, ored_instance_types,
              Add<HConstant>(static_cast<int32_t>(kStringEncodingMask))),
          graph()->GetConstant0(), Token::NE);
      if_onebyte.Then();
      {
        // Allocate sequential one-byte string object.
        Push(length);
        Push(one_byte_string_map);
      }
      if_onebyte.Else();
      {
        // Allocate sequential two-byte string object.
        HValue* size = AddUncasted<HShl>(length, graph()->GetConstant1());
        size->ClearFlag(HValue::kCanOverflow);
        size->SetFlag(HValue::kUint32);
        Push(size);
        Push(string_map);
      }
      if_onebyte.End();
      HValue* map = Pop();
 
      // Calculate the number of bytes needed for the characters in the
      // string while observing object alignment.
      STATIC_ASSERT((SeqString::kHeaderSize & kObjectAlignmentMask) == 0);
      HValue* size = BuildObjectSizeAlignment(Pop(), SeqString::kHeaderSize);
 
      // Allocate the string object. HAllocate does not care whether we pass
      // STRING_TYPE or ONE_BYTE_STRING_TYPE here, so we just use STRING_TYPE.
      HAllocate* result = BuildAllocate(
          size, HType::String(), STRING_TYPE, allocation_mode);
      Add<HStoreNamedField>(result, HObjectAccess::ForMap(), map);
 
      // Initialize the string fields.
      Add<HStoreNamedField>(result, HObjectAccess::ForStringHashField(),
                            Add<HConstant>(String::kEmptyHashField));
      Add<HStoreNamedField>(result, HObjectAccess::ForStringLength(), length);
 
      // Copy characters to the result string.
      IfBuilder if_twobyte(this);
      if_twobyte.If<HCompareObjectEqAndBranch>(map, string_map);
      if_twobyte.Then();
      {
        // Copy characters from the left string.
        BuildCopySeqStringChars(
            left, graph()->GetConstant0(), String::TWO_BYTE_ENCODING,
            result, graph()->GetConstant0(), String::TWO_BYTE_ENCODING,
            left_length);
 
        // Copy characters from the right string.
        BuildCopySeqStringChars(
            right, graph()->GetConstant0(), String::TWO_BYTE_ENCODING,
            result, left_length, String::TWO_BYTE_ENCODING,
            right_length);
      }
      if_twobyte.Else();
      {
        // Copy characters from the left string.
        BuildCopySeqStringChars(
            left, graph()->GetConstant0(), String::ONE_BYTE_ENCODING,
            result, graph()->GetConstant0(), String::ONE_BYTE_ENCODING,
            left_length);
 
        // Copy characters from the right string.
        BuildCopySeqStringChars(
            right, graph()->GetConstant0(), String::ONE_BYTE_ENCODING,
            result, left_length, String::ONE_BYTE_ENCODING,
            right_length);
      }
      if_twobyte.End();
 
      // Count the native string addition.
      AddIncrementCounter(isolate()->counters()->string_add_native());
 
      // Return the sequential string.
      Push(result);
    }
    if_sameencodingandsequential.Else();
    {
      // Fallback to the runtime to add the two strings.
      Add<HPushArguments>(left, right);
      Push(Add<HCallRuntime>(
            isolate()->factory()->empty_string(),
            Runtime::FunctionForId(Runtime::kStringAdd),
            2));
    }
    if_sameencodingandsequential.End();
  }
  if_createcons.End();
 
  return Pop();
}

References DCHECK_NE, v8::internal::EQ, v8::internal::kObjectAlignmentMask, v8::internal::kOneByteStringTag, v8::internal::kSeqStringTag, v8::internal::kStringEncodingMask, v8::internal::kStringRepresentationMask, map, v8::internal::compiler::Push(), size, STATIC_ASSERT, and STRING_TYPE.

Here is the call graph for this function:

BuildWrapReceiver()

HValue * v8::internal::HGraphBuilder::BuildWrapReceiver ( HValue *  object, HValue *  function  )

protected

Definition at line 1289 of file hydrogen.cc.

                                                                         {
  if (object->type().IsJSObject()) return object;
  if (function->IsConstant() &&
      HConstant::cast(function)->handle(isolate())->IsJSFunction()) {
    Handle<JSFunction> f = Handle<JSFunction>::cast(
        HConstant::cast(function)->handle(isolate()));
    SharedFunctionInfo* shared = f->shared();
    if (shared->strict_mode() == STRICT || shared->native()) return object;
  }
  return Add<HWrapReceiver>(object, function);
}

References v8::internal::handle(), v8::internal::STRICT, v8::internal::SharedFunctionInfo::strict_mode(), and v8::internal::HValue::type().

Referenced by v8::internal::HOptimizedGraphBuilder::TryCallApply().

Here is the call graph for this function:

Here is the caller graph for this function:

context()

virtual HValue* v8::internal::HGraphBuilder::context ( )

pure virtual

Implemented in v8::internal::HOptimizedGraphBuilder, and v8::internal::CodeStubGraphBuilderBase.

Referenced by AddLoadJSBuiltin(), New(), and NewUncasted().

Here is the caller graph for this function:

CreateBasicBlock()

HBasicBlock * v8::internal::HGraphBuilder::CreateBasicBlock ( HEnvironment *  env )

protected

Definition at line 1240 of file hydrogen.cc.

                                                              {
  HBasicBlock* b = graph()->CreateBasicBlock();
  b->SetInitialEnvironment(env);
  return b;
}

Referenced by Add(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), v8::internal::CodeStubGraphBuilderBase::BuildGraph(), and v8::internal::HOptimizedGraphBuilder::BuildGraph().

Here is the caller graph for this function:

CreateGraph()

HGraph * v8::internal::HGraphBuilder::CreateGraph

(

)

Definition at line 1174 of file hydrogen.cc.

                                   {
  graph_ = new(zone()) HGraph(info_);
  if (FLAG_hydrogen_stats) isolate()->GetHStatistics()->Initialize(info_);
  CompilationPhase phase("H_Block building", info_);
  set_current_block(graph()->entry_block());
  if (!BuildGraph()) return NULL;
  graph()->FinalizeUniqueness();
  return graph_;
}

References NULL.

Referenced by v8::internal::OptimizedCompileJob::CreateGraph(), and v8::internal::DoGenerateCode().

Here is the caller graph for this function:

CreateLoopHeaderBlock()

HBasicBlock * v8::internal::HGraphBuilder::CreateLoopHeaderBlock ( )

protected

Definition at line 1247 of file hydrogen.cc.

                                                  {
  HBasicBlock* header = graph()->CreateBasicBlock();
  HEnvironment* entry_env = environment()->CopyAsLoopHeader(header);
  header->SetInitialEnvironment(entry_env);
  header->AttachLoopInformation();
  return header;
}

Referenced by v8::internal::HOptimizedGraphBuilder::BuildLoopEntry().

Here is the caller graph for this function:

current_block()

HBasicBlock* v8::internal::HGraphBuilder::current_block ( ) const

inline

Definition at line 1057 of file hydrogen.h.

{ return current_block_; }

References current_block_.

Referenced by Add(), AddLeaveInlined(), v8::internal::CodeStubGraphBuilderBase::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), environment(), Goto(), v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareNil(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::TryInline(), and v8::internal::HOptimizedGraphBuilder::VisitLogicalExpression().

Here is the caller graph for this function:

EnforceNumberType()

HValue * v8::internal::HGraphBuilder::EnforceNumberType ( HValue *  number, Type *  expected  )

protected

Definition at line 10171 of file hydrogen.cc.

                                                         {
  if (expected->Is(Type::SignedSmall())) {
    return AddUncasted<HForceRepresentation>(number, Representation::Smi());
  }
  if (expected->Is(Type::Signed32())) {
    return AddUncasted<HForceRepresentation>(number,
                                             Representation::Integer32());
  }
  return number;
}

References v8::internal::Representation::Integer32(), v8::internal::TypeImpl< Config >::Is(), and v8::internal::Representation::Smi().

Referenced by BuildBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

EnterInlinedSource()

void v8::internal::HGraphBuilder::EnterInlinedSource ( int  start_position, int  id  )

inlineprotected

Definition at line 1887 of file hydrogen.h.

                                                      {
    if (FLAG_hydrogen_track_positions) {
      start_position_ = start_position;
      position_.set_inlining_id(id);
    }
  }

References position_, v8::internal::HSourcePosition::set_inlining_id(), and start_position_.

Here is the call graph for this function:

environment()

HEnvironment* v8::internal::HGraphBuilder::environment ( ) const

inline

Definition at line 1059 of file hydrogen.h.

                                    {
    return current_block()->last_environment();
  }

References current_block().

Referenced by v8::internal::AstContext::AstContext(), v8::internal::HOptimizedGraphBuilder::Bind(), v8::internal::HOptimizedGraphBuilder::BindIfLive(), v8::internal::HOptimizedGraphBuilder::BuildContextChainWalk(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildInlinedCallArray(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), v8::internal::HOptimizedGraphBuilder::BuildStore(), v8::internal::HOptimizedGraphBuilder::context(), v8::internal::HOptimizedGraphBuilder::Drop(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::IsCallArrayInlineable(), v8::internal::HOptimizedGraphBuilder::LookupAndMakeLive(), Pop(), Push(), v8::internal::HOptimizedGraphBuilder::SetUpScope(), v8::internal::HOptimizedGraphBuilder::Top(), v8::internal::HOptimizedGraphBuilder::TryArgumentsAccess(), v8::internal::HOptimizedGraphBuilder::TryCallApply(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

EstablishElementsAllocationSize()

HConstant * v8::internal::HGraphBuilder::EstablishElementsAllocationSize ( ElementsKind  kind, int  capacity  )

protected

Definition at line 2593 of file hydrogen.cc.

                  {
  int base_size = IsFastDoubleElementsKind(kind)
      ? FixedDoubleArray::SizeFor(capacity)
      : FixedArray::SizeFor(capacity);
 
  return Add<HConstant>(base_size);
}

References v8::internal::IsFastDoubleElementsKind().

Here is the call graph for this function:

FinishCurrentBlock()

void v8::internal::HGraphBuilder::FinishCurrentBlock

(

HControlInstruction *

last

)

Definition at line 1198 of file hydrogen.cc.

                                                                {
  DCHECK(!FLAG_hydrogen_track_positions ||
         !info_->IsOptimizing() ||
         !position_.IsUnknown());
  current_block()->Finish(last, source_position());
  if (last->IsReturn() || last->IsAbnormalExit()) {
    set_current_block(NULL);
  }
}

References DCHECK, and NULL.

Referenced by Add(), v8::internal::CodeStubGraphBuilderBase::BuildGraph(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), and v8::internal::HOptimizedGraphBuilder::VisitLogicalExpression().

Here is the caller graph for this function:

FinishExitCurrentBlock()

void v8::internal::HGraphBuilder::FinishExitCurrentBlock

(

HControlInstruction *

instruction

)

Definition at line 1209 of file hydrogen.cc.

                                                                           {
  DCHECK(!FLAG_hydrogen_track_positions || !info_->IsOptimizing() ||
         !position_.IsUnknown());
  current_block()->FinishExit(instruction, source_position());
  if (instruction->IsReturn() || instruction->IsAbnormalExit()) {
    set_current_block(NULL);
  }
}

References DCHECK, and NULL.

Referenced by Add().

Here is the caller graph for this function:

FinishExitWithHardDeoptimization()

void v8::internal::HGraphBuilder::FinishExitWithHardDeoptimization ( const char *  reason )

protected

Definition at line 1272 of file hydrogen.cc.

                                                                       {
  Add<HDeoptimize>(reason, Deoptimizer::EAGER);
  FinishExitCurrentBlock(New<HAbnormalExit>());
}

Referenced by v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), and v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess().

Here is the caller graph for this function:

Goto() [1/2]

void v8::internal::HGraphBuilder::Goto ( HBasicBlock *  from, HBasicBlock *  target, FunctionState *  state = NULL, bool  add_simulate = true  )

inline

Definition at line 1080 of file hydrogen.h.

                                      {
    from->Goto(target, source_position(), state, add_simulate);
  }

References source_position().

Referenced by v8::internal::CodeStubGraphBuilderBase::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildLoopEntry(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), v8::internal::HOptimizedGraphBuilder::CreateJoin(), v8::internal::HOptimizedGraphBuilder::CreateLoop(), Goto(), GotoNoSimulate(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::JoinContinue(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

Goto() [2/2]

void v8::internal::HGraphBuilder::Goto ( HBasicBlock *  target, FunctionState *  state = NULL, bool  add_simulate = true  )

inline

Definition at line 1086 of file hydrogen.h.

                                      {
    Goto(current_block(), target, state, add_simulate);
  }

References current_block(), and Goto().

Here is the call graph for this function:

GotoNoSimulate() [1/2]

void v8::internal::HGraphBuilder::GotoNoSimulate ( HBasicBlock *  from, HBasicBlock *  target  )

inline

Definition at line 1091 of file hydrogen.h.

                                                              {
    Goto(from, target, NULL, false);
  }

References Goto(), and NULL.

Referenced by v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), and v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess().

Here is the call graph for this function:

Here is the caller graph for this function:

GotoNoSimulate() [2/2]

void v8::internal::HGraphBuilder::GotoNoSimulate ( HBasicBlock *  target )

inline

Definition at line 1094 of file hydrogen.h.

                                           {
    Goto(target, NULL, false);
  }

References Goto(), and NULL.

Here is the call graph for this function:

graph()

HGraph* v8::internal::HGraphBuilder::graph ( ) const

inline

Definition at line 1063 of file hydrogen.h.

{ return graph_; }

References graph_.

Referenced by Add(), BuildArrayBufferViewInitialization(), v8::internal::HOptimizedGraphBuilder::BuildArrayIndexOf(), v8::internal::CodeStubGraphBuilderBase::BuildArrayNArgumentsConstructor(), v8::internal::CodeStubGraphBuilderBase::BuildArraySingleArgumentConstructor(), BuildBinaryOperation(), v8::internal::HOptimizedGraphBuilder::BuildCallConstantFunction(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), v8::internal::CodeStubGraphBuilder< Stub >::BuildCodeUninitializedStub(), v8::internal::HOptimizedGraphBuilder::BuildCompareInstruction(), v8::internal::HOptimizedGraphBuilder::BuildEmitInObjectProperties(), v8::internal::CodeStubGraphBuilderBase::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildIncrement(), v8::internal::CodeStubGraphBuilderBase::BuildInstallCode(), v8::internal::HOptimizedGraphBuilder::BuildKeyedHoleMode(), v8::internal::HOptimizedGraphBuilder::BuildMonomorphicAccess(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), v8::internal::HOptimizedGraphBuilder::CreateJoin(), v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareNil(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::ImplicitReceiverFor(), v8::internal::HOptimizedGraphBuilder::SetUpScope(), v8::internal::HOptimizedGraphBuilder::TryArgumentsAccess(), v8::internal::HOptimizedGraphBuilder::TryInline(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(), v8::internal::CodeStubGraphBuilderBase::UnmappedCase(), v8::internal::HOptimizedGraphBuilder::VisitDelete(), v8::internal::HOptimizedGraphBuilder::VisitLogicalExpression(), v8::internal::HOptimizedGraphBuilder::VisitNot(), and v8::internal::HOptimizedGraphBuilder::VisitVoid().

Here is the caller graph for this function:

isolate()

Isolate* v8::internal::HGraphBuilder::isolate ( ) const

inline

Definition at line 1064 of file hydrogen.h.

{ return graph_->isolate(); }

References graph_.

Referenced by Add(), v8::internal::HOptimizedGraphBuilder::array_function(), v8::internal::HOptimizedGraphBuilder::BuildAllocateExternalElements(), v8::internal::HOptimizedGraphBuilder::BuildAllocateFixedTypedArray(), v8::internal::HOptimizedGraphBuilder::BuildArrayIndexOf(), BuildCheckPrototypeMaps(), v8::internal::HOptimizedGraphBuilder::BuildEmitFixedArray(), v8::internal::HOptimizedGraphBuilder::BuildEmitInObjectProperties(), v8::internal::HOptimizedGraphBuilder::BuildEmitObjectHeader(), v8::internal::HOptimizedGraphBuilder::BuildFastLiteral(), v8::internal::HOptimizedGraphBuilder::BuildInitElementsInObjectHeader(), v8::internal::HOptimizedGraphBuilder::BuildKeyedGeneric(), v8::internal::HOptimizedGraphBuilder::BuildKeyedHoleMode(), v8::internal::HOptimizedGraphBuilder::BuildLoadNamedField(), v8::internal::HOptimizedGraphBuilder::BuildMonomorphicAccess(), v8::internal::HOptimizedGraphBuilder::BuildNamedGeneric(), v8::internal::HOptimizedGraphBuilder::BuildStoreNamedField(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::CanAccessMonomorphic(), v8::internal::HOptimizedGraphBuilder::HandleGlobalVariableAssignment(), v8::internal::HOptimizedGraphBuilder::HandleKeyedElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::ImplicitReceiverFor(), v8::internal::IsLiteralCompareBool(), v8::internal::HOptimizedGraphBuilder::NewArgumentAdaptorCall(), v8::internal::HOptimizedGraphBuilder::TryArgumentsAccess(), v8::internal::HOptimizedGraphBuilder::TryCallApply(), v8::internal::HOptimizedGraphBuilder::TryInlineApiCall(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(), v8::internal::TypedArrayMap(), and v8::internal::HOptimizedGraphBuilder::VisitDeclarations().

Here is the caller graph for this function:

MatchRotateRight()

bool v8::internal::HGraphBuilder::MatchRotateRight ( HValue *  left, HValue *  right, HValue **  operand, HValue **  shift_amount  )

protected

Definition at line 10132 of file hydrogen.cc.

                                                            {
  HShl* shl;
  HShr* shr;
  if (left->IsShl() && right->IsShr()) {
    shl = HShl::cast(left);
    shr = HShr::cast(right);
  } else if (left->IsShr() && right->IsShl()) {
    shl = HShl::cast(right);
    shr = HShr::cast(left);
  } else {
    return false;
  }
  if (shl->left() != shr->left()) return false;
 
  if (!ShiftAmountsAllowReplaceByRotate(shl->right(), shr->right()) &&
      !ShiftAmountsAllowReplaceByRotate(shr->right(), shl->right())) {
    return false;
  }
  *operand= shr->left();
  *shift_amount = shr->right();
  return true;
}

References v8::internal::ShiftAmountsAllowReplaceByRotate().

Referenced by BuildBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

New() [1/10]

template<class I >

I* v8::internal::HGraphBuilder::New ( )

inline

Definition at line 1110 of file hydrogen.h.

{ return I::New(zone(), context()); }

References context(), and zone().

Referenced by v8::internal::HOsrBuilder::BuildOsrLoopEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

New() [2/10]

template<>

HContext* v8::internal::HGraphBuilder::New ( )

inline

Definition at line 2035 of file hydrogen.h.

                                              {
  return HContext::New(zone());
}

References zone().

Here is the call graph for this function:

New() [3/10]

template<class I , class P1 >

I* v8::internal::HGraphBuilder::New ( P1  p1 )

inline

Definition at line 1124 of file hydrogen.h.

{ return I::New(zone(), context(), p1); }

References context(), v8::internal::p1, and zone().

Here is the call graph for this function:

New() [4/10]

template<class I , class P1 , class P2 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2  )

inline

Definition at line 1152 of file hydrogen.h.

                       {
    return I::New(zone(), context(), p1, p2);
  }

References context(), v8::internal::p1, v8::internal::p2, and zone().

Here is the call graph for this function:

New() [5/10]

template<class I , class P1 , class P2 , class P3 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2, P3  p3  )

inline

Definition at line 1180 of file hydrogen.h.

                              {
    return I::New(zone(), context(), p1, p2, p3);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, and zone().

Here is the call graph for this function:

New() [6/10]

template<class I , class P1 , class P2 , class P3 , class P4 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2, P3  p3, P4  p4  )

inline

Definition at line 1200 of file hydrogen.h.

                                     {
    return I::New(zone(), context(), p1, p2, p3, p4);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, and zone().

Here is the call graph for this function:

New() [7/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5  )

inline

Definition at line 1220 of file hydrogen.h.

                                            {
    return I::New(zone(), context(), p1, p2, p3, p4, p5);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, and zone().

Here is the call graph for this function:

New() [8/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6  )

inline

Definition at line 1240 of file hydrogen.h.

                                                   {
    return I::New(zone(), context(), p1, p2, p3, p4, p5, p6);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, and zone().

Here is the call graph for this function:

New() [9/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7  )

inline

Definition at line 1262 of file hydrogen.h.

                                                              {
    return I::New(zone(), context(), p1, p2, p3, p4, p5, p6, p7);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, v8::internal::p7, and zone().

Here is the call graph for this function:

New() [10/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >

I* v8::internal::HGraphBuilder::New ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7, P8  p8  )

inline

Definition at line 1287 of file hydrogen.h.

                                                                     {
    return I::New(zone(), context(), p1, p2, p3, p4, p5, p6, p7, p8);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, v8::internal::p7, v8::internal::p8, and zone().

Here is the call graph for this function:

NewUncasted() [1/10]

template<class I >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( )

inline

Definition at line 1107 of file hydrogen.h.

{ return I::New(zone(), context()); }

References context(), and zone().

Here is the call graph for this function:

NewUncasted() [2/10]

template<>

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( )

inline

Definition at line 2041 of file hydrogen.h.

                                                          {
  return New<HContext>();
}

NewUncasted() [3/10]

template<class I , class P1 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1 )

inline

Definition at line 1119 of file hydrogen.h.

                                   {
    return I::New(zone(), context(), p1);
  }

References context(), v8::internal::p1, and zone().

Here is the call graph for this function:

NewUncasted() [4/10]

template<class I , class P1 , class P2 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2  )

inline

Definition at line 1147 of file hydrogen.h.

                                          {
    return I::New(zone(), context(), p1, p2);
  }

References context(), v8::internal::p1, v8::internal::p2, and zone().

Here is the call graph for this function:

NewUncasted() [5/10]

template<class I , class P1 , class P2 , class P3 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2, P3  p3  )

inline

Definition at line 1175 of file hydrogen.h.

                                                 {
    return I::New(zone(), context(), p1, p2, p3);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, and zone().

Here is the call graph for this function:

NewUncasted() [6/10]

template<class I , class P1 , class P2 , class P3 , class P4 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2, P3  p3, P4  p4  )

inline

Definition at line 1195 of file hydrogen.h.

                                                        {
    return I::New(zone(), context(), p1, p2, p3, p4);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, and zone().

Here is the call graph for this function:

NewUncasted() [7/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5  )

inline

Definition at line 1215 of file hydrogen.h.

                                                               {
    return I::New(zone(), context(), p1, p2, p3, p4, p5);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, and zone().

Here is the call graph for this function:

NewUncasted() [8/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6  )

inline

Definition at line 1235 of file hydrogen.h.

                                                                      {
    return I::New(zone(), context(), p1, p2, p3, p4, p5, p6);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, and zone().

Here is the call graph for this function:

NewUncasted() [9/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7  )

inline

Definition at line 1256 of file hydrogen.h.

                                                                             {
    return I::New(zone(), context(), p1, p2, p3, p4, p5, p6, p7);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, v8::internal::p7, and zone().

Here is the call graph for this function:

NewUncasted() [10/10]

template<class I , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >

HInstruction* v8::internal::HGraphBuilder::NewUncasted ( P1  p1, P2  p2, P3  p3, P4  p4, P5  p5, P6  p6, P7  p7, P8  p8  )

inline

Definition at line 1280 of file hydrogen.h.

                                                        {
    return I::New(zone(), context(), p1, p2, p3, p4, p5, p6, p7, p8);
  }

References context(), v8::internal::p1, v8::internal::p2, v8::internal::p3, v8::internal::p4, v8::internal::p5, v8::internal::p6, v8::internal::p7, v8::internal::p8, and zone().

Here is the call graph for this function:

Pop()

HValue* v8::internal::HGraphBuilder::Pop ( )

inline

Definition at line 1071 of file hydrogen.h.

{ return environment()->Pop(); }

References environment().

Referenced by v8::internal::HOptimizedGraphBuilder::BuildArrayIndexOf(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), v8::internal::HOptimizedGraphBuilder::BuildIncrement(), v8::internal::HOptimizedGraphBuilder::BuildLoad(), v8::internal::HOptimizedGraphBuilder::BuildStore(), v8::internal::HOptimizedGraphBuilder::HandleCompoundAssignment(), v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareNil(), v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareTypeof(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::PushArgumentsFromEnvironment(), v8::internal::HOptimizedGraphBuilder::TryArgumentsAccess(), v8::internal::HOptimizedGraphBuilder::TryCallApply(), v8::internal::HOptimizedGraphBuilder::TryInlineApiCall(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinFunctionCall(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(), v8::internal::HOptimizedGraphBuilder::VisitArithmeticExpression(), v8::internal::HOptimizedGraphBuilder::VisitDelete(), v8::internal::HOptimizedGraphBuilder::VisitLogicalExpression(), v8::internal::HOptimizedGraphBuilder::VisitNot(), and v8::internal::HOptimizedGraphBuilder::VisitTypeof().

Here is the call graph for this function:

Here is the caller graph for this function:

Push()

void v8::internal::HGraphBuilder::Push ( HValue *  value )

inline

Definition at line 1070 of file hydrogen.h.

{ environment()->Push(value); }

References environment().

Referenced by v8::internal::HOptimizedGraphBuilder::BuildArrayIndexOf(), v8::internal::HOptimizedGraphBuilder::BuildBinaryOperation(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), v8::internal::HOptimizedGraphBuilder::BuildCompareInstruction(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildExternalElementLoad(), v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildFastElementLoad(), v8::internal::HOptimizedGraphBuilder::BuildIncrement(), v8::internal::HOptimizedGraphBuilder::BuildLoad(), v8::internal::HOptimizedGraphBuilder::BuildMonomorphicAccess(), v8::internal::HOptimizedGraphBuilder::BuildStore(), v8::internal::HOptimizedGraphBuilder::BuildStoreForEffect(), v8::internal::HOptimizedGraphBuilder::HandleCompoundAssignment(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::PushLoad(), v8::internal::HOptimizedGraphBuilder::TryArgumentsAccess(), v8::internal::HOptimizedGraphBuilder::TryCallApply(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(), and v8::internal::HOptimizedGraphBuilder::VisitNot().

Here is the call graph for this function:

Here is the caller graph for this function:

scope()

Scope* v8::internal::HGraphBuilder::scope ( ) const

inline

Definition at line 1054 of file hydrogen.h.

{ return scope_; }

References scope_.

Referenced by v8::internal::HOptimizedGraphBuilder::BuildContextChainWalk(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::HOptimizedGraphBuilder::HandleCompoundAssignment(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), set_scope(), v8::internal::HOptimizedGraphBuilder::SetUpScope(), v8::internal::HOptimizedGraphBuilder::TryCallApply(), v8::internal::HOptimizedGraphBuilder::TryInline(), and v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall().

Here is the caller graph for this function:

ScriptPositionToSourcePosition()

HSourcePosition v8::internal::HGraphBuilder::ScriptPositionToSourcePosition ( int  position )

inlineprotected

Definition at line 1897 of file hydrogen.h.

                                                               {
    HSourcePosition pos = position_;
    pos.set_position(position - start_position_);
    return pos;
  }

References position_, v8::internal::HSourcePosition::set_position(), and start_position_.

Referenced by v8::internal::HOptimizedGraphBuilder::TryInlineApply(), v8::internal::HOptimizedGraphBuilder::TryInlineCall(), v8::internal::HOptimizedGraphBuilder::TryInlineConstruct(), and v8::internal::HOptimizedGraphBuilder::VisitArithmeticExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

set_current_block()

void v8::internal::HGraphBuilder::set_current_block ( HBasicBlock *  block )

inline

Definition at line 1058 of file hydrogen.h.

{ current_block_ = block; }

References current_block_.

Referenced by Add(), v8::internal::CodeStubGraphBuilderBase::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildGraph(), v8::internal::HOptimizedGraphBuilder::BuildLoopEntry(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicCallNamed(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), v8::internal::HOptimizedGraphBuilder::HandlePolymorphicNamedFieldAccess(), v8::internal::HOptimizedGraphBuilder::TryInline(), v8::internal::HOptimizedGraphBuilder::VisitLogicalExpression(), and v8::internal::HOptimizedGraphBuilder::VisitNot().

Here is the caller graph for this function:

set_scope()

void v8::internal::HGraphBuilder::set_scope ( Scope *  scope )

inline

Definition at line 1055 of file hydrogen.h.

{ scope_ = scope; }

References scope(), and scope_.

Referenced by v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

set_source_position()

void v8::internal::HGraphBuilder::set_source_position ( HSourcePosition  position )

inlineprotected

Definition at line 1904 of file hydrogen.h.

                                                     {
    position_ = position;
  }

References position_.

SetSourcePosition()

void v8::internal::HGraphBuilder::SetSourcePosition ( int  position )

inlineprotected

Definition at line 1882 of file hydrogen.h.

                                       {
    DCHECK(position != RelocInfo::kNoPosition);
    position_.set_position(position - start_position_);
  }

References DCHECK, v8::internal::RelocInfo::kNoPosition, position_, v8::internal::HSourcePosition::set_position(), and start_position_.

Referenced by v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareNil(), v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareTypeof(), v8::internal::HOptimizedGraphBuilder::HOptimizedGraphBuilder(), and v8::internal::HOptimizedGraphBuilder::VisitArithmeticExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

source_position()

HSourcePosition v8::internal::HGraphBuilder::source_position ( )

inlineprotected

Definition at line 1903 of file hydrogen.h.

{ return position_; }

References position_.

Referenced by AddLeaveInlined(), Goto(), v8::internal::HOptimizedGraphBuilder::TryInlineGetter(), and v8::internal::HOptimizedGraphBuilder::TryInlineSetter().

Here is the caller graph for this function:

top_info()

CompilationInfo* v8::internal::HGraphBuilder::top_info ( )

inline

Definition at line 1065 of file hydrogen.h.

{ return info_; }

References info_.

Referenced by BuildBinaryOperation(), v8::internal::HOptimizedGraphBuilder::BuildFastLiteral(), v8::internal::HOptimizedGraphBuilder::BuildInlinedCallArray(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::LoadFieldMaps(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::top_info(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the caller graph for this function:

TruncateToNumber()

HValue * v8::internal::HGraphBuilder::TruncateToNumber ( HValue *  value, Type **  expected  )

protected

Definition at line 10184 of file hydrogen.cc.

                                                                      {
  if (value->IsConstant()) {
    HConstant* constant = HConstant::cast(value);
    Maybe<HConstant*> number = constant->CopyToTruncatedNumber(zone());
    if (number.has_value) {
      *expected = Type::Number(zone());
      return AddInstruction(number.value);
    }
  }
 
  // We put temporary values on the stack, which don't correspond to anything
  // in baseline code. Since nothing is observable we avoid recording those
  // pushes with a NoObservableSideEffectsScope.
  NoObservableSideEffectsScope no_effects(this);
 
  Type* expected_type = *expected;
 
  // Separate the number type from the rest.
  Type* expected_obj =
      Type::Intersect(expected_type, Type::NonNumber(zone()), zone());
  Type* expected_number =
      Type::Intersect(expected_type, Type::Number(zone()), zone());
 
  // We expect to get a number.
  // (We need to check first, since Type::None->Is(Type::Any()) == true.
  if (expected_obj->Is(Type::None())) {
    DCHECK(!expected_number->Is(Type::None(zone())));
    return value;
  }
 
  if (expected_obj->Is(Type::Undefined(zone()))) {
    // This is already done by HChange.
    *expected = Type::Union(expected_number, Type::Number(zone()), zone());
    return value;
  }
 
  return value;
}

References AddInstruction(), DCHECK, v8::Maybe< T >::has_value, v8::internal::TypeImpl< ZoneTypeConfig >::Intersect(), v8::internal::TypeImpl< Config >::Is(), v8::None, v8::Undefined(), v8::internal::TypeImpl< ZoneTypeConfig >::Union(), v8::Maybe< T >::value, and zone().

Referenced by BuildBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

zone()

Zone* v8::internal::HGraphBuilder::zone ( ) const

inline

Definition at line 1062 of file hydrogen.h.

{ return info_->zone(); }

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

Referenced by BuildBinaryOperation(), v8::internal::HOptimizedGraphBuilder::BuildCompareInstruction(), v8::internal::HOptimizedGraphBuilder::BuildLoadNamedField(), v8::internal::HOptimizedGraphBuilder::BuildNamedAccess(), v8::internal::HOsrBuilder::BuildOsrLoopEntry(), v8::internal::ComputeReceiverTypes(), v8::internal::HOptimizedGraphBuilder::HandleKeyedElementAccess(), v8::internal::HOptimizedGraphBuilder::HandleLiteralCompareNil(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::LoadFieldMaps(), New(), NewUncasted(), v8::internal::HOptimizedGraphBuilder::operator new(), v8::internal::HOptimizedGraphBuilder::PushArgumentsFromEnvironment(), v8::internal::HOptimizedGraphBuilder::SetUpScope(), v8::internal::HOptimizedGraphBuilder::ToType(), TruncateToNumber(), v8::internal::HOptimizedGraphBuilder::TryInline(), v8::internal::HOptimizedGraphBuilder::TryInlineApiCall(), v8::internal::HOptimizedGraphBuilder::TryInlineApiGetter(), v8::internal::HOptimizedGraphBuilder::TryInlineApiSetter(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinFunctionCall(), v8::internal::HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(), v8::internal::HOptimizedGraphBuilder::VisitArithmeticExpression(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::zone(), and v8::internal::AstContext::zone().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

current_block_

HBasicBlock* v8::internal::HGraphBuilder::current_block_

private

Definition at line 1924 of file hydrogen.h.

Referenced by current_block(), and set_current_block().

graph_

HGraph* v8::internal::HGraphBuilder::graph_

private

Definition at line 1923 of file hydrogen.h.

Referenced by graph(), and isolate().

info_

CompilationInfo* v8::internal::HGraphBuilder::info_

private

Definition at line 1922 of file hydrogen.h.

Referenced by v8::internal::HOptimizedGraphBuilder::BASE_EMBEDDED::info(), top_info(), and zone().

kElementLoopUnrollThreshold

const int v8::internal::HGraphBuilder::kElementLoopUnrollThreshold = 8

static

Definition at line 1308 of file hydrogen.h.

Referenced by v8::internal::HOptimizedGraphBuilder::IsCallArrayInlineable().

position_

HSourcePosition v8::internal::HGraphBuilder::position_

private

Definition at line 1926 of file hydrogen.h.

Referenced by EnterInlinedSource(), ScriptPositionToSourcePosition(), set_source_position(), SetSourcePosition(), and source_position().

scope_

Scope* v8::internal::HGraphBuilder::scope_

private

Definition at line 1925 of file hydrogen.h.

Referenced by v8::internal::HOptimizedGraphBuilder::BASE_EMBEDDED::scope(), scope(), and set_scope().

start_position_

int v8::internal::HGraphBuilder::start_position_

private

Definition at line 1927 of file hydrogen.h.

Referenced by EnterInlinedSource(), ScriptPositionToSourcePosition(), and SetSourcePosition().

---

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

• /mnt/V8SourceCode/src/hydrogen.h
• /mnt/V8SourceCode/src/hydrogen.cc