v8::internal::compiler Namespace Reference

Namespaces
	anonymous_namespace{common-operator-unittest.cc}
	anonymous_namespace{common-operator.cc}
	anonymous_namespace{graph-reducer-unittest.cc}
	anonymous_namespace{graph-unittest.cc}
	anonymous_namespace{instruction-selector-arm-unittest.cc}
	anonymous_namespace{instruction-selector-arm64-unittest.cc}
	anonymous_namespace{instruction-selector-ia32-unittest.cc}
	anonymous_namespace{instruction-selector-unittest.cc}
	anonymous_namespace{instruction-selector-x64-unittest.cc}
	anonymous_namespace{js-builtin-reducer-unittest.cc}
	anonymous_namespace{machine-operator-reducer-unittest.cc}
	anonymous_namespace{simplified-operator-reducer-unittest.cc}
	anonymous_namespace{simplified-operator-unittest.cc}
	anonymous_namespace{typer.cc}
	anonymous_namespace{value-numbering-reducer-unittest.cc}
	anonymous_namespace{value-numbering-reducer.cc}

Classes
class	FINAL
class	ArmOperandGenerator
struct	ArmLinkageHelperTraits
struct	Arm64LinkageHelperTraits
class	AstGraphBuilder
class	BASE_EMBEDDED
class	BasicBlockInstrumentor
class	ChangeLoweringTest
class	ChangeLoweringCommonTest
class	ChangeLowering32Test
class	ChangeLowering64Test
class	InstructionOperandConverter
struct	StaticParameterTraits< ExternalReference >
class	ControlBuilder
class	IfBuilder
class	LoopBuilder
class	SwitchBuilder
class	BlockBuilder
class	Frame
class	FrameOffset
class	NodeInputIterationTraits
class	NodeUseIterationTraits
class	GenericGraphVisit
class	GenericGraphBase
class	GenericGraph
class	GenericNode
class	GraphBuilder
class	StructuredGraphBuilder
class	GraphReducerTest
class	Reducer
class	GraphTest
class	Escaped
class	JSONGraphNodeWriter
class	JSONGraphEdgeWriter
class	GraphVisualizer
struct	AsDOT
struct	AsJSON
class	Graph
class	GraphDecorator
class	IA32OperandConverter
class	AddressingModeUnitTest
class	AddressingModeMatcher
struct	IA32LinkageHelperTraits
class	OperandGenerator
struct	CallBuffer
class	InstructionSelectorTest
class	InstructionSelectorTestWithParam
class	InstructionOperand
class	UnallocatedOperand
class	Instruction
class	GapInstruction
class	FrameStateDescriptor
class	JSBuiltinReducerTest
class	JSCallReduction
class	ContextSpecializationVisitor
class	JSContextSpecializer
class	JSGenericLowering
class	JSGraph
class	InlinerVisitor
class	Inlinee
class	CopyVisitor
class	JSCallFunctionAccessor
class	JSInliner
class	ContextAccess
struct	LoadNamedParameters
struct	CallParameters
struct	StoreNamedParameters
class	JSOperatorBuilder
struct	StaticParameterTraits< ContextAccess >
struct	StaticParameterTraits< Runtime::FunctionId >
class	JSBinopReduction
class	LinkageHelper
class	LinkageLocation
class	Linkage
class	MachineOperatorReducerTest
class	MachineOperatorReducerTestWithParam
struct	StaticParameterTraits< StoreRepresentation >
struct	StaticParameterTraits< LoadRepresentation >
struct	MachineOperatorBuilderImpl
class	Signature
class	NodeAuxData
class	NodeCache
struct	NodeMatcher
struct	ValueMatcher
class	ScaleFactorMatcher
class	IndexAndDisplacementMatcher
class	NodeProperties
class	NodeData
class	IrOpcode
class	OperatorProperties
class	Operator
class	SimpleOperator
struct	StaticParameterTraits
struct	StaticParameterTraits< int >
struct	StaticParameterTraits< double >
struct	StaticParameterTraits< Unique< Object > >
struct	StaticParameterTraits< Unique< Name > >
class	Operator1
class	PhaseStats
class	AstGraphBuilderWithPositions
class	Pipeline
class	RawMachineAssembler
class	LifetimePosition
class	UseInterval
class	UsePosition
class	LiveRange
class	RegisterAllocatorPhase
class	RepresentationChanger
class	BasicBlockData
class	Schedule
class	CFGBuilder
class	ScheduleEarlyNodeVisitor
class	PrepareUsesVisitor
class	ScheduleLateNodeVisitor
struct	SpecialRPOStackFrame
struct	BlockList
struct	LoopInfo
class	Scheduler
class	RepresentationSelector
class	SimplifiedLowering
class	SimplifiedOperatorReducerTest
class	SimplifiedOperatorReducerTestWithParam
class	SimplifiedPureOperatorTest
class	SimplifiedElementAccessOperatorTest
struct	StaticParameterTraits< FieldAccess >
struct	StaticParameterTraits< ElementAccess >
struct	FieldAccess
struct	ElementAccess
class	Typer
class	ValueNumberingReducerTest
class	Verifier
class	ScheduleVerifier
struct	Immediate64
struct	RegisterOrOperand
class	X64OperandConverter
struct	X64LinkageHelperTraits

Typedefs
typedef InstructionSelectorTestWithParam< DPI >	InstructionSelectorDPITest
typedef InstructionSelectorTestWithParam< ODPI >	InstructionSelectorODPITest
typedef InstructionSelectorTestWithParam< Shift >	InstructionSelectorShiftTest
typedef InstructionSelectorTestWithParam< MemoryAccess >	InstructionSelectorMemoryAccessTest
typedef LinkageHelper< ArmLinkageHelperTraits >	LH
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorLogicalTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorAddSubTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorDPFlagSetTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorOvfAddSubTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorMulDivTest
typedef InstructionSelectorTestWithParam< MulDPInst >	InstructionSelectorIntDPWithIntMulTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorFPArithTest
typedef InstructionSelectorTestWithParam< FPCmp >	InstructionSelectorFPCmpTest
typedef InstructionSelectorTestWithParam< Conversion >	InstructionSelectorConversionTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorComparisonTest
typedef InstructionSelectorTestWithParam< MachInst2 >	InstructionSelectorLogicalWithNotRHSTest
typedef ZoneList< MoveOperands >::iterator	op_iterator
typedef int	NodeId
typedef int32_t	InstructionCode
typedef BitField< ArchOpcode, 0, 7 >	ArchOpcodeField
typedef BitField< AddressingMode, 7, 5 >	AddressingModeField
typedef BitField< FlagsMode, 12, 2 >	FlagsModeField
typedef BitField< FlagsCondition, 14, 5 >	FlagsConditionField
typedef BitField< int, 14, 18 >	MiscField
typedef InstructionSelectorTestWithParam< MachineType >	InstructionSelectorPhiTest
typedef ZoneVector< InstructionOperand * >	InstructionOperandVector
typedef ZoneDeque< Constant >	ConstantDeque
typedef std::map< int, Constant, std::less< int >, zone_allocator< std::pair< int, Constant > > >	ConstantMap
typedef ZoneDeque< Instruction * >	InstructionDeque
typedef ZoneDeque< PointerMap * >	PointerMapDeque
typedef ZoneVector< FrameStateDescriptor * >	DeoptimizationVector
typedef Signature< LinkageLocation >	LocationSignature
typedef MachineOperatorReducerTestWithParam< UnaryOperator >	MachineUnaryOperatorReducerTest
typedef MachineType	LoadRepresentation
typedef uint16_t	MachineTypeUnion
typedef Signature< MachineType >	MachineSignature
typedef NodeCache< int64_t >	Int64NodeCache
typedef NodeCache< int32_t >	Int32NodeCache
typedef NodeCache< void * >	PtrNodeCache
typedef IntMatcher< int32_t, IrOpcode::kInt32Constant >	Int32Matcher
typedef IntMatcher< uint32_t, IrOpcode::kInt32Constant >	Uint32Matcher
typedef IntMatcher< int64_t, IrOpcode::kInt64Constant >	Int64Matcher
typedef IntMatcher< uint64_t, IrOpcode::kInt64Constant >	Uint64Matcher
typedef FloatMatcher< float, IrOpcode::kFloat32Constant >	Float32Matcher
typedef FloatMatcher< double, IrOpcode::kFloat64Constant >	Float64Matcher
typedef FloatMatcher< double, IrOpcode::kNumberConstant >	NumberMatcher
typedef BinopMatcher< Int32Matcher, Int32Matcher >	Int32BinopMatcher
typedef BinopMatcher< Uint32Matcher, Uint32Matcher >	Uint32BinopMatcher
typedef BinopMatcher< Int64Matcher, Int64Matcher >	Int64BinopMatcher
typedef BinopMatcher< Uint64Matcher, Uint64Matcher >	Uint64BinopMatcher
typedef BinopMatcher< Float64Matcher, Float64Matcher >	Float64BinopMatcher
typedef GenericGraphVisit::NullNodeVisitor< NodeData, Node >	NullNodeVisitor
typedef std::set< Node *, std::less< Node * >, zone_allocator< Node * > >	NodeSet
typedef NodeSet::iterator	NodeSetIter
typedef NodeSet::reverse_iterator	NodeSetRIter
typedef ZoneVector< Node * >	NodeVector
typedef NodeVector::iterator	NodeVectorIter
typedef NodeVector::const_iterator	NodeVectorConstIter
typedef NodeVector::reverse_iterator	NodeVectorRIter
typedef ZoneVector< NodeVector >	NodeVectorVector
typedef NodeVectorVector::iterator	NodeVectorVectorIter
typedef NodeVectorVector::reverse_iterator	NodeVectorVectorRIter
typedef Node::Uses::iterator	UseIter
typedef Node::Inputs::iterator	InputIter
typedef GenericGraphVisit::NullNodeVisitor< BasicBlockData, BasicBlock >	NullBasicBlockVisitor
typedef ZoneVector< BasicBlock * >	BasicBlockVector
typedef BasicBlockVector::iterator	BasicBlockVectorIter
typedef BasicBlockVector::reverse_iterator	BasicBlockVectorRIter
typedef SimplifiedOperatorReducerTestWithParam< UnaryOperator >	SimplifiedUnaryOperatorTest

Enumerations
enum	ImmediateMode {   kArithmeticImm , kShift32Imm , kShift64Imm , kLogical32Imm ,   kLogical64Imm , kLoadStoreImm8 , kLoadStoreImm16 , kLoadStoreImm32 ,   kLoadStoreImm64 , kNoImmediate }
enum	LhsKind { VARIABLE , NAMED_PROPERTY , KEYED_PROPERTY }
enum	OutputFrameStateCombine { kPushOutput , kIgnoreOutput }
enum	FrameStateType { JS_FRAME , ARGUMENTS_ADAPTOR }
enum	ArchOpcode { kLastArchOpcode = -1 ARCH_OPCODE_LIST(COUNT_ARCH_OPCODE) }
enum	AddressingMode { kLastAddressingMode = -1 ADDRESSING_MODE_LIST(COUNT_ADDRESSING_MODE) }
enum	FlagsMode { kFlags_none = 0 , kFlags_branch = 1 , kFlags_set = 2 }
enum	FlagsCondition {   kEqual , kNotEqual , kSignedLessThan , kSignedGreaterThanOrEqual ,   kSignedLessThanOrEqual , kSignedGreaterThan , kUnsignedLessThan , kUnsignedGreaterThanOrEqual ,   kUnsignedLessThanOrEqual , kUnsignedGreaterThan , kUnorderedEqual , kUnorderedNotEqual ,   kUnorderedLessThan , kUnorderedGreaterThanOrEqual , kUnorderedLessThanOrEqual , kUnorderedGreaterThan ,   kOverflow , kNotOverflow }
enum	WriteBarrierKind { kNoWriteBarrier , kFullWriteBarrier }
enum	MachineType {   kRepBit = 1 << 0 , kRepWord8 = 1 << 1 , kRepWord16 = 1 << 2 , kRepWord32 = 1 << 3 ,   kRepWord64 = 1 << 4 , kRepFloat32 = 1 << 5 , kRepFloat64 = 1 << 6 , kRepTagged = 1 << 7 ,   kTypeBool = 1 << 8 , kTypeInt32 = 1 << 9 , kTypeUint32 = 1 << 10 , kTypeInt64 = 1 << 11 ,   kTypeUint64 = 1 << 12 , kTypeNumber = 1 << 13 , kTypeAny = 1 << 14 , kMachNone = 0 ,   kMachFloat32 = kRepFloat32 | kTypeNumber , kMachFloat64 = kRepFloat64 | kTypeNumber , kMachInt8 = kRepWord8 | kTypeInt32 , kMachUint8 = kRepWord8 | kTypeUint32 ,   kMachInt16 = kRepWord16 | kTypeInt32 , kMachUint16 = kRepWord16 | kTypeUint32 , kMachInt32 = kRepWord32 | kTypeInt32 , kMachUint32 = kRepWord32 | kTypeUint32 ,   kMachInt64 = kRepWord64 | kTypeInt64 , kMachUint64 = kRepWord64 | kTypeUint64 , kMachPtr = (kPointerSize == 4) ? kRepWord32 : kRepWord64 , kMachAnyTagged = kRepTagged | kTypeAny }
enum	RegisterKind { UNALLOCATED_REGISTERS , GENERAL_REGISTERS , DOUBLE_REGISTERS }
enum	Phase { PROPAGATE , LOWER }
enum	BaseTaggedness { kUntaggedBase , kTaggedBase }
enum	Immediate64Type { kImm64Value , kImm64Handle , kImm64Reference }
enum	RegisterOrOperandType { kRegister , kDoubleRegister , kOperand }

Functions
	TEST_P (InstructionSelectorDPITest, Parameters)
	TEST_P (InstructionSelectorDPITest, Immediate)
	TEST_P (InstructionSelectorDPITest, ShiftByParameter)
	TEST_P (InstructionSelectorDPITest, ShiftByImmediate)
	TEST_P (InstructionSelectorDPITest, BranchWithParameters)
	TEST_P (InstructionSelectorDPITest, BranchWithImmediate)
	TEST_P (InstructionSelectorDPITest, BranchWithShiftByParameter)
	TEST_P (InstructionSelectorDPITest, BranchWithShiftByImmediate)
	TEST_P (InstructionSelectorDPITest, BranchIfZeroWithParameters)
	TEST_P (InstructionSelectorDPITest, BranchIfNotZeroWithParameters)
	TEST_P (InstructionSelectorDPITest, BranchIfZeroWithImmediate)
	TEST_P (InstructionSelectorDPITest, BranchIfNotZeroWithImmediate)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorDPITest, ::testing::ValuesIn(kDPIs))
	TEST_P (InstructionSelectorODPITest, OvfWithParameters)
	TEST_P (InstructionSelectorODPITest, OvfWithImmediate)
	TEST_P (InstructionSelectorODPITest, OvfWithShiftByParameter)
	TEST_P (InstructionSelectorODPITest, OvfWithShiftByImmediate)
	TEST_P (InstructionSelectorODPITest, ValWithParameters)
	TEST_P (InstructionSelectorODPITest, ValWithImmediate)
	TEST_P (InstructionSelectorODPITest, ValWithShiftByParameter)
	TEST_P (InstructionSelectorODPITest, ValWithShiftByImmediate)
	TEST_P (InstructionSelectorODPITest, BothWithParameters)
	TEST_P (InstructionSelectorODPITest, BothWithImmediate)
	TEST_P (InstructionSelectorODPITest, BothWithShiftByParameter)
	TEST_P (InstructionSelectorODPITest, BothWithShiftByImmediate)
	TEST_P (InstructionSelectorODPITest, BranchWithParameters)
	TEST_P (InstructionSelectorODPITest, BranchWithImmediate)
	TEST_P (InstructionSelectorODPITest, BranchIfZeroWithParameters)
	TEST_P (InstructionSelectorODPITest, BranchIfNotZeroWithParameters)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorODPITest, ::testing::ValuesIn(kODPIs))
	TEST_P (InstructionSelectorShiftTest, Parameters)
	TEST_P (InstructionSelectorShiftTest, Immediate)
	TEST_P (InstructionSelectorShiftTest, Word32EqualWithParameter)
	TEST_P (InstructionSelectorShiftTest, Word32EqualWithParameterAndImmediate)
	TEST_P (InstructionSelectorShiftTest, Word32EqualToZeroWithParameters)
	TEST_P (InstructionSelectorShiftTest, Word32EqualToZeroWithImmediate)
	TEST_P (InstructionSelectorShiftTest, Word32NotWithParameters)
	TEST_P (InstructionSelectorShiftTest, Word32NotWithImmediate)
	TEST_P (InstructionSelectorShiftTest, Word32AndWithWord32NotWithParameters)
	TEST_P (InstructionSelectorShiftTest, Word32AndWithWord32NotWithImmediate)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorShiftTest, ::testing::ValuesIn(kShifts))
	TEST_P (InstructionSelectorMemoryAccessTest, LoadWithParameters)
	TEST_P (InstructionSelectorMemoryAccessTest, LoadWithImmediateIndex)
	TEST_P (InstructionSelectorMemoryAccessTest, StoreWithParameters)
	TEST_P (InstructionSelectorMemoryAccessTest, StoreWithImmediateIndex)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorMemoryAccessTest, ::testing::ValuesIn(kMemoryAccesses))
	TEST_F (InstructionSelectorTest, ChangeFloat32ToFloat64WithParameter)
	TEST_F (InstructionSelectorTest, TruncateFloat64ToFloat32WithParameter)
	TEST_F (InstructionSelectorTest, Int32AddWithInt32Mul)
	TEST_F (InstructionSelectorTest, Int32DivWithParameters)
	TEST_F (InstructionSelectorTest, Int32DivWithParametersForSUDIV)
	TEST_F (InstructionSelectorTest, Int32ModWithParameters)
	TEST_F (InstructionSelectorTest, Int32ModWithParametersForSUDIV)
	TEST_F (InstructionSelectorTest, Int32ModWithParametersForSUDIVAndMLS)
	TEST_F (InstructionSelectorTest, Int32MulWithParameters)
	TEST_F (InstructionSelectorTest, Int32MulWithImmediate)
	TEST_F (InstructionSelectorTest, Int32SubWithInt32Mul)
	TEST_F (InstructionSelectorTest, Int32SubWithInt32MulForMLS)
	TEST_F (InstructionSelectorTest, Int32UDivWithParameters)
	TEST_F (InstructionSelectorTest, Int32UDivWithParametersForSUDIV)
	TEST_F (InstructionSelectorTest, Int32UModWithParameters)
	TEST_F (InstructionSelectorTest, Int32UModWithParametersForSUDIV)
	TEST_F (InstructionSelectorTest, Int32UModWithParametersForSUDIVAndMLS)
	TEST_F (InstructionSelectorTest, Word32AndWithUbfxImmediateForARMv7)
	TEST_F (InstructionSelectorTest, Word32AndWithBfcImmediateForARMv7)
	TEST_F (InstructionSelectorTest, Word32ShrWithWord32AndWithImmediateForARMv7)
	TEST_F (InstructionSelectorTest, Word32AndWithWord32Not)
	TEST_F (InstructionSelectorTest, Word32EqualWithParameters)
	TEST_F (InstructionSelectorTest, Word32EqualWithImmediate)
	TEST_F (InstructionSelectorTest, Word32EqualWithZero)
	TEST_F (InstructionSelectorTest, Word32NotWithParameter)
	TEST_F (InstructionSelectorTest, Word32AndWithWord32ShrWithImmediateForARMv7)
static void	VisitRRRFloat64 (InstructionSelector *selector, ArchOpcode opcode, Node *node)
static bool	TryMatchROR (InstructionSelector *selector, InstructionCode *opcode_return, Node *node, InstructionOperand **value_return, InstructionOperand **shift_return)
static bool	TryMatchASR (InstructionSelector *selector, InstructionCode *opcode_return, Node *node, InstructionOperand **value_return, InstructionOperand **shift_return)
static bool	TryMatchLSL (InstructionSelector *selector, InstructionCode *opcode_return, Node *node, InstructionOperand **value_return, InstructionOperand **shift_return)
static bool	TryMatchLSR (InstructionSelector *selector, InstructionCode *opcode_return, Node *node, InstructionOperand **value_return, InstructionOperand **shift_return)
static bool	TryMatchShift (InstructionSelector *selector, InstructionCode *opcode_return, Node *node, InstructionOperand **value_return, InstructionOperand **shift_return)
static bool	TryMatchImmediateOrShift (InstructionSelector *selector, InstructionCode *opcode_return, Node *node, size_t *input_count_return, InstructionOperand **inputs)
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode, InstructionCode reverse_opcode, FlagsContinuation *cont)
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode, InstructionCode reverse_opcode)
static void	EmitBic (InstructionSelector *selector, Node *node, Node *left, Node *right)
template<typename TryMatchShift >
static void	VisitShift (InstructionSelector *selector, Node *node, TryMatchShift try_match_shift, FlagsContinuation *cont)
template<typename TryMatchShift >
static void	VisitShift (InstructionSelector *selector, Node *node, TryMatchShift try_match_shift)
static void	EmitDiv (InstructionSelector *selector, ArchOpcode div_opcode, ArchOpcode f64i32_opcode, ArchOpcode i32f64_opcode, InstructionOperand *result_operand, InstructionOperand *left_operand, InstructionOperand *right_operand)
static void	VisitDiv (InstructionSelector *selector, Node *node, ArchOpcode div_opcode, ArchOpcode f64i32_opcode, ArchOpcode i32f64_opcode)
static void	VisitMod (InstructionSelector *selector, Node *node, ArchOpcode div_opcode, ArchOpcode f64i32_opcode, ArchOpcode i32f64_opcode)
static void	VisitWordCompare (InstructionSelector *selector, Node *node, InstructionCode opcode, FlagsContinuation *cont, bool commutative)
static int	AlignedStackSlots (int stack_slots)
	TEST_P (InstructionSelectorLogicalTest, Parameter)
	TEST_P (InstructionSelectorLogicalTest, Immediate)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorLogicalTest, ::testing::ValuesIn(kLogicalInstructions))
	TEST_P (InstructionSelectorAddSubTest, ImmediateOnRight)
	TEST_P (InstructionSelectorAddSubTest, ImmediateOnLeft)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorAddSubTest, ::testing::ValuesIn(kAddSubInstructions))
	TEST_F (InstructionSelectorTest, SubZeroOnLeft)
	TEST_P (InstructionSelectorDPFlagSetTest, BranchWithParameters)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorDPFlagSetTest, ::testing::ValuesIn(kDPFlagSetInstructions))
	TEST_F (InstructionSelectorTest, AndBranchWithImmediateOnRight)
	TEST_F (InstructionSelectorTest, AddBranchWithImmediateOnRight)
	TEST_F (InstructionSelectorTest, SubBranchWithImmediateOnRight)
	TEST_F (InstructionSelectorTest, AndBranchWithImmediateOnLeft)
	TEST_F (InstructionSelectorTest, AddBranchWithImmediateOnLeft)
	TEST_P (InstructionSelectorOvfAddSubTest, OvfParameter)
	TEST_P (InstructionSelectorOvfAddSubTest, OvfImmediateOnRight)
	TEST_P (InstructionSelectorOvfAddSubTest, ValParameter)
	TEST_P (InstructionSelectorOvfAddSubTest, ValImmediateOnRight)
	TEST_P (InstructionSelectorOvfAddSubTest, BothParameter)
	TEST_P (InstructionSelectorOvfAddSubTest, BothImmediateOnRight)
	TEST_P (InstructionSelectorOvfAddSubTest, BranchWithImmediateOnRight)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorOvfAddSubTest, ::testing::ValuesIn(kOvfAddSubInstructions))
	TEST_F (InstructionSelectorTest, OvfFlagAddImmediateOnLeft)
	TEST_F (InstructionSelectorTest, OvfValAddImmediateOnLeft)
	TEST_F (InstructionSelectorTest, OvfBothAddImmediateOnLeft)
	TEST_F (InstructionSelectorTest, OvfBranchWithImmediateOnLeft)
	TEST_P (InstructionSelectorShiftTest, Parameter)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorShiftTest, ::testing::ValuesIn(kShiftInstructions))
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorMulDivTest, ::testing::ValuesIn(kMulDivInstructions))
	TEST_P (InstructionSelectorIntDPWithIntMulTest, AddWithMul)
	TEST_P (InstructionSelectorIntDPWithIntMulTest, SubWithMul)
	TEST_P (InstructionSelectorIntDPWithIntMulTest, NegativeMul)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorIntDPWithIntMulTest, ::testing::ValuesIn(kMulDPInstructions))
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorFPArithTest, ::testing::ValuesIn(kFPArithInstructions))
	TEST_P (InstructionSelectorFPCmpTest, Parameter)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorFPCmpTest, ::testing::ValuesIn(kFPCmpInstructions))
	TEST_P (InstructionSelectorConversionTest, Parameter)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorConversionTest, ::testing::ValuesIn(kConversionInstructions))
	TEST_P (InstructionSelectorComparisonTest, WithParameters)
	TEST_P (InstructionSelectorComparisonTest, WithImmediate)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorComparisonTest, ::testing::ValuesIn(kComparisonInstructions))
	TEST_F (InstructionSelectorTest, Word64EqualWithZero)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorLogicalWithNotRHSTest, ::testing::ValuesIn(kLogicalWithNotRHSs))
	TEST_F (InstructionSelectorTest, Word64NotWithParameter)
	TEST_F (InstructionSelectorTest, Word32XorMinusOneWithParameter)
	TEST_F (InstructionSelectorTest, Word64XorMinusOneWithParameter)
static void	VisitRRR (InstructionSelector *selector, ArchOpcode opcode, Node *node)
static void	VisitRRRFloat64 (InstructionSelector *selector, ArchOpcode opcode, Node *node)
static void	VisitRRO (InstructionSelector *selector, ArchOpcode opcode, Node *node, ImmediateMode operand_mode)
template<typename Matcher >
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode, ImmediateMode operand_mode, FlagsContinuation *cont)
template<typename Matcher >
static void	VisitBinop (InstructionSelector *selector, Node *node, ArchOpcode opcode, ImmediateMode operand_mode)
template<typename Matcher >
static void	VisitLogical (InstructionSelector *selector, Node *node, Matcher *m, ArchOpcode opcode, bool left_can_cover, bool right_can_cover, ImmediateMode imm_mode)
static void	VisitCompare (InstructionSelector *selector, InstructionCode opcode, InstructionOperand *left, InstructionOperand *right, FlagsContinuation *cont)
static void	VisitWordCompare (InstructionSelector *selector, Node *node, InstructionCode opcode, FlagsContinuation *cont, bool commutative)
static LhsKind	DetermineLhsKind (Expression *expr)
static Handle< SharedFunctionInfo >	SearchSharedFunctionInfo (Code *unoptimized_code, FunctionLiteral *expr)
static NodeVector::iterator	FindInsertionPoint (NodeVector *nodes)
static const Operator *	PointerConstant (CommonOperatorBuilder *common, void *ptr)
std::ostream &	operator<< (std::ostream &os, const MachineType &type)
	TARGET_TEST_P (ChangeLoweringCommonTest, ChangeBitToBool)
	TARGET_TEST_P (ChangeLoweringCommonTest, ChangeBoolToBit)
	TARGET_TEST_P (ChangeLoweringCommonTest, ChangeFloat64ToTagged)
	TARGET_TEST_P (ChangeLoweringCommonTest, StringAdd)
	INSTANTIATE_TEST_CASE_P (ChangeLoweringTest, ChangeLoweringCommonTest, ::testing::Values(kRepWord32, kRepWord64))
	TARGET_TEST_F (ChangeLowering32Test, ChangeInt32ToTagged)
	TARGET_TEST_F (ChangeLowering32Test, ChangeTaggedToFloat64)
	TARGET_TEST_F (ChangeLowering32Test, ChangeTaggedToInt32)
	TARGET_TEST_F (ChangeLowering32Test, ChangeTaggedToUint32)
	TARGET_TEST_F (ChangeLowering32Test, ChangeUint32ToTagged)
	TARGET_TEST_F (ChangeLowering64Test, ChangeInt32ToTagged)
	TARGET_TEST_F (ChangeLowering64Test, ChangeTaggedToFloat64)
	TARGET_TEST_F (ChangeLowering64Test, ChangeTaggedToInt32)
	TARGET_TEST_F (ChangeLowering64Test, ChangeTaggedToUint32)
	TARGET_TEST_F (ChangeLowering64Test, ChangeUint32ToTagged)
static void	FinishCode (MacroAssembler *masm)
	TEST_P (CommonSharedOperatorTest, InstancesAreGloballyShared)
	TEST_P (CommonSharedOperatorTest, NumberOfInputsAndOutputs)
	TEST_P (CommonSharedOperatorTest, OpcodeIsCorrect)
	TEST_P (CommonSharedOperatorTest, Properties)
	INSTANTIATE_TEST_CASE_P (CommonOperatorTest, CommonSharedOperatorTest, ::testing::ValuesIn(kSharedOperators))
	TEST_F (CommonOperatorTest, Float32Constant)
	TEST_F (CommonOperatorTest, ValueEffect)
	TEST_F (CommonOperatorTest, Finish)
static void	VerifyMovesAreInjective (ZoneList< MoveOperands > *moves)
	TEST_F (GraphReducerTest, NodeIsDeadAfterReplace)
	TEST_F (GraphReducerTest, ReduceOnceForEveryReducer)
	TEST_F (GraphReducerTest, ReduceAgainAfterChanged)
static bool	NodeIdIsLessThan (const Node *node, NodeId id)
Matcher< Node * >	IsBranch (const Matcher< Node * > &value_matcher, const Matcher< Node * > &control_matcher)
Matcher< Node * >	IsMerge (const Matcher< Node * > &control0_matcher, const Matcher< Node * > &control1_matcher)
Matcher< Node * >	IsIfTrue (const Matcher< Node * > &control_matcher)
Matcher< Node * >	IsIfFalse (const Matcher< Node * > &control_matcher)
Matcher< Node * >	IsControlEffect (const Matcher< Node * > &control_matcher)
Matcher< Node * >	IsValueEffect (const Matcher< Node * > &value_matcher)
Matcher< Node * >	IsFinish (const Matcher< Node * > &value_matcher, const Matcher< Node * > &effect_matcher)
Matcher< Node * >	IsExternalConstant (const Matcher< ExternalReference > &value_matcher)
Matcher< Node * >	IsHeapConstant (const Matcher< Unique< HeapObject > > &value_matcher)
Matcher< Node * >	IsInt32Constant (const Matcher< int32_t > &value_matcher)
Matcher< Node * >	IsInt64Constant (const Matcher< int64_t > &value_matcher)
Matcher< Node * >	IsFloat32Constant (const Matcher< float > &value_matcher)
Matcher< Node * >	IsFloat64Constant (const Matcher< double > &value_matcher)
Matcher< Node * >	IsNumberConstant (const Matcher< double > &value_matcher)
Matcher< Node * >	IsPhi (const Matcher< MachineType > &type_matcher, const Matcher< Node * > &value0_matcher, const Matcher< Node * > &value1_matcher, const Matcher< Node * > &merge_matcher)
Matcher< Node * >	IsProjection (const Matcher< size_t > &index_matcher, const Matcher< Node * > &base_matcher)
Matcher< Node * >	IsCall (const Matcher< CallDescriptor * > &descriptor_matcher, const Matcher< Node * > &value0_matcher, const Matcher< Node * > &value1_matcher, const Matcher< Node * > &value2_matcher, const Matcher< Node * > &value3_matcher, const Matcher< Node * > &effect_matcher, const Matcher< Node * > &control_matcher)
Matcher< Node * >	IsLoad (const Matcher< LoadRepresentation > &rep_matcher, const Matcher< Node * > &base_matcher, const Matcher< Node * > &index_matcher, const Matcher< Node * > &effect_matcher)
Matcher< Node * >	IsStore (const Matcher< MachineType > &type_matcher, const Matcher< WriteBarrierKind > &write_barrier_matcher, const Matcher< Node * > &base_matcher, const Matcher< Node * > &index_matcher, const Matcher< Node * > &value_matcher, const Matcher< Node * > &effect_matcher, const Matcher< Node * > &control_matcher)
Matcher< Node * >	IsNumberLessThan (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsNumberSubtract (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord32And (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord32Sar (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord32Shl (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord32Ror (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord32Equal (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord64And (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord64Shl (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord64Sar (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsWord64Equal (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsInt32AddWithOverflow (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsInt32Mul (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsUint32LessThanOrEqual (const Matcher< Node * > &lhs_matcher, const Matcher< Node * > &rhs_matcher)
Matcher< Node * >	IsChangeFloat64ToInt32 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsChangeFloat64ToUint32 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsChangeInt32ToFloat64 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsChangeInt32ToInt64 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsChangeUint32ToFloat64 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsChangeUint32ToUint64 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsTruncateFloat64ToFloat32 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsTruncateFloat64ToInt32 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsTruncateInt64ToInt32 (const Matcher< Node * > &input_matcher)
Matcher< Node * >	IsFloat64Sqrt (const Matcher< Node * > &input_matcher)
OStream &	operator<< (OStream &os, const AsJSON &ad)
static Node *	GetControlCluster (Node *node)
static bool	IsLikelyBackEdge (Node *from, int index, Node *to)
OStream &	operator<< (OStream &os, const AsDOT &ad)
static bool	HasImmediateInput (Instruction *instr, int index)
	TEST_F (InstructionSelectorTest, Int32AddWithParameter)
	TEST_F (InstructionSelectorTest, Int32AddWithImmediate)
	TEST_F (InstructionSelectorTest, Int32SubWithParameter)
	TEST_F (InstructionSelectorTest, Int32SubWithImmediate)
	TEST_F (InstructionSelectorTest, BetterLeftOperandTestAddBinop)
	TEST_F (InstructionSelectorTest, BetterLeftOperandTestMulBinop)
	TEST_P (InstructionSelectorMemoryAccessTest, LoadWithImmediateBase)
	TEST_P (InstructionSelectorMemoryAccessTest, StoreWithImmediateBase)
	TEST_F (AddressingModeUnitTest, AddressingMode_MR)
	TEST_F (AddressingModeUnitTest, AddressingMode_MRI)
	TEST_F (AddressingModeUnitTest, AddressingMode_MR1)
	TEST_F (AddressingModeUnitTest, AddressingMode_MRN)
	TEST_F (AddressingModeUnitTest, AddressingMode_MR1I)
	TEST_F (AddressingModeUnitTest, AddressingMode_MRNI)
	TEST_F (AddressingModeUnitTest, AddressingMode_M1)
	TEST_F (AddressingModeUnitTest, AddressingMode_MN)
	TEST_F (AddressingModeUnitTest, AddressingMode_M1I)
	TEST_F (AddressingModeUnitTest, AddressingMode_MNI)
	TEST_F (AddressingModeUnitTest, AddressingMode_MI)
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode, FlagsContinuation *cont)
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode)
static void	VisitShift (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitDiv (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitMod (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitCompare (InstructionSelector *selector, InstructionCode opcode, InstructionOperand *left, InstructionOperand *right, FlagsContinuation *cont)
static void	VisitWordCompare (InstructionSelector *selector, Node *node, InstructionCode opcode, FlagsContinuation *cont, bool commutative)
OStream &	operator<< (OStream &os, const ArchOpcode &ao)
OStream &	operator<< (OStream &os, const AddressingMode &am)
OStream &	operator<< (OStream &os, const FlagsMode &fm)
OStream &	operator<< (OStream &os, const FlagsCondition &fc)
	TARGET_TEST_F (InstructionSelectorTest, ReturnFloat32Constant)
	TARGET_TEST_F (InstructionSelectorTest, ReturnParameter)
	TARGET_TEST_F (InstructionSelectorTest, ReturnZero)
	TARGET_TEST_F (InstructionSelectorTest, TruncateFloat64ToInt32WithParameter)
	TARGET_TEST_F (InstructionSelectorTest, DoubleParameter)
	TARGET_TEST_F (InstructionSelectorTest, ReferenceParameter)
	TARGET_TEST_F (InstructionSelectorTest, Finish)
	TARGET_TEST_P (InstructionSelectorPhiTest, Doubleness)
	TARGET_TEST_P (InstructionSelectorPhiTest, Referenceness)
	INSTANTIATE_TEST_CASE_P (InstructionSelectorTest, InstructionSelectorPhiTest, ::testing::Values(kMachFloat64, kMachInt8, kMachUint8, kMachInt16, kMachUint16, kMachInt32, kMachUint32, kMachInt64, kMachUint64, kMachPtr, kMachAnyTagged))
	TARGET_TEST_F (InstructionSelectorTest, ValueEffect)
	TARGET_TEST_F (InstructionSelectorTest, CallJSFunctionWithDeopt)
	TARGET_TEST_F (InstructionSelectorTest, CallFunctionStubWithDeopt)
	TARGET_TEST_F (InstructionSelectorTest, CallFunctionStubDeoptRecursiveFrameState)
static void	CheckNoPhis (const BasicBlock *block)
static InstructionOperand *	UseOrImmediate (OperandGenerator *g, Node *input)
OStream &	operator<< (OStream &os, const InstructionOperand &op)
OStream &	operator<< (OStream &os, const MoveOperands &mo)
OStream &	operator<< (OStream &os, const ParallelMove &pm)
OStream &	operator<< (OStream &os, const PointerMap &pm)
OStream &	operator<< (OStream &os, const Instruction &instr)
OStream &	operator<< (OStream &os, const Constant &constant)
OStream &	operator<< (OStream &os, const InstructionSequence &code)
	TEST_F (JSBuiltinReducerTest, MathAbs)
	TEST_F (JSBuiltinReducerTest, MathSqrt)
	TEST_F (JSBuiltinReducerTest, MathMax0)
	TEST_F (JSBuiltinReducerTest, MathMax1)
	TEST_F (JSBuiltinReducerTest, MathMax2)
	TEST_F (JSBuiltinReducerTest, MathImul)
	TEST_F (JSBuiltinReducerTest, MathFround)
static Reduction	ReplaceWithPureReduction (Node *node, Reduction reduction)
static CallDescriptor::Flags	FlagsForNode (Node *node)
static void	Parse (Handle< JSFunction > function, CompilationInfoWithZone *info)
static void	RelaxEffects (Node *node)
static Reduction	ReplaceWithReduction (Node *node, Reduction reduction)
OStream &	operator<< (OStream &os, const CallDescriptor::Kind &k)
OStream &	operator<< (OStream &os, const CallDescriptor &d)
	TEST_P (MachineUnaryOperatorReducerTest, Parameter)
	INSTANTIATE_TEST_CASE_P (MachineOperatorReducerTest, MachineUnaryOperatorReducerTest, ::testing::ValuesIn(kUnaryOperators))
	TEST_F (MachineOperatorReducerTest, ChangeFloat64ToFloat32WithConstant)
	TEST_F (MachineOperatorReducerTest, ChangeFloat64ToInt32WithChangeInt32ToFloat64)
	TEST_F (MachineOperatorReducerTest, ChangeFloat64ToInt32WithConstant)
	TEST_F (MachineOperatorReducerTest, ChangeFloat64ToUint32WithChangeUint32ToFloat64)
	TEST_F (MachineOperatorReducerTest, ChangeFloat64ToUint32WithConstant)
	TEST_F (MachineOperatorReducerTest, ChangeInt32ToFloat64WithConstant)
	TEST_F (MachineOperatorReducerTest, ChangeInt32ToInt64WithConstant)
	TEST_F (MachineOperatorReducerTest, ChangeUint32ToFloat64WithConstant)
	TEST_F (MachineOperatorReducerTest, ChangeUint32ToUint64WithConstant)
	TEST_F (MachineOperatorReducerTest, TruncateFloat64ToFloat32WithChangeFloat32ToFloat64)
	TEST_F (MachineOperatorReducerTest, TruncateFloat64ToFloat32WithConstant)
	TEST_F (MachineOperatorReducerTest, TruncateFloat64ToInt32WithChangeInt32ToFloat64)
	TEST_F (MachineOperatorReducerTest, TruncateFloat64ToInt32WithConstant)
	TEST_F (MachineOperatorReducerTest, TruncateInt64ToInt32WithChangeInt32ToInt64)
	TEST_F (MachineOperatorReducerTest, TruncateInt64ToInt32WithConstant)
	TEST_F (MachineOperatorReducerTest, ReduceToWord32RorWithParameters)
	TEST_F (MachineOperatorReducerTest, ReduceToWord32RorWithConstant)
	TEST_F (MachineOperatorReducerTest, Word32RorWithZeroShift)
	TEST_F (MachineOperatorReducerTest, Word32RorWithConstants)
	TEST_F (MachineOperatorReducerTest, Word32ShlWithZeroShift)
	TEST_F (MachineOperatorReducerTest, Word32ShlWithWord32Sar)
	TEST_F (MachineOperatorReducerTest, Word32ShlWithWord32Shr)
	TEST_F (MachineOperatorReducerTest, Int32AddWithOverflowWithZero)
	TEST_F (MachineOperatorReducerTest, Int32AddWithOverflowWithConstant)
	TEST_F (MachineOperatorReducerTest, Int32SubWithOverflowWithZero)
	TEST_F (MachineOperatorReducerTest, Int32SubWithOverflowWithConstant)
	TEST (MachineOperatorTest, PseudoOperatorsWhenWordSizeIs32Bit)
	TEST (MachineOperatorTest, PseudoOperatorsWhenWordSizeIs64Bit)
OStream &	operator<< (OStream &os, const WriteBarrierKind &write_barrier_kind)
OStream &	operator<< (OStream &os, const StoreRepresentation &rep)
bool	operator== (const StoreRepresentation &rep1, const StoreRepresentation &rep2)
bool	operator!= (const StoreRepresentation &rep1, const StoreRepresentation &rep2)
OStream &	operator<< (OStream &os, const MachineType &type)
MachineType	TypeOf (MachineType machine_type)
MachineType	RepresentationOf (MachineType machine_type)
int	ElementSizeOf (MachineType machine_type)
template<typename Key >
int32_t	NodeCacheHash (Key key)
template<>
int32_t	NodeCacheHash (int32_t key)
template<>
int32_t	NodeCacheHash (int64_t key)
template<>
int32_t	NodeCacheHash (double key)
template<>
int32_t	NodeCacheHash (void *key)
OStream &	operator<< (OStream &os, const Operator &op)
OStream &	operator<< (OStream &os, const Node &n)
template<typename T >
static const T &	OpParameter (const Node *node)
template<typename T >
static const T &	OpParameter (const Operator *op)
static bool	VerifyGraphs ()
static void	TraceSchedule (Schedule *schedule)
static LifetimePosition	Min (LifetimePosition a, LifetimePosition b)
static LifetimePosition	Max (LifetimePosition a, LifetimePosition b)
static int	UnhandledSortHelper (LiveRange *const *a, LiveRange *const *b)
	STATIC_ASSERT (DoubleRegister::kMaxNumAllocatableRegisters >=Register::kMaxNumAllocatableRegisters)
OStream &	operator<< (OStream &os, const BasicBlockData::Control &c)
OStream &	operator<< (OStream &os, const Schedule &s)
static void	Trace (const char *msg,...)
static int	Push (SpecialRPOStackFrame *stack, int depth, BasicBlock *child, int unvisited)
static LoopInfo *	ComputeLoopInfo (Zone *zone, SpecialRPOStackFrame *queue, int num_loops, int num_blocks, ZoneList< std::pair< BasicBlock *, int > > *backedges)
static WriteBarrierKind	ComputeWriteBarrierKind (BaseTaggedness base_is_tagged, MachineType representation, Type *type)
	TEST_P (SimplifiedUnaryOperatorTest, Parameter)
	INSTANTIATE_TEST_CASE_P (SimplifiedOperatorReducerTest, SimplifiedUnaryOperatorTest, ::testing::ValuesIn(kUnaryOperators))
	TEST_F (SimplifiedOperatorReducerTest, BooleanNotWithBooleanNot)
	TEST_F (SimplifiedOperatorReducerTest, BooleanNotWithFalseConstant)
	TEST_F (SimplifiedOperatorReducerTest, BooleanNotWithTrueConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeBitToBoolWithChangeBoolToBit)
	TEST_F (SimplifiedOperatorReducerTest, ChangeBitToBoolWithZeroConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeBitToBoolWithOneConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeBoolToBitWithFalseConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeBoolToBitWithTrueConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeBoolToBitWithChangeBitToBool)
	TEST_F (SimplifiedOperatorReducerTest, ChangeFloat64ToTaggedWithConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeInt32ToTaggedWithConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithChangeFloat64ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithChangeInt32ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithChangeUint32ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithNaNConstant1)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithNaNConstant2)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithChangeFloat64ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithChangeInt32ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithNaNConstant1)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithNaNConstant2)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithChangeFloat64ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithChangeUint32ToTagged)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithConstant)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithNaNConstant1)
	TEST_F (SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithNaNConstant2)
	TEST_F (SimplifiedOperatorReducerTest, ChangeUint32ToTagged)
std::ostream &	operator<< (std::ostream &os, const ElementAccess &access)
	TEST_P (SimplifiedPureOperatorTest, InstancesAreGloballyShared)
	TEST_P (SimplifiedPureOperatorTest, NumberOfInputsAndOutputs)
	TEST_P (SimplifiedPureOperatorTest, OpcodeIsCorrect)
	TEST_P (SimplifiedPureOperatorTest, Properties)
	INSTANTIATE_TEST_CASE_P (SimplifiedOperatorTest, SimplifiedPureOperatorTest, ::testing::ValuesIn(kPureOperators))
	TEST_P (SimplifiedElementAccessOperatorTest, LoadElement)
	TEST_P (SimplifiedElementAccessOperatorTest, StoreElement)
	INSTANTIATE_TEST_CASE_P (SimplifiedOperatorTest, SimplifiedElementAccessOperatorTest, ::testing::ValuesIn(kElementAccesses))
OStream &	operator<< (OStream &os, BaseTaggedness base_taggedness)
bool	operator== (ElementAccess const &lhs, ElementAccess const &rhs)
bool	operator!= (ElementAccess const &lhs, ElementAccess const &rhs)
OStream &	operator<< (OStream &os, ElementAccess const &access)
const FieldAccess &	FieldAccessOf (const Operator *op)
const ElementAccess &	ElementAccessOf (const Operator *op)
bool	operator== (const SourcePosition &lhs, const SourcePosition &rhs)
bool	operator!= (const SourcePosition &lhs, const SourcePosition &rhs)
	TEST_F (ValueNumberingReducerTest, AllInputsAreChecked)
	TEST_F (ValueNumberingReducerTest, DeadNodesAreNeverReturned)
	TEST_F (ValueNumberingReducerTest, OperatorEqualityNotIdentity)
	TEST_F (ValueNumberingReducerTest, SubsequentReductionsYieldTheSameNode)
	TEST_F (ValueNumberingReducerTest, WontReplaceNodeWithItself)
static bool	IsDefUseChainLinkPresent (Node *def, Node *use)
static bool	IsUseDefChainLinkPresent (Node *def, Node *use)
static bool	HasDominatingDef (Schedule *schedule, Node *node, BasicBlock *container, BasicBlock *use_block, int use_pos)
static void	CheckInputsDominate (Schedule *schedule, BasicBlock *block, Node *node, int use_pos)
static bool	HasImmediateInput (Instruction *instr, int index)
	TEST_F (InstructionSelectorTest, ChangeInt32ToInt64WithParameter)
	TEST_F (InstructionSelectorTest, ChangeUint32ToUint64WithParameter)
	TEST_F (InstructionSelectorTest, TruncateInt64ToInt32WithParameter)
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode, FlagsContinuation *cont)
static void	VisitBinop (InstructionSelector *selector, Node *node, InstructionCode opcode)
static void	VisitWord32Shift (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitWord64Shift (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitMul (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitDiv (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitMod (InstructionSelector *selector, Node *node, ArchOpcode opcode)
static void	VisitCompare (InstructionSelector *selector, InstructionCode opcode, InstructionOperand *left, InstructionOperand *right, FlagsContinuation *cont)
static void	VisitWordCompare (InstructionSelector *selector, Node *node, InstructionCode opcode, FlagsContinuation *cont, bool commutative)

Variables
static const MulDPInst	kMulDPInstructions []
static const MemoryAccess	kMemoryAccesses []
static const MachInst2	kComparisonInstructions []
static const MachInst2	kLogicalWithNotRHSs []
static base::LazyInstance< CommonOperatorBuilderImpl >::type	kImpl
const InstructionCode	kGapInstruction = -1
const InstructionCode	kBlockStartInstruction = -2
const InstructionCode	kSourcePositionInstruction = -3
static base::LazyInstance< MachineOperatorBuilderImpl >::type	kImpl
const MachineTypeUnion	kRepMask
const MachineTypeUnion	kTypeMask
static const int	kBlockOnStack = -2
static const int	kBlockVisited1 = -3
static const int	kBlockVisited2 = -4
static const int	kBlockUnvisited1 = -1
static const int	kBlockUnvisited2 = kBlockVisited1
static base::LazyInstance< SimplifiedOperatorBuilderImpl >::type	kImpl
static const int	kNonHeapObjectHeaderSize = kHeapObjectTag
const bool	kWin64 = false

Typedef Documentation

AddressingModeField

typedef BitField<AddressingMode, 7, 5> v8::internal::compiler::AddressingModeField

Definition at line 110 of file instruction-codes.h.

ArchOpcodeField

typedef BitField<ArchOpcode, 0, 7> v8::internal::compiler::ArchOpcodeField

Definition at line 109 of file instruction-codes.h.

BasicBlockVector

typedef ZoneVector<BasicBlock*> v8::internal::compiler::BasicBlockVector

Definition at line 149 of file schedule.h.

BasicBlockVectorIter

typedef BasicBlockVector::iterator v8::internal::compiler::BasicBlockVectorIter

Definition at line 150 of file schedule.h.

BasicBlockVectorRIter

typedef BasicBlockVector::reverse_iterator v8::internal::compiler::BasicBlockVectorRIter

Definition at line 151 of file schedule.h.

ConstantDeque

typedef ZoneDeque<Constant> v8::internal::compiler::ConstantDeque

Definition at line 800 of file instruction.h.

ConstantMap

typedef std::map<int, Constant, std::less<int>, zone_allocator<std::pair<int, Constant> > > v8::internal::compiler::ConstantMap

Definition at line 802 of file instruction.h.

DeoptimizationVector

typedef ZoneVector<FrameStateDescriptor*> v8::internal::compiler::DeoptimizationVector

Definition at line 806 of file instruction.h.

FlagsConditionField

typedef BitField<FlagsCondition, 14, 5> v8::internal::compiler::FlagsConditionField

Definition at line 112 of file instruction-codes.h.

FlagsModeField

typedef BitField<FlagsMode, 12, 2> v8::internal::compiler::FlagsModeField

Definition at line 111 of file instruction-codes.h.

Float32Matcher

typedef FloatMatcher<float, IrOpcode::kFloat32Constant> v8::internal::compiler::Float32Matcher

Definition at line 93 of file node-matchers.h.

Float64BinopMatcher

typedef BinopMatcher<Float64Matcher, Float64Matcher> v8::internal::compiler::Float64BinopMatcher

Definition at line 140 of file node-matchers.h.

Float64Matcher

typedef FloatMatcher<double, IrOpcode::kFloat64Constant> v8::internal::compiler::Float64Matcher

Definition at line 94 of file node-matchers.h.

InputIter

typedef Node::Inputs::iterator v8::internal::compiler::InputIter

Definition at line 82 of file node.h.

InstructionCode

typedef int32_t v8::internal::compiler::InstructionCode

Definition at line 103 of file instruction-codes.h.

InstructionDeque

typedef ZoneDeque<Instruction*> v8::internal::compiler::InstructionDeque

Definition at line 804 of file instruction.h.

InstructionOperandVector

typedef ZoneVector<InstructionOperand*> v8::internal::compiler::InstructionOperandVector

Definition at line 92 of file instruction.h.

InstructionSelectorAddSubTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorAddSubTest

Definition at line 294 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorComparisonTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorComparisonTest

Definition at line 1122 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorConversionTest

typedef InstructionSelectorTestWithParam<Conversion> v8::internal::compiler::InstructionSelectorConversionTest

Definition at line 964 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorDPFlagSetTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorDPFlagSetTest

Definition at line 386 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorDPITest

typedef InstructionSelectorTestWithParam<DPI> v8::internal::compiler::InstructionSelectorDPITest

Definition at line 121 of file instruction-selector-arm-unittest.cc.

InstructionSelectorFPArithTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorFPArithTest

Definition at line 920 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorFPCmpTest

typedef InstructionSelectorTestWithParam<FPCmp> v8::internal::compiler::InstructionSelectorFPCmpTest

Definition at line 939 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorIntDPWithIntMulTest

typedef InstructionSelectorTestWithParam<MulDPInst> v8::internal::compiler::InstructionSelectorIntDPWithIntMulTest

Definition at line 838 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorLogicalTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorLogicalTest

Definition at line 236 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorLogicalWithNotRHSTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorLogicalWithNotRHSTest

Definition at line 1250 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorMemoryAccessTest

typedef InstructionSelectorTestWithParam< MemoryAccess > v8::internal::compiler::InstructionSelectorMemoryAccessTest

Definition at line 1268 of file instruction-selector-arm-unittest.cc.

InstructionSelectorMulDivTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorMulDivTest

Definition at line 787 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorODPITest

typedef InstructionSelectorTestWithParam<ODPI> v8::internal::compiler::InstructionSelectorODPITest

Definition at line 504 of file instruction-selector-arm-unittest.cc.

InstructionSelectorOvfAddSubTest

typedef InstructionSelectorTestWithParam<MachInst2> v8::internal::compiler::InstructionSelectorOvfAddSubTest

Definition at line 509 of file instruction-selector-arm64-unittest.cc.

InstructionSelectorPhiTest

typedef InstructionSelectorTestWithParam<MachineType> v8::internal::compiler::InstructionSelectorPhiTest

Definition at line 227 of file instruction-selector-unittest.cc.

InstructionSelectorShiftTest

typedef InstructionSelectorTestWithParam< MachInst2 > v8::internal::compiler::InstructionSelectorShiftTest

Definition at line 987 of file instruction-selector-arm-unittest.cc.

Int32BinopMatcher

typedef BinopMatcher<Int32Matcher, Int32Matcher> v8::internal::compiler::Int32BinopMatcher

Definition at line 136 of file node-matchers.h.

Int32Matcher

typedef IntMatcher<int32_t, IrOpcode::kInt32Constant> v8::internal::compiler::Int32Matcher

Definition at line 79 of file node-matchers.h.

Int32NodeCache

typedef NodeCache<int32_t> v8::internal::compiler::Int32NodeCache

Definition at line 47 of file node-cache.h.

Int64BinopMatcher

typedef BinopMatcher<Int64Matcher, Int64Matcher> v8::internal::compiler::Int64BinopMatcher

Definition at line 138 of file node-matchers.h.

Int64Matcher

typedef IntMatcher<int64_t, IrOpcode::kInt64Constant> v8::internal::compiler::Int64Matcher

Definition at line 81 of file node-matchers.h.

Int64NodeCache

typedef NodeCache<int64_t> v8::internal::compiler::Int64NodeCache

Definition at line 46 of file node-cache.h.

LH

typedef LinkageHelper< X64LinkageHelperTraits > v8::internal::compiler::LH

Definition at line 36 of file linkage-arm.cc.

LoadRepresentation

typedef MachineType v8::internal::compiler::LoadRepresentation

Definition at line 25 of file machine-operator.h.

LocationSignature

typedef Signature<LinkageLocation> v8::internal::compiler::LocationSignature

Definition at line 35 of file linkage.h.

MachineSignature

typedef Signature<MachineType> v8::internal::compiler::MachineSignature

Definition at line 168 of file machine-type.h.

MachineTypeUnion

typedef uint16_t v8::internal::compiler::MachineTypeUnion

Definition at line 59 of file machine-type.h.

MachineUnaryOperatorReducerTest

typedef MachineOperatorReducerTestWithParam<UnaryOperator> v8::internal::compiler::MachineUnaryOperatorReducerTest

Definition at line 229 of file machine-operator-reducer-unittest.cc.

MiscField

typedef BitField<int, 14, 18> v8::internal::compiler::MiscField

Definition at line 113 of file instruction-codes.h.

NodeId

typedef int v8::internal::compiler::NodeId

Definition at line 18 of file generic-node.h.

NodeSet

typedef std::set<Node*, std::less<Node*>, zone_allocator<Node*> > v8::internal::compiler::NodeSet

Definition at line 68 of file node.h.

NodeSetIter

typedef NodeSet::iterator v8::internal::compiler::NodeSetIter

Definition at line 69 of file node.h.

NodeSetRIter

typedef NodeSet::reverse_iterator v8::internal::compiler::NodeSetRIter

Definition at line 70 of file node.h.

NodeVector

typedef ZoneVector<Node*> v8::internal::compiler::NodeVector

Definition at line 72 of file node.h.

NodeVectorConstIter

typedef NodeVector::const_iterator v8::internal::compiler::NodeVectorConstIter

Definition at line 74 of file node.h.

NodeVectorIter

typedef NodeVector::iterator v8::internal::compiler::NodeVectorIter

Definition at line 73 of file node.h.

NodeVectorRIter

typedef NodeVector::reverse_iterator v8::internal::compiler::NodeVectorRIter

Definition at line 75 of file node.h.

NodeVectorVector

typedef ZoneVector<NodeVector> v8::internal::compiler::NodeVectorVector

Definition at line 77 of file node.h.

NodeVectorVectorIter

typedef NodeVectorVector::iterator v8::internal::compiler::NodeVectorVectorIter

Definition at line 78 of file node.h.

NodeVectorVectorRIter

typedef NodeVectorVector::reverse_iterator v8::internal::compiler::NodeVectorVectorRIter

Definition at line 79 of file node.h.

NullBasicBlockVisitor

typedef GenericGraphVisit::NullNodeVisitor<BasicBlockData, BasicBlock> v8::internal::compiler::NullBasicBlockVisitor

Definition at line 147 of file schedule.h.

NullNodeVisitor

typedef GenericGraphVisit::NullNodeVisitor<NodeData, Node> v8::internal::compiler::NullNodeVisitor

Definition at line 66 of file node.h.

NumberMatcher

typedef FloatMatcher<double, IrOpcode::kNumberConstant> v8::internal::compiler::NumberMatcher

Definition at line 95 of file node-matchers.h.

op_iterator

typedef ZoneList<MoveOperands>::iterator v8::internal::compiler::op_iterator

Definition at line 15 of file gap-resolver.cc.

PointerMapDeque

typedef ZoneDeque<PointerMap*> v8::internal::compiler::PointerMapDeque

Definition at line 805 of file instruction.h.

PtrNodeCache

typedef NodeCache<void*> v8::internal::compiler::PtrNodeCache

Definition at line 48 of file node-cache.h.

SimplifiedUnaryOperatorTest

typedef SimplifiedOperatorReducerTestWithParam<UnaryOperator> v8::internal::compiler::SimplifiedUnaryOperatorTest

Definition at line 159 of file simplified-operator-reducer-unittest.cc.

Uint32BinopMatcher

typedef BinopMatcher<Uint32Matcher, Uint32Matcher> v8::internal::compiler::Uint32BinopMatcher

Definition at line 137 of file node-matchers.h.

Uint32Matcher

typedef IntMatcher<uint32_t, IrOpcode::kInt32Constant> v8::internal::compiler::Uint32Matcher

Definition at line 80 of file node-matchers.h.

Uint64BinopMatcher

typedef BinopMatcher<Uint64Matcher, Uint64Matcher> v8::internal::compiler::Uint64BinopMatcher

Definition at line 139 of file node-matchers.h.

Uint64Matcher

typedef IntMatcher<uint64_t, IrOpcode::kInt64Constant> v8::internal::compiler::Uint64Matcher

Definition at line 82 of file node-matchers.h.

UseIter

typedef Node::Uses::iterator v8::internal::compiler::UseIter

Definition at line 81 of file node.h.

Enumeration Type Documentation

AddressingMode

enum v8::internal::compiler::AddressingMode

Enumerator
kLastAddressingMode

Definition at line 59 of file instruction-codes.h.

                    {
#define DECLARE_ADDRESSING_MODE(Name) kMode_##Name,
  ADDRESSING_MODE_LIST(DECLARE_ADDRESSING_MODE)
#undef DECLARE_ADDRESSING_MODE
#define COUNT_ADDRESSING_MODE(Name) +1
  kLastAddressingMode = -1 ADDRESSING_MODE_LIST(COUNT_ADDRESSING_MODE)
#undef COUNT_ADDRESSING_MODE
};

ArchOpcode

enum v8::internal::compiler::ArchOpcode

Enumerator
kLastArchOpcode

Definition at line 40 of file instruction-codes.h.

                {
#define DECLARE_ARCH_OPCODE(Name) k##Name,
  ARCH_OPCODE_LIST(DECLARE_ARCH_OPCODE)
#undef DECLARE_ARCH_OPCODE
#define COUNT_ARCH_OPCODE(Name) +1
  kLastArchOpcode = -1 ARCH_OPCODE_LIST(COUNT_ARCH_OPCODE)
#undef COUNT_ARCH_OPCODE
};

BaseTaggedness

enum v8::internal::compiler::BaseTaggedness

Enumerator
kUntaggedBase
kTaggedBase

Definition at line 29 of file simplified-operator.h.

{ kUntaggedBase, kTaggedBase };

FlagsCondition

enum v8::internal::compiler::FlagsCondition

Enumerator
kEqual
kNotEqual
kSignedLessThan
kSignedGreaterThanOrEqual
kSignedLessThanOrEqual
kSignedGreaterThan
kUnsignedLessThan
kUnsignedGreaterThanOrEqual
kUnsignedLessThanOrEqual
kUnsignedGreaterThan
kUnorderedEqual
kUnorderedNotEqual
kUnorderedLessThan
kUnorderedGreaterThanOrEqual
kUnorderedLessThanOrEqual
kUnorderedGreaterThan
kOverflow
kNotOverflow

Definition at line 76 of file instruction-codes.h.

                    {
  kEqual,
  kNotEqual,
  kSignedLessThan,
  kSignedGreaterThanOrEqual,
  kSignedLessThanOrEqual,
  kSignedGreaterThan,
  kUnsignedLessThan,
  kUnsignedGreaterThanOrEqual,
  kUnsignedLessThanOrEqual,
  kUnsignedGreaterThan,
  kUnorderedEqual,
  kUnorderedNotEqual,
  kUnorderedLessThan,
  kUnorderedGreaterThanOrEqual,
  kUnorderedLessThanOrEqual,
  kUnorderedGreaterThan,
  kOverflow,
  kNotOverflow
};

FlagsMode

enum v8::internal::compiler::FlagsMode

Enumerator
kFlags_none
kFlags_branch
kFlags_set

Definition at line 71 of file instruction-codes.h.

{ kFlags_none = 0, kFlags_branch = 1, kFlags_set = 2 };

FrameStateType

enum v8::internal::compiler::FrameStateType

Enumerator
JS_FRAME
ARGUMENTS_ADAPTOR

Definition at line 36 of file common-operator.h.

                    {
  JS_FRAME,          // Represents an unoptimized JavaScriptFrame.
  ARGUMENTS_ADAPTOR  // Represents an ArgumentsAdaptorFrame.
};

Immediate64Type

enum v8::internal::compiler::Immediate64Type

Enumerator
kImm64Value
kImm64Handle
kImm64Reference

Definition at line 23 of file code-generator-x64.cc.

{ kImm64Value, kImm64Handle, kImm64Reference };

ImmediateMode

enum v8::internal::compiler::ImmediateMode

Enumerator
kArithmeticImm
kShift32Imm
kShift64Imm
kLogical32Imm
kLogical64Imm
kLoadStoreImm8
kLoadStoreImm16
kLoadStoreImm32
kLoadStoreImm64
kNoImmediate

Definition at line 12 of file instruction-selector-arm64.cc.

                   {
  kArithmeticImm,  // 12 bit unsigned immediate shifted left 0 or 12 bits
  kShift32Imm,     // 0 - 31
  kShift64Imm,     // 0 - 63
  kLogical32Imm,
  kLogical64Imm,
  kLoadStoreImm8,   // signed 8 bit or 12 bit unsigned scaled by access size
  kLoadStoreImm16,
  kLoadStoreImm32,
  kLoadStoreImm64,
  kNoImmediate
};

LhsKind

enum v8::internal::compiler::LhsKind

Enumerator
VARIABLE
NAMED_PROPERTY
KEYED_PROPERTY

Definition at line 117 of file ast-graph-builder.cc.

{ VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };

MachineType

enum v8::internal::compiler::MachineType

Enumerator
kRepBit
kRepWord8
kRepWord16
kRepWord32
kRepWord64
kRepFloat32
kRepFloat64
kRepTagged
kTypeBool
kTypeInt32
kTypeUint32
kTypeInt64
kTypeUint64
kTypeNumber
kTypeAny
kMachNone
kMachFloat32
kMachFloat64
kMachInt8
kMachUint8
kMachInt16
kMachUint16
kMachInt32
kMachUint32
kMachInt64
kMachUint64
kMachPtr
kMachAnyTagged

Definition at line 21 of file machine-type.h.

                 {
  // Representations.
  kRepBit = 1 << 0,
  kRepWord8 = 1 << 1,
  kRepWord16 = 1 << 2,
  kRepWord32 = 1 << 3,
  kRepWord64 = 1 << 4,
  kRepFloat32 = 1 << 5,
  kRepFloat64 = 1 << 6,
  kRepTagged = 1 << 7,
 
  // Types.
  kTypeBool = 1 << 8,
  kTypeInt32 = 1 << 9,
  kTypeUint32 = 1 << 10,
  kTypeInt64 = 1 << 11,
  kTypeUint64 = 1 << 12,
  kTypeNumber = 1 << 13,
  kTypeAny = 1 << 14,
 
  // Machine types.
  kMachNone = 0,
  kMachFloat32 = kRepFloat32 | kTypeNumber,
  kMachFloat64 = kRepFloat64 | kTypeNumber,
  kMachInt8 = kRepWord8 | kTypeInt32,
  kMachUint8 = kRepWord8 | kTypeUint32,
  kMachInt16 = kRepWord16 | kTypeInt32,
  kMachUint16 = kRepWord16 | kTypeUint32,
  kMachInt32 = kRepWord32 | kTypeInt32,
  kMachUint32 = kRepWord32 | kTypeUint32,
  kMachInt64 = kRepWord64 | kTypeInt64,
  kMachUint64 = kRepWord64 | kTypeUint64,
  kMachPtr = (kPointerSize == 4) ? kRepWord32 : kRepWord64,
  kMachAnyTagged = kRepTagged | kTypeAny
};

OutputFrameStateCombine

enum v8::internal::compiler::OutputFrameStateCombine

Enumerator
kPushOutput
kIgnoreOutput

Definition at line 29 of file common-operator.h.

                             {
  kPushOutput,   // Push the output on the expression stack.
  kIgnoreOutput  // Use the frame state as-is.
};

Phase

enum v8::internal::compiler::Phase

Enumerator
PROPAGATE
LOWER

Definition at line 31 of file simplified-lowering.cc.

           {
  // 1.) PROPAGATE: Traverse the graph from the end, pushing usage information
  //     backwards from uses to definitions, around cycles in phis, according
  //     to local rules for each operator.
  //     During this phase, the usage information for a node determines the best
  //     possible lowering for each operator so far, and that in turn determines
  //     the output representation.
  //     Therefore, to be correct, this phase must iterate to a fixpoint before
  //     the next phase can begin.
  PROPAGATE,
 
  // 2.) LOWER: perform lowering for all {Simplified} nodes by replacing some
  //     operators for some nodes, expanding some nodes to multiple nodes, or
  //     removing some (redundant) nodes.
  //     During this phase, use the {RepresentationChanger} to insert
  //     representation changes between uses that demand a particular
  //     representation and nodes that produce a different representation.
  LOWER
};

RegisterKind

enum v8::internal::compiler::RegisterKind

Enumerator
UNALLOCATED_REGISTERS
GENERAL_REGISTERS
DOUBLE_REGISTERS

Definition at line 27 of file register-allocator.h.

                  {
  UNALLOCATED_REGISTERS,
  GENERAL_REGISTERS,
  DOUBLE_REGISTERS
};

RegisterOrOperandType

enum v8::internal::compiler::RegisterOrOperandType

Enumerator
kRegister
kDoubleRegister
kOperand

Definition at line 34 of file code-generator-x64.cc.

{ kRegister, kDoubleRegister, kOperand };

WriteBarrierKind

enum v8::internal::compiler::WriteBarrierKind

Enumerator
kNoWriteBarrier
kFullWriteBarrier

Definition at line 20 of file machine-operator.h.

{ kNoWriteBarrier, kFullWriteBarrier };

Function Documentation

AlignedStackSlots()

static int v8::internal::compiler::AlignedStackSlots ( int  stack_slots )

static

Definition at line 678 of file code-generator-arm64.cc.

                                              {
  if (stack_slots & 1) stack_slots++;
  return stack_slots;
}

CheckInputsDominate()

static void v8::internal::compiler::CheckInputsDominate ( Schedule *  schedule, BasicBlock *  block, Node *  node, int  use_pos  )

static

Definition at line 274 of file verifier.cc.

                                                         {
  for (int j = OperatorProperties::GetValueInputCount(node->op()) - 1; j >= 0;
       j--) {
    BasicBlock* use_block = block;
    if (node->opcode() == IrOpcode::kPhi) {
      use_block = use_block->PredecessorAt(j);
      use_pos = static_cast<int>(use_block->nodes_.size()) - 1;
    }
    Node* input = node->InputAt(j);
    if (!HasDominatingDef(schedule, node->InputAt(j), block, use_block,
                          use_pos)) {
      V8_Fatal(__FILE__, __LINE__,
               "Node #%d:%s in B%d is not dominated by input@%d #%d:%s",
               node->id(), node->op()->mnemonic(), block->id(), j, input->id(),
               input->op()->mnemonic());
    }
  }
}

References v8::internal::compiler::OperatorProperties::GetValueInputCount(), HasDominatingDef(), and V8_Fatal().

Referenced by v8::internal::compiler::ScheduleVerifier::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckNoPhis()

static void v8::internal::compiler::CheckNoPhis ( const BasicBlock *  block )

inlinestatic

Definition at line 393 of file instruction-selector.cc.

                                                        {
#ifdef DEBUG
  // Branch targets should not have phis.
  for (BasicBlock::const_iterator i = block->begin(); i != block->end(); ++i) {
    const Node* node = *i;
    CHECK_NE(IrOpcode::kPhi, node->opcode());
  }
#endif
}

References CHECK_NE.

ComputeLoopInfo()

static LoopInfo* v8::internal::compiler::ComputeLoopInfo ( Zone *  zone, SpecialRPOStackFrame *  queue, int  num_loops, int  num_blocks, ZoneList< std::pair< BasicBlock *, int > > *  backedges  )

static

Definition at line 786 of file scheduler.cc.

                                                     {
  LoopInfo* loops = zone->NewArray<LoopInfo>(num_loops);
  memset(loops, 0, num_loops * sizeof(LoopInfo));
 
  // Compute loop membership starting from backedges.
  // O(max(loop_depth) * max(|loop|)
  for (int i = 0; i < backedges->length(); i++) {
    BasicBlock* member = backedges->at(i).first;
    BasicBlock* header = member->SuccessorAt(backedges->at(i).second);
    int loop_num = header->loop_end_;
    if (loops[loop_num].header == NULL) {
      loops[loop_num].header = header;
      loops[loop_num].members = new (zone) BitVector(num_blocks, zone);
    }
 
    int queue_length = 0;
    if (member != header) {
      // As long as the header doesn't have a backedge to itself,
      // Push the member onto the queue and process its predecessors.
      if (!loops[loop_num].members->Contains(member->id())) {
        loops[loop_num].members->Add(member->id());
      }
      queue[queue_length++].block = member;
    }
 
    // Propagate loop membership backwards. All predecessors of M up to the
    // loop header H are members of the loop too. O(|blocks between M and H|).
    while (queue_length > 0) {
      BasicBlock* block = queue[--queue_length].block;
      for (int i = 0; i < block->PredecessorCount(); i++) {
        BasicBlock* pred = block->PredecessorAt(i);
        if (pred != header) {
          if (!loops[loop_num].members->Contains(pred->id())) {
            loops[loop_num].members->Add(pred->id());
            queue[queue_length++].block = pred;
          }
        }
      }
    }
  }
  return loops;
}

References v8::internal::BitVector::Add(), v8::internal::compiler::SpecialRPOStackFrame::block, v8::internal::compiler::LoopInfo::header, v8::internal::compiler::LoopInfo::members, v8::internal::Zone::NewArray(), and NULL.

Referenced by v8::internal::compiler::Scheduler::ComputeSpecialRPO().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeWriteBarrierKind()

static WriteBarrierKind v8::internal::compiler::ComputeWriteBarrierKind ( BaseTaggedness  base_is_tagged, MachineType  representation, Type *  type  )

static

Definition at line 823 of file simplified-lowering.cc.

                                                            {
  // TODO(turbofan): skip write barriers for Smis, etc.
  if (base_is_tagged == kTaggedBase &&
      RepresentationOf(representation) == kRepTagged) {
    // Write barriers are only for writes into heap objects (i.e. tagged base).
    return kFullWriteBarrier;
  }
  return kNoWriteBarrier;
}

References kFullWriteBarrier, kNoWriteBarrier, kRepTagged, kTaggedBase, and RepresentationOf().

Referenced by v8::internal::compiler::SimplifiedLowering::DoStoreElement(), and v8::internal::compiler::SimplifiedLowering::DoStoreField().

Here is the call graph for this function:

Here is the caller graph for this function:

DetermineLhsKind()

static LhsKind v8::internal::compiler::DetermineLhsKind ( Expression *  expr )

static

Definition at line 121 of file ast-graph-builder.cc.

                                                  {
  Property* property = expr->AsProperty();
  DCHECK(expr->IsValidReferenceExpression());
  LhsKind lhs_kind =
      (property == NULL) ? VARIABLE : (property->key()->IsPropertyName())
                                          ? NAMED_PROPERTY
                                          : KEYED_PROPERTY;
  return lhs_kind;
}

References DCHECK, v8::internal::Expression::IsValidReferenceExpression(), KEYED_PROPERTY, NAMED_PROPERTY, NULL, and VARIABLE.

Referenced by v8::internal::compiler::AstGraphBuilder::VisitForInAssignment().

Here is the call graph for this function:

Here is the caller graph for this function:

ElementAccessOf()

const ElementAccess & v8::internal::compiler::ElementAccessOf

(

const Operator *

op

)

Definition at line 56 of file simplified-operator.cc.

                                                         {
  DCHECK_NOT_NULL(op);
  DCHECK(op->opcode() == IrOpcode::kLoadElement ||
         op->opcode() == IrOpcode::kStoreElement);
  return OpParameter<ElementAccess>(op);
}

References DCHECK, DCHECK_NOT_NULL, and v8::internal::compiler::Operator::opcode().

Referenced by v8::internal::compiler::SimplifiedLowering::DoLoadElement(), v8::internal::compiler::SimplifiedLowering::DoStoreElement(), TEST_P(), and v8::internal::compiler::RepresentationSelector::VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

ElementSizeOf()

int v8::internal::compiler::ElementSizeOf ( MachineType  machine_type )

inline

Definition at line 83 of file machine-type.h.

                                                   {
  switch (RepresentationOf(machine_type)) {
    case kRepBit:
    case kRepWord8:
      return 1;
    case kRepWord16:
      return 2;
    case kRepWord32:
    case kRepFloat32:
      return 4;
    case kRepWord64:
    case kRepFloat64:
      return 8;
    case kRepTagged:
      return kPointerSize;
    default:
      UNREACHABLE();
      return kPointerSize;
  }
}

References v8::internal::kPointerSize, kRepBit, kRepFloat32, kRepFloat64, kRepTagged, kRepWord16, kRepWord32, kRepWord64, kRepWord8, RepresentationOf(), and UNREACHABLE.

Referenced by v8::internal::compiler::SimplifiedLowering::ComputeIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

EmitBic()

static void v8::internal::compiler::EmitBic ( InstructionSelector *  selector, Node *  node, Node *  left, Node *  right  )

inlinestatic

Definition at line 382 of file instruction-selector-arm.cc.

                                                    {
  ArmOperandGenerator g(selector);
  InstructionCode opcode = kArmBic;
  InstructionOperand* value_operand;
  InstructionOperand* shift_operand;
  if (TryMatchShift(selector, &opcode, right, &value_operand, &shift_operand)) {
    selector->Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
                   value_operand, shift_operand);
    return;
  }
  selector->Emit(opcode | AddressingModeField::encode(kMode_Operand2_R),
                 g.DefineAsRegister(node), g.UseRegister(left),
                 g.UseRegister(right));
}

References v8::internal::compiler::OperandGenerator::DefineAsRegister(), v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), TryMatchShift(), and v8::internal::compiler::OperandGenerator::UseRegister().

Here is the call graph for this function:

EmitDiv()

static void v8::internal::compiler::EmitDiv ( InstructionSelector *  selector, ArchOpcode  div_opcode, ArchOpcode  f64i32_opcode, ArchOpcode  i32f64_opcode, InstructionOperand *  result_operand, InstructionOperand *  left_operand, InstructionOperand *  right_operand  )

static

Definition at line 614 of file instruction-selector-arm.cc.

                                                       {
  ArmOperandGenerator g(selector);
  if (selector->IsSupported(SUDIV)) {
    selector->Emit(div_opcode, result_operand, left_operand, right_operand);
    return;
  }
  InstructionOperand* left_double_operand = g.TempDoubleRegister();
  InstructionOperand* right_double_operand = g.TempDoubleRegister();
  InstructionOperand* result_double_operand = g.TempDoubleRegister();
  selector->Emit(f64i32_opcode, left_double_operand, left_operand);
  selector->Emit(f64i32_opcode, right_double_operand, right_operand);
  selector->Emit(kArmVdivF64, result_double_operand, left_double_operand,
                 right_double_operand);
  selector->Emit(i32f64_opcode, result_operand, result_double_operand);
}

References v8::internal::SUDIV, and v8::internal::compiler::OperandGenerator::TempDoubleRegister().

Referenced by VisitDiv(), and VisitMod().

Here is the call graph for this function:

Here is the caller graph for this function:

FieldAccessOf()

const FieldAccess & v8::internal::compiler::FieldAccessOf

(

const Operator *

op

)

Definition at line 48 of file simplified-operator.cc.

                                                     {
  DCHECK_NOT_NULL(op);
  DCHECK(op->opcode() == IrOpcode::kLoadField ||
         op->opcode() == IrOpcode::kStoreField);
  return OpParameter<FieldAccess>(op);
}

References DCHECK, DCHECK_NOT_NULL, and v8::internal::compiler::Operator::opcode().

Referenced by v8::internal::compiler::SimplifiedLowering::DoLoadField(), v8::internal::compiler::SimplifiedLowering::DoStoreField(), and v8::internal::compiler::RepresentationSelector::VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

FindInsertionPoint()

static NodeVector::iterator v8::internal::compiler::FindInsertionPoint ( NodeVector *  nodes )

static

Definition at line 18 of file basic-block-instrumentor.cc.

                                                                {
  NodeVector::iterator i = nodes->begin();
  for (; i != nodes->end(); ++i) {
    const Operator* op = (*i)->op();
    if (OperatorProperties::IsBasicBlockBegin(op)) continue;
    switch (op->opcode()) {
      case IrOpcode::kParameter:
      case IrOpcode::kPhi:
      case IrOpcode::kEffectPhi:
        continue;
    }
    break;
  }
  return i;
}

References v8::internal::compiler::OperatorProperties::IsBasicBlockBegin(), and v8::internal::compiler::Operator::opcode().

Referenced by v8::internal::compiler::BasicBlockInstrumentor::Instrument().

Here is the call graph for this function:

Here is the caller graph for this function:

FinishCode()

static void v8::internal::compiler::FinishCode ( MacroAssembler *  masm )

inlinestatic

Definition at line 122 of file code-generator-impl.h.

                                                    {
#if V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_ARM
  masm->CheckConstPool(true, false);
#endif
}

References v8::internal::Assembler::CheckConstPool().

Here is the call graph for this function:

FlagsForNode()

static CallDescriptor::Flags v8::internal::compiler::FlagsForNode ( Node *  node )

static

Definition at line 134 of file js-generic-lowering.cc.

                                                    {
  CallDescriptor::Flags result = CallDescriptor::kNoFlags;
  if (OperatorProperties::HasFrameStateInput(node->op())) {
    result |= CallDescriptor::kNeedsFrameState;
  }
  return result;
}

References v8::internal::compiler::OperatorProperties::HasFrameStateInput().

Referenced by v8::internal::compiler::JSGenericLowering::ReplaceWithCompareIC(), and v8::internal::compiler::JSGenericLowering::ReplaceWithStubCall().

Here is the call graph for this function:

Here is the caller graph for this function:

GetControlCluster()

static Node* v8::internal::compiler::GetControlCluster ( Node *  node )

static

Definition at line 184 of file graph-visualizer.cc.

                                           {
  if (OperatorProperties::IsBasicBlockBegin(node->op())) {
    return node;
  } else if (OperatorProperties::GetControlInputCount(node->op()) == 1) {
    Node* control = NodeProperties::GetControlInput(node, 0);
    return OperatorProperties::IsBasicBlockBegin(control->op()) ? control
                                                                : NULL;
  } else {
    return NULL;
  }
}

References v8::internal::compiler::NodeProperties::GetControlInput(), v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::OperatorProperties::IsBasicBlockBegin(), and NULL.

Referenced by v8::internal::compiler::GraphVisualizer::AnnotateNode(), v8::internal::compiler::GraphVisualizer::Pre(), and v8::internal::compiler::GraphVisualizer::PrintEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

HasDominatingDef()

static bool v8::internal::compiler::HasDominatingDef ( Schedule *  schedule, Node *  node, BasicBlock *  container, BasicBlock *  use_block, int  use_pos  )

static

Definition at line 256 of file verifier.cc.

                                          {
  BasicBlock* block = use_block;
  while (true) {
    while (use_pos >= 0) {
      if (block->nodes_[use_pos] == node) return true;
      use_pos--;
    }
    block = block->dominator_;
    if (block == NULL) break;
    use_pos = static_cast<int>(block->nodes_.size()) - 1;
    if (node == block->control_input_) return true;
  }
  return false;
}

References NULL.

Referenced by CheckInputsDominate().

Here is the caller graph for this function:

HasImmediateInput() [1/2]

static bool v8::internal::compiler::HasImmediateInput ( Instruction *  instr, int  index  )

static

Definition at line 165 of file code-generator-ia32.cc.

                                                             {
  return instr->InputAt(index)->IsImmediate();
}

References v8::internal::compiler::Instruction::InputAt().

Here is the call graph for this function:

HasImmediateInput() [2/2]

static bool v8::internal::compiler::HasImmediateInput ( Instruction *  instr, int  index  )

static

Definition at line 230 of file code-generator-x64.cc.

                                                             {
  return instr->InputAt(index)->IsImmediate();
}

References v8::internal::compiler::Instruction::InputAt().

Here is the call graph for this function:

INSTANTIATE_TEST_CASE_P() [1/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	ChangeLoweringTest	,
		ChangeLoweringCommonTest	,
		::testing::Values(kRepWord32, kRepWord64)
	)

INSTANTIATE_TEST_CASE_P() [2/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	CommonOperatorTest	,
		CommonSharedOperatorTest	,
		::testing::ValuesIn(kSharedOperators)
	)

INSTANTIATE_TEST_CASE_P() [3/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorAddSubTest	,
		::testing::ValuesIn(kAddSubInstructions)
	)

INSTANTIATE_TEST_CASE_P() [4/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorComparisonTest	,
		::testing::ValuesIn(kComparisonInstructions)
	)

INSTANTIATE_TEST_CASE_P() [5/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorConversionTest	,
		::testing::ValuesIn(kConversionInstructions)
	)

INSTANTIATE_TEST_CASE_P() [6/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorDPFlagSetTest	,
		::testing::ValuesIn(kDPFlagSetInstructions)
	)

INSTANTIATE_TEST_CASE_P() [7/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorDPITest	,
		::testing::ValuesIn(kDPIs)
	)

INSTANTIATE_TEST_CASE_P() [8/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorFPArithTest	,
		::testing::ValuesIn(kFPArithInstructions)
	)

INSTANTIATE_TEST_CASE_P() [9/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorFPCmpTest	,
		::testing::ValuesIn(kFPCmpInstructions)
	)

INSTANTIATE_TEST_CASE_P() [10/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorIntDPWithIntMulTest	,
		::testing::ValuesIn(kMulDPInstructions)
	)

INSTANTIATE_TEST_CASE_P() [11/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorLogicalTest	,
		::testing::ValuesIn(kLogicalInstructions)
	)

INSTANTIATE_TEST_CASE_P() [12/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorLogicalWithNotRHSTest	,
		::testing::ValuesIn(kLogicalWithNotRHSs)
	)

INSTANTIATE_TEST_CASE_P() [13/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorMemoryAccessTest	,
		::testing::ValuesIn(kMemoryAccesses)
	)

INSTANTIATE_TEST_CASE_P() [14/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorMulDivTest	,
		::testing::ValuesIn(kMulDivInstructions)
	)

INSTANTIATE_TEST_CASE_P() [15/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorODPITest	,
		::testing::ValuesIn(kODPIs)
	)

INSTANTIATE_TEST_CASE_P() [16/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorOvfAddSubTest	,
		::testing::ValuesIn(kOvfAddSubInstructions)
	)

INSTANTIATE_TEST_CASE_P() [17/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorPhiTest	,
		::testing::Values(kMachFloat64, kMachInt8, kMachUint8, kMachInt16, kMachUint16, kMachInt32, kMachUint32, kMachInt64, kMachUint64, kMachPtr, kMachAnyTagged)
	)

INSTANTIATE_TEST_CASE_P() [18/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorShiftTest	,
		::testing::ValuesIn(kShiftInstructions)
	)

INSTANTIATE_TEST_CASE_P() [19/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	InstructionSelectorTest	,
		InstructionSelectorShiftTest	,
		::testing::ValuesIn(kShifts)
	)

INSTANTIATE_TEST_CASE_P() [20/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	MachineOperatorReducerTest	,
		MachineUnaryOperatorReducerTest	,
		::testing::ValuesIn(kUnaryOperators)
	)

INSTANTIATE_TEST_CASE_P() [21/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	SimplifiedOperatorReducerTest	,
		SimplifiedUnaryOperatorTest	,
		::testing::ValuesIn(kUnaryOperators)
	)

INSTANTIATE_TEST_CASE_P() [22/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	SimplifiedOperatorTest	,
		SimplifiedElementAccessOperatorTest	,
		::testing::ValuesIn(kElementAccesses)
	)

INSTANTIATE_TEST_CASE_P() [23/23]

v8::internal::compiler::INSTANTIATE_TEST_CASE_P	(	SimplifiedOperatorTest	,
		SimplifiedPureOperatorTest	,
		::testing::ValuesIn(kPureOperators)
	)

IsBranch()

Matcher< Node * > v8::internal::compiler::IsBranch	(	const Matcher< Node * > &	value_matcher,
		const Matcher< Node * > &	control_matcher
	)

Definition at line 606 of file graph-unittest.cc.

                                                               {
  return MakeMatcher(new IsBranchMatcher(value_matcher, control_matcher));
}

Referenced by v8::internal::compiler::FINAL< kOperandKind, kNumCachedOperands >::false_block(), TARGET_TEST_F(), TARGET_TEST_P(), TEST_F(), and v8::internal::compiler::FINAL< kOperandKind, kNumCachedOperands >::true_block().

Here is the caller graph for this function:

IsCall()

Matcher< Node * > v8::internal::compiler::IsCall	(	const Matcher< CallDescriptor * > &	descriptor_matcher,
		const Matcher< Node * > &	value0_matcher,
		const Matcher< Node * > &	value1_matcher,
		const Matcher< Node * > &	value2_matcher,
		const Matcher< Node * > &	value3_matcher,
		const Matcher< Node * > &	effect_matcher,
		const Matcher< Node * > &	control_matcher
	)

Definition at line 705 of file graph-unittest.cc.

                                                             {
  return MakeMatcher(new IsCallMatcher(
      descriptor_matcher, value0_matcher, value1_matcher, value2_matcher,
      value3_matcher, effect_matcher, control_matcher));
}

Referenced by v8::internal::compiler::ChangeLoweringTest::IsAllocateHeapNumber().

Here is the caller graph for this function:

IsChangeFloat64ToInt32()

Matcher<Node*> v8::internal::compiler::IsChangeFloat64ToInt32

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F(), and TEST_F().

Here is the caller graph for this function:

IsChangeFloat64ToUint32()

Matcher<Node*> v8::internal::compiler::IsChangeFloat64ToUint32

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F(), and TEST_F().

Here is the caller graph for this function:

IsChangeInt32ToFloat64()

Matcher<Node*> v8::internal::compiler::IsChangeInt32ToFloat64

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F(), and TEST_F().

Here is the caller graph for this function:

IsChangeInt32ToInt64()

Matcher<Node*> v8::internal::compiler::IsChangeInt32ToInt64

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsChangeUint32ToFloat64()

Matcher<Node*> v8::internal::compiler::IsChangeUint32ToFloat64

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F(), and TEST_F().

Here is the caller graph for this function:

IsChangeUint32ToUint64()

Matcher<Node*> v8::internal::compiler::IsChangeUint32ToUint64

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsControlEffect()

Matcher< Node * > v8::internal::compiler::IsControlEffect

(

const Matcher< Node * > &

control_matcher

)

Definition at line 629 of file graph-unittest.cc.

                                                                      {
  return MakeMatcher(
      new IsControl1Matcher(IrOpcode::kControlEffect, control_matcher));
}

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsDefUseChainLinkPresent()

static bool v8::internal::compiler::IsDefUseChainLinkPresent ( Node *  def, Node *  use  )

static

Definition at line 28 of file verifier.cc.

                                                           {
  Node::Uses uses = def->uses();
  for (Node::Uses::iterator it = uses.begin(); it != uses.end(); ++it) {
    if (*it == use) return true;
  }
  return false;
}

References use().

Referenced by v8::internal::compiler::Verifier::Visitor::Pre().

Here is the call graph for this function:

Here is the caller graph for this function:

IsExternalConstant()

Matcher< Node * > v8::internal::compiler::IsExternalConstant

(

const Matcher< ExternalReference > &

value_matcher

)

Definition at line 646 of file graph-unittest.cc.

                                                     {
  return MakeMatcher(new IsConstantMatcher<ExternalReference>(
      IrOpcode::kExternalConstant, value_matcher));
}

Referenced by v8::internal::compiler::ChangeLoweringTest::IsAllocateHeapNumber().

Here is the caller graph for this function:

IsFinish()

Matcher< Node * > v8::internal::compiler::IsFinish	(	const Matcher< Node * > &	value_matcher,
		const Matcher< Node * > &	effect_matcher
	)

Definition at line 640 of file graph-unittest.cc.

                                                              {
  return MakeMatcher(new IsFinishMatcher(value_matcher, effect_matcher));
}

Referenced by TARGET_TEST_F(), and TARGET_TEST_P().

Here is the caller graph for this function:

IsFloat32Constant()

Matcher< Node * > v8::internal::compiler::IsFloat32Constant

(

const Matcher< float > &

value_matcher

)

Definition at line 672 of file graph-unittest.cc.

                                                                      {
  return MakeMatcher(
      new IsConstantMatcher<float>(IrOpcode::kFloat32Constant, value_matcher));
}

Referenced by TEST_F().

Here is the caller graph for this function:

IsFloat64Constant()

Matcher< Node * > v8::internal::compiler::IsFloat64Constant

(

const Matcher< double > &

value_matcher

)

Definition at line 678 of file graph-unittest.cc.

                                                                       {
  return MakeMatcher(
      new IsConstantMatcher<double>(IrOpcode::kFloat64Constant, value_matcher));
}

Referenced by TEST_F().

Here is the caller graph for this function:

IsFloat64Sqrt()

Matcher<Node*> v8::internal::compiler::IsFloat64Sqrt

(

const Matcher< Node * > &

input_matcher

)

Referenced by TEST_F().

Here is the caller graph for this function:

IsHeapConstant()

Matcher< Node * > v8::internal::compiler::IsHeapConstant

(

const Matcher< Unique< HeapObject > > &

value_matcher

)

Definition at line 653 of file graph-unittest.cc.

                                                       {
  return MakeMatcher(new IsConstantMatcher<Unique<HeapObject> >(
      IrOpcode::kHeapConstant, value_matcher));
}

Referenced by v8::internal::compiler::ChangeLoweringTest::IsAllocateHeapNumber(), v8::internal::compiler::GraphTest::IsFalseConstant(), and v8::internal::compiler::GraphTest::IsTrueConstant().

Here is the caller graph for this function:

IsIfFalse()

Matcher< Node * > v8::internal::compiler::IsIfFalse

(

const Matcher< Node * > &

control_matcher

)

Definition at line 623 of file graph-unittest.cc.

                                                                {
  return MakeMatcher(
      new IsControl1Matcher(IrOpcode::kIfFalse, control_matcher));
}

Referenced by TARGET_TEST_F(), TARGET_TEST_P(), and TEST_F().

Here is the caller graph for this function:

IsIfTrue()

Matcher< Node * > v8::internal::compiler::IsIfTrue

(

const Matcher< Node * > &

control_matcher

)

Definition at line 618 of file graph-unittest.cc.

                                                               {
  return MakeMatcher(new IsControl1Matcher(IrOpcode::kIfTrue, control_matcher));
}

Referenced by TARGET_TEST_F(), TARGET_TEST_P(), and TEST_F().

Here is the caller graph for this function:

IsInt32AddWithOverflow()

Matcher<Node*> v8::internal::compiler::IsInt32AddWithOverflow	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsInt32Constant()

Matcher< Node * > v8::internal::compiler::IsInt32Constant

(

const Matcher< int32_t > &

value_matcher

)

Definition at line 660 of file graph-unittest.cc.

                                                                      {
  return MakeMatcher(
      new IsConstantMatcher<int32_t>(IrOpcode::kInt32Constant, value_matcher));
}

Referenced by v8::internal::compiler::ChangeLoweringTest::IsAllocateHeapNumber(), TARGET_TEST_F(), TARGET_TEST_P(), and TEST_F().

Here is the caller graph for this function:

IsInt32Mul()

Matcher<Node*> v8::internal::compiler::IsInt32Mul	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TEST_F().

Here is the caller graph for this function:

IsInt64Constant()

Matcher< Node * > v8::internal::compiler::IsInt64Constant

(

const Matcher< int64_t > &

value_matcher

)

Definition at line 666 of file graph-unittest.cc.

                                                                      {
  return MakeMatcher(
      new IsConstantMatcher<int64_t>(IrOpcode::kInt64Constant, value_matcher));
}

Referenced by TEST_F().

Here is the caller graph for this function:

IsLikelyBackEdge()

static bool v8::internal::compiler::IsLikelyBackEdge ( Node *  from, int  index, Node *  to  )

static

Definition at line 225 of file graph-visualizer.cc.

                                                              {
  if (from->opcode() == IrOpcode::kPhi ||
      from->opcode() == IrOpcode::kEffectPhi) {
    Node* control = NodeProperties::GetControlInput(from, 0);
    return control->opcode() != IrOpcode::kMerge && control != to && index != 0;
  } else if (from->opcode() == IrOpcode::kLoop) {
    return index != 0;
  } else {
    return false;
  }
}

References v8::internal::compiler::NodeProperties::GetControlInput(), and to().

Referenced by v8::internal::compiler::GraphVisualizer::PrintEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

IsLoad()

Matcher< Node * > v8::internal::compiler::IsLoad	(	const Matcher< LoadRepresentation > &	rep_matcher,
		const Matcher< Node * > &	base_matcher,
		const Matcher< Node * > &	index_matcher,
		const Matcher< Node * > &	effect_matcher
	)

Definition at line 718 of file graph-unittest.cc.

                                                            {
  return MakeMatcher(new IsLoadMatcher(rep_matcher, base_matcher, index_matcher,
                                       effect_matcher));
}

Referenced by v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::CanAccessAsMonomorphic(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::CanAccessMonomorphic(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::LoadResult(), and TARGET_TEST_F().

Here is the caller graph for this function:

IsMerge()

Matcher< Node * > v8::internal::compiler::IsMerge	(	const Matcher< Node * > &	control0_matcher,
		const Matcher< Node * > &	control1_matcher
	)

Definition at line 612 of file graph-unittest.cc.

                                                               {
  return MakeMatcher(new IsMergeMatcher(control0_matcher, control1_matcher));
}

Referenced by TARGET_TEST_F(), TARGET_TEST_P(), and TEST_F().

Here is the caller graph for this function:

IsNumberConstant()

Matcher< Node * > v8::internal::compiler::IsNumberConstant

(

const Matcher< double > &

value_matcher

)

Definition at line 684 of file graph-unittest.cc.

                                                                      {
  return MakeMatcher(
      new IsConstantMatcher<double>(IrOpcode::kNumberConstant, value_matcher));
}

Referenced by v8::internal::compiler::ChangeLoweringTest::IsAllocateHeapNumber(), and TEST_F().

Here is the caller graph for this function:

IsNumberLessThan()

Matcher<Node*> v8::internal::compiler::IsNumberLessThan	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TEST_F().

Here is the caller graph for this function:

IsNumberSubtract()

Matcher<Node*> v8::internal::compiler::IsNumberSubtract	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TEST_F().

Here is the caller graph for this function:

IsPhi()

Matcher< Node * > v8::internal::compiler::IsPhi	(	const Matcher< MachineType > &	type_matcher,
		const Matcher< Node * > &	value0_matcher,
		const Matcher< Node * > &	value1_matcher,
		const Matcher< Node * > &	merge_matcher
	)

Definition at line 690 of file graph-unittest.cc.

                                                          {
  return MakeMatcher(new IsPhiMatcher(type_matcher, value0_matcher,
                                      value1_matcher, merge_matcher));
}

Referenced by TARGET_TEST_F(), TARGET_TEST_P(), and TEST_F().

Here is the caller graph for this function:

IsProjection()

Matcher< Node * > v8::internal::compiler::IsProjection	(	const Matcher< size_t > &	index_matcher,
		const Matcher< Node * > &	base_matcher
	)

Definition at line 699 of file graph-unittest.cc.

                                                                {
  return MakeMatcher(new IsProjectionMatcher(index_matcher, base_matcher));
}

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsStore()

Matcher< Node * > v8::internal::compiler::IsStore	(	const Matcher< MachineType > &	type_matcher,
		const Matcher< WriteBarrierKind > &	write_barrier_matcher,
		const Matcher< Node * > &	base_matcher,
		const Matcher< Node * > &	index_matcher,
		const Matcher< Node * > &	value_matcher,
		const Matcher< Node * > &	effect_matcher,
		const Matcher< Node * > &	control_matcher
	)

Definition at line 727 of file graph-unittest.cc.

                                                              {
  return MakeMatcher(new IsStoreMatcher(
      type_matcher, write_barrier_matcher, base_matcher, index_matcher,
      value_matcher, effect_matcher, control_matcher));
}

Referenced by TARGET_TEST_F(), and TARGET_TEST_P().

Here is the caller graph for this function:

IsTruncateFloat64ToFloat32()

Matcher<Node*> v8::internal::compiler::IsTruncateFloat64ToFloat32

(

const Matcher< Node * > &

input_matcher

)

Referenced by TEST_F().

Here is the caller graph for this function:

IsTruncateFloat64ToInt32()

Matcher<Node*> v8::internal::compiler::IsTruncateFloat64ToInt32

(

const Matcher< Node * > &

input_matcher

)

IsTruncateInt64ToInt32()

Matcher<Node*> v8::internal::compiler::IsTruncateInt64ToInt32

(

const Matcher< Node * > &

input_matcher

)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsUint32LessThanOrEqual()

Matcher<Node*> v8::internal::compiler::IsUint32LessThanOrEqual	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsUseDefChainLinkPresent()

static bool v8::internal::compiler::IsUseDefChainLinkPresent ( Node *  def, Node *  use  )

static

Definition at line 37 of file verifier.cc.

                                                           {
  Node::Inputs inputs = use->inputs();
  for (Node::Inputs::iterator it = inputs.begin(); it != inputs.end(); ++it) {
    if (*it == def) return true;
  }
  return false;
}

References use().

Referenced by v8::internal::compiler::Verifier::Visitor::Pre().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValueEffect()

Matcher< Node * > v8::internal::compiler::IsValueEffect

(

const Matcher< Node * > &

value_matcher

)

Definition at line 635 of file graph-unittest.cc.

                                                                  {
  return MakeMatcher(new IsUnopMatcher(IrOpcode::kValueEffect, value_matcher));
}

Referenced by TARGET_TEST_P().

Here is the caller graph for this function:

IsWord32And()

Matcher<Node*> v8::internal::compiler::IsWord32And	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F(), and TEST_F().

Here is the caller graph for this function:

IsWord32Equal()

Matcher<Node*> v8::internal::compiler::IsWord32Equal	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by v8::internal::compiler::ChangeLoweringTest::IsWordEqual().

Here is the caller graph for this function:

IsWord32Ror()

Matcher<Node*> v8::internal::compiler::IsWord32Ror	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TEST_F().

Here is the caller graph for this function:

IsWord32Sar()

Matcher<Node*> v8::internal::compiler::IsWord32Sar	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsWord32Shl()

Matcher<Node*> v8::internal::compiler::IsWord32Shl	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsWord64And()

Matcher<Node*> v8::internal::compiler::IsWord64And	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsWord64Equal()

Matcher<Node*> v8::internal::compiler::IsWord64Equal	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by v8::internal::compiler::ChangeLoweringTest::IsWordEqual().

Here is the caller graph for this function:

IsWord64Sar()

Matcher<Node*> v8::internal::compiler::IsWord64Sar	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

IsWord64Shl()

Matcher<Node*> v8::internal::compiler::IsWord64Shl	(	const Matcher< Node * > &	lhs_matcher,
		const Matcher< Node * > &	rhs_matcher
	)

Referenced by TARGET_TEST_F().

Here is the caller graph for this function:

Max()

static LifetimePosition v8::internal::compiler::Max ( LifetimePosition  a, LifetimePosition  b  )

inlinestatic

Definition at line 20 of file register-allocator.cc.

                                                                           {
  return a.Value() > b.Value() ? a : b;
}

References v8::internal::compiler::LifetimePosition::Value().

Referenced by v8::internal::compiler::LiveRange::AddUseInterval(), v8::ResourceConstraints::ConfigureDefaults(), v8::EmbedderDataFor(), and v8::internal::TypeImpl< Config >::Max().

Here is the call graph for this function:

Here is the caller graph for this function:

Min()

static LifetimePosition v8::internal::compiler::Min ( LifetimePosition  a, LifetimePosition  b  )

inlinestatic

Definition at line 15 of file register-allocator.cc.

                                                                           {
  return a.Value() < b.Value() ? a : b;
}

References v8::internal::compiler::LifetimePosition::Value().

Referenced by v8::internal::compiler::LiveRange::AddUseInterval(), v8::ResourceConstraints::ConfigureDefaults(), v8::internal::TypeImpl< Config >::Min(), and v8::internal::compiler::LiveRange::SetSpillStartIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

NodeCacheHash() [1/5]

template<>

int32_t v8::internal::compiler::NodeCacheHash ( double  key )

inline

Definition at line 33 of file node-cache.cc.

                                         {
  return ComputeLongHash(bit_cast<int64_t>(key));
}

References v8::internal::ComputeLongHash().

Here is the call graph for this function:

NodeCacheHash() [2/5]

template<>

int32_t v8::internal::compiler::NodeCacheHash ( int32_t  key )

inline

Definition at line 21 of file node-cache.cc.

                                          {
  return ComputeIntegerHash(key, 0);
}

References v8::internal::ComputeIntegerHash().

Here is the call graph for this function:

NodeCacheHash() [3/5]

template<>

int32_t v8::internal::compiler::NodeCacheHash ( int64_t  key )

inline

Definition at line 27 of file node-cache.cc.

                                          {
  return ComputeLongHash(key);
}

References v8::internal::ComputeLongHash().

Here is the call graph for this function:

NodeCacheHash() [4/5]

template<typename Key >

int32_t v8::internal::compiler::NodeCacheHash

(

Key

key

)

Definition at line 15 of file node-cache.cc.

                               {
  UNIMPLEMENTED();
  return 0;
}

References UNIMPLEMENTED.

Referenced by v8::internal::compiler::NodeCache< Key >::Find(), and v8::internal::compiler::NodeCache< Key >::Resize().

Here is the caller graph for this function:

NodeCacheHash() [5/5]

template<>

int32_t v8::internal::compiler::NodeCacheHash ( void *  key )

inline

Definition at line 39 of file node-cache.cc.

                                        {
  return ComputePointerHash(key);
}

References v8::internal::ComputePointerHash().

Here is the call graph for this function:

NodeIdIsLessThan()

static bool v8::internal::compiler::NodeIdIsLessThan ( const Node *  node, NodeId  id  )

static

Definition at line 19 of file graph-reducer.cc.

                                                          {
  return node->id() < id;
}

operator!=() [1/3]

bool v8::internal::compiler::operator!= ( const SourcePosition &  lhs, const SourcePosition &  rhs  )

inline

Definition at line 41 of file source-position.h.

                                                                             {
  return !(lhs == rhs);
}

operator!=() [2/3]

bool v8::internal::compiler::operator!= ( const StoreRepresentation &  rep1, const StoreRepresentation &  rep2  )

inline

Definition at line 50 of file machine-operator.h.

                                                        {
  return !(rep1 == rep2);
}

operator!=() [3/3]

bool v8::internal::compiler::operator!=	(	ElementAccess const &	lhs,
		ElementAccess const &	rhs
	)

Definition at line 35 of file simplified-operator.cc.

                                                                    {
  return !(lhs == rhs);
}

operator<<() [1/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		BaseTaggedness	base_taggedness
	)

Definition at line 16 of file simplified-operator.cc.

                                                                 {
  switch (base_taggedness) {
    case kUntaggedBase:
      return os << "untagged base";
    case kTaggedBase:
      return os << "tagged base";
  }
  UNREACHABLE();
  return os;
}

References kTaggedBase, kUntaggedBase, and UNREACHABLE.

operator<<() [2/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const AddressingMode &	am
	)

Definition at line 180 of file instruction.cc.

                                                           {
  switch (am) {
    case kMode_None:
      return os;
#define CASE(Name)   \
  case kMode_##Name: \
    return os << #Name;
      TARGET_ADDRESSING_MODE_LIST(CASE)
#undef CASE
  }
  UNREACHABLE();
  return os;
}

References CASE, TARGET_ADDRESSING_MODE_LIST, and UNREACHABLE.

operator<<() [3/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const ArchOpcode &	ao
	)

Definition at line 167 of file instruction.cc.

                                                       {
  switch (ao) {
#define CASE(Name) \
  case k##Name:    \
    return os << #Name;
    ARCH_OPCODE_LIST(CASE)
#undef CASE
  }
  UNREACHABLE();
  return os;
}

References ARCH_OPCODE_LIST, CASE, and UNREACHABLE.

operator<<() [4/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const AsDOT &	ad
	)

Definition at line 380 of file graph-visualizer.cc.

                                                  {
  Zone tmp_zone(ad.graph.zone()->isolate());
  GraphVisualizer(os, &tmp_zone, &ad.graph).Print();
  return os;
}

References v8::internal::compiler::AsDOT::graph, v8::internal::Zone::isolate(), v8::internal::compiler::GraphVisualizer::Print(), and v8::internal::compiler::GenericGraphBase::zone().

Here is the call graph for this function:

operator<<() [5/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const AsJSON &	ad
	)

Definition at line 149 of file graph-visualizer.cc.

                                                   {
  Zone tmp_zone(ad.graph.zone()->isolate());
  os << "{\"nodes\":[";
  JSONGraphNodeWriter(os, &tmp_zone, &ad.graph).Print();
  os << "],\"edges\":[";
  JSONGraphEdgeWriter(os, &tmp_zone, &ad.graph).Print();
  os << "]}";
  return os;
}

References v8::internal::compiler::AsJSON::graph, v8::internal::Zone::isolate(), v8::internal::compiler::JSONGraphNodeWriter::Print(), v8::internal::compiler::JSONGraphEdgeWriter::Print(), and v8::internal::compiler::GenericGraphBase::zone().

Here is the call graph for this function:

operator<<() [6/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const BasicBlockData::Control &	c
	)

Definition at line 15 of file schedule.cc.

                                                                 {
  switch (c) {
    case BasicBlockData::kNone:
      return os << "none";
    case BasicBlockData::kGoto:
      return os << "goto";
    case BasicBlockData::kBranch:
      return os << "branch";
    case BasicBlockData::kReturn:
      return os << "return";
    case BasicBlockData::kThrow:
      return os << "throw";
  }
  UNREACHABLE();
  return os;
}

References v8::internal::compiler::BasicBlockData::kBranch, v8::internal::compiler::BasicBlockData::kGoto, v8::internal::compiler::BasicBlockData::kNone, v8::internal::compiler::BasicBlockData::kReturn, v8::internal::compiler::BasicBlockData::kThrow, and UNREACHABLE.

operator<<() [7/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const CallDescriptor &	d
	)

Definition at line 34 of file linkage.cc.

                                                          {
  // TODO(svenpanne) Output properties etc. and be less cryptic.
  return os << d.kind() << ":" << d.debug_name() << ":r" << d.ReturnCount()
            << "j" << d.JSParameterCount() << "i" << d.InputCount() << "f"
            << d.FrameStateCount();
}

operator<<() [8/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const CallDescriptor::Kind &	k
	)

Definition at line 18 of file linkage.cc.

                                                              {
  switch (k) {
    case CallDescriptor::kCallCodeObject:
      os << "Code";
      break;
    case CallDescriptor::kCallJSFunction:
      os << "JS";
      break;
    case CallDescriptor::kCallAddress:
      os << "Addr";
      break;
  }
  return os;
}

operator<<() [9/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const Constant &	constant
	)

Definition at line 297 of file instruction.cc.

                                                           {
  switch (constant.type()) {
    case Constant::kInt32:
      return os << constant.ToInt32();
    case Constant::kInt64:
      return os << constant.ToInt64() << "l";
    case Constant::kFloat32:
      return os << constant.ToFloat32() << "f";
    case Constant::kFloat64:
      return os << constant.ToFloat64();
    case Constant::kExternalReference:
      return os << constant.ToExternalReference().address();
    case Constant::kHeapObject:
      return os << Brief(*constant.ToHeapObject());
  }
  UNREACHABLE();
  return os;
}

References UNREACHABLE.

operator<<() [10/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const FlagsCondition &	fc
	)

Definition at line 209 of file instruction.cc.

                                                           {
  switch (fc) {
    case kEqual:
      return os << "equal";
    case kNotEqual:
      return os << "not equal";
    case kSignedLessThan:
      return os << "signed less than";
    case kSignedGreaterThanOrEqual:
      return os << "signed greater than or equal";
    case kSignedLessThanOrEqual:
      return os << "signed less than or equal";
    case kSignedGreaterThan:
      return os << "signed greater than";
    case kUnsignedLessThan:
      return os << "unsigned less than";
    case kUnsignedGreaterThanOrEqual:
      return os << "unsigned greater than or equal";
    case kUnsignedLessThanOrEqual:
      return os << "unsigned less than or equal";
    case kUnsignedGreaterThan:
      return os << "unsigned greater than";
    case kUnorderedEqual:
      return os << "unordered equal";
    case kUnorderedNotEqual:
      return os << "unordered not equal";
    case kUnorderedLessThan:
      return os << "unordered less than";
    case kUnorderedGreaterThanOrEqual:
      return os << "unordered greater than or equal";
    case kUnorderedLessThanOrEqual:
      return os << "unordered less than or equal";
    case kUnorderedGreaterThan:
      return os << "unordered greater than";
    case kOverflow:
      return os << "overflow";
    case kNotOverflow:
      return os << "not overflow";
  }
  UNREACHABLE();
  return os;
}

References kEqual, kNotEqual, kNotOverflow, kOverflow, kSignedGreaterThan, kSignedGreaterThanOrEqual, kSignedLessThan, kSignedLessThanOrEqual, kUnorderedEqual, kUnorderedGreaterThan, kUnorderedGreaterThanOrEqual, kUnorderedLessThan, kUnorderedLessThanOrEqual, kUnorderedNotEqual, kUnsignedGreaterThan, kUnsignedGreaterThanOrEqual, kUnsignedLessThan, kUnsignedLessThanOrEqual, and UNREACHABLE.

operator<<() [11/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const FlagsMode &	fm
	)

Definition at line 195 of file instruction.cc.

                                                      {
  switch (fm) {
    case kFlags_none:
      return os;
    case kFlags_branch:
      return os << "branch";
    case kFlags_set:
      return os << "set";
  }
  UNREACHABLE();
  return os;
}

References kFlags_branch, kFlags_none, kFlags_set, and UNREACHABLE.

operator<<() [12/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const Instruction &	instr
	)

Definition at line 253 of file instruction.cc.

                                                           {
  if (instr.OutputCount() > 1) os << "(";
  for (size_t i = 0; i < instr.OutputCount(); i++) {
    if (i > 0) os << ", ";
    os << *instr.OutputAt(i);
  }
 
  if (instr.OutputCount() > 1) os << ") = ";
  if (instr.OutputCount() == 1) os << " = ";
 
  if (instr.IsGapMoves()) {
    const GapInstruction* gap = GapInstruction::cast(&instr);
    os << (instr.IsBlockStart() ? " block-start" : "gap ");
    for (int i = GapInstruction::FIRST_INNER_POSITION;
         i <= GapInstruction::LAST_INNER_POSITION; i++) {
      os << "(";
      if (gap->parallel_moves_[i] != NULL) os << *gap->parallel_moves_[i];
      os << ") ";
    }
  } else if (instr.IsSourcePosition()) {
    const SourcePositionInstruction* pos =
        SourcePositionInstruction::cast(&instr);
    os << "position (" << pos->source_position().raw() << ")";
  } else {
    os << ArchOpcodeField::decode(instr.opcode());
    AddressingMode am = AddressingModeField::decode(instr.opcode());
    if (am != kMode_None) {
      os << " : " << AddressingModeField::decode(instr.opcode());
    }
    FlagsMode fm = FlagsModeField::decode(instr.opcode());
    if (fm != kFlags_none) {
      os << " && " << fm << " if "
         << FlagsConditionField::decode(instr.opcode());
    }
  }
  if (instr.InputCount() > 0) {
    for (size_t i = 0; i < instr.InputCount(); i++) {
      os << " " << *instr.InputAt(i);
    }
  }
  return os << "\n";
}

operator<<() [13/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const InstructionOperand &	op
	)

Definition at line 13 of file instruction.cc.

                                                               {
  switch (op.kind()) {
    case InstructionOperand::INVALID:
      return os << "(0)";
    case InstructionOperand::UNALLOCATED: {
      const UnallocatedOperand* unalloc = UnallocatedOperand::cast(&op);
      os << "v" << unalloc->virtual_register();
      if (unalloc->basic_policy() == UnallocatedOperand::FIXED_SLOT) {
        return os << "(=" << unalloc->fixed_slot_index() << "S)";
      }
      switch (unalloc->extended_policy()) {
        case UnallocatedOperand::NONE:
          return os;
        case UnallocatedOperand::FIXED_REGISTER:
          return os << "(=" << Register::AllocationIndexToString(
                                   unalloc->fixed_register_index()) << ")";
        case UnallocatedOperand::FIXED_DOUBLE_REGISTER:
          return os << "(=" << DoubleRegister::AllocationIndexToString(
                                   unalloc->fixed_register_index()) << ")";
        case UnallocatedOperand::MUST_HAVE_REGISTER:
          return os << "(R)";
        case UnallocatedOperand::SAME_AS_FIRST_INPUT:
          return os << "(1)";
        case UnallocatedOperand::ANY:
          return os << "(-)";
      }
    }
    case InstructionOperand::CONSTANT:
      return os << "[constant:" << op.index() << "]";
    case InstructionOperand::IMMEDIATE:
      return os << "[immediate:" << op.index() << "]";
    case InstructionOperand::STACK_SLOT:
      return os << "[stack:" << op.index() << "]";
    case InstructionOperand::DOUBLE_STACK_SLOT:
      return os << "[double_stack:" << op.index() << "]";
    case InstructionOperand::REGISTER:
      return os << "[" << Register::AllocationIndexToString(op.index())
                << "|R]";
    case InstructionOperand::DOUBLE_REGISTER:
      return os << "[" << DoubleRegister::AllocationIndexToString(op.index())
                << "|R]";
  }
  UNREACHABLE();
  return os;
}

References v8::internal::Register::AllocationIndexToString(), v8::internal::DwVfpRegister::AllocationIndexToString(), v8::internal::compiler::UnallocatedOperand::ANY, v8::internal::compiler::UnallocatedOperand::basic_policy(), v8::internal::compiler::UnallocatedOperand::cast(), v8::internal::compiler::InstructionOperand::CONSTANT, v8::internal::compiler::InstructionOperand::DOUBLE_REGISTER, v8::internal::compiler::InstructionOperand::DOUBLE_STACK_SLOT, v8::internal::compiler::UnallocatedOperand::extended_policy(), v8::internal::compiler::UnallocatedOperand::FIXED_DOUBLE_REGISTER, v8::internal::compiler::UnallocatedOperand::FIXED_REGISTER, v8::internal::compiler::UnallocatedOperand::fixed_register_index(), v8::internal::compiler::UnallocatedOperand::FIXED_SLOT, v8::internal::compiler::UnallocatedOperand::fixed_slot_index(), v8::internal::compiler::InstructionOperand::IMMEDIATE, v8::internal::compiler::InstructionOperand::index(), v8::internal::compiler::InstructionOperand::INVALID, v8::internal::compiler::InstructionOperand::kind(), v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, v8::internal::compiler::UnallocatedOperand::NONE, v8::internal::compiler::InstructionOperand::REGISTER, v8::internal::compiler::UnallocatedOperand::SAME_AS_FIRST_INPUT, v8::internal::compiler::InstructionOperand::STACK_SLOT, v8::internal::compiler::InstructionOperand::UNALLOCATED, UNREACHABLE, and v8::internal::compiler::UnallocatedOperand::virtual_register().

Here is the call graph for this function:

operator<<() [14/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const InstructionSequence &	code
	)

Definition at line 417 of file instruction.cc.

                                                                  {
  for (size_t i = 0; i < code.immediates_.size(); ++i) {
    Constant constant = code.immediates_[i];
    os << "IMM#" << i << ": " << constant << "\n";
  }
  int i = 0;
  for (ConstantMap::const_iterator it = code.constants_.begin();
       it != code.constants_.end(); ++i, ++it) {
    os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
  }
  for (int i = 0; i < code.BasicBlockCount(); i++) {
    BasicBlock* block = code.BlockAt(i);
 
    int bid = block->id();
    os << "RPO#" << block->rpo_number_ << ": B" << bid;
    CHECK(block->rpo_number_ == i);
    if (block->IsLoopHeader()) {
      os << " loop blocks: [" << block->rpo_number_ << ", " << block->loop_end_
         << ")";
    }
    os << "  instructions: [" << block->code_start_ << ", " << block->code_end_
       << ")\n  predecessors:";
 
    BasicBlock::Predecessors predecessors = block->predecessors();
    for (BasicBlock::Predecessors::iterator iter = predecessors.begin();
         iter != predecessors.end(); ++iter) {
      os << " B" << (*iter)->id();
    }
    os << "\n";
 
    for (BasicBlock::const_iterator j = block->begin(); j != block->end();
         ++j) {
      Node* phi = *j;
      if (phi->opcode() != IrOpcode::kPhi) continue;
      os << "     phi: v" << phi->id() << " =";
      Node::Inputs inputs = phi->inputs();
      for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
           ++iter) {
        os << " v" << (*iter)->id();
      }
      os << "\n";
    }
 
    ScopedVector<char> buf(32);
    for (int j = block->first_instruction_index();
         j <= block->last_instruction_index(); j++) {
      // TODO(svenpanne) Add some basic formatting to our streams.
      SNPrintF(buf, "%5d", j);
      os << "   " << buf.start() << ": " << *code.InstructionAt(j);
    }
 
    os << "  " << block->control_;
 
    if (block->control_input_ != NULL) {
      os << " v" << block->control_input_->id();
    }
 
    BasicBlock::Successors successors = block->successors();
    for (BasicBlock::Successors::iterator iter = successors.begin();
         iter != successors.end(); ++iter) {
      os << " B" << (*iter)->id();
    }
    os << "\n";
  }
  return os;
}

operator<<() [15/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const MachineType &	type
	)

Definition at line 20 of file machine-type.cc.

                                                          {
  bool before = false;
  PRINT(kRepBit);
  PRINT(kRepWord8);
  PRINT(kRepWord16);
  PRINT(kRepWord32);
  PRINT(kRepWord64);
  PRINT(kRepFloat32);
  PRINT(kRepFloat64);
  PRINT(kRepTagged);
 
  PRINT(kTypeBool);
  PRINT(kTypeInt32);
  PRINT(kTypeUint32);
  PRINT(kTypeInt64);
  PRINT(kTypeUint64);
  PRINT(kTypeNumber);
  PRINT(kTypeAny);
  return os;
}

References kRepBit, kRepFloat32, kRepFloat64, kRepTagged, kRepWord16, kRepWord32, kRepWord64, kRepWord8, kTypeAny, kTypeBool, kTypeInt32, kTypeInt64, kTypeNumber, kTypeUint32, kTypeUint64, and PRINT.

operator<<() [16/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const MoveOperands &	mo
	)

Definition at line 98 of file instruction.cc.

                                                         {
  os << *mo.destination();
  if (!mo.source()->Equals(mo.destination())) os << " = " << *mo.source();
  return os << ";";
}

operator<<() [17/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const Node &	n
	)

Definition at line 48 of file node.cc.

                                                {
  os << n.id() << ": " << *n.op();
  if (n.op()->InputCount() != 0) {
    os << "(";
    for (int i = 0; i < n.op()->InputCount(); ++i) {
      if (i != 0) os << ", ";
      os << n.InputAt(i)->id();
    }
    os << ")";
  }
  return os;
}

operator<<() [18/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const Operator &	op
	)

Definition at line 45 of file node.cc.

{ return op.PrintTo(os); }

operator<<() [19/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const ParallelMove &	pm
	)

Definition at line 113 of file instruction.cc.

                                                         {
  bool first = true;
  for (ZoneList<MoveOperands>::iterator move = pm.move_operands()->begin();
       move != pm.move_operands()->end(); ++move) {
    if (move->IsEliminated()) continue;
    if (!first) os << " ";
    first = false;
    os << *move;
  }
  return os;
}

References v8::internal::List< T, AllocationPolicy >::begin().

Here is the call graph for this function:

operator<<() [20/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const PointerMap &	pm
	)

Definition at line 155 of file instruction.cc.

                                                       {
  os << "{";
  for (ZoneList<InstructionOperand*>::iterator op =
           pm.pointer_operands_.begin();
       op != pm.pointer_operands_.end(); ++op) {
    if (op != pm.pointer_operands_.begin()) os << ";";
    os << *op;
  }
  return os << "}";
}

operator<<() [21/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const Schedule &	s
	)

Definition at line 33 of file schedule.cc.

                                                    {
  // TODO(svenpanne) Const-correct the RPO stuff/iterators.
  BasicBlockVector* rpo = const_cast<Schedule*>(&s)->rpo_order();
  for (BasicBlockVectorIter i = rpo->begin(); i != rpo->end(); ++i) {
    BasicBlock* block = *i;
    os << "--- BLOCK B" << block->id();
    if (block->PredecessorCount() != 0) os << " <- ";
    BasicBlock::Predecessors predecessors = block->predecessors();
    bool comma = false;
    for (BasicBlock::Predecessors::iterator j = predecessors.begin();
         j != predecessors.end(); ++j) {
      if (comma) os << ", ";
      comma = true;
      os << "B" << (*j)->id();
    }
    os << " ---\n";
    for (BasicBlock::const_iterator j = block->begin(); j != block->end();
         ++j) {
      Node* node = *j;
      os << "  " << *node;
      if (!NodeProperties::IsControl(node)) {
        Bounds bounds = NodeProperties::GetBounds(node);
        os << " : ";
        bounds.lower->PrintTo(os);
        if (!bounds.upper->Is(bounds.lower)) {
          os << "..";
          bounds.upper->PrintTo(os);
        }
      }
      os << "\n";
    }
    BasicBlock::Control control = block->control_;
    if (control != BasicBlock::kNone) {
      os << "  ";
      if (block->control_input_ != NULL) {
        os << *block->control_input_;
      } else {
        os << "Goto";
      }
      os << " -> ";
      BasicBlock::Successors successors = block->successors();
      comma = false;
      for (BasicBlock::Successors::iterator j = successors.begin();
           j != successors.end(); ++j) {
        if (comma) os << ", ";
        comma = true;
        os << "B" << (*j)->id();
      }
      os << "\n";
    }
  }
  return os;
}

References v8::internal::compiler::NodeProperties::GetBounds(), v8::internal::compiler::NodeProperties::IsControl(), v8::internal::BoundsImpl< Config >::lower, NULL, and v8::internal::BoundsImpl< Config >::upper.

Here is the call graph for this function:

operator<<() [22/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const StoreRepresentation &	rep
	)

Definition at line 27 of file machine-operator.cc.

                                                                 {
  return os << "(" << rep.machine_type() << " : " << rep.write_barrier_kind()
            << ")";
}

operator<<() [23/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		const WriteBarrierKind &	write_barrier_kind
	)

Definition at line 15 of file machine-operator.cc.

                                                                             {
  switch (write_barrier_kind) {
    case kNoWriteBarrier:
      return os << "NoWriteBarrier";
    case kFullWriteBarrier:
      return os << "FullWriteBarrier";
  }
  UNREACHABLE();
  return os;
}

References kFullWriteBarrier, kNoWriteBarrier, and UNREACHABLE.

operator<<() [24/26]

OStream & v8::internal::compiler::operator<<	(	OStream &	os,
		ElementAccess const &	access
	)

Definition at line 40 of file simplified-operator.cc.

                                                              {
  os << "[" << access.base_is_tagged << ", " << access.header_size << ", ";
  access.type->PrintTo(os);
  os << ", " << access.machine_type << "]";
  return os;
}

References v8::internal::compiler::ElementAccess::base_is_tagged, v8::internal::compiler::ElementAccess::header_size, v8::internal::compiler::ElementAccess::machine_type, v8::internal::TypeImpl< Config >::PrintTo(), and v8::internal::compiler::ElementAccess::type.

Here is the call graph for this function:

operator<<() [25/26]

std::ostream& v8::internal::compiler::operator<< ( std::ostream &  os, const ElementAccess &  access  )

inline

Definition at line 15 of file simplified-operator-unittest.cc.

                                                                           {
  OStringStream ost;
  ost << access;
  return os << ost.c_str();
}

References v8::internal::OStringStream::c_str().

Here is the call graph for this function:

operator<<() [26/26]

std::ostream& v8::internal::compiler::operator<< ( std::ostream &  os, const MachineType &  type  )

inline

Definition at line 24 of file change-lowering-unittest.cc.

                                                                       {
  OStringStream ost;
  ost << type;
  return os << ost.c_str();
}

References v8::internal::OStringStream::c_str().

Here is the call graph for this function:

operator==() [1/3]

bool v8::internal::compiler::operator== ( const SourcePosition &  lhs, const SourcePosition &  rhs  )

inline

Definition at line 37 of file source-position.h.

                                                                             {
  return lhs.raw() == rhs.raw();
}

operator==() [2/3]

bool v8::internal::compiler::operator== ( const StoreRepresentation &  rep1, const StoreRepresentation &  rep2  )

inline

Definition at line 44 of file machine-operator.h.

                                                        {
  return rep1.machine_type() == rep2.machine_type() &&
         rep1.write_barrier_kind() == rep2.write_barrier_kind();
}

operator==() [3/3]

bool v8::internal::compiler::operator==	(	ElementAccess const &	lhs,
		ElementAccess const &	rhs
	)

Definition at line 28 of file simplified-operator.cc.

                                                                    {
  return lhs.base_is_tagged == rhs.base_is_tagged &&
         lhs.header_size == rhs.header_size && lhs.type == rhs.type &&
         lhs.machine_type == rhs.machine_type;
}

References v8::internal::compiler::ElementAccess::base_is_tagged, v8::internal::compiler::ElementAccess::header_size, v8::internal::compiler::ElementAccess::machine_type, and v8::internal::compiler::ElementAccess::type.

OpParameter() [1/2]

template<typename T >

static const T& v8::internal::compiler::OpParameter ( const Node *  node )

inlinestatic

Definition at line 86 of file node.h.

                                                     {
  return OpParameter<T>(node->op());
}

Referenced by v8::internal::compiler::OperandGenerator::ToConstant().

Here is the caller graph for this function:

OpParameter() [2/2]

template<typename T >

static const T& v8::internal::compiler::OpParameter ( const Operator *  op )

inlinestatic

Definition at line 254 of file operator.h.

                                                       {
  return reinterpret_cast<const Operator1<T>*>(op)->parameter();
}

Parse()

static void v8::internal::compiler::Parse ( Handle< JSFunction >  function, CompilationInfoWithZone *  info  )

static

Definition at line 56 of file js-inlining.cc.

                                                                              {
  CHECK(Parser::Parse(info));
  CHECK(Rewriter::Rewrite(info));
  CHECK(Scope::Analyze(info));
  CHECK(Compiler::EnsureDeoptimizationSupport(info));
}

References v8::internal::Scope::Analyze(), CHECK, v8::internal::Compiler::EnsureDeoptimizationSupport(), v8::internal::Parser::Parse(), and v8::internal::Rewriter::Rewrite().

Referenced by v8::JSON::Parse(), v8::internal::RUNTIME_FUNCTION(), and v8::internal::compiler::JSInliner::TryInlineCall().

Here is the call graph for this function:

Here is the caller graph for this function:

PointerConstant()

static const Operator* v8::internal::compiler::PointerConstant ( CommonOperatorBuilder *  common, void *  ptr  )

static

Definition at line 36 of file basic-block-instrumentor.cc.

                                                  {
  return kPointerSize == 8
             ? common->Int64Constant(reinterpret_cast<intptr_t>(ptr))
             : common->Int32Constant(
                   static_cast<int32_t>(reinterpret_cast<intptr_t>(ptr)));
}

References v8::internal::kPointerSize.

Referenced by v8::internal::compiler::BasicBlockInstrumentor::Instrument().

Here is the caller graph for this function:

Push()

static int v8::internal::compiler::Push ( SpecialRPOStackFrame *  stack, int  depth, BasicBlock *  child, int  unvisited  )

static

Definition at line 773 of file scheduler.cc.

                               {
  if (child->rpo_number_ == unvisited) {
    stack[depth].block = child;
    stack[depth].index = 0;
    child->rpo_number_ = kBlockOnStack;
    return depth + 1;
  }
  return depth;
}

References v8::internal::compiler::SpecialRPOStackFrame::block, v8::internal::compiler::SpecialRPOStackFrame::index, and kBlockOnStack.

Referenced by v8::internal::FullCodeGenerator::AllocateModules(), v8::internal::HGraphBuilder::BuildAllocateArrayFromLength(), v8::internal::CodeStubGraphBuilder< Stub >::BuildCodeInitializedStub(), v8::internal::CodeStubGraphBuilder< Stub >::BuildCodeStub(), v8::internal::HGraphBuilder::BuildKeyedIndexCheck(), v8::internal::HGraphBuilder::BuildNumberToString(), v8::internal::HGraphBuilder::BuildStringAdd(), v8::internal::HGraphBuilder::BuildUncheckedDictionaryElementLoad(), v8::internal::HGraphBuilder::BuildUncheckedStringAdd(), v8::internal::compiler::Scheduler::ComputeSpecialRPO(), v8::internal::LCodeGen::DeoptimizeBranch(), v8::internal::LCodeGen::DeoptimizeIf(), v8::internal::LCodeGen::DoDeferredAllocate(), v8::internal::LCodeGen::DoDeferredLoadMutableDouble(), v8::internal::PostorderProcessor::PerformNonBacktrackingStep(), v8::internal::FullCodeGenerator::StackValueContext::Plug(), v8::internal::PostorderProcessor::SetupSuccessors(), and v8::internal::FullCodeGenerator::VisitLogicalExpression().

Here is the caller graph for this function:

RelaxEffects()

static void v8::internal::compiler::RelaxEffects ( Node *  node )

static

Definition at line 27 of file js-typed-lowering.cc.

                                     {
  NodeProperties::ReplaceWithValue(node, node, NULL);
}

References NULL, and v8::internal::compiler::NodeProperties::ReplaceWithValue().

Referenced by v8::internal::compiler::JSBinopReduction::ChangeToPureOperator().

Here is the call graph for this function:

Here is the caller graph for this function:

ReplaceWithPureReduction()

static Reduction v8::internal::compiler::ReplaceWithPureReduction ( Node *  node, Reduction  reduction  )

static

Definition at line 18 of file js-builtin-reducer.cc.

                                                                           {
  if (reduction.Changed()) {
    NodeProperties::ReplaceWithValue(node, reduction.replacement());
    return reduction;
  }
  return Reducer::NoChange();
}

References v8::internal::compiler::Reducer::NoChange(), and v8::internal::compiler::NodeProperties::ReplaceWithValue().

Here is the call graph for this function:

ReplaceWithReduction()

static Reduction v8::internal::compiler::ReplaceWithReduction ( Node *  node, Reduction  reduction  )

static

Definition at line 623 of file js-typed-lowering.cc.

                                                                       {
  if (reduction.Changed()) {
    NodeProperties::ReplaceWithValue(node, reduction.replacement());
    return reduction;
  }
  return Reducer::NoChange();
}

References v8::internal::compiler::Reducer::NoChange(), and v8::internal::compiler::NodeProperties::ReplaceWithValue().

Here is the call graph for this function:

RepresentationOf()

MachineType v8::internal::compiler::RepresentationOf ( MachineType  machine_type )

inline

Definition at line 76 of file machine-type.h.

                                                              {
  int result = machine_type & kRepMask;
  CHECK(base::bits::IsPowerOfTwo32(result));
  return static_cast<MachineType>(result);
}

References CHECK, v8::base::bits::IsPowerOfTwo32(), and kRepMask.

Referenced by ComputeWriteBarrierKind(), ElementSizeOf(), and v8::internal::compiler::OperandGenerator::ToUnallocatedOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

SearchSharedFunctionInfo()

static Handle<SharedFunctionInfo> v8::internal::compiler::SearchSharedFunctionInfo ( Code *  unoptimized_code, FunctionLiteral *  expr  )

static

Definition at line 134 of file ast-graph-builder.cc.

                                                   {
  int start_position = expr->start_position();
  for (RelocIterator it(unoptimized_code); !it.done(); it.next()) {
    RelocInfo* rinfo = it.rinfo();
    if (rinfo->rmode() != RelocInfo::EMBEDDED_OBJECT) continue;
    Object* obj = rinfo->target_object();
    if (obj->IsSharedFunctionInfo()) {
      SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
      if (shared->start_position() == start_position) {
        return Handle<SharedFunctionInfo>(shared);
      }
    }
  }
  return Handle<SharedFunctionInfo>();
}

References v8::internal::RelocIterator::done(), v8::internal::RelocInfo::EMBEDDED_OBJECT, v8::internal::RelocInfo::rmode(), and v8::internal::SharedFunctionInfo::start_position().

Here is the call graph for this function:

STATIC_ASSERT()

v8::internal::compiler::STATIC_ASSERT

(

DoubleRegister::kMaxNumAllocatableRegisters >=Register::kMaxNumAllocatableRegisters

)

Referenced by v8::internal::compiler::ChangeLoweringTest::HeapNumberValueOffset(), v8::internal::compiler::SimplifiedLowering::IsTagged(), v8::internal::compiler::IA32OperandConverter::ScaleFor(), v8::internal::compiler::X64OperandConverter::ScaleFor(), and TARGET_TEST_F().

Here is the caller graph for this function:

TARGET_TEST_F() [1/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering32Test	,
		ChangeInt32ToTagged
	)

Definition at line 196 of file change-lowering-unittest.cc.

                                                         {
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> add, branch, heap_number, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(kMachAnyTagged,
            IsFinish(
                AllOf(CaptureEq(&heap_number),
                      IsAllocateHeapNumber(_, CaptureEq(&if_true))),
                IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
                        IsInt32Constant(HeapNumberValueOffset()),
                        IsChangeInt32ToFloat64(val), CaptureEq(&heap_number),
                        CaptureEq(&if_true))),
            IsProjection(
                0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(val, val))),
            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                    IsIfFalse(AllOf(CaptureEq(&branch),
                                    IsBranch(IsProjection(1, CaptureEq(&add)),
                                             graph()->start()))))));
}

References _, IsBranch(), IsChangeInt32ToFloat64(), IsFinish(), IsIfFalse(), IsIfTrue(), IsInt32AddWithOverflow(), IsInt32Constant(), IsMerge(), IsPhi(), IsProjection(), IsStore(), kMachAnyTagged, kMachFloat64, and kNoWriteBarrier.

Here is the call graph for this function:

TARGET_TEST_F() [2/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering32Test	,
		ChangeTaggedToFloat64
	)

Definition at line 223 of file change-lowering-unittest.cc.

                                                           {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(
          kMachFloat64,
          IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
                 IsControlEffect(CaptureEq(&if_true))),
          IsChangeInt32ToFloat64(
              IsWord32Sar(val, IsInt32Constant(SmiShiftAmount()))),
          IsMerge(
              AllOf(CaptureEq(&if_true),
                    IsIfTrue(AllOf(
                        CaptureEq(&branch),
                        IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                 graph()->start())))),
              IsIfFalse(CaptureEq(&branch)))));
}

References IsBranch(), IsChangeInt32ToFloat64(), IsControlEffect(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsLoad(), IsMerge(), IsPhi(), IsWord32And(), IsWord32Sar(), kMachFloat64, v8::internal::kSmiTag, v8::internal::kSmiTagMask, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [3/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering32Test	,
		ChangeTaggedToInt32
	)

Definition at line 252 of file change-lowering-unittest.cc.

                                                         {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(kMachInt32,
            IsChangeFloat64ToInt32(IsLoad(
                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
                IsControlEffect(CaptureEq(&if_true)))),
            IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                    IsIfFalse(AllOf(
                        CaptureEq(&branch),
                        IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                 graph()->start()))))));
}

References IsBranch(), IsChangeFloat64ToInt32(), IsControlEffect(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsLoad(), IsMerge(), IsPhi(), IsWord32And(), IsWord32Sar(), kMachFloat64, kMachInt32, v8::internal::kSmiTag, v8::internal::kSmiTagMask, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [4/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering32Test	,
		ChangeTaggedToUint32
	)

Definition at line 278 of file change-lowering-unittest.cc.

                                                          {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeTaggedToUint32(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(kMachUint32,
            IsChangeFloat64ToUint32(IsLoad(
                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
                IsControlEffect(CaptureEq(&if_true)))),
            IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                    IsIfFalse(AllOf(
                        CaptureEq(&branch),
                        IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                 graph()->start()))))));
}

References IsBranch(), IsChangeFloat64ToUint32(), IsControlEffect(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsLoad(), IsMerge(), IsPhi(), IsWord32And(), IsWord32Sar(), kMachFloat64, kMachUint32, v8::internal::kSmiTag, v8::internal::kSmiTagMask, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [5/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering32Test	,
		ChangeUint32ToTagged
	)

Definition at line 304 of file change-lowering-unittest.cc.

                                                          {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeUint32ToTagged(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, heap_number, if_false;
  EXPECT_THAT(
      phi,
      IsPhi(
          kMachAnyTagged, IsWord32Shl(val, IsInt32Constant(SmiShiftAmount())),
          IsFinish(
              AllOf(CaptureEq(&heap_number),
                    IsAllocateHeapNumber(_, CaptureEq(&if_false))),
              IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
                      IsInt32Constant(HeapNumberValueOffset()),
                      IsChangeUint32ToFloat64(val), CaptureEq(&heap_number),
                      CaptureEq(&if_false))),
          IsMerge(
              IsIfTrue(AllOf(CaptureEq(&branch),
                             IsBranch(IsUint32LessThanOrEqual(
                                          val, IsInt32Constant(SmiMaxValue())),
                                      graph()->start()))),
              AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch))))));
}

References _, IsBranch(), IsChangeUint32ToFloat64(), IsFinish(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsMerge(), IsPhi(), IsStore(), IsUint32LessThanOrEqual(), IsWord32Shl(), kMachAnyTagged, kMachFloat64, kNoWriteBarrier, v8::internal::kSmiTag, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [6/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering64Test	,
		ChangeInt32ToTagged
	)

Definition at line 348 of file change-lowering-unittest.cc.

                                                         {
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  EXPECT_THAT(reduction.replacement(),
              IsWord64Shl(IsChangeInt32ToInt64(val),
                          IsInt32Constant(SmiShiftAmount())));
}

References IsChangeInt32ToInt64(), IsInt32Constant(), and IsWord64Shl().

Here is the call graph for this function:

TARGET_TEST_F() [7/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering64Test	,
		ChangeTaggedToFloat64
	)

Definition at line 360 of file change-lowering-unittest.cc.

                                                           {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(
          kMachFloat64,
          IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
                 IsControlEffect(CaptureEq(&if_true))),
          IsChangeInt32ToFloat64(IsTruncateInt64ToInt32(
              IsWord64Sar(val, IsInt32Constant(SmiShiftAmount())))),
          IsMerge(
              AllOf(CaptureEq(&if_true),
                    IsIfTrue(AllOf(
                        CaptureEq(&branch),
                        IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                 graph()->start())))),
              IsIfFalse(CaptureEq(&branch)))));
}

References IsBranch(), IsChangeInt32ToFloat64(), IsControlEffect(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsLoad(), IsMerge(), IsPhi(), IsTruncateInt64ToInt32(), IsWord64And(), IsWord64Sar(), kMachFloat64, v8::internal::kSmiTag, v8::internal::kSmiTagMask, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [8/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering64Test	,
		ChangeTaggedToInt32
	)

Definition at line 389 of file change-lowering-unittest.cc.

                                                         {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(kMachInt32,
            IsChangeFloat64ToInt32(IsLoad(
                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
                IsControlEffect(CaptureEq(&if_true)))),
            IsTruncateInt64ToInt32(
                IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                    IsIfFalse(AllOf(
                        CaptureEq(&branch),
                        IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                 graph()->start()))))));
}

References IsBranch(), IsChangeFloat64ToInt32(), IsControlEffect(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsLoad(), IsMerge(), IsPhi(), IsTruncateInt64ToInt32(), IsWord64And(), IsWord64Sar(), kMachFloat64, kMachInt32, v8::internal::kSmiTag, v8::internal::kSmiTagMask, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [9/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering64Test	,
		ChangeTaggedToUint32
	)

Definition at line 416 of file change-lowering-unittest.cc.

                                                          {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeTaggedToUint32(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, if_true;
  EXPECT_THAT(
      phi,
      IsPhi(kMachUint32,
            IsChangeFloat64ToUint32(IsLoad(
                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
                IsControlEffect(CaptureEq(&if_true)))),
            IsTruncateInt64ToInt32(
                IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                    IsIfFalse(AllOf(
                        CaptureEq(&branch),
                        IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                 graph()->start()))))));
}

References IsBranch(), IsChangeFloat64ToUint32(), IsControlEffect(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsLoad(), IsMerge(), IsPhi(), IsTruncateInt64ToInt32(), IsWord64And(), IsWord64Sar(), kMachFloat64, kMachUint32, v8::internal::kSmiTag, v8::internal::kSmiTagMask, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [10/21]

v8::internal::compiler::TARGET_TEST_F	(	ChangeLowering64Test	,
		ChangeUint32ToTagged
	)

Definition at line 443 of file change-lowering-unittest.cc.

                                                          {
  STATIC_ASSERT(kSmiTag == 0);
  STATIC_ASSERT(kSmiTagSize == 1);
 
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeUint32ToTagged(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch, heap_number, if_false;
  EXPECT_THAT(
      phi,
      IsPhi(
          kMachAnyTagged, IsWord64Shl(IsChangeUint32ToUint64(val),
                                      IsInt32Constant(SmiShiftAmount())),
          IsFinish(
              AllOf(CaptureEq(&heap_number),
                    IsAllocateHeapNumber(_, CaptureEq(&if_false))),
              IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
                      IsInt32Constant(HeapNumberValueOffset()),
                      IsChangeUint32ToFloat64(val), CaptureEq(&heap_number),
                      CaptureEq(&if_false))),
          IsMerge(
              IsIfTrue(AllOf(CaptureEq(&branch),
                             IsBranch(IsUint32LessThanOrEqual(
                                          val, IsInt32Constant(SmiMaxValue())),
                                      graph()->start()))),
              AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch))))));
}

References _, IsBranch(), IsChangeUint32ToFloat64(), IsChangeUint32ToUint64(), IsFinish(), IsIfFalse(), IsIfTrue(), IsInt32Constant(), IsMerge(), IsPhi(), IsStore(), IsUint32LessThanOrEqual(), IsWord64Shl(), kMachAnyTagged, kMachFloat64, kNoWriteBarrier, v8::internal::kSmiTag, v8::internal::kSmiTagSize, and STATIC_ASSERT().

Here is the call graph for this function:

TARGET_TEST_F() [11/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		CallFunctionStubDeoptRecursiveFrameState
	)

Definition at line 421 of file instruction-selector-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged, kMachAnyTagged,
                  kMachAnyTagged);
 
  BailoutId bailout_id_before(42);
  BailoutId bailout_id_parent(62);
 
  // Some arguments for the call node.
  Node* function_node = m.Parameter(0);
  Node* receiver = m.Parameter(1);
  Node* context = m.Int32Constant(66);
 
  // Build frame state for the state before the call.
  Node* parameters = m.NewNode(m.common()->StateValues(1), m.Int32Constant(63));
  Node* locals = m.NewNode(m.common()->StateValues(1), m.Int32Constant(64));
  Node* stack = m.NewNode(m.common()->StateValues(1), m.Int32Constant(65));
  Node* frame_state_parent = m.NewNode(
      m.common()->FrameState(JS_FRAME, bailout_id_parent, kIgnoreOutput),
      parameters, locals, stack, context, m.UndefinedConstant());
 
  Node* context2 = m.Int32Constant(46);
  Node* parameters2 =
      m.NewNode(m.common()->StateValues(1), m.Int32Constant(43));
  Node* locals2 = m.NewNode(m.common()->StateValues(1), m.Int32Constant(44));
  Node* stack2 = m.NewNode(m.common()->StateValues(1), m.Int32Constant(45));
  Node* frame_state_before = m.NewNode(
      m.common()->FrameState(JS_FRAME, bailout_id_before, kPushOutput),
      parameters2, locals2, stack2, context2, frame_state_parent);
 
  // Build the call.
  Node* call = m.CallFunctionStub0(function_node, receiver, context2,
                                   frame_state_before, CALL_AS_METHOD);
 
  m.Return(call);
 
  Stream s = m.Build(kAllExceptNopInstructions);
 
  // Skip until kArchCallJSFunction.
  size_t index = 0;
  for (; index < s.size() && s[index]->arch_opcode() != kArchCallCodeObject;
       index++) {
  }
  // Now we should have three instructions: call, return.
  EXPECT_EQ(index + 2, s.size());
 
  // Check the call instruction
  const Instruction* call_instr = s[index++];
  EXPECT_EQ(kArchCallCodeObject, call_instr->arch_opcode());
  size_t num_operands =
      1 +  // Code object.
      1 +  // Frame state deopt id
      4 +  // One input for each value in frame state + context.
      4 +  // One input for each value in the parent frame state + context.
      1 +  // Function.
      1;   // Context.
  EXPECT_EQ(num_operands, call_instr->InputCount());
  // Code object.
  EXPECT_TRUE(call_instr->InputAt(0)->IsImmediate());
 
  // Deoptimization id.
  int32_t deopt_id_before = s.ToInt32(call_instr->InputAt(1));
  FrameStateDescriptor* desc_before =
      s.GetFrameStateDescriptor(deopt_id_before);
  EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
  EXPECT_EQ(1u, desc_before->parameters_count());
  EXPECT_EQ(1u, desc_before->locals_count());
  EXPECT_EQ(1u, desc_before->stack_count());
  EXPECT_EQ(63, s.ToInt32(call_instr->InputAt(2)));
  // Context:
  EXPECT_EQ(66, s.ToInt32(call_instr->InputAt(3)));
  EXPECT_EQ(64, s.ToInt32(call_instr->InputAt(4)));
  EXPECT_EQ(65, s.ToInt32(call_instr->InputAt(5)));
  // Values from parent environment should follow.
  EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(6)));
  EXPECT_EQ(46, s.ToInt32(call_instr->InputAt(7)));
  EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(8)));
  EXPECT_EQ(45, s.ToInt32(call_instr->InputAt(9)));
 
  // Function.
  EXPECT_EQ(function_node->id(), s.ToVreg(call_instr->InputAt(10)));
  // Context.
  EXPECT_EQ(context2->id(), s.ToVreg(call_instr->InputAt(11)));
  // Continuation.
 
  EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
  EXPECT_EQ(index, s.size());
}

References v8::internal::compiler::Instruction::arch_opcode(), v8::internal::compiler::FrameStateDescriptor::bailout_id(), v8::internal::CALL_AS_METHOD, v8::internal::compiler::Instruction::InputAt(), v8::internal::compiler::Instruction::InputCount(), JS_FRAME, kIgnoreOutput, kMachAnyTagged, kPushOutput, v8::internal::compiler::FrameStateDescriptor::locals_count(), v8::internal::compiler::FrameStateDescriptor::parameters_count(), and v8::internal::compiler::FrameStateDescriptor::stack_count().

Here is the call graph for this function:

TARGET_TEST_F() [12/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		CallFunctionStubWithDeopt
	)

Definition at line 345 of file instruction-selector-unittest.cc.

                                                                  {
  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged, kMachAnyTagged,
                  kMachAnyTagged);
 
  BailoutId bailout_id_before(42);
 
  // Some arguments for the call node.
  Node* function_node = m.Parameter(0);
  Node* receiver = m.Parameter(1);
  Node* context = m.Int32Constant(1);  // Context is ignored.
 
  // Build frame state for the state before the call.
  Node* parameters = m.NewNode(m.common()->StateValues(1), m.Int32Constant(43));
  Node* locals = m.NewNode(m.common()->StateValues(1), m.Int32Constant(44));
  Node* stack = m.NewNode(m.common()->StateValues(1), m.Int32Constant(45));
 
  Node* context_sentinel = m.Int32Constant(0);
  Node* frame_state_before = m.NewNode(
      m.common()->FrameState(JS_FRAME, bailout_id_before, kPushOutput),
      parameters, locals, stack, context_sentinel, m.UndefinedConstant());
 
  // Build the call.
  Node* call = m.CallFunctionStub0(function_node, receiver, context,
                                   frame_state_before, CALL_AS_METHOD);
 
  m.Return(call);
 
  Stream s = m.Build(kAllExceptNopInstructions);
 
  // Skip until kArchCallJSFunction.
  size_t index = 0;
  for (; index < s.size() && s[index]->arch_opcode() != kArchCallCodeObject;
       index++) {
  }
  // Now we should have two instructions: call, return.
  ASSERT_EQ(index + 2, s.size());
 
  // Check the call instruction
  const Instruction* call_instr = s[index++];
  EXPECT_EQ(kArchCallCodeObject, call_instr->arch_opcode());
  size_t num_operands =
      1 +  // Code object.
      1 +
      4 +  // Frame state deopt id + one input for each value in frame state.
      1 +  // Function.
      1;   // Context.
  ASSERT_EQ(num_operands, call_instr->InputCount());
 
  // Code object.
  EXPECT_TRUE(call_instr->InputAt(0)->IsImmediate());
 
  // Deoptimization id.
  int32_t deopt_id_before = s.ToInt32(call_instr->InputAt(1));
  FrameStateDescriptor* desc_before =
      s.GetFrameStateDescriptor(deopt_id_before);
  EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
  EXPECT_EQ(kPushOutput, desc_before->state_combine());
  EXPECT_EQ(1u, desc_before->parameters_count());
  EXPECT_EQ(1u, desc_before->locals_count());
  EXPECT_EQ(1u, desc_before->stack_count());
  EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(2)));
  EXPECT_EQ(0, s.ToInt32(call_instr->InputAt(3)));
  EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(4)));
  EXPECT_EQ(45, s.ToInt32(call_instr->InputAt(5)));
 
  // Function.
  EXPECT_EQ(function_node->id(), s.ToVreg(call_instr->InputAt(6)));
  // Context.
  EXPECT_EQ(context->id(), s.ToVreg(call_instr->InputAt(7)));
 
  EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
 
  EXPECT_EQ(index, s.size());
}

References v8::internal::compiler::Instruction::arch_opcode(), v8::internal::compiler::FrameStateDescriptor::bailout_id(), v8::internal::CALL_AS_METHOD, v8::internal::compiler::Instruction::InputAt(), v8::internal::compiler::Instruction::InputCount(), JS_FRAME, kMachAnyTagged, kPushOutput, v8::internal::compiler::FrameStateDescriptor::locals_count(), v8::internal::compiler::FrameStateDescriptor::parameters_count(), v8::internal::compiler::FrameStateDescriptor::stack_count(), and v8::internal::compiler::FrameStateDescriptor::state_combine().

Here is the call graph for this function:

TARGET_TEST_F() [13/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		CallJSFunctionWithDeopt
	)

Definition at line 307 of file instruction-selector-unittest.cc.

                                                                {
  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged, kMachAnyTagged,
                  kMachAnyTagged);
 
  BailoutId bailout_id(42);
 
  Node* function_node = m.Parameter(0);
  Node* receiver = m.Parameter(1);
  Node* context = m.Parameter(2);
 
  Node* parameters = m.NewNode(m.common()->StateValues(1), m.Int32Constant(1));
  Node* locals = m.NewNode(m.common()->StateValues(0));
  Node* stack = m.NewNode(m.common()->StateValues(0));
  Node* context_dummy = m.Int32Constant(0);
 
  Node* state_node = m.NewNode(
      m.common()->FrameState(JS_FRAME, bailout_id, kPushOutput), parameters,
      locals, stack, context_dummy, m.UndefinedConstant());
  Node* call = m.CallJS0(function_node, receiver, context, state_node);
  m.Return(call);
 
  Stream s = m.Build(kAllExceptNopInstructions);
 
  // Skip until kArchCallJSFunction.
  size_t index = 0;
  for (; index < s.size() && s[index]->arch_opcode() != kArchCallJSFunction;
       index++) {
  }
  // Now we should have two instructions: call and return.
  ASSERT_EQ(index + 2, s.size());
 
  EXPECT_EQ(kArchCallJSFunction, s[index++]->arch_opcode());
  EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
 
  // TODO(jarin) Check deoptimization table.
}

References JS_FRAME, kMachAnyTagged, and kPushOutput.

TARGET_TEST_F() [14/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		DoubleParameter
	)

Definition at line 177 of file instruction-selector-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachFloat64, kMachFloat64);
  Node* param = m.Parameter(0);
  m.Return(param);
  Stream s = m.Build(kAllInstructions);
  EXPECT_TRUE(s.IsDouble(param->id()));
}

References kMachFloat64.

TARGET_TEST_F() [15/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		Finish
	)

Definition at line 199 of file instruction-selector-unittest.cc.

                                               {
  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged);
  Node* param = m.Parameter(0);
  Node* finish = m.NewNode(m.common()->Finish(1), param, m.graph()->start());
  m.Return(finish);
  Stream s = m.Build(kAllInstructions);
  ASSERT_EQ(3U, s.size());
  EXPECT_EQ(kArchNop, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  ASSERT_TRUE(s[0]->Output()->IsUnallocated());
  EXPECT_EQ(param->id(), s.ToVreg(s[0]->Output()));
  EXPECT_EQ(kArchNop, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->InputCount());
  ASSERT_TRUE(s[1]->InputAt(0)->IsUnallocated());
  EXPECT_EQ(param->id(), s.ToVreg(s[1]->InputAt(0)));
  ASSERT_EQ(1U, s[1]->OutputCount());
  ASSERT_TRUE(s[1]->Output()->IsUnallocated());
  EXPECT_TRUE(UnallocatedOperand::cast(s[1]->Output())->HasSameAsInputPolicy());
  EXPECT_EQ(finish->id(), s.ToVreg(s[1]->Output()));
  EXPECT_TRUE(s.IsReference(finish->id()));
}

References v8::internal::compiler::UnallocatedOperand::cast(), and kMachAnyTagged.

Here is the call graph for this function:

TARGET_TEST_F() [16/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		ReferenceParameter
	)

Definition at line 186 of file instruction-selector-unittest.cc.

                                                           {
  StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged);
  Node* param = m.Parameter(0);
  m.Return(param);
  Stream s = m.Build(kAllInstructions);
  EXPECT_TRUE(s.IsReference(param->id()));
}

References kMachAnyTagged.

TARGET_TEST_F() [17/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		ReturnFloat32Constant
	)

Definition at line 116 of file instruction-selector-unittest.cc.

                                                              {
  const float kValue = 4.2f;
  StreamBuilder m(this, kMachFloat32);
  m.Return(m.Float32Constant(kValue));
  Stream s = m.Build(kAllInstructions);
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kArchNop, s[0]->arch_opcode());
  ASSERT_EQ(InstructionOperand::CONSTANT, s[0]->OutputAt(0)->kind());
  EXPECT_FLOAT_EQ(kValue, s.ToFloat32(s[0]->OutputAt(0)));
  EXPECT_EQ(kArchRet, s[1]->arch_opcode());
  EXPECT_EQ(1U, s[1]->InputCount());
}

References v8::internal::compiler::InstructionOperand::CONSTANT, and kMachFloat32.

TARGET_TEST_F() [18/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		ReturnParameter
	)

Definition at line 130 of file instruction-selector-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachInt32, kMachInt32);
  m.Return(m.Parameter(0));
  Stream s = m.Build(kAllInstructions);
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kArchNop, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kArchRet, s[1]->arch_opcode());
  EXPECT_EQ(1U, s[1]->InputCount());
}

References kMachInt32.

TARGET_TEST_F() [19/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		ReturnZero
	)

Definition at line 142 of file instruction-selector-unittest.cc.

                                                   {
  StreamBuilder m(this, kMachInt32);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build(kAllInstructions);
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kArchNop, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(InstructionOperand::CONSTANT, s[0]->OutputAt(0)->kind());
  EXPECT_EQ(0, s.ToInt32(s[0]->OutputAt(0)));
  EXPECT_EQ(kArchRet, s[1]->arch_opcode());
  EXPECT_EQ(1U, s[1]->InputCount());
}

References v8::internal::compiler::InstructionOperand::CONSTANT, and kMachInt32.

TARGET_TEST_F() [20/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		TruncateFloat64ToInt32WithParameter
	)

Definition at line 160 of file instruction-selector-unittest.cc.

                                                                            {
  StreamBuilder m(this, kMachInt32, kMachFloat64);
  m.Return(m.TruncateFloat64ToInt32(m.Parameter(0)));
  Stream s = m.Build(kAllInstructions);
  ASSERT_EQ(3U, s.size());
  EXPECT_EQ(kArchNop, s[0]->arch_opcode());
  EXPECT_EQ(kArchTruncateDoubleToI, s[1]->arch_opcode());
  EXPECT_EQ(1U, s[1]->InputCount());
  EXPECT_EQ(1U, s[1]->OutputCount());
  EXPECT_EQ(kArchRet, s[2]->arch_opcode());
}

References kMachFloat64, and kMachInt32.

TARGET_TEST_F() [21/21]

v8::internal::compiler::TARGET_TEST_F	(	InstructionSelectorTest	,
		ValueEffect
	)

Definition at line 281 of file instruction-selector-unittest.cc.

                                                    {
  StreamBuilder m1(this, kMachInt32, kMachPtr);
  Node* p1 = m1.Parameter(0);
  m1.Return(m1.Load(kMachInt32, p1, m1.Int32Constant(0)));
  Stream s1 = m1.Build(kAllInstructions);
  StreamBuilder m2(this, kMachInt32, kMachPtr);
  Node* p2 = m2.Parameter(0);
  m2.Return(m2.NewNode(m2.machine()->Load(kMachInt32), p2, m2.Int32Constant(0),
                       m2.NewNode(m2.common()->ValueEffect(1), p2)));
  Stream s2 = m2.Build(kAllInstructions);
  EXPECT_LE(3U, s1.size());
  ASSERT_EQ(s1.size(), s2.size());
  TRACED_FORRANGE(size_t, i, 0, s1.size() - 1) {
    const Instruction* i1 = s1[i];
    const Instruction* i2 = s2[i];
    EXPECT_EQ(i1->arch_opcode(), i2->arch_opcode());
    EXPECT_EQ(i1->InputCount(), i2->InputCount());
    EXPECT_EQ(i1->OutputCount(), i2->OutputCount());
  }
}

References v8::internal::compiler::Instruction::arch_opcode(), v8::internal::compiler::Instruction::InputCount(), kMachInt32, kMachPtr, v8::internal::compiler::Instruction::OutputCount(), v8::internal::p1, v8::internal::p2, v8::internal::s1, and v8::internal::s2.

Here is the call graph for this function:

TARGET_TEST_P() [1/6]

v8::internal::compiler::TARGET_TEST_P	(	ChangeLoweringCommonTest	,
		ChangeBitToBool
	)

Definition at line 125 of file change-lowering-unittest.cc.

                                                         {
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeBitToBool(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* phi = reduction.replacement();
  Capture<Node*> branch;
  EXPECT_THAT(phi,
              IsPhi(static_cast<MachineType>(kTypeBool | kRepTagged),
                    IsTrueConstant(), IsFalseConstant(),
                    IsMerge(IsIfTrue(AllOf(CaptureEq(&branch),
                                           IsBranch(val, graph()->start()))),
                            IsIfFalse(CaptureEq(&branch)))));
}

References IsBranch(), IsIfFalse(), IsIfTrue(), IsMerge(), IsPhi(), kRepTagged, and kTypeBool.

Here is the call graph for this function:

TARGET_TEST_P() [2/6]

v8::internal::compiler::TARGET_TEST_P	(	ChangeLoweringCommonTest	,
		ChangeBoolToBit
	)

Definition at line 142 of file change-lowering-unittest.cc.

                                                         {
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  EXPECT_THAT(reduction.replacement(), IsWordEqual(val, IsTrueConstant()));
}

TARGET_TEST_P() [3/6]

v8::internal::compiler::TARGET_TEST_P	(	ChangeLoweringCommonTest	,
		ChangeFloat64ToTagged
	)

Definition at line 152 of file change-lowering-unittest.cc.

                                                               {
  Node* val = Parameter(0);
  Node* node = graph()->NewNode(simplified()->ChangeFloat64ToTagged(), val);
  Reduction reduction = Reduce(node);
  ASSERT_TRUE(reduction.Changed());
 
  Node* finish = reduction.replacement();
  Capture<Node*> heap_number;
  EXPECT_THAT(
      finish,
      IsFinish(
          AllOf(CaptureEq(&heap_number),
                IsAllocateHeapNumber(IsValueEffect(val), graph()->start())),
          IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
                  IsInt32Constant(HeapNumberValueOffset()), val,
                  CaptureEq(&heap_number), graph()->start())));
}

References IsFinish(), IsInt32Constant(), IsStore(), IsValueEffect(), kMachFloat64, and kNoWriteBarrier.

Here is the call graph for this function:

TARGET_TEST_P() [4/6]

v8::internal::compiler::TARGET_TEST_P	(	ChangeLoweringCommonTest	,
		StringAdd
	)

Definition at line 171 of file change-lowering-unittest.cc.

                                                   {
  Node* node =
      graph()->NewNode(simplified()->StringAdd(), Parameter(0), Parameter(1));
  Reduction reduction = Reduce(node);
  EXPECT_FALSE(reduction.Changed());
}

TARGET_TEST_P() [5/6]

v8::internal::compiler::TARGET_TEST_P	(	InstructionSelectorPhiTest	,
		Doubleness
	)

Definition at line 230 of file instruction-selector-unittest.cc.

                                                      {
  const MachineType type = GetParam();
  StreamBuilder m(this, type, type, type);
  Node* param0 = m.Parameter(0);
  Node* param1 = m.Parameter(1);
  MLabel a, b, c;
  m.Branch(m.Int32Constant(0), &a, &b);
  m.Bind(&a);
  m.Goto(&c);
  m.Bind(&b);
  m.Goto(&c);
  m.Bind(&c);
  Node* phi = m.Phi(type, param0, param1);
  m.Return(phi);
  Stream s = m.Build(kAllInstructions);
  EXPECT_EQ(s.IsDouble(phi->id()), s.IsDouble(param0->id()));
  EXPECT_EQ(s.IsDouble(phi->id()), s.IsDouble(param1->id()));
}

TARGET_TEST_P() [6/6]

v8::internal::compiler::TARGET_TEST_P	(	InstructionSelectorPhiTest	,
		Referenceness
	)

Definition at line 250 of file instruction-selector-unittest.cc.

                                                         {
  const MachineType type = GetParam();
  StreamBuilder m(this, type, type, type);
  Node* param0 = m.Parameter(0);
  Node* param1 = m.Parameter(1);
  MLabel a, b, c;
  m.Branch(m.Int32Constant(1), &a, &b);
  m.Bind(&a);
  m.Goto(&c);
  m.Bind(&b);
  m.Goto(&c);
  m.Bind(&c);
  Node* phi = m.Phi(type, param0, param1);
  m.Return(phi);
  Stream s = m.Build(kAllInstructions);
  EXPECT_EQ(s.IsReference(phi->id()), s.IsReference(param0->id()));
  EXPECT_EQ(s.IsReference(phi->id()), s.IsReference(param1->id()));
}

TEST() [1/2]

v8::internal::compiler::TEST	(	MachineOperatorTest	,
		PseudoOperatorsWhenWordSizeIs32Bit
	)

Definition at line 280 of file machine-operator-unittest.cc.

                                                              {
  MachineOperatorBuilder machine(kRepWord32);
  EXPECT_EQ(machine.Word32And(), machine.WordAnd());
  EXPECT_EQ(machine.Word32Or(), machine.WordOr());
  EXPECT_EQ(machine.Word32Xor(), machine.WordXor());
  EXPECT_EQ(machine.Word32Shl(), machine.WordShl());
  EXPECT_EQ(machine.Word32Shr(), machine.WordShr());
  EXPECT_EQ(machine.Word32Sar(), machine.WordSar());
  EXPECT_EQ(machine.Word32Ror(), machine.WordRor());
  EXPECT_EQ(machine.Word32Equal(), machine.WordEqual());
  EXPECT_EQ(machine.Int32Add(), machine.IntAdd());
  EXPECT_EQ(machine.Int32Sub(), machine.IntSub());
  EXPECT_EQ(machine.Int32Mul(), machine.IntMul());
  EXPECT_EQ(machine.Int32Div(), machine.IntDiv());
  EXPECT_EQ(machine.Int32UDiv(), machine.IntUDiv());
  EXPECT_EQ(machine.Int32Mod(), machine.IntMod());
  EXPECT_EQ(machine.Int32UMod(), machine.IntUMod());
  EXPECT_EQ(machine.Int32LessThan(), machine.IntLessThan());
  EXPECT_EQ(machine.Int32LessThanOrEqual(), machine.IntLessThanOrEqual());
}

References kRepWord32.

TEST() [2/2]

v8::internal::compiler::TEST	(	MachineOperatorTest	,
		PseudoOperatorsWhenWordSizeIs64Bit
	)

Definition at line 302 of file machine-operator-unittest.cc.

                                                              {
  MachineOperatorBuilder machine(kRepWord64);
  EXPECT_EQ(machine.Word64And(), machine.WordAnd());
  EXPECT_EQ(machine.Word64Or(), machine.WordOr());
  EXPECT_EQ(machine.Word64Xor(), machine.WordXor());
  EXPECT_EQ(machine.Word64Shl(), machine.WordShl());
  EXPECT_EQ(machine.Word64Shr(), machine.WordShr());
  EXPECT_EQ(machine.Word64Sar(), machine.WordSar());
  EXPECT_EQ(machine.Word64Ror(), machine.WordRor());
  EXPECT_EQ(machine.Word64Equal(), machine.WordEqual());
  EXPECT_EQ(machine.Int64Add(), machine.IntAdd());
  EXPECT_EQ(machine.Int64Sub(), machine.IntSub());
  EXPECT_EQ(machine.Int64Mul(), machine.IntMul());
  EXPECT_EQ(machine.Int64Div(), machine.IntDiv());
  EXPECT_EQ(machine.Int64UDiv(), machine.IntUDiv());
  EXPECT_EQ(machine.Int64Mod(), machine.IntMod());
  EXPECT_EQ(machine.Int64UMod(), machine.IntUMod());
  EXPECT_EQ(machine.Int64LessThan(), machine.IntLessThan());
  EXPECT_EQ(machine.Int64LessThanOrEqual(), machine.IntLessThanOrEqual());
}

References kRepWord64.

TEST_F() [1/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_M1
	)

Definition at line 378 of file instruction-selector-ia32-unittest.cc.

                                                  {
  Node* base = null_ptr;
  Node* index = index_reg;
  Run(base, index, kMode_MR);
}

TEST_F() [2/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_M1I
	)

Definition at line 396 of file instruction-selector-ia32-unittest.cc.

                                                   {
  Node* base = null_ptr;
  Node* index = m->Int32Add(index_reg, non_zero);
  Run(base, index, kMode_MRI);
}

TEST_F() [3/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MI
	)

Definition at line 414 of file instruction-selector-ia32-unittest.cc.

                                                  {
  Node* bases[] = {null_ptr, non_zero};
  Node* indices[] = {zero, non_zero};
  for (size_t i = 0; i < arraysize(bases); ++i) {
    for (size_t j = 0; j < arraysize(indices); ++j) {
      Reset();
      Node* base = bases[i];
      Node* index = indices[j];
      Run(base, index, kMode_MI);
    }
  }
}

References arraysize, and v8::internal::zero.

TEST_F() [4/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MN
	)

Definition at line 385 of file instruction-selector-ia32-unittest.cc.

                                                  {
  AddressingMode expected[] = {kMode_MR, kMode_M2, kMode_M4, kMode_M8};
  for (size_t i = 0; i < arraysize(scales); ++i) {
    Reset();
    Node* base = null_ptr;
    Node* index = m->Int32Mul(index_reg, scales[i]);
    Run(base, index, expected[i]);
  }
}

References arraysize.

TEST_F() [5/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MNI
	)

Definition at line 403 of file instruction-selector-ia32-unittest.cc.

                                                   {
  AddressingMode expected[] = {kMode_MRI, kMode_M2I, kMode_M4I, kMode_M8I};
  for (size_t i = 0; i < arraysize(scales); ++i) {
    Reset();
    Node* base = null_ptr;
    Node* index = m->Int32Add(m->Int32Mul(index_reg, scales[i]), non_zero);
    Run(base, index, expected[i]);
  }
}

References arraysize.

TEST_F() [6/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MR
	)

Definition at line 328 of file instruction-selector-ia32-unittest.cc.

                                                  {
  Node* base = base_reg;
  Node* index = zero;
  Run(base, index, kMode_MR);
}

References v8::internal::zero.

TEST_F() [7/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MR1
	)

Definition at line 342 of file instruction-selector-ia32-unittest.cc.

                                                   {
  Node* base = base_reg;
  Node* index = index_reg;
  Run(base, index, kMode_MR1);
}

TEST_F() [8/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MR1I
	)

Definition at line 360 of file instruction-selector-ia32-unittest.cc.

                                                    {
  Node* base = base_reg;
  Node* index = m->Int32Add(index_reg, non_zero);
  Run(base, index, kMode_MR1I);
}

TEST_F() [9/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MRI
	)

Definition at line 335 of file instruction-selector-ia32-unittest.cc.

                                                   {
  Node* base = base_reg;
  Node* index = non_zero;
  Run(base, index, kMode_MRI);
}

TEST_F() [10/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MRN
	)

Definition at line 349 of file instruction-selector-ia32-unittest.cc.

                                                   {
  AddressingMode expected[] = {kMode_MR1, kMode_MR2, kMode_MR4, kMode_MR8};
  for (size_t i = 0; i < arraysize(scales); ++i) {
    Reset();
    Node* base = base_reg;
    Node* index = m->Int32Mul(index_reg, scales[i]);
    Run(base, index, expected[i]);
  }
}

References arraysize.

TEST_F() [11/132]

v8::internal::compiler::TEST_F	(	AddressingModeUnitTest	,
		AddressingMode_MRNI
	)

Definition at line 367 of file instruction-selector-ia32-unittest.cc.

                                                    {
  AddressingMode expected[] = {kMode_MR1I, kMode_MR2I, kMode_MR4I, kMode_MR8I};
  for (size_t i = 0; i < arraysize(scales); ++i) {
    Reset();
    Node* base = base_reg;
    Node* index = m->Int32Add(m->Int32Mul(index_reg, scales[i]), non_zero);
    Run(base, index, expected[i]);
  }
}

References arraysize.

TEST_F() [12/132]

v8::internal::compiler::TEST_F	(	CommonOperatorTest	,
		Finish
	)

Definition at line 169 of file common-operator-unittest.cc.

                                   {
  TRACED_FOREACH(int, arguments, kArguments) {
    const Operator* op = common()->Finish(arguments);
    EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
    EXPECT_EQ(arguments, OperatorProperties::GetEffectInputCount(op));
    EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
    EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
  }
}

References v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::OperatorProperties::GetValueOutputCount(), and v8::internal::compiler::anonymous_namespace{common-operator-unittest.cc}::kArguments.

Here is the call graph for this function:

TEST_F() [13/132]

v8::internal::compiler::TEST_F	(	CommonOperatorTest	,
		Float32Constant
	)

Definition at line 144 of file common-operator-unittest.cc.

                                            {
  TRACED_FOREACH(float, value, kFloat32Values) {
    const Operator* op = common()->Float32Constant(value);
    EXPECT_FLOAT_EQ(value, OpParameter<float>(op));
    EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
    EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
  }
}

References v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::OperatorProperties::GetValueOutputCount(), and v8::internal::compiler::anonymous_namespace{common-operator-unittest.cc}::kFloat32Values.

Here is the call graph for this function:

TEST_F() [14/132]

v8::internal::compiler::TEST_F	(	CommonOperatorTest	,
		ValueEffect
	)

Definition at line 157 of file common-operator-unittest.cc.

                                        {
  TRACED_FOREACH(int, arguments, kArguments) {
    const Operator* op = common()->ValueEffect(arguments);
    EXPECT_EQ(arguments, OperatorProperties::GetValueInputCount(op));
    EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
    EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
    EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
  }
}

References v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::OperatorProperties::GetValueOutputCount(), and v8::internal::compiler::anonymous_namespace{common-operator-unittest.cc}::kArguments.

Here is the call graph for this function:

TEST_F() [15/132]

v8::internal::compiler::TEST_F	(	GraphReducerTest	,
		NodeIsDeadAfterReplace
	)

Definition at line 77 of file graph-reducer-unittest.cc.

                                                 {
  StrictMock<MockReducer> r;
  Node* node0 = graph()->NewNode(&OP0);
  Node* node1 = graph()->NewNode(&OP1, node0);
  Node* node2 = graph()->NewNode(&OP1, node0);
  EXPECT_CALL(r, Reduce(node1)).WillOnce(Return(Reducer::Replace(node2)));
  ReduceNode(node1, &r);
  EXPECT_FALSE(node0->IsDead());
  EXPECT_TRUE(node1->IsDead());
  EXPECT_FALSE(node2->IsDead());
}

References v8::internal::compiler::anonymous_namespace{graph-reducer-unittest.cc}::OP0, OP1, and v8::internal::compiler::Reducer::Replace().

Here is the call graph for this function:

TEST_F() [16/132]

v8::internal::compiler::TEST_F	(	GraphReducerTest	,
		ReduceAgainAfterChanged
	)

Definition at line 99 of file graph-reducer-unittest.cc.

                                                  {
  Sequence s1, s2, s3;
  StrictMock<MockReducer> r1, r2, r3;
  Node* node0 = graph()->NewNode(&OP0);
  EXPECT_CALL(r1, Reduce(node0));
  EXPECT_CALL(r2, Reduce(node0));
  EXPECT_CALL(r3, Reduce(node0)).InSequence(s1, s2, s3).WillOnce(
      Return(Reducer::Changed(node0)));
  EXPECT_CALL(r1, Reduce(node0)).InSequence(s1);
  EXPECT_CALL(r2, Reduce(node0)).InSequence(s2);
  EXPECT_CALL(r3, Reduce(node0)).InSequence(s3);
  ReduceNode(node0, &r1, &r2, &r3);
}

References v8::internal::compiler::Reducer::Changed(), v8::internal::compiler::anonymous_namespace{graph-reducer-unittest.cc}::OP0, v8::internal::r1, v8::internal::r2, v8::internal::r3, v8::internal::s1, v8::internal::s2, and v8::internal::s3.

Here is the call graph for this function:

TEST_F() [17/132]

v8::internal::compiler::TEST_F	(	GraphReducerTest	,
		ReduceOnceForEveryReducer
	)

Definition at line 90 of file graph-reducer-unittest.cc.

                                                    {
  StrictMock<MockReducer> r1, r2;
  Node* node0 = graph()->NewNode(&OP0);
  EXPECT_CALL(r1, Reduce(node0));
  EXPECT_CALL(r2, Reduce(node0));
  ReduceNode(node0, &r1, &r2);
}

References v8::internal::compiler::anonymous_namespace{graph-reducer-unittest.cc}::OP0, v8::internal::r1, and v8::internal::r2.

TEST_F() [18/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		AddBranchWithImmediateOnLeft
	)

Definition at line 485 of file instruction-selector-arm64-unittest.cc.

                                                              {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Int32Add(m.Int32Constant(imm), m.Parameter(0)), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Cmn32, s[0]->arch_opcode());
    ASSERT_LE(1U, s[0]->InputCount());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_branch, kMachInt32, and kNotEqual.

TEST_F() [19/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		AddBranchWithImmediateOnRight
	)

Definition at line 430 of file instruction-selector-arm64-unittest.cc.

                                                               {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Int32Add(m.Parameter(0), m.Int32Constant(imm)), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Cmn32, s[0]->arch_opcode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_branch, kMachInt32, and kNotEqual.

TEST_F() [20/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		AndBranchWithImmediateOnLeft
	)

Definition at line 466 of file instruction-selector-arm64-unittest.cc.

                                                              {
  TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Word32And(m.Int32Constant(imm), m.Parameter(0)), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Tst32, s[0]->arch_opcode());
    ASSERT_LE(1U, s[0]->InputCount());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References kFlags_branch, v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kLogicalImmediates, kMachInt32, and kNotEqual.

TEST_F() [21/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		AndBranchWithImmediateOnRight
	)

Definition at line 412 of file instruction-selector-arm64-unittest.cc.

                                                               {
  TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Word32And(m.Parameter(0), m.Int32Constant(imm)), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Tst32, s[0]->arch_opcode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References kFlags_branch, v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kLogicalImmediates, kMachInt32, and kNotEqual.

TEST_F() [22/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		BetterLeftOperandTestAddBinop
	)

Definition at line 106 of file instruction-selector-ia32-unittest.cc.

                                                               {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  Node* param1 = m.Parameter(0);
  Node* param2 = m.Parameter(1);
  Node* add = m.Int32Add(param1, param2);
  m.Return(m.Int32Add(add, param1));
  Stream s = m.Build();
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
  ASSERT_EQ(2U, s[0]->InputCount());
  ASSERT_TRUE(s[0]->InputAt(0)->IsUnallocated());
  EXPECT_EQ(param2->id(), s.ToVreg(s[0]->InputAt(0)));
}

References kMachInt32.

TEST_F() [23/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		BetterLeftOperandTestMulBinop
	)

Definition at line 121 of file instruction-selector-ia32-unittest.cc.

                                                               {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  Node* param1 = m.Parameter(0);
  Node* param2 = m.Parameter(1);
  Node* mul = m.Int32Mul(param1, param2);
  m.Return(m.Int32Mul(mul, param1));
  Stream s = m.Build();
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kIA32Imul, s[0]->arch_opcode());
  ASSERT_EQ(2U, s[0]->InputCount());
  ASSERT_TRUE(s[0]->InputAt(0)->IsUnallocated());
  EXPECT_EQ(param2->id(), s.ToVreg(s[0]->InputAt(0)));
}

References kMachInt32.

TEST_F() [24/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		ChangeFloat32ToFloat64WithParameter
	)

Definition at line 1345 of file instruction-selector-arm-unittest.cc.

                                                                     {
  StreamBuilder m(this, kMachFloat64, kMachFloat32);
  m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmVcvtF64F32, s[0]->arch_opcode());
  EXPECT_EQ(1U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachFloat32, and kMachFloat64.

TEST_F() [25/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		ChangeInt32ToInt64WithParameter
	)

Definition at line 26 of file instruction-selector-x64-unittest.cc.

                                                                 {
  StreamBuilder m(this, kMachInt64, kMachInt32);
  m.Return(m.ChangeInt32ToInt64(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kX64Movsxlq, s[0]->arch_opcode());
}

References kMachInt32, and kMachInt64.

TEST_F() [26/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		ChangeUint32ToUint64WithParameter
	)

Definition at line 35 of file instruction-selector-x64-unittest.cc.

                                                                   {
  StreamBuilder m(this, kMachUint64, kMachUint32);
  m.Return(m.ChangeUint32ToUint64(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kX64Movl, s[0]->arch_opcode());
}

References kMachUint32, and kMachUint64.

TEST_F() [27/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32AddWithImmediate
	)

Definition at line 30 of file instruction-selector-ia32-unittest.cc.

                                                       {
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    {
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Int32Add(m.Parameter(0), m.Int32Constant(imm)));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
      ASSERT_EQ(2U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    }
    {
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Int32Add(m.Int32Constant(imm), m.Parameter(0)));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
      ASSERT_EQ(2U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    }
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-ia32-unittest.cc}::kImmediates, and kMachInt32.

TEST_F() [28/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32AddWithInt32Mul
	)

Definition at line 1371 of file instruction-selector-arm-unittest.cc.

                                                      {
  {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(
        m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmMla, s[0]->arch_opcode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(
        m.Int32Add(m.Int32Mul(m.Parameter(1), m.Parameter(2)), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmMla, s[0]->arch_opcode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32.

TEST_F() [29/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32AddWithParameter
	)

Definition at line 21 of file instruction-selector-ia32-unittest.cc.

                                                       {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Add(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
}

References kMachInt32.

TEST_F() [30/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32DivWithParameters
	)

Definition at line 1395 of file instruction-selector-arm-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Div(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(4U, s.size());
  EXPECT_EQ(kArmVcvtF64S32, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kArmVcvtF64S32, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  EXPECT_EQ(kArmVdivF64, s[2]->arch_opcode());
  ASSERT_EQ(2U, s[2]->InputCount());
  ASSERT_EQ(1U, s[2]->OutputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[2]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->Output()), s.ToVreg(s[2]->InputAt(1)));
  EXPECT_EQ(kArmVcvtS32F64, s[3]->arch_opcode());
  ASSERT_EQ(1U, s[3]->InputCount());
  EXPECT_EQ(s.ToVreg(s[2]->Output()), s.ToVreg(s[3]->InputAt(0)));
}

References kMachInt32.

TEST_F() [31/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32DivWithParametersForSUDIV
	)

Definition at line 1415 of file instruction-selector-arm-unittest.cc.

                                                                {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Div(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build(SUDIV);
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmSdiv, s[0]->arch_opcode());
}

References kMachInt32, and v8::internal::SUDIV.

TEST_F() [32/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32ModWithParameters
	)

Definition at line 1424 of file instruction-selector-arm-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Mod(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(6U, s.size());
  EXPECT_EQ(kArmVcvtF64S32, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kArmVcvtF64S32, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  EXPECT_EQ(kArmVdivF64, s[2]->arch_opcode());
  ASSERT_EQ(2U, s[2]->InputCount());
  ASSERT_EQ(1U, s[2]->OutputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[2]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->Output()), s.ToVreg(s[2]->InputAt(1)));
  EXPECT_EQ(kArmVcvtS32F64, s[3]->arch_opcode());
  ASSERT_EQ(1U, s[3]->InputCount());
  EXPECT_EQ(s.ToVreg(s[2]->Output()), s.ToVreg(s[3]->InputAt(0)));
  EXPECT_EQ(kArmMul, s[4]->arch_opcode());
  ASSERT_EQ(1U, s[4]->OutputCount());
  ASSERT_EQ(2U, s[4]->InputCount());
  EXPECT_EQ(s.ToVreg(s[3]->Output()), s.ToVreg(s[4]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->InputAt(0)), s.ToVreg(s[4]->InputAt(1)));
  EXPECT_EQ(kArmSub, s[5]->arch_opcode());
  ASSERT_EQ(1U, s[5]->OutputCount());
  ASSERT_EQ(2U, s[5]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[5]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[4]->Output()), s.ToVreg(s[5]->InputAt(1)));
}

References kMachInt32.

TEST_F() [33/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32ModWithParametersForSUDIV
	)

Definition at line 1454 of file instruction-selector-arm-unittest.cc.

                                                                {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Mod(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build(SUDIV);
  ASSERT_EQ(3U, s.size());
  EXPECT_EQ(kArmSdiv, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  ASSERT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(kArmMul, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  ASSERT_EQ(2U, s[1]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(1)), s.ToVreg(s[1]->InputAt(1)));
  EXPECT_EQ(kArmSub, s[2]->arch_opcode());
  ASSERT_EQ(1U, s[2]->OutputCount());
  ASSERT_EQ(2U, s[2]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[2]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->Output()), s.ToVreg(s[2]->InputAt(1)));
}

References kMachInt32, and v8::internal::SUDIV.

TEST_F() [34/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32ModWithParametersForSUDIVAndMLS
	)

Definition at line 1475 of file instruction-selector-arm-unittest.cc.

                                                                      {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Mod(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build(MLS, SUDIV);
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kArmSdiv, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  ASSERT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(kArmMls, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  ASSERT_EQ(3U, s[1]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(1)), s.ToVreg(s[1]->InputAt(1)));
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[1]->InputAt(2)));
}

References kMachInt32, v8::internal::MLS, and v8::internal::SUDIV.

TEST_F() [35/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32MulWithImmediate
	)

Definition at line 1503 of file instruction-selector-arm-unittest.cc.

                                                       {
  // x * (2^k + 1) -> x + (x >> k)
  TRACED_FORRANGE(int32_t, k, 1, 30) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant((1 << k) + 1)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmAdd, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R_LSL_I, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(k, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  // x * (2^k - 1) -> -x + (x >> k)
  TRACED_FORRANGE(int32_t, k, 3, 30) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant((1 << k) - 1)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmRsb, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R_LSL_I, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(k, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  // (2^k + 1) * x -> x + (x >> k)
  TRACED_FORRANGE(int32_t, k, 1, 30) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Int32Mul(m.Int32Constant((1 << k) + 1), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmAdd, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R_LSL_I, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(k, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  // x * (2^k - 1) -> -x + (x >> k)
  TRACED_FORRANGE(int32_t, k, 3, 30) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Int32Mul(m.Int32Constant((1 << k) - 1), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmRsb, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R_LSL_I, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(k, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32.

TEST_F() [36/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32MulWithParameters
	)

Definition at line 1492 of file instruction-selector-arm-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Mul(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmMul, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32.

TEST_F() [37/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32SubWithImmediate
	)

Definition at line 64 of file instruction-selector-ia32-unittest.cc.

                                                       {
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(imm)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kIA32Sub, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-ia32-unittest.cc}::kImmediates, and kMachInt32.

TEST_F() [38/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32SubWithInt32Mul
	)

Definition at line 1559 of file instruction-selector-arm-unittest.cc.

                                                      {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
  m.Return(
      m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
  Stream s = m.Build();
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kArmMul, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kArmSub, s[1]->arch_opcode());
  ASSERT_EQ(2U, s[1]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(1)));
}

References kMachInt32.

TEST_F() [39/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32SubWithInt32MulForMLS
	)

Definition at line 1573 of file instruction-selector-arm-unittest.cc.

                                                            {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
  m.Return(
      m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
  Stream s = m.Build(MLS);
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmMls, s[0]->arch_opcode());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(3U, s[0]->InputCount());
}

References kMachInt32, and v8::internal::MLS.

TEST_F() [40/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32SubWithParameter
	)

Definition at line 54 of file instruction-selector-ia32-unittest.cc.

                                                       {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32Sub(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kIA32Sub, s[0]->arch_opcode());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32.

TEST_F() [41/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32UDivWithParameters
	)

Definition at line 1585 of file instruction-selector-arm-unittest.cc.

                                                         {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32UDiv(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(4U, s.size());
  EXPECT_EQ(kArmVcvtF64U32, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kArmVcvtF64U32, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  EXPECT_EQ(kArmVdivF64, s[2]->arch_opcode());
  ASSERT_EQ(2U, s[2]->InputCount());
  ASSERT_EQ(1U, s[2]->OutputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[2]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->Output()), s.ToVreg(s[2]->InputAt(1)));
  EXPECT_EQ(kArmVcvtU32F64, s[3]->arch_opcode());
  ASSERT_EQ(1U, s[3]->InputCount());
  EXPECT_EQ(s.ToVreg(s[2]->Output()), s.ToVreg(s[3]->InputAt(0)));
}

References kMachInt32.

TEST_F() [42/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32UDivWithParametersForSUDIV
	)

Definition at line 1605 of file instruction-selector-arm-unittest.cc.

                                                                 {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32UDiv(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build(SUDIV);
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
}

References kMachInt32, and v8::internal::SUDIV.

TEST_F() [43/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32UModWithParameters
	)

Definition at line 1614 of file instruction-selector-arm-unittest.cc.

                                                         {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32UMod(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(6U, s.size());
  EXPECT_EQ(kArmVcvtF64U32, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kArmVcvtF64U32, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  EXPECT_EQ(kArmVdivF64, s[2]->arch_opcode());
  ASSERT_EQ(2U, s[2]->InputCount());
  ASSERT_EQ(1U, s[2]->OutputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[2]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->Output()), s.ToVreg(s[2]->InputAt(1)));
  EXPECT_EQ(kArmVcvtU32F64, s[3]->arch_opcode());
  ASSERT_EQ(1U, s[3]->InputCount());
  EXPECT_EQ(s.ToVreg(s[2]->Output()), s.ToVreg(s[3]->InputAt(0)));
  EXPECT_EQ(kArmMul, s[4]->arch_opcode());
  ASSERT_EQ(1U, s[4]->OutputCount());
  ASSERT_EQ(2U, s[4]->InputCount());
  EXPECT_EQ(s.ToVreg(s[3]->Output()), s.ToVreg(s[4]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->InputAt(0)), s.ToVreg(s[4]->InputAt(1)));
  EXPECT_EQ(kArmSub, s[5]->arch_opcode());
  ASSERT_EQ(1U, s[5]->OutputCount());
  ASSERT_EQ(2U, s[5]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[5]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[4]->Output()), s.ToVreg(s[5]->InputAt(1)));
}

References kMachInt32.

TEST_F() [44/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32UModWithParametersForSUDIV
	)

Definition at line 1644 of file instruction-selector-arm-unittest.cc.

                                                                 {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32UMod(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build(SUDIV);
  ASSERT_EQ(3U, s.size());
  EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  ASSERT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(kArmMul, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  ASSERT_EQ(2U, s[1]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(1)), s.ToVreg(s[1]->InputAt(1)));
  EXPECT_EQ(kArmSub, s[2]->arch_opcode());
  ASSERT_EQ(1U, s[2]->OutputCount());
  ASSERT_EQ(2U, s[2]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[2]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[1]->Output()), s.ToVreg(s[2]->InputAt(1)));
}

References kMachInt32, and v8::internal::SUDIV.

TEST_F() [45/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Int32UModWithParametersForSUDIVAndMLS
	)

Definition at line 1665 of file instruction-selector-arm-unittest.cc.

                                                                       {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Int32UMod(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build(MLS, SUDIV);
  ASSERT_EQ(2U, s.size());
  EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
  ASSERT_EQ(1U, s[0]->OutputCount());
  ASSERT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(kArmMls, s[1]->arch_opcode());
  ASSERT_EQ(1U, s[1]->OutputCount());
  ASSERT_EQ(3U, s[1]->InputCount());
  EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(0)));
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(1)), s.ToVreg(s[1]->InputAt(1)));
  EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[1]->InputAt(2)));
}

References kMachInt32, v8::internal::MLS, and v8::internal::SUDIV.

TEST_F() [46/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		OvfBothAddImmediateOnLeft
	)

Definition at line 699 of file instruction-selector-arm64-unittest.cc.

                                                           {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    Node* n = m.Int32AddWithOverflow(m.Int32Constant(imm), m.Parameter(0));
    m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
    Stream s = m.Build();
 
    ASSERT_LE(1U, s.size());
    EXPECT_EQ(kArm64Add32, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_set, kMachInt32, and kOverflow.

TEST_F() [47/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		OvfBranchWithImmediateOnLeft
	)

Definition at line 717 of file instruction-selector-arm64-unittest.cc.

                                                              {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    Node* n = m.Int32AddWithOverflow(m.Int32Constant(imm), m.Parameter(0));
    m.Branch(m.Projection(1, n), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(0));
    m.Bind(&b);
    m.Return(m.Projection(0, n));
    Stream s = m.Build();
 
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Add32, s[0]->arch_opcode());
    ASSERT_EQ(4U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_branch, kMachInt32, and kOverflow.

TEST_F() [48/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		OvfFlagAddImmediateOnLeft
	)

Definition at line 664 of file instruction-selector-arm64-unittest.cc.

                                                           {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        1, m.Int32AddWithOverflow(m.Int32Constant(imm), m.Parameter(0))));
    Stream s = m.Build();
 
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Add32, s[0]->arch_opcode());
    EXPECT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_set, kMachInt32, and kOverflow.

TEST_F() [49/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		OvfValAddImmediateOnLeft
	)

Definition at line 682 of file instruction-selector-arm64-unittest.cc.

                                                          {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        0, m.Int32AddWithOverflow(m.Int32Constant(imm), m.Parameter(0))));
    Stream s = m.Build();
 
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Add32, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_none, s[0]->flags_mode());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_none, and kMachInt32.

TEST_F() [50/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		SubBranchWithImmediateOnRight
	)

Definition at line 448 of file instruction-selector-arm64-unittest.cc.

                                                               {
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Int32Sub(m.Parameter(0), m.Int32Constant(imm)), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Cmp32, s[0]->arch_opcode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_branch, kMachInt32, and kNotEqual.

TEST_F() [51/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		SubZeroOnLeft
	)

Definition at line 354 of file instruction-selector-arm64-unittest.cc.

                                               {
  // Subtraction with zero on the left maps to Neg.
  {
    // 32-bit subtract.
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Int32Sub(m.Int32Constant(0), m.Parameter(0)));
    Stream s = m.Build();
 
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Neg32, s[0]->arch_opcode());
    EXPECT_EQ(1U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    // 64-bit subtract.
    StreamBuilder m(this, kMachInt64, kMachInt64, kMachInt64);
    m.Return(m.Int64Sub(m.Int64Constant(0), m.Parameter(0)));
    Stream s = m.Build();
 
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Neg, s[0]->arch_opcode());
    EXPECT_EQ(1U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32, and kMachInt64.

TEST_F() [52/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		TruncateFloat64ToFloat32WithParameter
	)

Definition at line 1356 of file instruction-selector-arm-unittest.cc.

                                                                       {
  StreamBuilder m(this, kMachFloat32, kMachFloat64);
  m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmVcvtF32F64, s[0]->arch_opcode());
  EXPECT_EQ(1U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachFloat32, and kMachFloat64.

TEST_F() [53/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		TruncateInt64ToInt32WithParameter
	)

Definition at line 55 of file instruction-selector-x64-unittest.cc.

                                                                   {
  StreamBuilder m(this, kMachInt32, kMachInt64);
  m.Return(m.TruncateInt64ToInt32(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kX64Movl, s[0]->arch_opcode());
}

References kMachInt32, and kMachInt64.

TEST_F() [54/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32AndWithBfcImmediateForARMv7
	)

Definition at line 1708 of file instruction-selector-arm-unittest.cc.

                                                                   {
  TRACED_FORRANGE(int32_t, lsb, 0, 31) {
    TRACED_FORRANGE(int32_t, width, 1, (32 - lsb) - 1) {
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Word32And(
          m.Parameter(0),
          m.Int32Constant(~((0xffffffffu >> (32 - width)) << lsb))));
      Stream s = m.Build(ARMv7);
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kArmBfc, s[0]->arch_opcode());
      ASSERT_EQ(1U, s[0]->OutputCount());
      EXPECT_TRUE(
          UnallocatedOperand::cast(s[0]->Output())->HasSameAsInputPolicy());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
    }
  }
  TRACED_FORRANGE(int32_t, lsb, 0, 31) {
    TRACED_FORRANGE(int32_t, width, 1, (32 - lsb) - 1) {
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(
          m.Word32And(m.Int32Constant(~((0xffffffffu >> (32 - width)) << lsb)),
                      m.Parameter(0)));
      Stream s = m.Build(ARMv7);
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kArmBfc, s[0]->arch_opcode());
      ASSERT_EQ(1U, s[0]->OutputCount());
      EXPECT_TRUE(
          UnallocatedOperand::cast(s[0]->Output())->HasSameAsInputPolicy());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
    }
  }
}

References v8::internal::ARMv7, v8::internal::compiler::UnallocatedOperand::cast(), and kMachInt32.

Here is the call graph for this function:

TEST_F() [55/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32AndWithUbfxImmediateForARMv7
	)

Definition at line 1682 of file instruction-selector-arm-unittest.cc.

                                                                    {
  TRACED_FORRANGE(int32_t, width, 1, 32) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32And(m.Parameter(0),
                         m.Int32Constant(0xffffffffu >> (32 - width))));
    Stream s = m.Build(ARMv7);
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmUbfx, s[0]->arch_opcode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(0, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
  }
  TRACED_FORRANGE(int32_t, width, 1, 32) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32And(m.Int32Constant(0xffffffffu >> (32 - width)),
                         m.Parameter(0)));
    Stream s = m.Build(ARMv7);
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmUbfx, s[0]->arch_opcode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(0, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
  }
}

References v8::internal::ARMv7, and kMachInt32.

TEST_F() [56/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32AndWithWord32Not
	)

Definition at line 1784 of file instruction-selector-arm-unittest.cc.

                                                        {
  {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Word32And(m.Parameter(0), m.Word32Not(m.Parameter(1))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmBic, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
    EXPECT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Word32And(m.Word32Not(m.Parameter(0)), m.Parameter(1)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmBic, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
    EXPECT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32.

TEST_F() [57/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32AndWithWord32ShrWithImmediateForARMv7
	)

Definition at line 1896 of file instruction-selector-arm-unittest.cc.

                                                                             {
  TRACED_FORRANGE(int32_t, lsb, 0, 31) {
    TRACED_FORRANGE(int32_t, width, 1, 32 - lsb) {
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Word32And(m.Word32Shr(m.Parameter(0), m.Int32Constant(lsb)),
                           m.Int32Constant(0xffffffffu >> (32 - width))));
      Stream s = m.Build(ARMv7);
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kArmUbfx, s[0]->arch_opcode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
    }
  }
  TRACED_FORRANGE(int32_t, lsb, 0, 31) {
    TRACED_FORRANGE(int32_t, width, 1, 32 - lsb) {
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Word32And(m.Int32Constant(0xffffffffu >> (32 - width)),
                           m.Word32Shr(m.Parameter(0), m.Int32Constant(lsb))));
      Stream s = m.Build(ARMv7);
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kArmUbfx, s[0]->arch_opcode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
    }
  }
}

References v8::internal::ARMv7, and kMachInt32.

TEST_F() [58/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32EqualWithImmediate
	)

Definition at line 1822 of file instruction-selector-arm-unittest.cc.

                                                          {
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    if (imm == 0) continue;
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(m.Parameter(0), m.Int32Constant(imm)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    if (imm == 0) continue;
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(m.Int32Constant(imm), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_set, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, and kMachInt32.

TEST_F() [59/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32EqualWithParameters
	)

Definition at line 1808 of file instruction-selector-arm-unittest.cc.

                                                           {
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Word32Equal(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kEqual, s[0]->flags_condition());
}

References kEqual, kFlags_set, and kMachInt32.

TEST_F() [60/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32EqualWithZero
	)

Definition at line 1854 of file instruction-selector-arm-unittest.cc.

                                                     {
  {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(m.Parameter(0), m.Int32Constant(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmTst, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(m.Int32Constant(0), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmTst, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_set, and kMachInt32.

TEST_F() [61/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32NotWithParameter
	)

Definition at line 1884 of file instruction-selector-arm-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachInt32, kMachInt32);
  m.Return(m.Word32Not(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmMvn, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(1U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32.

TEST_F() [62/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32ShrWithWord32AndWithImmediateForARMv7
	)

Definition at line 1746 of file instruction-selector-arm-unittest.cc.

                                                                             {
  TRACED_FORRANGE(int32_t, lsb, 0, 31) {
    TRACED_FORRANGE(int32_t, width, 1, 32 - lsb) {
      uint32_t max = 1 << lsb;
      if (max > static_cast<uint32_t>(kMaxInt)) max -= 1;
      uint32_t jnk = rng()->NextInt(max);
      uint32_t msk = ((0xffffffffu >> (32 - width)) << lsb) | jnk;
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Word32Shr(m.Word32And(m.Parameter(0), m.Int32Constant(msk)),
                           m.Int32Constant(lsb)));
      Stream s = m.Build(ARMv7);
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kArmUbfx, s[0]->arch_opcode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
    }
  }
  TRACED_FORRANGE(int32_t, lsb, 0, 31) {
    TRACED_FORRANGE(int32_t, width, 1, 32 - lsb) {
      uint32_t max = 1 << lsb;
      if (max > static_cast<uint32_t>(kMaxInt)) max -= 1;
      uint32_t jnk = rng()->NextInt(max);
      uint32_t msk = ((0xffffffffu >> (32 - width)) << lsb) | jnk;
      StreamBuilder m(this, kMachInt32, kMachInt32);
      m.Return(m.Word32Shr(m.Word32And(m.Int32Constant(msk), m.Parameter(0)),
                           m.Int32Constant(lsb)));
      Stream s = m.Build(ARMv7);
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(kArmUbfx, s[0]->arch_opcode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
    }
  }
}

References v8::internal::ARMv7, kMachInt32, and v8::internal::kMaxInt.

TEST_F() [63/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word32XorMinusOneWithParameter
	)

Definition at line 1352 of file instruction-selector-arm64-unittest.cc.

                                                                {
  {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Xor(m.Parameter(0), m.Int32Constant(-1)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Not32, s[0]->arch_opcode());
    EXPECT_EQ(1U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Xor(m.Int32Constant(-1), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Not32, s[0]->arch_opcode());
    EXPECT_EQ(1U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32.

TEST_F() [64/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word64EqualWithZero
	)

Definition at line 1208 of file instruction-selector-arm64-unittest.cc.

                                                     {
  {
    StreamBuilder m(this, kMachInt64, kMachInt64);
    m.Return(m.Word64Equal(m.Parameter(0), m.Int64Constant(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Tst, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  {
    StreamBuilder m(this, kMachInt64, kMachInt64);
    m.Return(m.Word64Equal(m.Int64Constant(0), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Tst, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(s.ToVreg(s[0]->InputAt(0)), s.ToVreg(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_set, and kMachInt64.

TEST_F() [65/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word64NotWithParameter
	)

Definition at line 1341 of file instruction-selector-arm64-unittest.cc.

                                                        {
  StreamBuilder m(this, kMachInt64, kMachInt64);
  m.Return(m.Word64Not(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArm64Not, s[0]->arch_opcode());
  EXPECT_EQ(1U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt64.

TEST_F() [66/132]

v8::internal::compiler::TEST_F	(	InstructionSelectorTest	,
		Word64XorMinusOneWithParameter
	)

Definition at line 1374 of file instruction-selector-arm64-unittest.cc.

                                                                {
  {
    StreamBuilder m(this, kMachInt64, kMachInt64);
    m.Return(m.Word64Xor(m.Parameter(0), m.Int64Constant(-1)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Not, s[0]->arch_opcode());
    EXPECT_EQ(1U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    StreamBuilder m(this, kMachInt64, kMachInt64);
    m.Return(m.Word64Xor(m.Int64Constant(-1), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArm64Not, s[0]->arch_opcode());
    EXPECT_EQ(1U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt64.

TEST_F() [67/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathAbs
	)

Definition at line 66 of file js-builtin-reducer-unittest.cc.

                                      {
  Handle<JSFunction> f(isolate()->context()->math_abs_fun());
 
  TRACED_FOREACH(Type*, t0, kNumberTypes) {
    Node* p0 = Parameter(t0, 0);
    Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
    Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
                                  fun, UndefinedConstant(), p0);
    Reduction r = Reduce(call);
 
    if (t0->Is(Type::Unsigned32())) {
      ASSERT_TRUE(r.Changed());
      EXPECT_THAT(r.replacement(), p0);
    } else {
      Capture<Node*> branch;
      ASSERT_TRUE(r.Changed());
      EXPECT_THAT(
          r.replacement(),
          IsPhi(kMachNone, p0, IsNumberSubtract(IsNumberConstant(0), p0),
                IsMerge(IsIfTrue(CaptureEq(&branch)),
                        IsIfFalse(AllOf(
                            CaptureEq(&branch),
                            IsBranch(IsNumberLessThan(IsNumberConstant(0), p0),
                                     graph()->start()))))));
    }
  }
}

References IsBranch(), IsIfFalse(), IsIfTrue(), IsMerge(), IsNumberConstant(), IsNumberLessThan(), IsNumberSubtract(), IsPhi(), kMachNone, v8::internal::compiler::anonymous_namespace{js-builtin-reducer-unittest.cc}::kNumberTypes, v8::internal::NO_CALL_FUNCTION_FLAGS, and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [68/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathFround
	)

Definition at line 213 of file js-builtin-reducer-unittest.cc.

                                         {
  Handle<Object> m =
      JSObject::GetProperty(isolate()->global_object(),
                            isolate()->factory()->NewStringFromAsciiChecked(
                                "Math")).ToHandleChecked();
  Handle<JSFunction> f = Handle<JSFunction>::cast(
      JSObject::GetProperty(m, isolate()->factory()->NewStringFromAsciiChecked(
                                   "fround")).ToHandleChecked());
 
  TRACED_FOREACH(Type*, t0, kNumberTypes) {
    Node* p0 = Parameter(t0, 0);
    Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
    Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
                                  fun, UndefinedConstant(), p0);
    Reduction r = Reduce(call);
 
    ASSERT_TRUE(r.Changed());
    EXPECT_THAT(r.replacement(), IsTruncateFloat64ToFloat32(p0));
  }
}

References v8::internal::Handle< T >::cast(), v8::internal::Object::GetProperty(), IsTruncateFloat64ToFloat32(), v8::internal::compiler::anonymous_namespace{js-builtin-reducer-unittest.cc}::kNumberTypes, v8::internal::NO_CALL_FUNCTION_FLAGS, and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [69/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathImul
	)

Definition at line 184 of file js-builtin-reducer-unittest.cc.

                                       {
  Handle<JSFunction> f(isolate()->context()->math_imul_fun());
 
  TRACED_FOREACH(Type*, t0, kNumberTypes) {
    TRACED_FOREACH(Type*, t1, kNumberTypes) {
      Node* p0 = Parameter(t0, 0);
      Node* p1 = Parameter(t1, 1);
      Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
      Node* call =
          graph()->NewNode(javascript()->Call(4, NO_CALL_FUNCTION_FLAGS), fun,
                           UndefinedConstant(), p0, p1);
      Reduction r = Reduce(call);
 
      if (t0->Is(Type::Integral32()) && t1->Is(Type::Integral32())) {
        ASSERT_TRUE(r.Changed());
        EXPECT_THAT(r.replacement(), IsInt32Mul(p0, p1));
      } else {
        ASSERT_FALSE(r.Changed());
        EXPECT_EQ(IrOpcode::kJSCallFunction, call->opcode());
      }
    }
  }
}

References IsInt32Mul(), v8::internal::compiler::anonymous_namespace{js-builtin-reducer-unittest.cc}::kNumberTypes, v8::internal::NO_CALL_FUNCTION_FLAGS, v8::internal::p0, and v8::internal::p1.

Here is the call graph for this function:

TEST_F() [70/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathMax0
	)

Definition at line 119 of file js-builtin-reducer-unittest.cc.

                                       {
  Handle<JSFunction> f(isolate()->context()->math_max_fun());
 
  Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
  Node* call = graph()->NewNode(javascript()->Call(2, NO_CALL_FUNCTION_FLAGS),
                                fun, UndefinedConstant());
  Reduction r = Reduce(call);
 
  ASSERT_TRUE(r.Changed());
  EXPECT_THAT(r.replacement(), IsNumberConstant(-V8_INFINITY));
}

References IsNumberConstant(), v8::internal::NO_CALL_FUNCTION_FLAGS, and V8_INFINITY.

Here is the call graph for this function:

TEST_F() [71/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathMax1
	)

Definition at line 132 of file js-builtin-reducer-unittest.cc.

                                       {
  Handle<JSFunction> f(isolate()->context()->math_max_fun());
 
  TRACED_FOREACH(Type*, t0, kNumberTypes) {
    Node* p0 = Parameter(t0, 0);
    Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
    Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
                                  fun, UndefinedConstant(), p0);
    Reduction r = Reduce(call);
 
    ASSERT_TRUE(r.Changed());
    EXPECT_THAT(r.replacement(), p0);
  }
}

References v8::internal::compiler::anonymous_namespace{js-builtin-reducer-unittest.cc}::kNumberTypes, v8::internal::NO_CALL_FUNCTION_FLAGS, and v8::internal::p0.

TEST_F() [72/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathMax2
	)

Definition at line 148 of file js-builtin-reducer-unittest.cc.

                                       {
  Handle<JSFunction> f(isolate()->context()->math_max_fun());
 
  TRACED_FOREACH(Type*, t0, kNumberTypes) {
    TRACED_FOREACH(Type*, t1, kNumberTypes) {
      Node* p0 = Parameter(t0, 0);
      Node* p1 = Parameter(t1, 1);
      Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
      Node* call =
          graph()->NewNode(javascript()->Call(4, NO_CALL_FUNCTION_FLAGS), fun,
                           UndefinedConstant(), p0, p1);
      Reduction r = Reduce(call);
 
      if (t0->Is(Type::Integral32()) && t1->Is(Type::Integral32())) {
        Capture<Node*> branch;
        ASSERT_TRUE(r.Changed());
        EXPECT_THAT(
            r.replacement(),
            IsPhi(kMachNone, p1, p0,
                  IsMerge(IsIfTrue(CaptureEq(&branch)),
                          IsIfFalse(AllOf(CaptureEq(&branch),
                                          IsBranch(IsNumberLessThan(p0, p1),
                                                   graph()->start()))))));
      } else {
        ASSERT_FALSE(r.Changed());
        EXPECT_EQ(IrOpcode::kJSCallFunction, call->opcode());
      }
    }
  }
}

References IsBranch(), IsIfFalse(), IsIfTrue(), IsMerge(), IsNumberLessThan(), IsPhi(), kMachNone, v8::internal::compiler::anonymous_namespace{js-builtin-reducer-unittest.cc}::kNumberTypes, v8::internal::NO_CALL_FUNCTION_FLAGS, v8::internal::p0, and v8::internal::p1.

Here is the call graph for this function:

TEST_F() [73/132]

v8::internal::compiler::TEST_F	(	JSBuiltinReducerTest	,
		MathSqrt
	)

Definition at line 99 of file js-builtin-reducer-unittest.cc.

                                       {
  Handle<JSFunction> f(isolate()->context()->math_sqrt_fun());
 
  TRACED_FOREACH(Type*, t0, kNumberTypes) {
    Node* p0 = Parameter(t0, 0);
    Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
    Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
                                  fun, UndefinedConstant(), p0);
    Reduction r = Reduce(call);
 
    ASSERT_TRUE(r.Changed());
    EXPECT_THAT(r.replacement(), IsFloat64Sqrt(p0));
  }
}

References IsFloat64Sqrt(), v8::internal::compiler::anonymous_namespace{js-builtin-reducer-unittest.cc}::kNumberTypes, v8::internal::NO_CALL_FUNCTION_FLAGS, and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [74/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeFloat64ToFloat32WithConstant
	)

Definition at line 249 of file machine-operator-reducer-unittest.cc.

                                                                       {
  TRACED_FOREACH(float, x, kFloat32Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        machine()->ChangeFloat32ToFloat64(), Float32Constant(x)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsFloat64Constant(x));
  }
}

References IsFloat64Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kFloat32Values.

Here is the call graph for this function:

TEST_F() [75/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeFloat64ToInt32WithChangeInt32ToFloat64
	)

Definition at line 263 of file machine-operator-reducer-unittest.cc.

                                                     {
  Node* value = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      machine()->ChangeFloat64ToInt32(),
      graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(value, reduction.replacement());
}

TEST_F() [76/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeFloat64ToInt32WithConstant
	)

Definition at line 274 of file machine-operator-reducer-unittest.cc.

                                                                     {
  TRACED_FOREACH(int32_t, x, kInt32Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        machine()->ChangeFloat64ToInt32(), Float64Constant(FastI2D(x))));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsInt32Constant(x));
  }
}

References v8::internal::FastI2D(), IsInt32Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kInt32Values.

Here is the call graph for this function:

TEST_F() [77/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeFloat64ToUint32WithChangeUint32ToFloat64
	)

Definition at line 288 of file machine-operator-reducer-unittest.cc.

                                                       {
  Node* value = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      machine()->ChangeFloat64ToUint32(),
      graph()->NewNode(machine()->ChangeUint32ToFloat64(), value)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(value, reduction.replacement());
}

TEST_F() [78/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeFloat64ToUint32WithConstant
	)

Definition at line 299 of file machine-operator-reducer-unittest.cc.

                                                                      {
  TRACED_FOREACH(uint32_t, x, kUint32Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        machine()->ChangeFloat64ToUint32(), Float64Constant(FastUI2D(x))));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsInt32Constant(bit_cast<int32_t>(x)));
  }
}

References v8::internal::FastUI2D(), IsInt32Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kUint32Values.

Here is the call graph for this function:

TEST_F() [79/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeInt32ToFloat64WithConstant
	)

Definition at line 313 of file machine-operator-reducer-unittest.cc.

                                                                     {
  TRACED_FOREACH(int32_t, x, kInt32Values) {
    Reduction reduction = Reduce(
        graph()->NewNode(machine()->ChangeInt32ToFloat64(), Int32Constant(x)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastI2D(x)));
  }
}

References v8::internal::FastI2D(), IsFloat64Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kInt32Values.

Here is the call graph for this function:

TEST_F() [80/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeInt32ToInt64WithConstant
	)

Definition at line 327 of file machine-operator-reducer-unittest.cc.

                                                                   {
  TRACED_FOREACH(int32_t, x, kInt32Values) {
    Reduction reduction = Reduce(
        graph()->NewNode(machine()->ChangeInt32ToInt64(), Int32Constant(x)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsInt64Constant(x));
  }
}

References IsInt64Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kInt32Values.

Here is the call graph for this function:

TEST_F() [81/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeUint32ToFloat64WithConstant
	)

Definition at line 341 of file machine-operator-reducer-unittest.cc.

                                                                      {
  TRACED_FOREACH(uint32_t, x, kUint32Values) {
    Reduction reduction =
        Reduce(graph()->NewNode(machine()->ChangeUint32ToFloat64(),
                                Int32Constant(bit_cast<int32_t>(x))));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastUI2D(x)));
  }
}

References v8::internal::FastUI2D(), IsFloat64Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kUint32Values.

Here is the call graph for this function:

TEST_F() [82/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ChangeUint32ToUint64WithConstant
	)

Definition at line 356 of file machine-operator-reducer-unittest.cc.

                                                                     {
  TRACED_FOREACH(uint32_t, x, kUint32Values) {
    Reduction reduction =
        Reduce(graph()->NewNode(machine()->ChangeUint32ToUint64(),
                                Int32Constant(bit_cast<int32_t>(x))));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(),
                IsInt64Constant(bit_cast<int64_t>(static_cast<uint64_t>(x))));
  }
}

References IsInt64Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kUint32Values.

Here is the call graph for this function:

TEST_F() [83/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Int32AddWithOverflowWithConstant
	)

Definition at line 599 of file machine-operator-reducer-unittest.cc.

                                                                     {
  TRACED_FOREACH(int32_t, x, kInt32Values) {
    TRACED_FOREACH(int32_t, y, kInt32Values) {
      int32_t z;
      Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(),
                                   Int32Constant(x), Int32Constant(y));
 
      Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
      ASSERT_TRUE(r.Changed());
      EXPECT_THAT(r.replacement(),
                  IsInt32Constant(base::bits::SignedAddOverflow32(x, y, &z)));
 
      r = Reduce(graph()->NewNode(common()->Projection(0), add));
      ASSERT_TRUE(r.Changed());
      EXPECT_THAT(r.replacement(), IsInt32Constant(z));
    }
  }
}

References IsInt32Constant(), v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kInt32Values, v8::base::bits::SignedAddOverflow32(), and v8::base::internal::y.

Here is the call graph for this function:

TEST_F() [84/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Int32AddWithOverflowWithZero
	)

Definition at line 570 of file machine-operator-reducer-unittest.cc.

                                                                 {
  Node* p0 = Parameter(0);
  {
    Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(),
                                 Int32Constant(0), p0);
 
    Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
    ASSERT_TRUE(r.Changed());
    EXPECT_THAT(r.replacement(), IsInt32Constant(0));
 
    r = Reduce(graph()->NewNode(common()->Projection(0), add));
    ASSERT_TRUE(r.Changed());
    EXPECT_EQ(p0, r.replacement());
  }
  {
    Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), p0,
                                 Int32Constant(0));
 
    Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
    ASSERT_TRUE(r.Changed());
    EXPECT_THAT(r.replacement(), IsInt32Constant(0));
 
    r = Reduce(graph()->NewNode(common()->Projection(0), add));
    ASSERT_TRUE(r.Changed());
    EXPECT_EQ(p0, r.replacement());
  }
}

References IsInt32Constant(), and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [85/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Int32SubWithOverflowWithConstant
	)

Definition at line 638 of file machine-operator-reducer-unittest.cc.

                                                                     {
  TRACED_FOREACH(int32_t, x, kInt32Values) {
    TRACED_FOREACH(int32_t, y, kInt32Values) {
      int32_t z;
      Node* add = graph()->NewNode(machine()->Int32SubWithOverflow(),
                                   Int32Constant(x), Int32Constant(y));
 
      Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
      ASSERT_TRUE(r.Changed());
      EXPECT_THAT(r.replacement(),
                  IsInt32Constant(base::bits::SignedSubOverflow32(x, y, &z)));
 
      r = Reduce(graph()->NewNode(common()->Projection(0), add));
      ASSERT_TRUE(r.Changed());
      EXPECT_THAT(r.replacement(), IsInt32Constant(z));
    }
  }
}

References IsInt32Constant(), v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kInt32Values, v8::base::bits::SignedSubOverflow32(), and v8::base::internal::y.

Here is the call graph for this function:

TEST_F() [86/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Int32SubWithOverflowWithZero
	)

Definition at line 623 of file machine-operator-reducer-unittest.cc.

                                                                 {
  Node* p0 = Parameter(0);
  Node* add =
      graph()->NewNode(machine()->Int32SubWithOverflow(), p0, Int32Constant(0));
 
  Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
  ASSERT_TRUE(r.Changed());
  EXPECT_THAT(r.replacement(), IsInt32Constant(0));
 
  r = Reduce(graph()->NewNode(common()->Projection(0), add));
  ASSERT_TRUE(r.Changed());
  EXPECT_EQ(p0, r.replacement());
}

References IsInt32Constant(), and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [87/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ReduceToWord32RorWithConstant
	)

Definition at line 472 of file machine-operator-reducer-unittest.cc.

                                                                  {
  Node* value = Parameter(0);
  TRACED_FORRANGE(int32_t, k, 0, 31) {
    Node* shl =
        graph()->NewNode(machine()->Word32Shl(), value, Int32Constant(k));
    Node* shr =
        graph()->NewNode(machine()->Word32Shr(), value, Int32Constant(32 - k));
 
    // (x << K) | (x >> ((32 - K) - y)) => x ror K
    Node* node1 = graph()->NewNode(machine()->Word32Or(), shl, shr);
    Reduction reduction1 = Reduce(node1);
    EXPECT_TRUE(reduction1.Changed());
    EXPECT_EQ(reduction1.replacement(), node1);
    EXPECT_THAT(reduction1.replacement(),
                IsWord32Ror(value, IsInt32Constant(k)));
 
    // (x >> (32 - K)) | (x << K) => x ror K
    Node* node2 = graph()->NewNode(machine()->Word32Or(), shr, shl);
    Reduction reduction2 = Reduce(node2);
    EXPECT_TRUE(reduction2.Changed());
    EXPECT_EQ(reduction2.replacement(), node2);
    EXPECT_THAT(reduction2.replacement(),
                IsWord32Ror(value, IsInt32Constant(k)));
  }
}

References IsInt32Constant(), and IsWord32Ror().

Here is the call graph for this function:

TEST_F() [88/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		ReduceToWord32RorWithParameters
	)

Definition at line 448 of file machine-operator-reducer-unittest.cc.

                                                                    {
  Node* value = Parameter(0);
  Node* shift = Parameter(1);
  Node* shl = graph()->NewNode(machine()->Word32Shl(), value, shift);
  Node* shr = graph()->NewNode(
      machine()->Word32Shr(), value,
      graph()->NewNode(machine()->Int32Sub(), Int32Constant(32), shift));
 
  // (x << y) | (x >> (32 - y)) => x ror y
  Node* node1 = graph()->NewNode(machine()->Word32Or(), shl, shr);
  Reduction reduction1 = Reduce(node1);
  EXPECT_TRUE(reduction1.Changed());
  EXPECT_EQ(reduction1.replacement(), node1);
  EXPECT_THAT(reduction1.replacement(), IsWord32Ror(value, shift));
 
  // (x >> (32 - y)) | (x << y) => x ror y
  Node* node2 = graph()->NewNode(machine()->Word32Or(), shr, shl);
  Reduction reduction2 = Reduce(node2);
  EXPECT_TRUE(reduction2.Changed());
  EXPECT_EQ(reduction2.replacement(), node2);
  EXPECT_THAT(reduction2.replacement(), IsWord32Ror(value, shift));
}

References IsWord32Ror(), and shift.

Here is the call graph for this function:

TEST_F() [89/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		TruncateFloat64ToFloat32WithChangeFloat32ToFloat64
	)

Definition at line 372 of file machine-operator-reducer-unittest.cc.

                                                           {
  Node* value = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      machine()->TruncateFloat64ToFloat32(),
      graph()->NewNode(machine()->ChangeFloat32ToFloat64(), value)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(value, reduction.replacement());
}

TEST_F() [90/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		TruncateFloat64ToFloat32WithConstant
	)

Definition at line 383 of file machine-operator-reducer-unittest.cc.

                                                                         {
  TRACED_FOREACH(double, x, kFloat64Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        machine()->TruncateFloat64ToFloat32(), Float64Constant(x)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsFloat32Constant(DoubleToFloat32(x)));
  }
}

References v8::internal::DoubleToFloat32(), IsFloat32Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kFloat64Values.

Here is the call graph for this function:

TEST_F() [91/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		TruncateFloat64ToInt32WithChangeInt32ToFloat64
	)

Definition at line 397 of file machine-operator-reducer-unittest.cc.

                                                       {
  Node* value = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      machine()->TruncateFloat64ToInt32(),
      graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(value, reduction.replacement());
}

TEST_F() [92/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		TruncateFloat64ToInt32WithConstant
	)

Definition at line 408 of file machine-operator-reducer-unittest.cc.

                                                                       {
  TRACED_FOREACH(double, x, kFloat64Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        machine()->TruncateFloat64ToInt32(), Float64Constant(x)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(x)));
  }
}

References v8::internal::DoubleToInt32(), IsInt32Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kFloat64Values.

Here is the call graph for this function:

TEST_F() [93/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		TruncateInt64ToInt32WithChangeInt32ToInt64
	)

Definition at line 422 of file machine-operator-reducer-unittest.cc.

                                                                               {
  Node* value = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      machine()->TruncateInt64ToInt32(),
      graph()->NewNode(machine()->ChangeInt32ToInt64(), value)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(value, reduction.replacement());
}

TEST_F() [94/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		TruncateInt64ToInt32WithConstant
	)

Definition at line 432 of file machine-operator-reducer-unittest.cc.

                                                                     {
  TRACED_FOREACH(int64_t, x, kInt64Values) {
    Reduction reduction = Reduce(
        graph()->NewNode(machine()->TruncateInt64ToInt32(), Int64Constant(x)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(),
                IsInt32Constant(bit_cast<int32_t>(
                    static_cast<uint32_t>(bit_cast<uint64_t>(x)))));
  }
}

References IsInt32Constant(), and v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kInt64Values.

Here is the call graph for this function:

TEST_F() [95/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Word32RorWithConstants
	)

Definition at line 509 of file machine-operator-reducer-unittest.cc.

                                                           {
  TRACED_FOREACH(int32_t, x, kUint32Values) {
    TRACED_FORRANGE(int32_t, y, 0, 31) {
      Node* node = graph()->NewNode(machine()->Word32Ror(), Int32Constant(x),
                                    Int32Constant(y));
      Reduction reduction = Reduce(node);
      EXPECT_TRUE(reduction.Changed());
      EXPECT_THAT(reduction.replacement(),
                  IsInt32Constant(base::bits::RotateRight32(x, y)));
    }
  }
}

References IsInt32Constant(), v8::internal::compiler::anonymous_namespace{machine-operator-reducer-unittest.cc}::kUint32Values, v8::base::bits::RotateRight32(), and v8::base::internal::y.

Here is the call graph for this function:

TEST_F() [96/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Word32RorWithZeroShift
	)

Definition at line 499 of file machine-operator-reducer-unittest.cc.

                                                           {
  Node* value = Parameter(0);
  Node* node =
      graph()->NewNode(machine()->Word32Ror(), value, Int32Constant(0));
  Reduction reduction = Reduce(node);
  EXPECT_TRUE(reduction.Changed());
  EXPECT_EQ(reduction.replacement(), value);
}

TEST_F() [97/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Word32ShlWithWord32Sar
	)

Definition at line 536 of file machine-operator-reducer-unittest.cc.

                                                           {
  Node* p0 = Parameter(0);
  TRACED_FORRANGE(int32_t, x, 1, 31) {
    Node* node = graph()->NewNode(
        machine()->Word32Shl(),
        graph()->NewNode(machine()->Word32Sar(), p0, Int32Constant(x)),
        Int32Constant(x));
    Reduction r = Reduce(node);
    ASSERT_TRUE(r.Changed());
    int32_t m = bit_cast<int32_t>(~((1U << x) - 1U));
    EXPECT_THAT(r.replacement(), IsWord32And(p0, IsInt32Constant(m)));
  }
}

References IsInt32Constant(), IsWord32And(), and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [98/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Word32ShlWithWord32Shr
	)

Definition at line 551 of file machine-operator-reducer-unittest.cc.

                                                           {
  Node* p0 = Parameter(0);
  TRACED_FORRANGE(int32_t, x, 1, 31) {
    Node* node = graph()->NewNode(
        machine()->Word32Shl(),
        graph()->NewNode(machine()->Word32Shr(), p0, Int32Constant(x)),
        Int32Constant(x));
    Reduction r = Reduce(node);
    ASSERT_TRUE(r.Changed());
    int32_t m = bit_cast<int32_t>(~((1U << x) - 1U));
    EXPECT_THAT(r.replacement(), IsWord32And(p0, IsInt32Constant(m)));
  }
}

References IsInt32Constant(), IsWord32And(), and v8::internal::p0.

Here is the call graph for this function:

TEST_F() [99/132]

v8::internal::compiler::TEST_F	(	MachineOperatorReducerTest	,
		Word32ShlWithZeroShift
	)

Definition at line 527 of file machine-operator-reducer-unittest.cc.

                                                           {
  Node* p0 = Parameter(0);
  Node* node = graph()->NewNode(machine()->Word32Shl(), p0, Int32Constant(0));
  Reduction r = Reduce(node);
  ASSERT_TRUE(r.Changed());
  EXPECT_EQ(p0, r.replacement());
}

References v8::internal::p0.

TEST_F() [100/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		BooleanNotWithBooleanNot
	)

Definition at line 179 of file simplified-operator-reducer-unittest.cc.

                                                                {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(
      graph()->NewNode(simplified()->BooleanNot(),
                       graph()->NewNode(simplified()->BooleanNot(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(param0, reduction.replacement());
}

TEST_F() [101/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		BooleanNotWithFalseConstant
	)

Definition at line 189 of file simplified-operator-reducer-unittest.cc.

                                                                   {
  Reduction reduction0 =
      Reduce(graph()->NewNode(simplified()->BooleanNot(), FalseConstant()));
  ASSERT_TRUE(reduction0.Changed());
  EXPECT_THAT(reduction0.replacement(), IsTrueConstant());
}

TEST_F() [102/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		BooleanNotWithTrueConstant
	)

Definition at line 197 of file simplified-operator-reducer-unittest.cc.

                                                                  {
  Reduction reduction1 =
      Reduce(graph()->NewNode(simplified()->BooleanNot(), TrueConstant()));
  ASSERT_TRUE(reduction1.Changed());
  EXPECT_THAT(reduction1.replacement(), IsFalseConstant());
}

TEST_F() [103/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeBitToBoolWithChangeBoolToBit
	)

Definition at line 209 of file simplified-operator-reducer-unittest.cc.

                                                                          {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeBitToBool(),
      graph()->NewNode(simplified()->ChangeBoolToBit(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(param0, reduction.replacement());
}

TEST_F() [104/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeBitToBoolWithOneConstant
	)

Definition at line 227 of file simplified-operator-reducer-unittest.cc.

                                                                      {
  Reduction reduction = Reduce(
      graph()->NewNode(simplified()->ChangeBitToBool(), Int32Constant(1)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsTrueConstant());
}

TEST_F() [105/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeBitToBoolWithZeroConstant
	)

Definition at line 219 of file simplified-operator-reducer-unittest.cc.

                                                                       {
  Reduction reduction = Reduce(
      graph()->NewNode(simplified()->ChangeBitToBool(), Int32Constant(0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsFalseConstant());
}

TEST_F() [106/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeBoolToBitWithChangeBitToBool
	)

Definition at line 255 of file simplified-operator-reducer-unittest.cc.

                                                                          {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeBoolToBit(),
      graph()->NewNode(simplified()->ChangeBitToBool(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(param0, reduction.replacement());
}

TEST_F() [107/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeBoolToBitWithFalseConstant
	)

Definition at line 239 of file simplified-operator-reducer-unittest.cc.

                                                                        {
  Reduction reduction = Reduce(
      graph()->NewNode(simplified()->ChangeBoolToBit(), FalseConstant()));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
}

References IsInt32Constant().

Here is the call graph for this function:

TEST_F() [108/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeBoolToBitWithTrueConstant
	)

Definition at line 247 of file simplified-operator-reducer-unittest.cc.

                                                                       {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeBoolToBit(), TrueConstant()));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsInt32Constant(1));
}

References IsInt32Constant().

Here is the call graph for this function:

TEST_F() [109/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeFloat64ToTaggedWithConstant
	)

Definition at line 269 of file simplified-operator-reducer-unittest.cc.

                                                                         {
  TRACED_FOREACH(double, n, kFloat64Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        simplified()->ChangeFloat64ToTagged(), Float64Constant(n)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsNumberConstant(n));
  }
}

References IsNumberConstant(), and v8::internal::compiler::anonymous_namespace{simplified-operator-reducer-unittest.cc}::kFloat64Values.

Here is the call graph for this function:

TEST_F() [110/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeInt32ToTaggedWithConstant
	)

Definition at line 283 of file simplified-operator-reducer-unittest.cc.

                                                                       {
  TRACED_FOREACH(int32_t, n, kInt32Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        simplified()->ChangeInt32ToTagged(), Int32Constant(n)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsNumberConstant(FastI2D(n)));
  }
}

References v8::internal::FastI2D(), IsNumberConstant(), and v8::internal::compiler::anonymous_namespace{simplified-operator-reducer-unittest.cc}::kInt32Values.

Here is the call graph for this function:

TEST_F() [111/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToFloat64WithChangeFloat64ToTagged
	)

Definition at line 297 of file simplified-operator-reducer-unittest.cc.

                                                       {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToFloat64(),
      graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(param0, reduction.replacement());
}

TEST_F() [112/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToFloat64WithChangeInt32ToTagged
	)

Definition at line 308 of file simplified-operator-reducer-unittest.cc.

                                                     {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToFloat64(),
      graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsChangeInt32ToFloat64(param0));
}

References IsChangeInt32ToFloat64().

Here is the call graph for this function:

TEST_F() [113/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToFloat64WithChangeUint32ToTagged
	)

Definition at line 319 of file simplified-operator-reducer-unittest.cc.

                                                      {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToFloat64(),
      graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsChangeUint32ToFloat64(param0));
}

References IsChangeUint32ToFloat64().

Here is the call graph for this function:

TEST_F() [114/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToFloat64WithConstant
	)

Definition at line 330 of file simplified-operator-reducer-unittest.cc.

                                                                         {
  TRACED_FOREACH(double, n, kFloat64Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        simplified()->ChangeTaggedToFloat64(), NumberConstant(n)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsFloat64Constant(n));
  }
}

References IsFloat64Constant(), and v8::internal::compiler::anonymous_namespace{simplified-operator-reducer-unittest.cc}::kFloat64Values.

Here is the call graph for this function:

TEST_F() [115/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToFloat64WithNaNConstant1
	)

Definition at line 340 of file simplified-operator-reducer-unittest.cc.

                                                                             {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
                              NumberConstant(-base::OS::nan_value())));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsFloat64Constant(IsNaN()));
}

References IsFloat64Constant(), and v8::base::OS::nan_value().

Here is the call graph for this function:

TEST_F() [116/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToFloat64WithNaNConstant2
	)

Definition at line 349 of file simplified-operator-reducer-unittest.cc.

                                                                             {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
                              NumberConstant(base::OS::nan_value())));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsFloat64Constant(IsNaN()));
}

References IsFloat64Constant(), and v8::base::OS::nan_value().

Here is the call graph for this function:

TEST_F() [117/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToInt32WithChangeFloat64ToTagged
	)

Definition at line 362 of file simplified-operator-reducer-unittest.cc.

                                                     {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToInt32(),
      graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToInt32(param0));
}

References IsChangeFloat64ToInt32().

Here is the call graph for this function:

TEST_F() [118/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToInt32WithChangeInt32ToTagged
	)

Definition at line 373 of file simplified-operator-reducer-unittest.cc.

                                                   {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToInt32(),
      graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(param0, reduction.replacement());
}

TEST_F() [119/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToInt32WithConstant
	)

Definition at line 384 of file simplified-operator-reducer-unittest.cc.

                                                                       {
  TRACED_FOREACH(double, n, kFloat64Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        simplified()->ChangeTaggedToInt32(), NumberConstant(n)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n)));
  }
}

References v8::internal::DoubleToInt32(), IsInt32Constant(), and v8::internal::compiler::anonymous_namespace{simplified-operator-reducer-unittest.cc}::kFloat64Values.

Here is the call graph for this function:

TEST_F() [120/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToInt32WithNaNConstant1
	)

Definition at line 394 of file simplified-operator-reducer-unittest.cc.

                                                                           {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeTaggedToInt32(),
                              NumberConstant(-base::OS::nan_value())));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
}

References IsInt32Constant(), and v8::base::OS::nan_value().

Here is the call graph for this function:

TEST_F() [121/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToInt32WithNaNConstant2
	)

Definition at line 403 of file simplified-operator-reducer-unittest.cc.

                                                                           {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeTaggedToInt32(),
                              NumberConstant(base::OS::nan_value())));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
}

References IsInt32Constant(), and v8::base::OS::nan_value().

Here is the call graph for this function:

TEST_F() [122/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToUint32WithChangeFloat64ToTagged
	)

Definition at line 416 of file simplified-operator-reducer-unittest.cc.

                                                      {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToUint32(),
      graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToUint32(param0));
}

References IsChangeFloat64ToUint32().

Here is the call graph for this function:

TEST_F() [123/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToUint32WithChangeUint32ToTagged
	)

Definition at line 427 of file simplified-operator-reducer-unittest.cc.

                                                     {
  Node* param0 = Parameter(0);
  Reduction reduction = Reduce(graph()->NewNode(
      simplified()->ChangeTaggedToUint32(),
      graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0)));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_EQ(param0, reduction.replacement());
}

TEST_F() [124/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToUint32WithConstant
	)

Definition at line 438 of file simplified-operator-reducer-unittest.cc.

                                                                        {
  TRACED_FOREACH(double, n, kFloat64Values) {
    Reduction reduction = Reduce(graph()->NewNode(
        simplified()->ChangeTaggedToUint32(), NumberConstant(n)));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(),
                IsInt32Constant(bit_cast<int32_t>(DoubleToUint32(n))));
  }
}

References v8::internal::DoubleToUint32(), IsInt32Constant(), and v8::internal::compiler::anonymous_namespace{simplified-operator-reducer-unittest.cc}::kFloat64Values.

Here is the call graph for this function:

TEST_F() [125/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToUint32WithNaNConstant1
	)

Definition at line 449 of file simplified-operator-reducer-unittest.cc.

                                                                            {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeTaggedToUint32(),
                              NumberConstant(-base::OS::nan_value())));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
}

References IsInt32Constant(), and v8::base::OS::nan_value().

Here is the call graph for this function:

TEST_F() [126/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeTaggedToUint32WithNaNConstant2
	)

Definition at line 458 of file simplified-operator-reducer-unittest.cc.

                                                                            {
  Reduction reduction =
      Reduce(graph()->NewNode(simplified()->ChangeTaggedToUint32(),
                              NumberConstant(base::OS::nan_value())));
  ASSERT_TRUE(reduction.Changed());
  EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
}

References IsInt32Constant(), and v8::base::OS::nan_value().

Here is the call graph for this function:

TEST_F() [127/132]

v8::internal::compiler::TEST_F	(	SimplifiedOperatorReducerTest	,
		ChangeUint32ToTagged
	)

Definition at line 471 of file simplified-operator-reducer-unittest.cc.

                                                            {
  TRACED_FOREACH(uint32_t, n, kUint32Values) {
    Reduction reduction =
        Reduce(graph()->NewNode(simplified()->ChangeUint32ToTagged(),
                                Int32Constant(bit_cast<int32_t>(n))));
    ASSERT_TRUE(reduction.Changed());
    EXPECT_THAT(reduction.replacement(), IsNumberConstant(FastUI2D(n)));
  }
}

References v8::internal::FastUI2D(), IsNumberConstant(), and v8::internal::compiler::anonymous_namespace{simplified-operator-reducer-unittest.cc}::kUint32Values.

Here is the call graph for this function:

TEST_F() [128/132]

v8::internal::compiler::TEST_F	(	ValueNumberingReducerTest	,
		AllInputsAreChecked
	)

Definition at line 38 of file value-numbering-reducer-unittest.cc.

                                                       {
  Node* na = graph()->NewNode(&kOp0);
  Node* nb = graph()->NewNode(&kOp0);
  Node* n1 = graph()->NewNode(&kOp0, na);
  Node* n2 = graph()->NewNode(&kOp0, nb);
  EXPECT_FALSE(Reduce(n1).Changed());
  EXPECT_FALSE(Reduce(n2).Changed());
}

References v8::internal::compiler::anonymous_namespace{value-numbering-reducer-unittest.cc}::kOp0.

TEST_F() [129/132]

v8::internal::compiler::TEST_F	(	ValueNumberingReducerTest	,
		DeadNodesAreNeverReturned
	)

Definition at line 48 of file value-numbering-reducer-unittest.cc.

                                                             {
  Node* n0 = graph()->NewNode(&kOp0);
  Node* n1 = graph()->NewNode(&kOp1, n0);
  EXPECT_FALSE(Reduce(n1).Changed());
  n1->Kill();
  EXPECT_FALSE(Reduce(graph()->NewNode(&kOp1, n0)).Changed());
}

References v8::internal::compiler::anonymous_namespace{value-numbering-reducer-unittest.cc}::kOp0, and v8::internal::compiler::anonymous_namespace{value-numbering-reducer-unittest.cc}::kOp1.

TEST_F() [130/132]

v8::internal::compiler::TEST_F	(	ValueNumberingReducerTest	,
		OperatorEqualityNotIdentity
	)

Definition at line 57 of file value-numbering-reducer-unittest.cc.

                                                               {
  static const size_t kMaxInputCount = 16;
  Node* inputs[kMaxInputCount];
  for (size_t i = 0; i < arraysize(inputs); ++i) {
    Operator::Opcode opcode = static_cast<Operator::Opcode>(
        std::numeric_limits<Operator::Opcode>::max() - i);
    inputs[i] = graph()->NewNode(new (zone()) SimpleOperator(
        opcode, Operator::kNoProperties, 0, 1, "Operator"));
  }
  TRACED_FORRANGE(size_t, input_count, 0, arraysize(inputs)) {
    const SimpleOperator op1(static_cast<Operator::Opcode>(input_count),
                             Operator::kNoProperties,
                             static_cast<int>(input_count), 1, "op");
    Node* n1 = graph()->NewNode(&op1, static_cast<int>(input_count), inputs);
    Reduction r1 = Reduce(n1);
    EXPECT_FALSE(r1.Changed());
 
    const SimpleOperator op2(static_cast<Operator::Opcode>(input_count),
                             Operator::kNoProperties,
                             static_cast<int>(input_count), 1, "op");
    Node* n2 = graph()->NewNode(&op2, static_cast<int>(input_count), inputs);
    Reduction r2 = Reduce(n2);
    EXPECT_TRUE(r2.Changed());
    EXPECT_EQ(n1, r2.replacement());
  }
}

References arraysize, v8::internal::compiler::Operator::kNoProperties, v8::internal::r1, and v8::internal::r2.

TEST_F() [131/132]

v8::internal::compiler::TEST_F	(	ValueNumberingReducerTest	,
		SubsequentReductionsYieldTheSameNode
	)

Definition at line 85 of file value-numbering-reducer-unittest.cc.

                                                                        {
  static const size_t kMaxInputCount = 16;
  Node* inputs[kMaxInputCount];
  for (size_t i = 0; i < arraysize(inputs); ++i) {
    Operator::Opcode opcode = static_cast<Operator::Opcode>(
        std::numeric_limits<Operator::Opcode>::max() - i);
    inputs[i] = graph()->NewNode(new (zone()) SimpleOperator(
        opcode, Operator::kNoProperties, 0, 1, "Operator"));
  }
  TRACED_FORRANGE(size_t, input_count, 0, arraysize(inputs)) {
    const SimpleOperator op1(1, Operator::kNoProperties,
                             static_cast<int>(input_count), 1, "op1");
    Node* n = graph()->NewNode(&op1, static_cast<int>(input_count), inputs);
    Reduction r = Reduce(n);
    EXPECT_FALSE(r.Changed());
 
    r = Reduce(graph()->NewNode(&op1, static_cast<int>(input_count), inputs));
    ASSERT_TRUE(r.Changed());
    EXPECT_EQ(n, r.replacement());
 
    r = Reduce(graph()->NewNode(&op1, static_cast<int>(input_count), inputs));
    ASSERT_TRUE(r.Changed());
    EXPECT_EQ(n, r.replacement());
  }
}

References arraysize, and v8::internal::compiler::Operator::kNoProperties.

TEST_F() [132/132]

v8::internal::compiler::TEST_F	(	ValueNumberingReducerTest	,
		WontReplaceNodeWithItself
	)

Definition at line 112 of file value-numbering-reducer-unittest.cc.

                                                             {
  Node* n = graph()->NewNode(&kOp0);
  EXPECT_FALSE(Reduce(n).Changed());
  EXPECT_FALSE(Reduce(n).Changed());
}

References v8::internal::compiler::anonymous_namespace{value-numbering-reducer-unittest.cc}::kOp0.

TEST_P() [1/76]

v8::internal::compiler::TEST_P	(	CommonSharedOperatorTest	,
		InstancesAreGloballyShared
	)

Definition at line 67 of file common-operator-unittest.cc.

                                                             {
  const SharedOperator& sop = GetParam();
  CommonOperatorBuilder common1(zone());
  CommonOperatorBuilder common2(zone());
  EXPECT_EQ((common1.*sop.constructor)(), (common2.*sop.constructor)());
}

TEST_P() [2/76]

v8::internal::compiler::TEST_P	(	CommonSharedOperatorTest	,
		NumberOfInputsAndOutputs
	)

Definition at line 75 of file common-operator-unittest.cc.

                                                           {
  CommonOperatorBuilder common(zone());
  const SharedOperator& sop = GetParam();
  const Operator* op = (common.*sop.constructor)();
 
  EXPECT_EQ(sop.value_input_count, OperatorProperties::GetValueInputCount(op));
  EXPECT_EQ(sop.effect_input_count,
            OperatorProperties::GetEffectInputCount(op));
  EXPECT_EQ(sop.control_input_count,
            OperatorProperties::GetControlInputCount(op));
  EXPECT_EQ(
      sop.value_input_count + sop.effect_input_count + sop.control_input_count,
      OperatorProperties::GetTotalInputCount(op));
 
  EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
  EXPECT_EQ(sop.effect_output_count,
            OperatorProperties::GetEffectOutputCount(op));
  EXPECT_EQ(sop.control_output_count,
            OperatorProperties::GetControlOutputCount(op));
}

References v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), and v8::internal::compiler::OperatorProperties::GetValueOutputCount().

Here is the call graph for this function:

TEST_P() [3/76]

v8::internal::compiler::TEST_P	(	CommonSharedOperatorTest	,
		OpcodeIsCorrect
	)

Definition at line 97 of file common-operator-unittest.cc.

                                                  {
  CommonOperatorBuilder common(zone());
  const SharedOperator& sop = GetParam();
  const Operator* op = (common.*sop.constructor)();
  EXPECT_EQ(sop.opcode, op->opcode());
}

References v8::internal::compiler::Operator::opcode().

Here is the call graph for this function:

TEST_P() [4/76]

v8::internal::compiler::TEST_P	(	CommonSharedOperatorTest	,
		Properties
	)

Definition at line 105 of file common-operator-unittest.cc.

                                             {
  CommonOperatorBuilder common(zone());
  const SharedOperator& sop = GetParam();
  const Operator* op = (common.*sop.constructor)();
  EXPECT_EQ(sop.properties, op->properties());
}

References v8::internal::compiler::Operator::properties().

Here is the call graph for this function:

TEST_P() [5/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorAddSubTest	,
		ImmediateOnLeft
	)

Definition at line 327 of file instruction-selector-arm64-unittest.cc.

                                                       {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
 
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, type, type);
    m.Return((m.*dpi.constructor)(BuildConstant(m, type, imm), m.Parameter(0)));
    Stream s = m.Build();
 
    // Add can support an immediate on the left by commuting, but Sub can't
    // commute. We test zero-on-left Sub later.
    if (strstr(dpi.constructor_name, "Add") != NULL) {
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
      ASSERT_EQ(2U, s[0]->InputCount());
      EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
      EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
      EXPECT_EQ(1U, s[0]->OutputCount());
    }
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::BuildConstant(), v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, and NULL.

Here is the call graph for this function:

TEST_P() [6/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorAddSubTest	,
		ImmediateOnRight
	)

Definition at line 310 of file instruction-selector-arm64-unittest.cc.

                                                        {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, type, type);
    m.Return((m.*dpi.constructor)(m.Parameter(0), BuildConstant(m, type, imm)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
    EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::BuildConstant(), and v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates.

Here is the call graph for this function:

TEST_P() [7/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorComparisonTest	,
		WithImmediate
	)

Definition at line 1140 of file instruction-selector-arm64-unittest.cc.

                                                         {
  const MachInst2 cmp = GetParam();
  const MachineType type = cmp.machine_type;
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    // Compare with 0 are turned into tst instruction.
    if (imm == 0) continue;
    StreamBuilder m(this, type, type);
    m.Return((m.*cmp.constructor)(m.Parameter(0), BuildConstant(m, type, imm)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(cmp.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
    EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    // Compare with 0 are turned into tst instruction.
    if (imm == 0) continue;
    StreamBuilder m(this, type, type);
    m.Return((m.*cmp.constructor)(BuildConstant(m, type, imm), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(cmp.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
    EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::BuildConstant(), v8::internal::compiler::InstructionOperand::IMMEDIATE, v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kEqual, and kFlags_set.

Here is the call graph for this function:

TEST_P() [8/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorComparisonTest	,
		WithParameters
	)

Definition at line 1125 of file instruction-selector-arm64-unittest.cc.

                                                          {
  const MachInst2 cmp = GetParam();
  const MachineType type = cmp.machine_type;
  StreamBuilder m(this, type, type, type);
  m.Return((m.*cmp.constructor)(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(cmp.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kEqual, s[0]->flags_condition());
}

References kEqual, and kFlags_set.

TEST_P() [9/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorConversionTest	,
		Parameter
	)

Definition at line 967 of file instruction-selector-arm64-unittest.cc.

                                                     {
  const Conversion conv = GetParam();
  StreamBuilder m(this, conv.mi.machine_type, conv.src_machine_type);
  m.Return((m.*conv.mi.constructor)(m.Parameter(0)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(conv.mi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(1U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

TEST_P() [10/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPFlagSetTest	,
		BranchWithParameters
	)

Definition at line 389 of file instruction-selector-arm64-unittest.cc.

                                                               {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  StreamBuilder m(this, type, type, type);
  MLabel a, b;
  m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)), &a, &b);
  m.Bind(&a);
  m.Return(m.Int32Constant(1));
  m.Bind(&b);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kNotEqual, s[0]->flags_condition());
}

References kFlags_branch, and kNotEqual.

TEST_P() [11/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchIfNotZeroWithImmediate
	)

Definition at line 455 of file instruction-selector-arm-unittest.cc.

                                                                 {
  const DPI dpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Word32NotEqual(
                 (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                 m.Int32Constant(0)),
             &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Word32NotEqual(
                 (m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)),
                 m.Int32Constant(0)),
             &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References kFlags_branch, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, kMachInt32, and kNotEqual.

TEST_P() [12/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchIfNotZeroWithParameters
	)

Definition at line 393 of file instruction-selector-arm-unittest.cc.

                                                                  {
  const DPI dpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  MLabel a, b;
  m.Branch(
      m.Word32NotEqual((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)),
                       m.Int32Constant(0)),
      &a, &b);
  m.Bind(&a);
  m.Return(m.Int32Constant(1));
  m.Bind(&b);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kNotEqual, s[0]->flags_condition());
}

References kFlags_branch, kMachInt32, and kNotEqual.

TEST_P() [13/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchIfZeroWithImmediate
	)

Definition at line 414 of file instruction-selector-arm-unittest.cc.

                                                              {
  const DPI dpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Word32Equal(
                 (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                 m.Int32Constant(0)),
             &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch(m.Word32Equal(
                 (m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)),
                 m.Int32Constant(0)),
             &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_branch, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, and kMachInt32.

TEST_P() [14/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchIfZeroWithParameters
	)

Definition at line 373 of file instruction-selector-arm-unittest.cc.

                                                               {
  const DPI dpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  MLabel a, b;
  m.Branch(m.Word32Equal((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)),
                         m.Int32Constant(0)),
           &a, &b);
  m.Bind(&a);
  m.Return(m.Int32Constant(1));
  m.Bind(&b);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kEqual, s[0]->flags_condition());
}

References kEqual, kFlags_branch, and kMachInt32.

TEST_P() [15/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchWithImmediate
	)

Definition at line 246 of file instruction-selector-arm-unittest.cc.

                                                        {
  const DPI dpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)), &a,
             &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch((m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)), &a,
             &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References kFlags_branch, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, kMachInt32, and kNotEqual.

TEST_P() [16/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchWithParameters
	)

Definition at line 228 of file instruction-selector-arm-unittest.cc.

                                                         {
  const DPI dpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  MLabel a, b;
  m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)), &a, &b);
  m.Bind(&a);
  m.Return(m.Int32Constant(1));
  m.Bind(&b);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kNotEqual, s[0]->flags_condition());
}

References kFlags_branch, kMachInt32, and kNotEqual.

TEST_P() [17/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchWithShiftByImmediate
	)

Definition at line 324 of file instruction-selector-arm-unittest.cc.

                                                               {
  const DPI dpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      MLabel a, b;
      m.Branch((m.*dpi.constructor)(m.Parameter(0),
                                    (m.*shift.constructor)(
                                        m.Parameter(1), m.Int32Constant(imm))),
               &a, &b);
      m.Bind(&a);
      m.Return(m.Int32Constant(1));
      m.Bind(&b);
      m.Return(m.Int32Constant(0));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(5U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
      EXPECT_EQ(kNotEqual, s[0]->flags_condition());
    }
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      MLabel a, b;
      m.Branch((m.*dpi.constructor)(
                   (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                   m.Parameter(1)),
               &a, &b);
      m.Bind(&a);
      m.Return(m.Int32Constant(1));
      m.Bind(&b);
      m.Return(m.Int32Constant(0));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(5U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
      EXPECT_EQ(kNotEqual, s[0]->flags_condition());
    }
  }
}

References kFlags_branch, kMachInt32, kNotEqual, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [18/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		BranchWithShiftByParameter
	)

Definition at line 283 of file instruction-selector-arm-unittest.cc.

                                                               {
  const DPI dpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch((m.*dpi.constructor)(
                 m.Parameter(0),
                 (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))),
             &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    MLabel a, b;
    m.Branch((m.*dpi.constructor)(
                 (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)),
                 m.Parameter(2)),
             &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(1));
    m.Bind(&b);
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kNotEqual, s[0]->flags_condition());
  }
}

References kFlags_branch, kMachInt32, kNotEqual, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [19/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		Immediate
	)

Definition at line 137 of file instruction-selector-arm-unittest.cc.

                                              {
  const DPI dpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return((m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, and kMachInt32.

TEST_P() [20/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		Parameters
	)

Definition at line 124 of file instruction-selector-arm-unittest.cc.

                                               {
  const DPI dpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32.

TEST_P() [21/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		ShiftByImmediate
	)

Definition at line 193 of file instruction-selector-arm-unittest.cc.

                                                     {
  const DPI dpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      m.Return((m.*dpi.constructor)(
          m.Parameter(0),
          (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm))));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_EQ(1U, s[0]->OutputCount());
    }
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      m.Return((m.*dpi.constructor)(
          (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm)),
          m.Parameter(1)));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.reverse_arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_EQ(1U, s[0]->OutputCount());
    }
  }
}

References kMachInt32, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [22/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorDPITest	,
		ShiftByParameter
	)

Definition at line 164 of file instruction-selector-arm-unittest.cc.

                                                     {
  const DPI dpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return((m.*dpi.constructor)(
        m.Parameter(0),
        (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return((m.*dpi.constructor)(
        (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)),
        m.Parameter(2)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [23/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorFPCmpTest	,
		Parameter
	)

Definition at line 942 of file instruction-selector-arm64-unittest.cc.

                                                {
  const FPCmp cmp = GetParam();
  StreamBuilder m(this, kMachInt32, cmp.mi.machine_type, cmp.mi.machine_type);
  m.Return((m.*cmp.mi.constructor)(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(cmp.mi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(cmp.cond, s[0]->flags_condition());
}

References kFlags_set, and kMachInt32.

TEST_P() [24/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorIntDPWithIntMulTest	,
		AddWithMul
	)

Definition at line 841 of file instruction-selector-arm64-unittest.cc.

                                                           {
  const MulDPInst mdpi = GetParam();
  const MachineType type = mdpi.machine_type;
  {
    StreamBuilder m(this, type, type, type, type);
    Node* n = (m.*mdpi.mul_constructor)(m.Parameter(1), m.Parameter(2));
    m.Return((m.*mdpi.add_constructor)(m.Parameter(0), n));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(mdpi.add_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    StreamBuilder m(this, type, type, type, type);
    Node* n = (m.*mdpi.mul_constructor)(m.Parameter(0), m.Parameter(1));
    m.Return((m.*mdpi.add_constructor)(n, m.Parameter(2)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(mdpi.add_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

TEST_P() [25/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorIntDPWithIntMulTest	,
		NegativeMul
	)

Definition at line 883 of file instruction-selector-arm64-unittest.cc.

                                                            {
  const MulDPInst mdpi = GetParam();
  const MachineType type = mdpi.machine_type;
  {
    StreamBuilder m(this, type, type, type);
    Node* n =
        (m.*mdpi.sub_constructor)(BuildConstant(m, type, 0), m.Parameter(0));
    m.Return((m.*mdpi.mul_constructor)(n, m.Parameter(1)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(mdpi.neg_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
  {
    StreamBuilder m(this, type, type, type);
    Node* n =
        (m.*mdpi.sub_constructor)(BuildConstant(m, type, 0), m.Parameter(1));
    m.Return((m.*mdpi.mul_constructor)(m.Parameter(0), n));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(mdpi.neg_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::BuildConstant().

Here is the call graph for this function:

TEST_P() [26/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorIntDPWithIntMulTest	,
		SubWithMul
	)

Definition at line 867 of file instruction-selector-arm64-unittest.cc.

                                                           {
  const MulDPInst mdpi = GetParam();
  const MachineType type = mdpi.machine_type;
  {
    StreamBuilder m(this, type, type, type, type);
    Node* n = (m.*mdpi.mul_constructor)(m.Parameter(1), m.Parameter(2));
    m.Return((m.*mdpi.sub_constructor)(m.Parameter(0), n));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(mdpi.sub_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

TEST_P() [27/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorLogicalTest	,
		Immediate
	)

Definition at line 252 of file instruction-selector-arm64-unittest.cc.

                                                  {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  // TODO(all): Add support for testing 64-bit immediates.
  if (type == kMachInt32) {
    // Immediate on the right.
    TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
      StreamBuilder m(this, type, type);
      m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
      ASSERT_EQ(2U, s[0]->InputCount());
      EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(1U, s[0]->OutputCount());
    }
 
    // Immediate on the left; all logical ops should commute.
    TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
      StreamBuilder m(this, type, type);
      m.Return((m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
      ASSERT_EQ(2U, s[0]->InputCount());
      EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
      EXPECT_EQ(1U, s[0]->OutputCount());
    }
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kLogicalImmediates, and kMachInt32.

TEST_P() [28/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorLogicalTest	,
		Parameter
	)

Definition at line 239 of file instruction-selector-arm64-unittest.cc.

                                                  {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  StreamBuilder m(this, type, type, type);
  m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

TEST_P() [29/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorMemoryAccessTest	,
		LoadWithImmediateBase
	)

Definition at line 184 of file instruction-selector-ia32-unittest.cc.

                                                                   {
  const MemoryAccess memacc = GetParam();
  TRACED_FOREACH(int32_t, base, kImmediates) {
    StreamBuilder m(this, memacc.type, kMachPtr);
    m.Return(m.Load(memacc.type, m.Int32Constant(base), m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(memacc.load_opcode, s[0]->arch_opcode());
    if (base == 0) {
      ASSERT_EQ(1U, s[0]->InputCount());
    } else {
    ASSERT_EQ(2U, s[0]->InputCount());
    ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
    EXPECT_EQ(base, s.ToInt32(s[0]->InputAt(1)));
    }
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References v8::internal::compiler::InstructionOperand::IMMEDIATE, v8::internal::compiler::anonymous_namespace{instruction-selector-ia32-unittest.cc}::kImmediates, and kMachPtr.

TEST_P() [30/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorMemoryAccessTest	,
		LoadWithImmediateIndex
	)

Definition at line 1285 of file instruction-selector-arm-unittest.cc.

                                                                    {
  const MemoryAccess memacc = GetParam();
  TRACED_FOREACH(int32_t, index, memacc.immediates) {
    StreamBuilder m(this, memacc.type, kMachPtr);
    m.Return(m.Load(memacc.type, m.Parameter(0), m.Int32Constant(index)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(memacc.ldr_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Offset_RI, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
    EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(1)));
    ASSERT_EQ(1U, s[0]->OutputCount());
    EXPECT_TRUE((s.*memacc.val_predicate)(s[0]->Output()));
  }
}

References v8::internal::compiler::InstructionOperand::IMMEDIATE, and kMachPtr.

TEST_P() [31/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorMemoryAccessTest	,
		LoadWithParameters
	)

Definition at line 1271 of file instruction-selector-arm-unittest.cc.

                                                                {
  const MemoryAccess memacc = GetParam();
  StreamBuilder m(this, memacc.type, kMachPtr, kMachInt32);
  m.Return(m.Load(memacc.type, m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(memacc.ldr_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Offset_RR, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  ASSERT_EQ(1U, s[0]->OutputCount());
  EXPECT_TRUE((s.*memacc.val_predicate)(s[0]->Output()));
}

References kMachInt32, and kMachPtr.

TEST_P() [32/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorMemoryAccessTest	,
		StoreWithImmediateBase
	)

Definition at line 237 of file instruction-selector-ia32-unittest.cc.

                                                                    {
  const MemoryAccess memacc = GetParam();
  TRACED_FOREACH(int32_t, base, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32, memacc.type);
    m.Store(memacc.type, m.Int32Constant(base), m.Parameter(0), m.Parameter(1));
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(memacc.store_opcode, s[0]->arch_opcode());
    if (base == 0) {
      ASSERT_EQ(2U, s[0]->InputCount());
    } else {
    ASSERT_EQ(3U, s[0]->InputCount());
    ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
    EXPECT_EQ(base, s.ToInt32(s[0]->InputAt(1)));
    }
    EXPECT_EQ(0U, s[0]->OutputCount());
  }
}

References v8::internal::compiler::InstructionOperand::IMMEDIATE, v8::internal::compiler::anonymous_namespace{instruction-selector-ia32-unittest.cc}::kImmediates, kMachInt32, and v8::internal::U.

TEST_P() [33/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorMemoryAccessTest	,
		StoreWithImmediateIndex
	)

Definition at line 1317 of file instruction-selector-arm-unittest.cc.

                                                                     {
  const MemoryAccess memacc = GetParam();
  TRACED_FOREACH(int32_t, index, memacc.immediates) {
    StreamBuilder m(this, kMachInt32, kMachPtr, memacc.type);
    m.Store(memacc.type, m.Parameter(0), m.Int32Constant(index),
            m.Parameter(1));
    m.Return(m.Int32Constant(0));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(memacc.str_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Offset_RI, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
    EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(0U, s[0]->OutputCount());
  }
}

References v8::internal::compiler::InstructionOperand::IMMEDIATE, kMachInt32, kMachPtr, and v8::internal::U.

TEST_P() [34/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorMemoryAccessTest	,
		StoreWithParameters
	)

Definition at line 1303 of file instruction-selector-arm-unittest.cc.

                                                                 {
  const MemoryAccess memacc = GetParam();
  StreamBuilder m(this, kMachInt32, kMachPtr, kMachInt32, memacc.type);
  m.Store(memacc.type, m.Parameter(0), m.Parameter(1), m.Parameter(2));
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(memacc.str_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Offset_RR, s[0]->addressing_mode());
  EXPECT_EQ(3U, s[0]->InputCount());
  EXPECT_EQ(0U, s[0]->OutputCount());
}

References kMachInt32, kMachPtr, and v8::internal::U.

TEST_P() [35/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BothWithImmediate
	)

Definition at line 766 of file instruction-selector-arm-unittest.cc.

                                                       {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
    m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
    Stream s = m.Build();
    ASSERT_LE(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    Node* n = (m.*odpi.constructor)(m.Int32Constant(imm), m.Parameter(0));
    m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
    Stream s = m.Build();
    ASSERT_LE(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References kFlags_set, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, kMachInt32, and kOverflow.

TEST_P() [36/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BothWithParameters
	)

Definition at line 750 of file instruction-selector-arm-unittest.cc.

                                                        {
  const ODPI odpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
  m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
  Stream s = m.Build();
  ASSERT_LE(1U, s.size());
  EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(2U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kOverflow, s[0]->flags_condition());
}

References kFlags_set, kMachInt32, and kOverflow.

TEST_P() [37/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BothWithShiftByImmediate
	)

Definition at line 832 of file instruction-selector-arm-unittest.cc.

                                                              {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      Node* n = (m.*odpi.constructor)(
          m.Parameter(0),
          (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm)));
      m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
      Stream s = m.Build();
      ASSERT_LE(1U, s.size());
      EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_EQ(2U, s[0]->OutputCount());
      EXPECT_EQ(kFlags_set, s[0]->flags_mode());
      EXPECT_EQ(kOverflow, s[0]->flags_condition());
    }
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      Node* n = (m.*odpi.constructor)(
          (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm)),
          m.Parameter(1));
      m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
      Stream s = m.Build();
      ASSERT_LE(1U, s.size());
      EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_EQ(2U, s[0]->OutputCount());
      EXPECT_EQ(kFlags_set, s[0]->flags_mode());
      EXPECT_EQ(kOverflow, s[0]->flags_condition());
    }
  }
}

References kFlags_set, kMachInt32, kOverflow, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [38/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BothWithShiftByParameter
	)

Definition at line 799 of file instruction-selector-arm-unittest.cc.

                                                              {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    Node* n = (m.*odpi.constructor)(
        m.Parameter(0), (m.*shift.constructor)(m.Parameter(1), m.Parameter(2)));
    m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
    Stream s = m.Build();
    ASSERT_LE(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    Node* n = (m.*odpi.constructor)(
        (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)), m.Parameter(2));
    m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
    Stream s = m.Build();
    ASSERT_LE(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References kFlags_set, kMachInt32, kOverflow, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [39/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BranchIfNotZeroWithParameters
	)

Definition at line 958 of file instruction-selector-arm-unittest.cc.

                                                                   {
  const ODPI odpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  MLabel a, b;
  Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
  m.Branch(m.Word32NotEqual(m.Projection(1, n), m.Int32Constant(0)), &a, &b);
  m.Bind(&a);
  m.Return(m.Projection(0, n));
  m.Bind(&b);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(4U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kOverflow, s[0]->flags_condition());
}

References kFlags_branch, kMachInt32, and kOverflow.

TEST_P() [40/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BranchIfZeroWithParameters
	)

Definition at line 937 of file instruction-selector-arm-unittest.cc.

                                                                {
  const ODPI odpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  MLabel a, b;
  Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
  m.Branch(m.Word32Equal(m.Projection(1, n), m.Int32Constant(0)), &a, &b);
  m.Bind(&a);
  m.Return(m.Projection(0, n));
  m.Bind(&b);
  m.Return(m.Int32Constant(0));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(4U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kNotOverflow, s[0]->flags_condition());
}

References kFlags_branch, kMachInt32, and kNotOverflow.

TEST_P() [41/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BranchWithImmediate
	)

Definition at line 894 of file instruction-selector-arm-unittest.cc.

                                                         {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
    m.Branch(m.Projection(1, n), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(0));
    m.Bind(&b);
    m.Return(m.Projection(0, n));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(4U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    MLabel a, b;
    Node* n = (m.*odpi.constructor)(m.Int32Constant(imm), m.Parameter(0));
    m.Branch(m.Projection(1, n), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(0));
    m.Bind(&b);
    m.Return(m.Projection(0, n));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(4U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References kFlags_branch, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, kMachInt32, and kOverflow.

TEST_P() [42/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		BranchWithParameters
	)

Definition at line 873 of file instruction-selector-arm-unittest.cc.

                                                          {
  const ODPI odpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  MLabel a, b;
  Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
  m.Branch(m.Projection(1, n), &a, &b);
  m.Bind(&a);
  m.Return(m.Int32Constant(0));
  m.Bind(&b);
  m.Return(m.Projection(0, n));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(4U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
  EXPECT_EQ(kOverflow, s[0]->flags_condition());
}

References kFlags_branch, kMachInt32, and kOverflow.

TEST_P() [43/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		OvfWithImmediate
	)

Definition at line 523 of file instruction-selector-arm-unittest.cc.

                                                      {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        1, (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        1, (m.*odpi.constructor)(m.Int32Constant(imm), m.Parameter(0))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References kFlags_set, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, kMachInt32, and kOverflow.

TEST_P() [44/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		OvfWithParameters
	)

Definition at line 507 of file instruction-selector-arm-unittest.cc.

                                                       {
  const ODPI odpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(
      m.Projection(1, (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_LE(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kOverflow, s[0]->flags_condition());
}

References kFlags_set, kMachInt32, and kOverflow.

TEST_P() [45/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		OvfWithShiftByImmediate
	)

Definition at line 591 of file instruction-selector-arm-unittest.cc.

                                                             {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      m.Return(m.Projection(
          1, (m.*odpi.constructor)(m.Parameter(0),
                                   (m.*shift.constructor)(
                                       m.Parameter(1), m.Int32Constant(imm)))));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_LE(1U, s[0]->OutputCount());
      EXPECT_EQ(kFlags_set, s[0]->flags_mode());
      EXPECT_EQ(kOverflow, s[0]->flags_condition());
    }
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      m.Return(m.Projection(
          1, (m.*odpi.constructor)(
                 (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm)),
                 m.Parameter(0))));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_LE(1U, s[0]->OutputCount());
      EXPECT_EQ(kFlags_set, s[0]->flags_mode());
      EXPECT_EQ(kOverflow, s[0]->flags_condition());
    }
  }
}

References kFlags_set, kMachInt32, kOverflow, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [46/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		OvfWithShiftByParameter
	)

Definition at line 556 of file instruction-selector-arm-unittest.cc.

                                                             {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        1, (m.*odpi.constructor)(
               m.Parameter(0),
               (m.*shift.constructor)(m.Parameter(1), m.Parameter(2)))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        1, (m.*odpi.constructor)(
               (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)),
               m.Parameter(0))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References kFlags_set, kMachInt32, kOverflow, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [47/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		ValWithImmediate
	)

Definition at line 647 of file instruction-selector-arm-unittest.cc.

                                                      {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        0, (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_none, s[0]->flags_mode());
  }
  TRACED_FOREACH(int32_t, imm, kImmediates) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        0, (m.*odpi.constructor)(m.Int32Constant(imm), m.Parameter(0))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_none, s[0]->flags_mode());
  }
}

References kFlags_none, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kImmediates, and kMachInt32.

TEST_P() [48/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		ValWithParameters
	)

Definition at line 632 of file instruction-selector-arm-unittest.cc.

                                                       {
  const ODPI odpi = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(
      m.Projection(0, (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_LE(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_none, s[0]->flags_mode());
}

References kFlags_none, and kMachInt32.

TEST_P() [49/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		ValWithShiftByImmediate
	)

Definition at line 711 of file instruction-selector-arm-unittest.cc.

                                                             {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      m.Return(m.Projection(
          0, (m.*odpi.constructor)(m.Parameter(0),
                                   (m.*shift.constructor)(
                                       m.Parameter(1), m.Int32Constant(imm)))));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_LE(1U, s[0]->OutputCount());
      EXPECT_EQ(kFlags_none, s[0]->flags_mode());
    }
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
      StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
      m.Return(m.Projection(
          0, (m.*odpi.constructor)(
                 (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm)),
                 m.Parameter(0))));
      Stream s = m.Build();
      ASSERT_EQ(1U, s.size());
      EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
      EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
      ASSERT_EQ(3U, s[0]->InputCount());
      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
      EXPECT_LE(1U, s[0]->OutputCount());
      EXPECT_EQ(kFlags_none, s[0]->flags_mode());
    }
  }
}

References kFlags_none, kMachInt32, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [50/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorODPITest	,
		ValWithShiftByParameter
	)

Definition at line 678 of file instruction-selector-arm-unittest.cc.

                                                             {
  const ODPI odpi = GetParam();
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        0, (m.*odpi.constructor)(
               m.Parameter(0),
               (m.*shift.constructor)(m.Parameter(1), m.Parameter(2)))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_none, s[0]->flags_mode());
  }
  TRACED_FOREACH(Shift, shift, kShifts) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Projection(
        0, (m.*odpi.constructor)(
               (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)),
               m.Parameter(0))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_none, s[0]->flags_mode());
  }
}

References kFlags_none, kMachInt32, v8::internal::compiler::anonymous_namespace{instruction-selector-arm-unittest.cc}::kShifts, and shift.

TEST_P() [51/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		BothImmediateOnRight
	)

Definition at line 596 of file instruction-selector-arm64-unittest.cc.

                                                               {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, type, type);
    Node* n = (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
    m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
    Stream s = m.Build();
    ASSERT_LE(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_set, and kOverflow.

TEST_P() [52/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		BothParameter
	)

Definition at line 580 of file instruction-selector-arm64-unittest.cc.

                                                        {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  StreamBuilder m(this, type, type, type);
  Node* n = (m.*dpi.constructor)(m.Parameter(0), m.Parameter(1));
  m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
  Stream s = m.Build();
  ASSERT_LE(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(2U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kOverflow, s[0]->flags_condition());
}

References kFlags_set, and kOverflow.

TEST_P() [53/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		BranchWithImmediateOnRight
	)

Definition at line 636 of file instruction-selector-arm64-unittest.cc.

                                                                     {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, type, type);
    MLabel a, b;
    Node* n = (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
    m.Branch(m.Projection(1, n), &a, &b);
    m.Bind(&a);
    m.Return(m.Int32Constant(0));
    m.Bind(&b);
    m.Return(m.Projection(0, n));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(4U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_branch, and kOverflow.

TEST_P() [54/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		OvfImmediateOnRight
	)

Definition at line 528 of file instruction-selector-arm64-unittest.cc.

                                                              {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, type, type);
    m.Return(m.Projection(
        1, (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kOverflow, s[0]->flags_condition());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, kFlags_set, and kOverflow.

TEST_P() [55/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		OvfParameter
	)

Definition at line 512 of file instruction-selector-arm64-unittest.cc.

                                                       {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  StreamBuilder m(this, type, type, type);
  m.Return(
      m.Projection(1, (m.*dpi.constructor)(m.Parameter(0), m.Parameter(1))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_LE(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kOverflow, s[0]->flags_condition());
}

References kFlags_set, and kOverflow.

TEST_P() [56/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		ValImmediateOnRight
	)

Definition at line 562 of file instruction-selector-arm64-unittest.cc.

                                                              {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
    StreamBuilder m(this, type, type);
    m.Return(m.Projection(
        0, (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_LE(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_none, s[0]->flags_mode());
  }
}

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates, and kFlags_none.

TEST_P() [57/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorOvfAddSubTest	,
		ValParameter
	)

Definition at line 547 of file instruction-selector-arm64-unittest.cc.

                                                       {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  StreamBuilder m(this, type, type, type);
  m.Return(
      m.Projection(0, (m.*dpi.constructor)(m.Parameter(0), m.Parameter(1))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_LE(1U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_none, s[0]->flags_mode());
}

References kFlags_none.

TEST_P() [58/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Immediate
	)

Definition at line 1003 of file instruction-selector-arm-unittest.cc.

                                                {
  const Shift shift = GetParam();
  TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return((m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmMov, s[0]->arch_opcode());
    EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32, and shift.

TEST_P() [59/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Parameter
	)

Definition at line 748 of file instruction-selector-arm64-unittest.cc.

                                                {
  const MachInst2 dpi = GetParam();
  const MachineType type = dpi.machine_type;
  StreamBuilder m(this, type, type, type);
  m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

TEST_P() [60/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Parameters
	)

Definition at line 990 of file instruction-selector-arm-unittest.cc.

                                                 {
  const Shift shift = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return((m.*shift.constructor)(m.Parameter(0), m.Parameter(1)));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmMov, s[0]->arch_opcode());
  EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32, and shift.

TEST_P() [61/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32AndWithWord32NotWithImmediate
	)

Definition at line 1168 of file instruction-selector-arm-unittest.cc.

                                                                          {
  const Shift shift = GetParam();
  TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Word32And(m.Parameter(0),
                         m.Word32Not((m.*shift.constructor)(
                             m.Parameter(1), m.Int32Constant(imm)))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmBic, s[0]->arch_opcode());
    EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32, and shift.

TEST_P() [62/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32AndWithWord32NotWithParameters
	)

Definition at line 1154 of file instruction-selector-arm-unittest.cc.

                                                                           {
  const Shift shift = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Word32And(m.Parameter(0), m.Word32Not((m.*shift.constructor)(
                                           m.Parameter(1), m.Parameter(2)))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmBic, s[0]->arch_opcode());
  EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
  EXPECT_EQ(3U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32, and shift.

TEST_P() [63/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32EqualToZeroWithImmediate
	)

Definition at line 1104 of file instruction-selector-arm-unittest.cc.

                                                                     {
  const Shift shift = GetParam();
  TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(
        m.Int32Constant(0),
        (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmMov, s[0]->arch_opcode());
    EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(2U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_set, kMachInt32, and shift.

TEST_P() [64/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32EqualToZeroWithParameters
	)

Definition at line 1087 of file instruction-selector-arm-unittest.cc.

                                                                      {
  const Shift shift = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(
      m.Word32Equal(m.Int32Constant(0),
                    (m.*shift.constructor)(m.Parameter(0), m.Parameter(1))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmMov, s[0]->arch_opcode());
  EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(2U, s[0]->OutputCount());
  EXPECT_EQ(kFlags_set, s[0]->flags_mode());
  EXPECT_EQ(kEqual, s[0]->flags_condition());
}

References kEqual, kFlags_set, kMachInt32, and shift.

TEST_P() [65/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32EqualWithParameter
	)

Definition at line 1019 of file instruction-selector-arm-unittest.cc.

                                                               {
  const Shift shift = GetParam();
  {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(
        m.Word32Equal(m.Parameter(0),
                      (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
    m.Return(
        m.Word32Equal((m.*shift.constructor)(m.Parameter(1), m.Parameter(2)),
                      m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
    EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
    EXPECT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_set, kMachInt32, and shift.

TEST_P() [66/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32EqualWithParameterAndImmediate
	)

Definition at line 1052 of file instruction-selector-arm-unittest.cc.

                                                                           {
  const Shift shift = GetParam();
  TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(
        (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm)),
        m.Parameter(0)));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
    EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
  TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
    StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
    m.Return(m.Word32Equal(
        m.Parameter(0),
        (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
    EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
    ASSERT_EQ(3U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
    EXPECT_EQ(1U, s[0]->OutputCount());
    EXPECT_EQ(kFlags_set, s[0]->flags_mode());
    EXPECT_EQ(kEqual, s[0]->flags_condition());
  }
}

References kEqual, kFlags_set, kMachInt32, and shift.

TEST_P() [67/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32NotWithImmediate
	)

Definition at line 1137 of file instruction-selector-arm-unittest.cc.

                                                             {
  const Shift shift = GetParam();
  TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
    StreamBuilder m(this, kMachInt32, kMachInt32);
    m.Return(m.Word32Not(
        (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm))));
    Stream s = m.Build();
    ASSERT_EQ(1U, s.size());
    EXPECT_EQ(kArmMvn, s[0]->arch_opcode());
    EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
    ASSERT_EQ(2U, s[0]->InputCount());
    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
    EXPECT_EQ(1U, s[0]->OutputCount());
  }
}

References kMachInt32, and shift.

TEST_P() [68/76]

v8::internal::compiler::TEST_P	(	InstructionSelectorShiftTest	,
		Word32NotWithParameters
	)

Definition at line 1124 of file instruction-selector-arm-unittest.cc.

                                                              {
  const Shift shift = GetParam();
  StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
  m.Return(m.Word32Not((m.*shift.constructor)(m.Parameter(0), m.Parameter(1))));
  Stream s = m.Build();
  ASSERT_EQ(1U, s.size());
  EXPECT_EQ(kArmMvn, s[0]->arch_opcode());
  EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
  EXPECT_EQ(2U, s[0]->InputCount());
  EXPECT_EQ(1U, s[0]->OutputCount());
}

References kMachInt32, and shift.

TEST_P() [69/76]

v8::internal::compiler::TEST_P	(	MachineUnaryOperatorReducerTest	,
		Parameter
	)

Definition at line 232 of file machine-operator-reducer-unittest.cc.

                                                   {
  const UnaryOperator unop = GetParam();
  Reduction reduction =
      Reduce(graph()->NewNode((machine()->*unop.constructor)(), Parameter(0)));
  EXPECT_FALSE(reduction.Changed());
}

TEST_P() [70/76]

v8::internal::compiler::TEST_P	(	SimplifiedElementAccessOperatorTest	,
		LoadElement
	)

Definition at line 176 of file simplified-operator-unittest.cc.

                                                         {
  SimplifiedOperatorBuilder simplified(zone());
  const ElementAccess& access = GetParam();
  const Operator* op = simplified.LoadElement(access);
 
  EXPECT_EQ(IrOpcode::kLoadElement, op->opcode());
  EXPECT_EQ(Operator::kNoThrow | Operator::kNoWrite, op->properties());
  EXPECT_EQ(access, ElementAccessOf(op));
 
  EXPECT_EQ(3, OperatorProperties::GetValueInputCount(op));
  EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
  EXPECT_EQ(4, OperatorProperties::GetTotalInputCount(op));
 
  EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
  EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
}

References ElementAccessOf(), v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::OperatorProperties::GetValueOutputCount(), v8::internal::compiler::Operator::kNoThrow, v8::internal::compiler::Operator::kNoWrite, v8::internal::compiler::Operator::opcode(), and v8::internal::compiler::Operator::properties().

Here is the call graph for this function:

TEST_P() [71/76]

v8::internal::compiler::TEST_P	(	SimplifiedElementAccessOperatorTest	,
		StoreElement
	)

Definition at line 196 of file simplified-operator-unittest.cc.

                                                          {
  SimplifiedOperatorBuilder simplified(zone());
  const ElementAccess& access = GetParam();
  const Operator* op = simplified.StoreElement(access);
 
  EXPECT_EQ(IrOpcode::kStoreElement, op->opcode());
  EXPECT_EQ(Operator::kNoRead | Operator::kNoThrow, op->properties());
  EXPECT_EQ(access, ElementAccessOf(op));
 
  EXPECT_EQ(4, OperatorProperties::GetValueInputCount(op));
  EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
  EXPECT_EQ(1, OperatorProperties::GetControlInputCount(op));
  EXPECT_EQ(6, OperatorProperties::GetTotalInputCount(op));
 
  EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
  EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
}

References ElementAccessOf(), v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::OperatorProperties::GetValueOutputCount(), v8::internal::compiler::Operator::kNoRead, v8::internal::compiler::Operator::kNoThrow, v8::internal::compiler::Operator::opcode(), and v8::internal::compiler::Operator::properties().

Here is the call graph for this function:

TEST_P() [72/76]

v8::internal::compiler::TEST_P	(	SimplifiedPureOperatorTest	,
		InstancesAreGloballyShared
	)

Definition at line 81 of file simplified-operator-unittest.cc.

                                                               {
  const PureOperator& pop = GetParam();
  SimplifiedOperatorBuilder simplified1(zone());
  SimplifiedOperatorBuilder simplified2(zone());
  EXPECT_EQ((simplified1.*pop.constructor)(), (simplified2.*pop.constructor)());
}

TEST_P() [73/76]

v8::internal::compiler::TEST_P	(	SimplifiedPureOperatorTest	,
		NumberOfInputsAndOutputs
	)

Definition at line 89 of file simplified-operator-unittest.cc.

                                                             {
  SimplifiedOperatorBuilder simplified(zone());
  const PureOperator& pop = GetParam();
  const Operator* op = (simplified.*pop.constructor)();
 
  EXPECT_EQ(pop.value_input_count, OperatorProperties::GetValueInputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetEffectInputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
  EXPECT_EQ(pop.value_input_count, OperatorProperties::GetTotalInputCount(op));
 
  EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
  EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
}

References v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::OperatorProperties::GetControlOutputCount(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::OperatorProperties::GetEffectOutputCount(), v8::internal::compiler::OperatorProperties::GetTotalInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), and v8::internal::compiler::OperatorProperties::GetValueOutputCount().

Here is the call graph for this function:

TEST_P() [74/76]

v8::internal::compiler::TEST_P	(	SimplifiedPureOperatorTest	,
		OpcodeIsCorrect
	)

Definition at line 105 of file simplified-operator-unittest.cc.

                                                    {
  SimplifiedOperatorBuilder simplified(zone());
  const PureOperator& pop = GetParam();
  const Operator* op = (simplified.*pop.constructor)();
  EXPECT_EQ(pop.opcode, op->opcode());
}

References v8::internal::compiler::Operator::opcode().

Here is the call graph for this function:

TEST_P() [75/76]

v8::internal::compiler::TEST_P	(	SimplifiedPureOperatorTest	,
		Properties
	)

Definition at line 113 of file simplified-operator-unittest.cc.

                                               {
  SimplifiedOperatorBuilder simplified(zone());
  const PureOperator& pop = GetParam();
  const Operator* op = (simplified.*pop.constructor)();
  EXPECT_EQ(pop.properties, op->properties() & pop.properties);
}

References v8::internal::compiler::Operator::properties().

Here is the call graph for this function:

TEST_P() [76/76]

v8::internal::compiler::TEST_P	(	SimplifiedUnaryOperatorTest	,
		Parameter
	)

Definition at line 162 of file simplified-operator-reducer-unittest.cc.

                                               {
  const UnaryOperator& unop = GetParam();
  Reduction reduction = Reduce(
      graph()->NewNode((simplified()->*unop.constructor)(), Parameter(0)));
  EXPECT_FALSE(reduction.Changed());
}

Trace()

static void v8::internal::compiler::Trace ( const char *  msg,   ...  )

inlinestatic

Definition at line 21 of file scheduler.cc.

                                               {
  if (FLAG_trace_turbo_scheduler) {
    va_list arguments;
    va_start(arguments, msg);
    base::OS::VPrint(msg, arguments);
    va_end(arguments);
  }
}

References v8::base::OS::VPrint().

Referenced by v8::internal::compiler::CFGBuilder::BuildBlockForNode(), v8::internal::compiler::Scheduler::BuildCFG(), v8::internal::compiler::Scheduler::ComputeSpecialRPO(), v8::internal::compiler::Scheduler::ConnectFloatingControl(), v8::internal::compiler::Scheduler::ConnectFloatingControlSubgraph(), v8::internal::compiler::Scheduler::GenerateImmediateDominatorTree(), v8::internal::compiler::ScheduleLateNodeVisitor::GetBlockForUse(), v8::internal::compiler::Scheduler::GetPlacement(), v8::internal::compiler::ScheduleEarlyNodeVisitor::Post(), v8::internal::compiler::PrepareUsesVisitor::PostEdge(), v8::internal::compiler::ScheduleEarlyNodeVisitor::Pre(), v8::internal::compiler::PrepareUsesVisitor::Pre(), v8::internal::compiler::ScheduleLateNodeVisitor::Pre(), v8::internal::compiler::Scheduler::PrepareUses(), v8::internal::compiler::Scheduler::ScheduleEarly(), v8::internal::compiler::Scheduler::ScheduleLate(), v8::internal::compiler::ScheduleLateNodeVisitor::ScheduleNode(), and v8::internal::compiler::CFGBuilder::TraceConnect().

Here is the call graph for this function:

Here is the caller graph for this function:

TraceSchedule()

static void v8::internal::compiler::TraceSchedule ( Schedule *  schedule )

static

Definition at line 159 of file pipeline.cc.

                                              {
  if (!FLAG_trace_turbo) return;
  OFStream os(stdout);
  os << "-- Schedule --------------------------------------\n" << *schedule;
}

Referenced by v8::internal::compiler::Pipeline::ComputeSchedule(), and v8::internal::compiler::Pipeline::GenerateCodeForMachineGraph().

Here is the caller graph for this function:

TryMatchASR()

static bool v8::internal::compiler::TryMatchASR ( InstructionSelector *  selector, InstructionCode *  opcode_return, Node *  node, InstructionOperand **  value_return, InstructionOperand **  shift_return  )

inlinestatic

Definition at line 142 of file instruction-selector-arm.cc.

                                                                  {
  ArmOperandGenerator g(selector);
  if (node->opcode() != IrOpcode::kWord32Sar) return false;
  Int32BinopMatcher m(node);
  *value_return = g.UseRegister(m.left().node());
  if (m.right().IsInRange(1, 32)) {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ASR_I);
    *shift_return = g.UseImmediate(m.right().node());
  } else {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ASR_R);
    *shift_return = g.UseRegister(m.right().node());
  }
  return true;
}

References v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), v8::internal::compiler::OperandGenerator::UseImmediate(), and v8::internal::compiler::OperandGenerator::UseRegister().

Referenced by TryMatchShift().

Here is the call graph for this function:

Here is the caller graph for this function:

TryMatchImmediateOrShift()

static bool v8::internal::compiler::TryMatchImmediateOrShift ( InstructionSelector *  selector, InstructionCode *  opcode_return, Node *  node, size_t *  input_count_return, InstructionOperand **  inputs  )

inlinestatic

Definition at line 211 of file instruction-selector-arm.cc.

                                                                         {
  ArmOperandGenerator g(selector);
  if (g.CanBeImmediate(node, *opcode_return)) {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_I);
    inputs[0] = g.UseImmediate(node);
    *input_count_return = 1;
    return true;
  }
  if (TryMatchShift(selector, opcode_return, node, &inputs[0], &inputs[1])) {
    *input_count_return = 2;
    return true;
  }
  return false;
}

References v8::internal::compiler::ArmOperandGenerator::CanBeImmediate(), v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), TryMatchShift(), and v8::internal::compiler::OperandGenerator::UseImmediate().

Referenced by VisitBinop(), and VisitWordCompare().

Here is the call graph for this function:

Here is the caller graph for this function:

TryMatchLSL()

static bool v8::internal::compiler::TryMatchLSL ( InstructionSelector *  selector, InstructionCode *  opcode_return, Node *  node, InstructionOperand **  value_return, InstructionOperand **  shift_return  )

inlinestatic

Definition at line 161 of file instruction-selector-arm.cc.

                                                                  {
  ArmOperandGenerator g(selector);
  if (node->opcode() != IrOpcode::kWord32Shl) return false;
  Int32BinopMatcher m(node);
  *value_return = g.UseRegister(m.left().node());
  if (m.right().IsInRange(0, 31)) {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_LSL_I);
    *shift_return = g.UseImmediate(m.right().node());
  } else {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_LSL_R);
    *shift_return = g.UseRegister(m.right().node());
  }
  return true;
}

References v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), v8::internal::compiler::OperandGenerator::UseImmediate(), and v8::internal::compiler::OperandGenerator::UseRegister().

Referenced by TryMatchShift().

Here is the call graph for this function:

Here is the caller graph for this function:

TryMatchLSR()

static bool v8::internal::compiler::TryMatchLSR ( InstructionSelector *  selector, InstructionCode *  opcode_return, Node *  node, InstructionOperand **  value_return, InstructionOperand **  shift_return  )

inlinestatic

Definition at line 180 of file instruction-selector-arm.cc.

                                                                  {
  ArmOperandGenerator g(selector);
  if (node->opcode() != IrOpcode::kWord32Shr) return false;
  Int32BinopMatcher m(node);
  *value_return = g.UseRegister(m.left().node());
  if (m.right().IsInRange(1, 32)) {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_LSR_I);
    *shift_return = g.UseImmediate(m.right().node());
  } else {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_LSR_R);
    *shift_return = g.UseRegister(m.right().node());
  }
  return true;
}

References v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), v8::internal::compiler::OperandGenerator::UseImmediate(), and v8::internal::compiler::OperandGenerator::UseRegister().

Referenced by TryMatchShift().

Here is the call graph for this function:

Here is the caller graph for this function:

TryMatchROR()

static bool v8::internal::compiler::TryMatchROR ( InstructionSelector *  selector, InstructionCode *  opcode_return, Node *  node, InstructionOperand **  value_return, InstructionOperand **  shift_return  )

static

Definition at line 123 of file instruction-selector-arm.cc.

                                                           {
  ArmOperandGenerator g(selector);
  if (node->opcode() != IrOpcode::kWord32Ror) return false;
  Int32BinopMatcher m(node);
  *value_return = g.UseRegister(m.left().node());
  if (m.right().IsInRange(1, 31)) {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ROR_I);
    *shift_return = g.UseImmediate(m.right().node());
  } else {
    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ROR_R);
    *shift_return = g.UseRegister(m.right().node());
  }
  return true;
}

References v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), v8::internal::compiler::OperandGenerator::UseImmediate(), and v8::internal::compiler::OperandGenerator::UseRegister().

Referenced by TryMatchShift().

Here is the call graph for this function:

Here is the caller graph for this function:

TryMatchShift()

static bool v8::internal::compiler::TryMatchShift ( InstructionSelector *  selector, InstructionCode *  opcode_return, Node *  node, InstructionOperand **  value_return, InstructionOperand **  shift_return  )

inlinestatic

Definition at line 199 of file instruction-selector-arm.cc.

                                                                    {
  return (
      TryMatchASR(selector, opcode_return, node, value_return, shift_return) ||
      TryMatchLSL(selector, opcode_return, node, value_return, shift_return) ||
      TryMatchLSR(selector, opcode_return, node, value_return, shift_return) ||
      TryMatchROR(selector, opcode_return, node, value_return, shift_return));
}

References TryMatchASR(), TryMatchLSL(), TryMatchLSR(), and TryMatchROR().

Referenced by EmitBic(), and TryMatchImmediateOrShift().

Here is the call graph for this function:

Here is the caller graph for this function:

TypeOf()

MachineType v8::internal::compiler::TypeOf ( MachineType  machine_type )

inline

Definition at line 70 of file machine-type.h.

                                                    {
  int result = machine_type & kTypeMask;
  return static_cast<MachineType>(result);
}

References kTypeMask.

Referenced by v8::internal::HInstruction::PrintTo(), and v8::internal::compiler::AstGraphBuilder::VisitTypeof().

Here is the caller graph for this function:

UnhandledSortHelper()

static int v8::internal::compiler::UnhandledSortHelper ( LiveRange *const *  a, LiveRange *const *  b  )

static

Definition at line 1703 of file register-allocator.cc.

                                                                         {
  DCHECK(!(*a)->ShouldBeAllocatedBefore(*b) ||
         !(*b)->ShouldBeAllocatedBefore(*a));
  if ((*a)->ShouldBeAllocatedBefore(*b)) return 1;
  if ((*b)->ShouldBeAllocatedBefore(*a)) return -1;
  return (*a)->id() - (*b)->id();
}

References DCHECK.

UseOrImmediate()

static InstructionOperand* v8::internal::compiler::UseOrImmediate ( OperandGenerator *  g, Node *  input  )

static

Definition at line 1012 of file instruction-selector.cc.

                                                                            {
  switch (input->opcode()) {
    case IrOpcode::kInt32Constant:
    case IrOpcode::kNumberConstant:
    case IrOpcode::kFloat64Constant:
    case IrOpcode::kHeapConstant:
      return g->UseImmediate(input);
    default:
      return g->UseUnique(input);
  }
}

References v8::internal::compiler::OperandGenerator::UseImmediate(), and v8::internal::compiler::OperandGenerator::UseUnique().

Here is the call graph for this function:

VerifyGraphs()

static bool v8::internal::compiler::VerifyGraphs ( )

inlinestatic

Definition at line 82 of file pipeline.cc.

                                  {
#ifdef DEBUG
  return true;
#else
  return FLAG_turbo_verify;
#endif
}

Referenced by v8::internal::compiler::Pipeline::ComputeSchedule(), and v8::internal::compiler::Pipeline::VerifyAndPrintGraph().

Here is the caller graph for this function:

VerifyMovesAreInjective()

static void v8::internal::compiler::VerifyMovesAreInjective ( ZoneList< MoveOperands > *  moves )

static

Definition at line 29 of file gap-resolver.cc.

                                                                   {
#ifdef ENABLE_SLOW_DCHECKS
  std::set<InstructionOperand*, InstructionOperandComparator> seen;
  for (op_iterator i = moves->begin(); i != moves->end(); ++i) {
    SLOW_DCHECK(seen.find(i->destination()) == seen.end());
    seen.insert(i->destination());
  }
#endif
}

References v8::internal::List< T, AllocationPolicy >::begin(), v8::internal::List< T, AllocationPolicy >::end(), and SLOW_DCHECK.

Here is the call graph for this function:

VisitBinop() [1/8]

template<typename Matcher >

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode, ImmediateMode  operand_mode  )

static

Definition at line 151 of file instruction-selector-arm64.cc.

                                                                      {
  FlagsContinuation cont;
  VisitBinop<Matcher>(selector, node, opcode, operand_mode, &cont);
}

VisitBinop() [2/8]

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode  )

static

Definition at line 298 of file instruction-selector-ia32.cc.

                                               {
  FlagsContinuation cont;
  VisitBinop(selector, node, opcode, &cont);
}

References VisitBinop().

Here is the call graph for this function:

VisitBinop() [3/8]

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode  )

static

Definition at line 290 of file instruction-selector-x64.cc.

                                               {
  FlagsContinuation cont;
  VisitBinop(selector, node, opcode, &cont);
}

References VisitBinop().

Here is the call graph for this function:

VisitBinop() [4/8]

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, FlagsContinuation *  cont  )

static

Definition at line 251 of file instruction-selector-ia32.cc.

                                                                        {
  IA32OperandGenerator g(selector);
  Int32BinopMatcher m(node);
  Node* left = m.left().node();
  Node* right = m.right().node();
  InstructionOperand* inputs[4];
  size_t input_count = 0;
  InstructionOperand* outputs[2];
  size_t output_count = 0;
 
  // TODO(turbofan): match complex addressing modes.
  if (g.CanBeImmediate(right)) {
    inputs[input_count++] = g.Use(left);
    inputs[input_count++] = g.UseImmediate(right);
  } else {
    if (node->op()->HasProperty(Operator::kCommutative) &&
        g.CanBeBetterLeftOperand(right)) {
      std::swap(left, right);
    }
    inputs[input_count++] = g.UseRegister(left);
    inputs[input_count++] = g.Use(right);
  }
 
  if (cont->IsBranch()) {
    inputs[input_count++] = g.Label(cont->true_block());
    inputs[input_count++] = g.Label(cont->false_block());
  }
 
  outputs[output_count++] = g.DefineSameAsFirst(node);
  if (cont->IsSet()) {
    // TODO(turbofan): Use byte register here.
    outputs[output_count++] = g.DefineAsRegister(cont->result());
  }
 
  DCHECK_NE(0, input_count);
  DCHECK_NE(0, output_count);
  DCHECK_GE(arraysize(inputs), input_count);
  DCHECK_GE(arraysize(outputs), output_count);
 
  Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
                                      outputs, input_count, inputs);
  if (cont->IsBranch()) instr->MarkAsControl();
}

References arraysize, DCHECK_GE, DCHECK_NE, v8::internal::compiler::Operator::kCommutative, and v8::internal::compiler::Instruction::MarkAsControl().

Here is the call graph for this function:

VisitBinop() [5/8]

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, FlagsContinuation *  cont  )

static

Definition at line 244 of file instruction-selector-x64.cc.

                                                                        {
  X64OperandGenerator g(selector);
  Int32BinopMatcher m(node);
  Node* left = m.left().node();
  Node* right = m.right().node();
  InstructionOperand* inputs[4];
  size_t input_count = 0;
  InstructionOperand* outputs[2];
  size_t output_count = 0;
 
  // TODO(turbofan): match complex addressing modes.
  if (g.CanBeImmediate(right)) {
    inputs[input_count++] = g.Use(left);
    inputs[input_count++] = g.UseImmediate(right);
  } else {
    if (node->op()->HasProperty(Operator::kCommutative) &&
        g.CanBeBetterLeftOperand(right)) {
      std::swap(left, right);
    }
    inputs[input_count++] = g.UseRegister(left);
    inputs[input_count++] = g.Use(right);
  }
 
  if (cont->IsBranch()) {
    inputs[input_count++] = g.Label(cont->true_block());
    inputs[input_count++] = g.Label(cont->false_block());
  }
 
  outputs[output_count++] = g.DefineSameAsFirst(node);
  if (cont->IsSet()) {
    outputs[output_count++] = g.DefineAsRegister(cont->result());
  }
 
  DCHECK_NE(0, input_count);
  DCHECK_NE(0, output_count);
  DCHECK_GE(arraysize(inputs), input_count);
  DCHECK_GE(arraysize(outputs), output_count);
 
  Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
                                      outputs, input_count, inputs);
  if (cont->IsBranch()) instr->MarkAsControl();
}

References arraysize, DCHECK_GE, DCHECK_NE, v8::internal::compiler::Operator::kCommutative, and v8::internal::compiler::Instruction::MarkAsControl().

Here is the call graph for this function:

VisitBinop() [6/8]

template<typename Matcher >

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, ImmediateMode  operand_mode, FlagsContinuation *  cont  )

static

Definition at line 115 of file instruction-selector-arm64.cc.

                                                {
  Arm64OperandGenerator g(selector);
  Matcher m(node);
  InstructionOperand* inputs[4];
  size_t input_count = 0;
  InstructionOperand* outputs[2];
  size_t output_count = 0;
 
  inputs[input_count++] = g.UseRegister(m.left().node());
  inputs[input_count++] = g.UseOperand(m.right().node(), operand_mode);
 
  if (cont->IsBranch()) {
    inputs[input_count++] = g.Label(cont->true_block());
    inputs[input_count++] = g.Label(cont->false_block());
  }
 
  outputs[output_count++] = g.DefineAsRegister(node);
  if (cont->IsSet()) {
    outputs[output_count++] = g.DefineAsRegister(cont->result());
  }
 
  DCHECK_NE(0, input_count);
  DCHECK_NE(0, output_count);
  DCHECK_GE(arraysize(inputs), input_count);
  DCHECK_GE(arraysize(outputs), output_count);
 
  Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
                                      outputs, input_count, inputs);
  if (cont->IsBranch()) instr->MarkAsControl();
}

References arraysize, DCHECK_GE, DCHECK_NE, and v8::internal::compiler::Instruction::MarkAsControl().

Here is the call graph for this function:

VisitBinop() [7/8]

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, InstructionCode  reverse_opcode  )

static

Definition at line 279 of file instruction-selector-arm.cc.

                                                                               {
  FlagsContinuation cont;
  VisitBinop(selector, node, opcode, reverse_opcode, &cont);
}

References VisitBinop().

Here is the call graph for this function:

VisitBinop() [8/8]

static void v8::internal::compiler::VisitBinop ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, InstructionCode  reverse_opcode, FlagsContinuation *  cont  )

static

Definition at line 231 of file instruction-selector-arm.cc.

                                                {
  ArmOperandGenerator g(selector);
  Int32BinopMatcher m(node);
  InstructionOperand* inputs[5];
  size_t input_count = 0;
  InstructionOperand* outputs[2];
  size_t output_count = 0;
 
  if (TryMatchImmediateOrShift(selector, &opcode, m.right().node(),
                               &input_count, &inputs[1])) {
    inputs[0] = g.UseRegister(m.left().node());
    input_count++;
  } else if (TryMatchImmediateOrShift(selector, &reverse_opcode,
                                      m.left().node(), &input_count,
                                      &inputs[1])) {
    inputs[0] = g.UseRegister(m.right().node());
    opcode = reverse_opcode;
    input_count++;
  } else {
    opcode |= AddressingModeField::encode(kMode_Operand2_R);
    inputs[input_count++] = g.UseRegister(m.left().node());
    inputs[input_count++] = g.UseRegister(m.right().node());
  }
 
  if (cont->IsBranch()) {
    inputs[input_count++] = g.Label(cont->true_block());
    inputs[input_count++] = g.Label(cont->false_block());
  }
 
  outputs[output_count++] = g.DefineAsRegister(node);
  if (cont->IsSet()) {
    outputs[output_count++] = g.DefineAsRegister(cont->result());
  }
 
  DCHECK_NE(0, input_count);
  DCHECK_NE(0, output_count);
  DCHECK_GE(arraysize(inputs), input_count);
  DCHECK_GE(arraysize(outputs), output_count);
  DCHECK_NE(kMode_None, AddressingModeField::decode(opcode));
 
  Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
                                      outputs, input_count, inputs);
  if (cont->IsBranch()) instr->MarkAsControl();
}

References arraysize, DCHECK_GE, DCHECK_NE, v8::internal::BitFieldBase< T, shift, size, uint32_t >::decode(), v8::internal::compiler::OperandGenerator::DefineAsRegister(), v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), v8::internal::compiler::OperandGenerator::Label(), v8::internal::compiler::Instruction::MarkAsControl(), TryMatchImmediateOrShift(), and v8::internal::compiler::OperandGenerator::UseRegister().

Referenced by VisitBinop().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitCompare() [1/3]

static void v8::internal::compiler::VisitCompare ( InstructionSelector *  selector, InstructionCode  opcode, InstructionOperand *  left, InstructionOperand *  right, FlagsContinuation *  cont  )

static

Definition at line 726 of file instruction-selector-arm64.cc.

                                                  {
  Arm64OperandGenerator g(selector);
  opcode = cont->Encode(opcode);
  if (cont->IsBranch()) {
    selector->Emit(opcode, NULL, left, right, g.Label(cont->true_block()),
                   g.Label(cont->false_block()))->MarkAsControl();
  } else {
    DCHECK(cont->IsSet());
    selector->Emit(opcode, g.DefineAsRegister(cont->result()), left, right);
  }
}

References DCHECK, and NULL.

Referenced by VisitWordCompare().

Here is the caller graph for this function:

VisitCompare() [2/3]

static void v8::internal::compiler::VisitCompare ( InstructionSelector *  selector, InstructionCode  opcode, InstructionOperand *  left, InstructionOperand *  right, FlagsContinuation *  cont  )

inlinestatic

Definition at line 543 of file instruction-selector-ia32.cc.

                                                         {
  IA32OperandGenerator g(selector);
  if (cont->IsBranch()) {
    selector->Emit(cont->Encode(opcode), NULL, left, right,
                   g.Label(cont->true_block()),
                   g.Label(cont->false_block()))->MarkAsControl();
  } else {
    DCHECK(cont->IsSet());
    // TODO(titzer): Needs byte register.
    selector->Emit(cont->Encode(opcode), g.DefineAsRegister(cont->result()),
                   left, right);
  }
}

References DCHECK, and NULL.

VisitCompare() [3/3]

static void v8::internal::compiler::VisitCompare ( InstructionSelector *  selector, InstructionCode  opcode, InstructionOperand *  left, InstructionOperand *  right, FlagsContinuation *  cont  )

static

Definition at line 666 of file instruction-selector-x64.cc.

                                                  {
  X64OperandGenerator g(selector);
  opcode = cont->Encode(opcode);
  if (cont->IsBranch()) {
    selector->Emit(opcode, NULL, left, right, g.Label(cont->true_block()),
                   g.Label(cont->false_block()))->MarkAsControl();
  } else {
    DCHECK(cont->IsSet());
    selector->Emit(opcode, g.DefineAsRegister(cont->result()), left, right);
  }
}

References DCHECK, and NULL.

VisitDiv() [1/3]

static void v8::internal::compiler::VisitDiv ( InstructionSelector *  selector, Node *  node, ArchOpcode  div_opcode, ArchOpcode  f64i32_opcode, ArchOpcode  i32f64_opcode  )

static

Definition at line 635 of file instruction-selector-arm.cc.

                                               {
  ArmOperandGenerator g(selector);
  Int32BinopMatcher m(node);
  EmitDiv(selector, div_opcode, f64i32_opcode, i32f64_opcode,
          g.DefineAsRegister(node), g.UseRegister(m.left().node()),
          g.UseRegister(m.right().node()));
}

References v8::internal::compiler::OperandGenerator::DefineAsRegister(), EmitDiv(), and v8::internal::compiler::OperandGenerator::UseRegister().

Here is the call graph for this function:

VisitDiv() [2/3]

static void v8::internal::compiler::VisitDiv ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

inlinestatic

Definition at line 405 of file instruction-selector-ia32.cc.

                                               {
  IA32OperandGenerator g(selector);
  InstructionOperand* temps[] = {g.TempRegister(edx)};
  size_t temp_count = arraysize(temps);
  selector->Emit(opcode, g.DefineAsFixed(node, eax),
                 g.UseFixed(node->InputAt(0), eax),
                 g.UseUnique(node->InputAt(1)), temp_count, temps);
}

References arraysize, v8::internal::eax, and v8::internal::edx.

VisitDiv() [3/3]

static void v8::internal::compiler::VisitDiv ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

static

Definition at line 492 of file instruction-selector-x64.cc.

                                        {
  X64OperandGenerator g(selector);
  InstructionOperand* temps[] = {g.TempRegister(rdx)};
  selector->Emit(
      opcode, g.DefineAsFixed(node, rax), g.UseFixed(node->InputAt(0), rax),
      g.UseUniqueRegister(node->InputAt(1)), arraysize(temps), temps);
}

References arraysize, v8::internal::rax, and v8::internal::rdx.

VisitLogical()

template<typename Matcher >

static void v8::internal::compiler::VisitLogical ( InstructionSelector *  selector, Node *  node, Matcher *  m, ArchOpcode  opcode, bool  left_can_cover, bool  right_can_cover, ImmediateMode  imm_mode  )

static

Definition at line 271 of file instruction-selector-arm64.cc.

                                                                       {
  Arm64OperandGenerator g(selector);
 
  // Map instruction to equivalent operation with inverted right input.
  ArchOpcode inv_opcode = opcode;
  switch (opcode) {
    case kArm64And32:
      inv_opcode = kArm64Bic32;
      break;
    case kArm64And:
      inv_opcode = kArm64Bic;
      break;
    case kArm64Or32:
      inv_opcode = kArm64Orn32;
      break;
    case kArm64Or:
      inv_opcode = kArm64Orn;
      break;
    case kArm64Eor32:
      inv_opcode = kArm64Eon32;
      break;
    case kArm64Eor:
      inv_opcode = kArm64Eon;
      break;
    default:
      UNREACHABLE();
  }
 
  // Select Logical(y, ~x) for Logical(Xor(x, -1), y).
  if ((m->left().IsWord32Xor() || m->left().IsWord64Xor()) && left_can_cover) {
    Matcher mleft(m->left().node());
    if (mleft.right().Is(-1)) {
      // TODO(all): support shifted operand on right.
      selector->Emit(inv_opcode, g.DefineAsRegister(node),
                     g.UseRegister(m->right().node()),
                     g.UseRegister(mleft.left().node()));
      return;
    }
  }
 
  // Select Logical(x, ~y) for Logical(x, Xor(y, -1)).
  if ((m->right().IsWord32Xor() || m->right().IsWord64Xor()) &&
      right_can_cover) {
    Matcher mright(m->right().node());
    if (mright.right().Is(-1)) {
      // TODO(all): support shifted operand on right.
      selector->Emit(inv_opcode, g.DefineAsRegister(node),
                     g.UseRegister(m->left().node()),
                     g.UseRegister(mright.left().node()));
      return;
    }
  }
 
  if (m->IsWord32Xor() && m->right().Is(-1)) {
    selector->Emit(kArm64Not32, g.DefineAsRegister(node),
                   g.UseRegister(m->left().node()));
  } else if (m->IsWord64Xor() && m->right().Is(-1)) {
    selector->Emit(kArm64Not, g.DefineAsRegister(node),
                   g.UseRegister(m->left().node()));
  } else {
    VisitBinop<Matcher>(selector, node, opcode, imm_mode);
  }
}

References UNREACHABLE.

VisitMod() [1/3]

static void v8::internal::compiler::VisitMod ( InstructionSelector *  selector, Node *  node, ArchOpcode  div_opcode, ArchOpcode  f64i32_opcode, ArchOpcode  i32f64_opcode  )

static

Definition at line 656 of file instruction-selector-arm.cc.

                                               {
  ArmOperandGenerator g(selector);
  Int32BinopMatcher m(node);
  InstructionOperand* div_operand = g.TempRegister();
  InstructionOperand* result_operand = g.DefineAsRegister(node);
  InstructionOperand* left_operand = g.UseRegister(m.left().node());
  InstructionOperand* right_operand = g.UseRegister(m.right().node());
  EmitDiv(selector, div_opcode, f64i32_opcode, i32f64_opcode, div_operand,
          left_operand, right_operand);
  if (selector->IsSupported(MLS)) {
    selector->Emit(kArmMls, result_operand, div_operand, right_operand,
                   left_operand);
    return;
  }
  InstructionOperand* mul_operand = g.TempRegister();
  selector->Emit(kArmMul, mul_operand, div_operand, right_operand);
  selector->Emit(kArmSub, result_operand, left_operand, mul_operand);
}

References v8::internal::compiler::OperandGenerator::DefineAsRegister(), EmitDiv(), v8::internal::MLS, v8::internal::compiler::OperandGenerator::TempRegister(), and v8::internal::compiler::OperandGenerator::UseRegister().

Here is the call graph for this function:

VisitMod() [2/3]

static void v8::internal::compiler::VisitMod ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

inlinestatic

Definition at line 426 of file instruction-selector-ia32.cc.

                                               {
  IA32OperandGenerator g(selector);
  InstructionOperand* temps[] = {g.TempRegister(eax), g.TempRegister(edx)};
  size_t temp_count = arraysize(temps);
  selector->Emit(opcode, g.DefineAsFixed(node, edx),
                 g.UseFixed(node->InputAt(0), eax),
                 g.UseUnique(node->InputAt(1)), temp_count, temps);
}

References arraysize, v8::internal::eax, and v8::internal::edx.

VisitMod() [3/3]

static void v8::internal::compiler::VisitMod ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

static

Definition at line 522 of file instruction-selector-x64.cc.

                                        {
  X64OperandGenerator g(selector);
  InstructionOperand* temps[] = {g.TempRegister(rax), g.TempRegister(rdx)};
  selector->Emit(
      opcode, g.DefineAsFixed(node, rdx), g.UseFixed(node->InputAt(0), rax),
      g.UseUniqueRegister(node->InputAt(1)), arraysize(temps), temps);
}

References arraysize, v8::internal::rax, and v8::internal::rdx.

VisitMul()

static void v8::internal::compiler::VisitMul ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

static

Definition at line 463 of file instruction-selector-x64.cc.

                                        {
  X64OperandGenerator g(selector);
  Int32BinopMatcher m(node);
  Node* left = m.left().node();
  Node* right = m.right().node();
  if (g.CanBeImmediate(right)) {
    selector->Emit(opcode, g.DefineAsRegister(node), g.Use(left),
                   g.UseImmediate(right));
  } else {
    if (g.CanBeBetterLeftOperand(right)) {
      std::swap(left, right);
    }
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.Use(right));
  }
}

VisitRRO()

static void v8::internal::compiler::VisitRRO ( InstructionSelector *  selector, ArchOpcode  opcode, Node *  node, ImmediateMode  operand_mode  )

static

Definition at line 104 of file instruction-selector-arm64.cc.

                                                             {
  Arm64OperandGenerator g(selector);
  selector->Emit(opcode, g.DefineAsRegister(node),
                 g.UseRegister(node->InputAt(0)),
                 g.UseOperand(node->InputAt(1), operand_mode));
}

VisitRRR()

static void v8::internal::compiler::VisitRRR ( InstructionSelector *  selector, ArchOpcode  opcode, Node *  node  )

static

Definition at line 86 of file instruction-selector-arm64.cc.

                                 {
  Arm64OperandGenerator g(selector);
  selector->Emit(opcode, g.DefineAsRegister(node),
                 g.UseRegister(node->InputAt(0)),
                 g.UseRegister(node->InputAt(1)));
}

VisitRRRFloat64() [1/2]

static void v8::internal::compiler::VisitRRRFloat64 ( InstructionSelector *  selector, ArchOpcode  opcode, Node *  node  )

static

Definition at line 114 of file instruction-selector-arm.cc.

                                        {
  ArmOperandGenerator g(selector);
  selector->Emit(opcode, g.DefineAsRegister(node),
                 g.UseRegister(node->InputAt(0)),
                 g.UseRegister(node->InputAt(1)));
}

References v8::internal::compiler::OperandGenerator::DefineAsRegister(), and v8::internal::compiler::OperandGenerator::UseRegister().

Here is the call graph for this function:

VisitRRRFloat64() [2/2]

static void v8::internal::compiler::VisitRRRFloat64 ( InstructionSelector *  selector, ArchOpcode  opcode, Node *  node  )

static

Definition at line 95 of file instruction-selector-arm64.cc.

                                        {
  Arm64OperandGenerator g(selector);
  selector->Emit(opcode, g.DefineAsRegister(node),
                 g.UseRegister(node->InputAt(0)),
                 g.UseRegister(node->InputAt(1)));
}

VisitShift() [1/3]

static void v8::internal::compiler::VisitShift ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

inlinestatic

Definition at line 327 of file instruction-selector-ia32.cc.

                                                 {
  IA32OperandGenerator g(selector);
  Node* left = node->InputAt(0);
  Node* right = node->InputAt(1);
 
  // TODO(turbofan): assembler only supports some addressing modes for shifts.
  if (g.CanBeImmediate(right)) {
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.UseImmediate(right));
  } else {
    Int32BinopMatcher m(node);
    if (m.right().IsWord32And()) {
      Int32BinopMatcher mright(right);
      if (mright.right().Is(0x1F)) {
        right = mright.left().node();
      }
    }
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.UseFixed(right, ecx));
  }
}

References v8::internal::ecx.

VisitShift() [2/3]

template<typename TryMatchShift >

static void v8::internal::compiler::VisitShift ( InstructionSelector *  selector, Node *  node, TryMatchShift  try_match_shift  )

inlinestatic

Definition at line 510 of file instruction-selector-arm.cc.

                                                             {
  FlagsContinuation cont;
  VisitShift(selector, node, try_match_shift, &cont);
}

References VisitShift().

Here is the call graph for this function:

VisitShift() [3/3]

template<typename TryMatchShift >

static void v8::internal::compiler::VisitShift ( InstructionSelector *  selector, Node *  node, TryMatchShift  try_match_shift, FlagsContinuation *  cont  )

inlinestatic

Definition at line 475 of file instruction-selector-arm.cc.

                                                       {
  ArmOperandGenerator g(selector);
  InstructionCode opcode = kArmMov;
  InstructionOperand* inputs[4];
  size_t input_count = 2;
  InstructionOperand* outputs[2];
  size_t output_count = 0;
 
  CHECK(try_match_shift(selector, &opcode, node, &inputs[0], &inputs[1]));
 
  if (cont->IsBranch()) {
    inputs[input_count++] = g.Label(cont->true_block());
    inputs[input_count++] = g.Label(cont->false_block());
  }
 
  outputs[output_count++] = g.DefineAsRegister(node);
  if (cont->IsSet()) {
    outputs[output_count++] = g.DefineAsRegister(cont->result());
  }
 
  DCHECK_NE(0, input_count);
  DCHECK_NE(0, output_count);
  DCHECK_GE(arraysize(inputs), input_count);
  DCHECK_GE(arraysize(outputs), output_count);
  DCHECK_NE(kMode_None, AddressingModeField::decode(opcode));
 
  Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
                                      outputs, input_count, inputs);
  if (cont->IsBranch()) instr->MarkAsControl();
}

References arraysize, CHECK, DCHECK_GE, DCHECK_NE, v8::internal::BitFieldBase< T, shift, size, uint32_t >::decode(), v8::internal::compiler::OperandGenerator::DefineAsRegister(), v8::internal::compiler::OperandGenerator::Label(), and v8::internal::compiler::Instruction::MarkAsControl().

Referenced by VisitShift().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitWord32Shift()

static void v8::internal::compiler::VisitWord32Shift ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

static

Definition at line 341 of file instruction-selector-x64.cc.

                                                {
  X64OperandGenerator g(selector);
  Node* left = node->InputAt(0);
  Node* right = node->InputAt(1);
 
  // TODO(turbofan): assembler only supports some addressing modes for shifts.
  if (g.CanBeImmediate(right)) {
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.UseImmediate(right));
  } else {
    Int32BinopMatcher m(node);
    if (m.right().IsWord32And()) {
      Int32BinopMatcher mright(right);
      if (mright.right().Is(0x1F)) {
        right = mright.left().node();
      }
    }
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.UseFixed(right, rcx));
  }
}

References v8::internal::rcx.

VisitWord64Shift()

static void v8::internal::compiler::VisitWord64Shift ( InstructionSelector *  selector, Node *  node, ArchOpcode  opcode  )

static

Definition at line 367 of file instruction-selector-x64.cc.

                                                {
  X64OperandGenerator g(selector);
  Node* left = node->InputAt(0);
  Node* right = node->InputAt(1);
 
  // TODO(turbofan): assembler only supports some addressing modes for shifts.
  if (g.CanBeImmediate(right)) {
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.UseImmediate(right));
  } else {
    Int64BinopMatcher m(node);
    if (m.right().IsWord64And()) {
      Int64BinopMatcher mright(right);
      if (mright.right().Is(0x3F)) {
        right = mright.left().node();
      }
    }
    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
                   g.UseFixed(right, rcx));
  }
}

References v8::internal::rcx.

VisitWordCompare() [1/4]

static void v8::internal::compiler::VisitWordCompare ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, FlagsContinuation *  cont, bool  commutative  )

static

Definition at line 862 of file instruction-selector-arm.cc.

                                               {
  ArmOperandGenerator g(selector);
  Int32BinopMatcher m(node);
  InstructionOperand* inputs[5];
  size_t input_count = 0;
  InstructionOperand* outputs[1];
  size_t output_count = 0;
 
  if (TryMatchImmediateOrShift(selector, &opcode, m.right().node(),
                               &input_count, &inputs[1])) {
    inputs[0] = g.UseRegister(m.left().node());
    input_count++;
  } else if (TryMatchImmediateOrShift(selector, &opcode, m.left().node(),
                                      &input_count, &inputs[1])) {
    if (!commutative) cont->Commute();
    inputs[0] = g.UseRegister(m.right().node());
    input_count++;
  } else {
    opcode |= AddressingModeField::encode(kMode_Operand2_R);
    inputs[input_count++] = g.UseRegister(m.left().node());
    inputs[input_count++] = g.UseRegister(m.right().node());
  }
 
  if (cont->IsBranch()) {
    inputs[input_count++] = g.Label(cont->true_block());
    inputs[input_count++] = g.Label(cont->false_block());
  } else {
    DCHECK(cont->IsSet());
    outputs[output_count++] = g.DefineAsRegister(cont->result());
  }
 
  DCHECK_NE(0, input_count);
  DCHECK_GE(arraysize(inputs), input_count);
  DCHECK_GE(arraysize(outputs), output_count);
 
  Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
                                      outputs, input_count, inputs);
  if (cont->IsBranch()) instr->MarkAsControl();
}

References arraysize, DCHECK, DCHECK_GE, DCHECK_NE, v8::internal::compiler::OperandGenerator::DefineAsRegister(), v8::internal::BitFieldBase< T, shift, size, uint32_t >::encode(), v8::internal::compiler::OperandGenerator::Label(), v8::internal::compiler::Instruction::MarkAsControl(), TryMatchImmediateOrShift(), and v8::internal::compiler::OperandGenerator::UseRegister().

Here is the call graph for this function:

VisitWordCompare() [2/4]

static void v8::internal::compiler::VisitWordCompare ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, FlagsContinuation *  cont, bool  commutative  )

static

Definition at line 742 of file instruction-selector-arm64.cc.

                                               {
  Arm64OperandGenerator g(selector);
  Node* left = node->InputAt(0);
  Node* right = node->InputAt(1);
 
  // Match immediates on left or right side of comparison.
  if (g.CanBeImmediate(right, kArithmeticImm)) {
    VisitCompare(selector, opcode, g.UseRegister(left), g.UseImmediate(right),
                 cont);
  } else if (g.CanBeImmediate(left, kArithmeticImm)) {
    if (!commutative) cont->Commute();
    VisitCompare(selector, opcode, g.UseRegister(right), g.UseImmediate(left),
                 cont);
  } else {
    VisitCompare(selector, opcode, g.UseRegister(left), g.UseRegister(right),
                 cont);
  }
}

References kArithmeticImm, and VisitCompare().

Here is the call graph for this function:

VisitWordCompare() [3/4]

static void v8::internal::compiler::VisitWordCompare ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, FlagsContinuation *  cont, bool  commutative  )

inlinestatic

Definition at line 563 of file instruction-selector-ia32.cc.

                                                                               {
  IA32OperandGenerator g(selector);
  Node* left = node->InputAt(0);
  Node* right = node->InputAt(1);
 
  // Match immediates on left or right side of comparison.
  if (g.CanBeImmediate(right)) {
    VisitCompare(selector, opcode, g.Use(left), g.UseImmediate(right), cont);
  } else if (g.CanBeImmediate(left)) {
    if (!commutative) cont->Commute();
    VisitCompare(selector, opcode, g.Use(right), g.UseImmediate(left), cont);
  } else {
    VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
  }
}

References VisitCompare().

Here is the call graph for this function:

VisitWordCompare() [4/4]

static void v8::internal::compiler::VisitWordCompare ( InstructionSelector *  selector, Node *  node, InstructionCode  opcode, FlagsContinuation *  cont, bool  commutative  )

static

Definition at line 682 of file instruction-selector-x64.cc.

                                               {
  X64OperandGenerator g(selector);
  Node* left = node->InputAt(0);
  Node* right = node->InputAt(1);
 
  // Match immediates on left or right side of comparison.
  if (g.CanBeImmediate(right)) {
    VisitCompare(selector, opcode, g.Use(left), g.UseImmediate(right), cont);
  } else if (g.CanBeImmediate(left)) {
    if (!commutative) cont->Commute();
    VisitCompare(selector, opcode, g.Use(right), g.UseImmediate(left), cont);
  } else {
    VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
  }
}

References VisitCompare().

Here is the call graph for this function:

Variable Documentation

kBlockOnStack

const int v8::internal::compiler::kBlockOnStack = -2

static

Definition at line 728 of file scheduler.cc.

Referenced by v8::internal::compiler::Scheduler::ComputeSpecialRPO(), and Push().

kBlockStartInstruction

const InstructionCode v8::internal::compiler::kBlockStartInstruction = -2

Definition at line 35 of file instruction.h.

Referenced by v8::internal::compiler::Instruction::IsBlockStart(), and v8::internal::compiler::Instruction::IsGapMoves().

kBlockUnvisited1

const int v8::internal::compiler::kBlockUnvisited1 = -1

static

Definition at line 731 of file scheduler.cc.

Referenced by v8::internal::compiler::Scheduler::ComputeSpecialRPO().

kBlockUnvisited2

const int v8::internal::compiler::kBlockUnvisited2 = kBlockVisited1

static

Definition at line 732 of file scheduler.cc.

Referenced by v8::internal::compiler::Scheduler::ComputeSpecialRPO().

kBlockVisited1

const int v8::internal::compiler::kBlockVisited1 = -3

static

Definition at line 729 of file scheduler.cc.

Referenced by v8::internal::compiler::Scheduler::ComputeSpecialRPO().

kBlockVisited2

const int v8::internal::compiler::kBlockVisited2 = -4

static

Definition at line 730 of file scheduler.cc.

Referenced by v8::internal::compiler::Scheduler::ComputeSpecialRPO().

kComparisonInstructions

const MachInst2 v8::internal::compiler::kComparisonInstructions[]

static

Initial value:

= {
    {&RawMachineAssembler::Word32Equal, "Word32Equal", kArm64Cmp32, kMachInt32},
    {&RawMachineAssembler::Word64Equal, "Word64Equal", kArm64Cmp, kMachInt64},
}

Definition at line 1115 of file instruction-selector-arm64-unittest.cc.

kGapInstruction

const InstructionCode v8::internal::compiler::kGapInstruction = -1

Definition at line 34 of file instruction.h.

Referenced by v8::internal::compiler::Instruction::IsGapMoves(), and v8::internal::compiler::GapInstruction::New().

kImpl [1/3]

base::LazyInstance<CommonOperatorBuilderImpl>::type v8::internal::compiler::kImpl

static

Initial value:

=
    LAZY_INSTANCE_INITIALIZER

Definition at line 86 of file common-operator.cc.

kImpl [2/3]

base::LazyInstance<MachineOperatorBuilderImpl>::type v8::internal::compiler::kImpl

static

Initial value:

=
    LAZY_INSTANCE_INITIALIZER

Definition at line 189 of file machine-operator.cc.

kImpl [3/3]

base::LazyInstance<SimplifiedOperatorBuilderImpl>::type v8::internal::compiler::kImpl

static

Initial value:

=
    LAZY_INSTANCE_INITIALIZER

Definition at line 145 of file simplified-operator.cc.

kLogicalWithNotRHSs

const MachInst2 v8::internal::compiler::kLogicalWithNotRHSs[]

static

Initial value:

= {
    {&RawMachineAssembler::Word32And, "Word32And", kArm64Bic32, kMachInt32},
    {&RawMachineAssembler::Word64And, "Word64And", kArm64Bic, kMachInt64},
    {&RawMachineAssembler::Word32Or, "Word32Or", kArm64Orn32, kMachInt32},
    {&RawMachineAssembler::Word64Or, "Word64Or", kArm64Orn, kMachInt64},
    {&RawMachineAssembler::Word32Xor, "Word32Xor", kArm64Eon32, kMachInt32},
    {&RawMachineAssembler::Word64Xor, "Word64Xor", kArm64Eon, kMachInt64}}

Definition at line 1240 of file instruction-selector-arm64-unittest.cc.

kMemoryAccesses

const MemoryAccess v8::internal::compiler::kMemoryAccesses[]

static

Definition at line 1007 of file instruction-selector-arm64-unittest.cc.

kMulDPInstructions

const MulDPInst v8::internal::compiler::kMulDPInstructions[]

static

Initial value:

= {
    {"Int32Mul", &RawMachineAssembler::Int32Mul, &RawMachineAssembler::Int32Add,
     &RawMachineAssembler::Int32Sub, kArm64Madd32, kArm64Msub32, kArm64Mneg32,
     kMachInt32},
    {"Int64Mul", &RawMachineAssembler::Int64Mul, &RawMachineAssembler::Int64Add,
     &RawMachineAssembler::Int64Sub, kArm64Madd, kArm64Msub, kArm64Mneg,
     kMachInt64}}

Definition at line 828 of file instruction-selector-arm64-unittest.cc.

kNonHeapObjectHeaderSize

const int v8::internal::compiler::kNonHeapObjectHeaderSize = kHeapObjectTag

static

Definition at line 67 of file simplified-operator.h.

kRepMask

const MachineTypeUnion v8::internal::compiler::kRepMask

Initial value:

= kRepBit | kRepWord8 | kRepWord16 |
                                  kRepWord32 | kRepWord64 | kRepFloat32 |
                                  kRepFloat64 | kRepTagged

Definition at line 62 of file machine-type.h.

Referenced by v8::internal::compiler::RepresentationChanger::GetRepresentationFor(), v8::internal::compiler::RepresentationSelector::ProcessInput(), RepresentationOf(), v8::internal::compiler::RepresentationSelector::SetOutput(), v8::internal::compiler::RepresentationSelector::VisitNode(), and v8::internal::compiler::RepresentationSelector::VisitPhi().

kSourcePositionInstruction

const InstructionCode v8::internal::compiler::kSourcePositionInstruction = -3

Definition at line 36 of file instruction.h.

Referenced by v8::internal::compiler::Instruction::IsSourcePosition().

kTypeMask

const MachineTypeUnion v8::internal::compiler::kTypeMask

Initial value:

= kTypeBool | kTypeInt32 | kTypeUint32 |
                                   kTypeInt64 | kTypeUint64 | kTypeNumber |
                                   kTypeAny

Definition at line 65 of file machine-type.h.

Referenced by TypeOf(), v8::internal::compiler::RepresentationSelector::VisitNode(), and v8::internal::compiler::RepresentationSelector::VisitPhi().

kWin64

const bool v8::internal::compiler::kWin64 = false

Definition at line 20 of file linkage-x64.cc.

Referenced by v8::internal::compiler::X64LinkageHelperTraits::CCalleeSaveRegisters(), v8::internal::compiler::X64LinkageHelperTraits::CRegisterParameter(), and v8::internal::compiler::X64LinkageHelperTraits::CRegisterParametersLength().