<s> static bool xtensa_lra_p ( void ) { return TARGET_LRA ; } </s>


<s> bool fp_zero_operand ( rtx op ) { if ( GET_MODE ( op ) != SFmode ) return false ; const REAL_VALUE_TYPE * r = CONST_DOUBLE_REAL_VALUE ( op ) ; return real_equal ( r , & dconst0 ) && ! REAL_VALUE_MINUS_ZERO ( * r ) ; } </s>

Returns true if OP is a floating point value with value 0.0 .


<s>
void
SNESRegisterInfo
::
splitReg
(
unsigned
Reg
,
unsigned
&
LoReg
,
unsigned
&
HiReg
)
const
{
assert
(
SNES
::
MainRegsRegClass
.
contains
(
Reg
)
&&
"can only split 16-bit registers"
)
;
LoReg
=
getSubReg
(
Reg
,
SNES
::
sub_lo
)
;
HiReg
=
getSubReg
(
Reg
,
SNES
::
sub_hi
)
;
}
</s>

Splits a 16-bit DREGS register into the lo/hi register pair .

SNES
SNES
SNES::MainRegsRegClass
"can only split 16-bit registers"
SNES::sub_lo
SNES::sub_hi


"calling %qD with SSE calling convention without "

"this is a GCC bug that can be worked around by adding "

Define how to find the value returned by a function . VALTYPE is the data type of the value ( as a tree ) . If the precise function being called is known , FUNC is its FUNCTION_DECL ; otherwise , FUNC is 0 .


<s> static void store_reg_modify ( int base , int reg , HOST_WIDE_INT mod ) { rtx insn , basereg , srcreg , delta ; gcc_assert ( VAL_14_BITS_P ( mod ) ) ; basereg = gen_rtx_REG ( Pmode , base ) ; srcreg = gen_rtx_REG ( word_mode , reg ) ; delta = GEN_INT ( mod ) ; insn = emit_insn ( gen_post_store ( basereg , srcreg , delta ) ) ; if ( DO_FRAME_NOTES ) { RTX_FRAME_RELATED_P ( insn ) = 1 ; RTX_FRAME_RELATED_P ( XVECEXP ( PATTERN ( insn ) , 0 , 0 ) ) = 1 ; RTX_FRAME_RELATED_P ( XVECEXP ( PATTERN ( insn ) , 0 , 1 ) ) = 1 ; } } </s>

Emit RTL to store REG at the memory location specified by BASE and then add MOD to BASE . MOD must be < = 8k .


<s> bool nds32_indirect_call_referenced_p ( rtx x ) { if ( GET_CODE ( x ) == UNSPEC && XINT ( x , 1 ) == UNSPEC_ICT ) x = XVECEXP ( x , 0 , 0 ) ; if ( GET_CODE ( x ) == SYMBOL_REF ) { tree decl = SYMBOL_REF_DECL ( x ) ; return decl && ( lookup_attribute ( "indirect_call" , DECL_ATTRIBUTES ( decl ) ) != NULL ) ; } return false ; } </s>

Return true X is a indirect call symbol .


<s> const char * BPFTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return NULL ; case BPFISD :: ADJDYNALLOC : return "BPFISD::ADJDYNALLOC" ; case BPFISD :: RET_FLAG : return "BPFISD::RET_FLAG" ; case BPFISD :: CALL : return "BPFISD::CALL" ; case BPFISD :: SELECT_CC : return "BPFISD::SELECT_CC" ; case BPFISD :: BR_CC : return "BPFISD::BR_CC" ; case BPFISD :: Wrapper : return "BPFISD::Wrapper" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


"Cannot store this register to stack slot!"

Store the specified register of the given register class to the specified stack frame index .


<s> unsigned PPCTargetLowering :: getPrefLoopAlignment ( MachineLoop * ML ) const { switch ( Subtarget . getDarwinDirective ( ) ) { default : break ; case PPC :: DIR_970 : case PPC :: DIR_PWR4 : case PPC :: DIR_PWR5 : case PPC :: DIR_PWR5X : case PPC :: DIR_PWR6 : case PPC :: DIR_PWR6X : case PPC :: DIR_PWR7 : case PPC :: DIR_PWR8 : { if ( ! ML ) break ; const PPCInstrInfo * TII = Subtarget . getInstrInfo ( ) ; uint64_t LoopSize = 0 ; for ( auto I = ML -> block_begin ( ) , IE = ML -> block_end ( ) ; I != IE ; ++ I ) for ( auto J = ( * I ) -> begin ( ) , JE = ( * I ) -> end ( ) ; J != JE ; ++ J ) LoopSize += TII -> GetInstSizeInBytes ( J ) ; if ( LoopSize > 16 && LoopSize <= 32 ) return 5 ; break ; } } return TargetLowering :: getPrefLoopAlignment ( ML ) ; } </s>


<s> bool enableMachineScheduler ( ) const override { return true ; } </s>

Enable the MachineScheduler pass for all X86 subtargets .


<s> static tree spu_gimplify_va_arg_expr ( tree valist , tree type , gimple_seq * pre_p , gimple_seq * post_p ATTRIBUTE_UNUSED ) { tree f_args , f_skip ; tree args , skip ; HOST_WIDE_INT size , rsize ; tree addr , tmp ; bool pass_by_reference_p ; f_args = TYPE_FIELDS ( TREE_TYPE ( va_list_type_node ) ) ; f_skip = DECL_CHAIN ( f_args ) ; valist = build_simple_mem_ref ( valist ) ; args = build3 ( COMPONENT_REF , TREE_TYPE ( f_args ) , valist , f_args , NULL_TREE ) ; skip = build3 ( COMPONENT_REF , TREE_TYPE ( f_skip ) , valist , f_skip , NULL_TREE ) ; addr = create_tmp_var ( ptr_type_node , "va_arg" ) ; pass_by_reference_p = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( pass_by_reference_p ) type = build_pointer_type ( type ) ; size = int_size_in_bytes ( type ) ; rsize = ( ( size + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ) * UNITS_PER_WORD ; tmp = fold_build_pointer_plus_hwi ( unshare_expr ( args ) , rsize ) ; tmp = build2 ( TRUTH_AND_EXPR , boolean_type_node , build2 ( GT_EXPR , boolean_type_node , tmp , unshare_expr ( skip ) ) , build2 ( LE_EXPR , boolean_type_node , unshare_expr ( args ) , unshare_expr ( skip ) ) ) ; tmp = build3 ( COND_EXPR , ptr_type_node , tmp , fold_build_pointer_plus_hwi ( unshare_expr ( skip ) , 32 ) , unshare_expr ( args ) ) ; gimplify_assign ( addr , tmp , pre_p ) ; tmp = fold_build_pointer_plus_hwi ( addr , rsize ) ; gimplify_assign ( unshare_expr ( args ) , tmp , pre_p ) ; addr = fold_convert ( build_pointer_type_for_mode ( type , ptr_mode , true ) , addr ) ; if ( pass_by_reference_p ) addr = build_va_arg_indirect_ref ( addr ) ; return build_va_arg_indirect_ref ( addr ) ; } </s>

Gimplify va_arg by updating the va_list structure VALIST as required to retrieve an argument of type TYPE , and returning that argument . ret = va_arg ( VALIST , TYPE ) ; generates code equivalent to : paddedsize = ( sizeof ( TYPE ) + 15 ) & -16 ; if ( VALIST.__args + paddedsize > VALIST.__skip & & VALIST.__args < = VALIST.__skip ) addr = VALIST.__skip + 32 ; else addr = VALIST.__args ; VALIST.__args = addr + paddedsize ; ret = * ( TYPE * ) addr ;


<s> unsigned X86InstrInfo :: isLoadFromStackSlotPostFE ( const MachineInstr & MI , int & FrameIndex ) const { unsigned Dummy ; if ( isFrameLoadOpcode ( MI . getOpcode ( ) , Dummy ) ) { unsigned Reg ; if ( ( Reg = isLoadFromStackSlot ( MI , FrameIndex ) ) ) return Reg ; SmallVector < const MachineMemOperand * , 1 > Accesses ; if ( hasLoadFromStackSlot ( MI , Accesses ) ) { FrameIndex = cast < FixedStackPseudoSourceValue > ( Accesses . front ( ) -> getPseudoValue ( ) ) -> getFrameIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

isLoadFromStackSlotPostFE - Check for post-frame ptr elimination stack locations as well .


<s> SDValue HexagonTargetLowering :: LowerReturn ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , const SmallVectorImpl < SDValue > & OutVals , SDLoc dl , SelectionDAG & DAG ) const { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , getTargetMachine ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeReturn ( Outs , RetCC_Hexagon ) ; SDValue Flag ; SmallVector < SDValue , 4 > RetOps ( 1 , Chain ) ; for ( unsigned i = 0 ; i != RVLocs . size ( ) ; ++ i ) { CCValAssign & VA = RVLocs [ i ] ; Chain = DAG . getCopyToReg ( Chain , dl , VA . getLocReg ( ) , OutVals [ i ] , Flag ) ; Flag = Chain . getValue ( 1 ) ; RetOps . push_back ( DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ) ; } RetOps [ 0 ] = Chain ; if ( Flag . getNode ( ) ) RetOps . push_back ( Flag ) ; return DAG . getNode ( HexagonISD :: RET_FLAG , dl , MVT :: Other , RetOps ) ; } </s>

This hook must be implemented to lower outgoing return values , described by the Outs array , into the specified DAG .


<s>
SDValue
MMIXTargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
IsVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
const
SmallVectorImpl
<
SDValue
>
&
OutVals
,
const
SDLoc
&
DL
,
SelectionDAG
&
DAG
)
const
{
if
(
IsVarArg
)
{
report_fatal_error
(
"VarArg not supported"
)
;
}
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
IsVarArg
,
DAG
.
getMachineFunction
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_MMIX
)
;
SDValue
Flag
;
SmallVector
<
SDValue
,
4
>
RetOps
(
1
,
Chain
)
;
for
(
unsigned
i
=
0
,
e
=
RVLocs
.
size
(
)
;
i
<
e
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
DL
,
VA
.
getLocReg
(
)
,
OutVals
[
i
]
,
Flag
)
;
Flag
=
Chain
.
getValue
(
1
)
;
RetOps
.
push_back
(
DAG
.
getRegister
(
VA
.
getLocReg
(
)
,
VA
.
getLocVT
(
)
)
)
;
}
RetOps
[
0
]
=
Chain
;
if
(
Flag
.
getNode
(
)
)
{
RetOps
.
push_back
(
Flag
)
;
}
return
DAG
.
getNode
(
MMIXISD
::
RET_FLAG
,
DL
,
MVT
::
Other
,
RetOps
)
;
}
</s>


<s> static bool aarch64_advsimd_valid_immediate ( unsigned HOST_WIDE_INT val64 , simd_immediate_info * info , enum simd_immediate_check which ) { unsigned int val32 = val64 & 0xffffffff ; unsigned int val16 = val64 & 0xffff ; unsigned int val8 = val64 & 0xff ; if ( val32 == ( val64 >> 32 ) ) { if ( ( which & AARCH64_CHECK_ORR ) != 0 && aarch64_advsimd_valid_immediate_hs ( val32 , info , which , simd_immediate_info :: MOV ) ) return true ; if ( ( which & AARCH64_CHECK_BIC ) != 0 && aarch64_advsimd_valid_immediate_hs ( ~ val32 , info , which , simd_immediate_info :: MVN ) ) return true ; if ( which == AARCH64_CHECK_MOV && val16 == ( val32 >> 16 ) && val8 == ( val16 >> 8 ) ) { if ( info ) * info = simd_immediate_info ( QImode , val8 ) ; return true ; } } if ( which == AARCH64_CHECK_MOV ) { unsigned int i ; for ( i = 0 ; i < 64 ; i += 8 ) { unsigned char byte = ( val64 >> i ) & 0xff ; if ( byte != 0 && byte != 0xff ) break ; } if ( i == 64 ) { if ( info ) * info = simd_immediate_info ( DImode , val64 ) ; return true ; } } return false ; } </s>

Return true if replicating VAL64 is a valid immediate for the Advanced SIMD operation described by WHICH . If INFO is nonnull , use it to describe valid immediates .


<s> void expand_epilogue ( ) { HOST_WIDE_INT size ; size = get_frame_size ( ) + current_function_outgoing_args_size ; size += ( current_function_outgoing_args_size ? 4 : 0 ) ; if ( frame_pointer_needed ) { emit_move_insn ( stack_pointer_rtx , frame_pointer_rtx ) ; size = 0 ; } else if ( size + REG_SAVE_BYTES > 255 ) { emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( size ) ) ) ; size = 0 ; } if ( size || regs_ever_live [ 2 ] || regs_ever_live [ 3 ] || regs_ever_live [ 6 ] || regs_ever_live [ 7 ] || regs_ever_live [ 14 ] || regs_ever_live [ 15 ] || regs_ever_live [ 16 ] || regs_ever_live [ 17 ] || frame_pointer_needed ) emit_jump_insn ( gen_return_internal_regs ( GEN_INT ( size + REG_SAVE_BYTES ) ) ) ; else emit_jump_insn ( gen_return_internal ( ) ) ; } </s>


<s> DFAPacketizer * HexagonInstrInfo :: CreateTargetScheduleState ( const TargetSubtargetInfo & STI ) const { const InstrItineraryData * II = STI . getInstrItineraryData ( ) ; return static_cast < const HexagonSubtarget & > ( STI ) . createDFAPacketizer ( II ) ; } </s>

Create machine specific model for scheduling .


<s> const TeakInstrInfo * getInstrInfo ( ) const override { return & InstrInfo ; } </s>


<s> static const predefined_function_abi & aarch64_simd_abi ( void ) { predefined_function_abi & simd_abi = function_abis [ ARM_PCS_SIMD ] ; if ( ! simd_abi . initialized_p ( ) ) { HARD_REG_SET full_reg_clobbers = default_function_abi . full_reg_clobbers ( ) ; for ( int regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( FP_SIMD_SAVED_REGNUM_P ( regno ) ) CLEAR_HARD_REG_BIT ( full_reg_clobbers , regno ) ; simd_abi . initialize ( ARM_PCS_SIMD , full_reg_clobbers ) ; } return simd_abi ; } </s>


<s> void AMDGPUTargetLowering :: ExtractVectorElements ( SDValue Op , SelectionDAG & DAG , SmallVectorImpl < SDValue > & Args , unsigned Start , unsigned Count ) const { EVT VT = Op . getValueType ( ) ; for ( unsigned i = Start , e = Start + Count ; i != e ; ++ i ) { Args . push_back ( DAG . getNode ( ISD :: EXTRACT_VECTOR_ELT , SDLoc ( Op ) , VT . getVectorElementType ( ) , Op , DAG . getConstant ( i , MVT :: i32 ) ) ) ; } } </s>

Append the extracted elements from Start to Count out of the vector Op in Args .


<s> bool RISCVFrameLowering :: canUseAsPrologue ( const MachineBasicBlock & MBB ) const { MachineBasicBlock * TmpMBB = const_cast < MachineBasicBlock * > ( & MBB ) ; const auto * RVFI = MBB . getParent ( ) -> getInfo < RISCVMachineFunctionInfo > ( ) ; if ( ! RVFI -> useSaveRestoreLibCalls ( ) ) return true ; RegScavenger RS ; RS . enterBasicBlock ( * TmpMBB ) ; return ! RS . isRegUsed ( RISCV :: X5 ) ; } </s>

Check whether or not the given MBB can be used as a prologue for the target .


"asked to expand an instruction that is not a shift"

expand - Expand a record into a set of elements if possible .


<s> bool SITargetLowering :: canMergeStoresTo ( unsigned AS , EVT MemVT , const SelectionDAG & DAG ) const { if ( AS == AMDGPUAS :: GLOBAL_ADDRESS || AS == AMDGPUAS :: FLAT_ADDRESS ) { return ( MemVT . getSizeInBits ( ) <= 4 * 32 ) ; } else if ( AS == AMDGPUAS :: PRIVATE_ADDRESS ) { unsigned MaxPrivateBits = 8 * getSubtarget ( ) -> getMaxPrivateElementSize ( ) ; return ( MemVT . getSizeInBits ( ) <= MaxPrivateBits ) ; } else if ( AS == AMDGPUAS :: LOCAL_ADDRESS || AS == AMDGPUAS :: REGION_ADDRESS ) { return ( MemVT . getSizeInBits ( ) <= 2 * 32 ) ; } return true ; } </s>

Returns if it 's reasonable to merge stores to MemVT size .


<s> static std :: unique_ptr < HexagonOperand > CreateReg ( unsigned RegNum , SMLoc S , SMLoc E ) { HexagonOperand * Op = new HexagonOperand ( Register ) ; Op -> Reg . RegNum = RegNum ; Op -> StartLoc = S ; Op -> EndLoc = E ; return std :: unique_ptr < HexagonOperand > ( Op ) ; } </s>

CreateReg - Allocate a single virtual register for the given type .


<s> static bool spu_scalar_mode_supported_p ( machine_mode mode ) { switch ( mode ) { case QImode : case HImode : case SImode : case SFmode : case DImode : case TImode : case DFmode : return true ; default : return false ; } } </s>

True if MODE is valid for the target . By `` valid '' , we mean able to be manipulated in non-trivial ways . In particular , this means all the arithmetic is supported .


"Unmatched number of shufflevectors and indices"

Lower interleaved load ( s ) into target specific instructions/intrinsics .


<s> int legitimate_constant_p ( rtx op ) { if ( ! SYMBOLIC_CONST ( op ) ) return 1 ; if ( TARGET_CPU_ZARCH && larl_operand ( op , VOIDmode ) ) return 1 ; if ( TLS_SYMBOLIC_CONST ( op ) ) return 0 ; if ( flag_pic ) return 1 ; return 0 ; } </s>

Nonzero if the constant value X is a legitimate general operand . It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE .


<s> MCFragment * findAssociatedFragment ( ) const override { return getSubExpr ( ) -> findAssociatedFragment ( ) ; } </s>

Find the `` associated section '' for this expression , which is currently defined as the absolute section for constants , or otherwise the section associated with the first defined symbol in the expression .


<s> static bool s390_match_ccmode_set ( rtx set , machine_mode req_mode ) { machine_mode set_mode ; gcc_assert ( GET_CODE ( set ) == SET ) ; gcc_assert ( req_mode != CCVIALLmode && req_mode != CCVIANYmode && req_mode != CCVFALLmode && req_mode != CCVFANYmode ) ; if ( GET_CODE ( SET_DEST ( set ) ) != REG || ! CC_REGNO_P ( REGNO ( SET_DEST ( set ) ) ) ) return 1 ; set_mode = GET_MODE ( SET_DEST ( set ) ) ; switch ( set_mode ) { case E_CCZ1mode : case E_CCSmode : case E_CCSRmode : case E_CCSFPSmode : case E_CCUmode : case E_CCURmode : case E_CCOmode : case E_CCLmode : case E_CCL1mode : case E_CCL2mode : case E_CCL3mode : case E_CCT1mode : case E_CCT2mode : case E_CCT3mode : case E_CCVEQmode : case E_CCVIHmode : case E_CCVIHUmode : case E_CCVFHmode : case E_CCVFHEmode : if ( req_mode != set_mode ) return 0 ; break ; case E_CCZmode : if ( req_mode != CCSmode && req_mode != CCUmode && req_mode != CCTmode && req_mode != CCSRmode && req_mode != CCURmode && req_mode != CCZ1mode ) return 0 ; break ; case E_CCAPmode : case E_CCANmode : if ( req_mode != CCAmode ) return 0 ; break ; default : gcc_unreachable ( ) ; } return ( GET_MODE ( SET_SRC ( set ) ) == set_mode ) ; } </s>

Return true if SET either does n't set the CC register , or else the source and destination have matching CC modes and that CC mode is at least as constrained as REQ_MODE .


<s> bool mayNeedRelaxation ( const MCInst & Inst ) const override { return false ; } </s>

Check whether the given instruction may need relaxation .


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
override
{
const
static
MCFixupKindInfo
Infos
[
TriCore
::
NumTargetFixupKinds
]
=
{
{
"fixup_leg_mov_hi16_pcrel"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_leg_mov_lo16_pcrel"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
}
;
if
(
Kind
<
FirstTargetFixupKind
)
{
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
}
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s> static MachineInstr * getDef ( unsigned Reg , const MachineRegisterInfo * MRI ) { if ( TargetRegisterInfo :: isPhysicalRegister ( Reg ) ) return 0 ; return MRI -> getUniqueVRegDef ( Reg ) ; } </s>

Get the concrete record with the specified name .


<s> const char * AMDGPUTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return 0 ; NODE_NAME_CASE ( CALL ) ; NODE_NAME_CASE ( UMUL ) ; NODE_NAME_CASE ( DIV_INF ) ; NODE_NAME_CASE ( RET_FLAG ) ; NODE_NAME_CASE ( BRANCH_COND ) ; NODE_NAME_CASE ( DWORDADDR ) NODE_NAME_CASE ( FRACT ) NODE_NAME_CASE ( FMAX ) NODE_NAME_CASE ( SMAX ) NODE_NAME_CASE ( UMAX ) NODE_NAME_CASE ( FMIN ) NODE_NAME_CASE ( SMIN ) NODE_NAME_CASE ( UMIN ) NODE_NAME_CASE ( URECIP ) NODE_NAME_CASE ( DOT4 ) NODE_NAME_CASE ( EXPORT ) NODE_NAME_CASE ( CONST_ADDRESS ) NODE_NAME_CASE ( REGISTER_LOAD ) NODE_NAME_CASE ( REGISTER_STORE ) NODE_NAME_CASE ( LOAD_CONSTANT ) NODE_NAME_CASE ( LOAD_INPUT ) NODE_NAME_CASE ( SAMPLE ) NODE_NAME_CASE ( SAMPLEB ) NODE_NAME_CASE ( SAMPLED ) NODE_NAME_CASE ( SAMPLEL ) NODE_NAME_CASE ( STORE_MSKOR ) NODE_NAME_CASE ( TBUFFER_STORE_FORMAT ) } } </s>

getTargetNodeName - This method returns the name of a target specific


<s> void apply ( ScheduleDAGInstrs * DAG ) override { SUnit * SUa = nullptr ; for ( SUnit & SU : DAG -> SUnits ) { MachineInstr & MI2 = * SU . getInstr ( ) ; if ( ! MI2 . mayLoad ( ) && ! MI2 . mayStore ( ) ) { SUa = nullptr ; continue ; } if ( ! SUa ) { SUa = & SU ; continue ; } MachineInstr & MI1 = * SUa -> getInstr ( ) ; if ( ( TII -> isVMEM ( MI1 ) && TII -> isVMEM ( MI2 ) ) || ( TII -> isFLAT ( MI1 ) && TII -> isFLAT ( MI2 ) ) || ( TII -> isSMRD ( MI1 ) && TII -> isSMRD ( MI2 ) ) || ( TII -> isDS ( MI1 ) && TII -> isDS ( MI2 ) ) ) { SU . addPredBarrier ( SUa ) ; for ( const SDep & SI : SU . Preds ) { if ( SI . getSUnit ( ) != SUa ) SUa -> addPred ( SDep ( SI . getSUnit ( ) , SDep :: Artificial ) ) ; } if ( & SU != & DAG -> ExitSU ) { for ( const SDep & SI : SUa -> Succs ) { if ( SI . getSUnit ( ) != & SU ) SI . getSUnit ( ) -> addPred ( SDep ( & SU , SDep :: Artificial ) ) ; } } } SUa = & SU ; } } </s>

Apply the profile inference algorithm for a given function .


<s> void Warning ( SMLoc L , const Twine & Msg ) { Parser . Warning ( L , Msg ) ; } </s>

Emit a warning at the location L , with the message Msg .


<s> unsigned long arm_current_func_type ( void ) { if ( ARM_FUNC_TYPE ( cfun -> machine -> func_type ) == ARM_FT_UNKNOWN ) cfun -> machine -> func_type = arm_compute_func_type ( ) ; return cfun -> machine -> func_type ; } </s>

Returns the type of the current function .


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { const PPCSubtarget & STI = MF . getSubtarget < PPCSubtarget > ( ) ; if ( ! STI . hasVSX ( ) ) return false ; TII = STI . getInstrInfo ( ) ; bool Changed = false ; for ( MachineFunction :: iterator I = MF . begin ( ) ; I != MF . end ( ) ; ) { MachineBasicBlock & B = * I ++ ; if ( processBlock ( B ) ) Changed = true ; } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> static void pa_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; rtx start_addr = gen_reg_rtx ( Pmode ) ; rtx end_addr = gen_reg_rtx ( Pmode ) ; rtx line_length = gen_reg_rtx ( Pmode ) ; rtx r_tramp , tmp ; emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ; r_tramp = force_reg ( Pmode , XEXP ( m_tramp , 0 ) ) ; if ( ! TARGET_64BIT ) { tmp = adjust_address ( m_tramp , Pmode , 36 ) ; emit_move_insn ( tmp , fnaddr ) ; tmp = adjust_address ( m_tramp , Pmode , 40 ) ; emit_move_insn ( tmp , chain_value ) ; tmp = adjust_address ( m_tramp , Pmode , 44 ) ; emit_move_insn ( tmp , r_tramp ) ; tmp = adjust_address ( m_tramp , Pmode , 48 ) ; emit_move_insn ( tmp , gen_rtx_REG ( Pmode , 19 ) ) ; emit_insn ( gen_andsi3 ( start_addr , r_tramp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; tmp = force_reg ( Pmode , plus_constant ( Pmode , r_tramp , TRAMPOLINE_CODE_SIZE - 1 ) ) ; emit_insn ( gen_andsi3 ( end_addr , tmp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; emit_move_insn ( line_length , GEN_INT ( MIN_CACHELINE_SIZE ) ) ; emit_insn ( gen_dcacheflushsi ( start_addr , end_addr , line_length ) ) ; emit_insn ( gen_icacheflushsi ( start_addr , end_addr , line_length , gen_reg_rtx ( Pmode ) , gen_reg_rtx ( Pmode ) ) ) ; } else { tmp = adjust_address ( m_tramp , Pmode , 56 ) ; emit_move_insn ( tmp , fnaddr ) ; tmp = adjust_address ( m_tramp , Pmode , 64 ) ; emit_move_insn ( tmp , chain_value ) ; tmp = adjust_address ( m_tramp , Pmode , 16 ) ; emit_move_insn ( tmp , force_reg ( Pmode , plus_constant ( Pmode , r_tramp , 32 ) ) ) ; tmp = adjust_address ( m_tramp , Pmode , 24 ) ; emit_move_insn ( tmp , gen_rtx_REG ( Pmode , 27 ) ) ; tmp = force_reg ( Pmode , plus_constant ( Pmode , r_tramp , 32 ) ) ; emit_insn ( gen_anddi3 ( start_addr , tmp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; tmp = force_reg ( Pmode , plus_constant ( Pmode , tmp , TRAMPOLINE_CODE_SIZE - 1 ) ) ; emit_insn ( gen_anddi3 ( end_addr , tmp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; emit_move_insn ( line_length , GEN_INT ( MIN_CACHELINE_SIZE ) ) ; emit_insn ( gen_dcacheflushdi ( start_addr , end_addr , line_length ) ) ; emit_insn ( gen_icacheflushdi ( start_addr , end_addr , line_length , gen_reg_rtx ( Pmode ) , gen_reg_rtx ( Pmode ) ) ) ; } </s>

Emit RTL insns to initialize the variable parts of a trampoline . FNADDR is an RTX for the address of the function 's pure code . CXT is an RTX for the static chain value for the function . Move the function address to the trampoline template at offset 36 . Move the static chain value to trampoline template at offset 40 . Move the trampoline address to trampoline template at offset 44 . Move r19 to trampoline template at offset 48 . The latter two words create a plabel for the indirect call to the trampoline . A similar sequence is used for the 64-bit port but the plabel is at the beginning of the trampoline . Finally , the cache entries for the trampoline code are flushed . This is necessary to ensure that the trampoline instruction sequence is written to memory prior to any attempts at prefetching the code sequence .


<s> void X86InstrInfo :: breakPartialRegDependency ( MachineBasicBlock :: iterator MI , unsigned OpNum , const TargetRegisterInfo * TRI ) const { unsigned Reg = MI -> getOperand ( OpNum ) . getReg ( ) ; if ( MI -> killsRegister ( Reg , TRI ) ) return ; if ( X86 :: VR128RegClass . contains ( Reg ) ) { unsigned Opc = Subtarget . hasAVX ( ) ? X86 :: VXORPSrr : X86 :: XORPSrr ; BuildMI ( * MI -> getParent ( ) , MI , MI -> getDebugLoc ( ) , get ( Opc ) , Reg ) . addReg ( Reg , RegState :: Undef ) . addReg ( Reg , RegState :: Undef ) ; MI -> addRegisterKilled ( Reg , TRI , true ) ; } else if ( X86 :: VR256RegClass . contains ( Reg ) ) { unsigned XReg = TRI -> getSubReg ( Reg , X86 :: sub_xmm ) ; BuildMI ( * MI -> getParent ( ) , MI , MI -> getDebugLoc ( ) , get ( X86 :: VXORPSrr ) , XReg ) . addReg ( XReg , RegState :: Undef ) . addReg ( XReg , RegState :: Undef ) . addReg ( Reg , RegState :: ImplicitDefine ) ; MI -> addRegisterKilled ( Reg , TRI , true ) ; } } </s>

Insert a dependency-breaking instruction before MI to eliminate an unwanted dependency on OpNum .


<s> TargetLowering :: AtomicExpansionKind WebAssemblyTargetLowering :: shouldExpandAtomicRMWInIR ( AtomicRMWInst * AI ) const { switch ( AI -> getOperation ( ) ) { case AtomicRMWInst :: Add : case AtomicRMWInst :: Sub : case AtomicRMWInst :: And : case AtomicRMWInst :: Or : case AtomicRMWInst :: Xor : case AtomicRMWInst :: Xchg : return AtomicExpansionKind :: None ; default : break ; } return AtomicExpansionKind :: CmpXChg ; } </s>

Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW , if at all .


"FPDelta isn't aligned per the Win64 ABI!"

"VLAs and dynamic stack realign, but no FP?!"

getFrameIndexReference - This method should return the base register and offset used to reference a frame index location .


<s> static HOST_WIDE_INT csky_constant_alignment ( const_tree exp , HOST_WIDE_INT align ) { if ( TREE_CODE ( exp ) == STRING_CST && ! optimize_size && align < BITS_PER_WORD ) return BITS_PER_WORD ; return align ; } </s>

Implement TARGET_CONSTANT_ALIGNMENT . Make strings word-aligned so strcpy from constants will be faster .


<s> void M88kIncomingValueHandler :: assignValueToAddress ( Register ValVReg , Register Addr , LLT MemTy , MachinePointerInfo & MPO , CCValAssign & VA ) { MachineFunction & MF = MIRBuilder . getMF ( ) ; auto * MMO = MF . getMachineMemOperand ( MPO , MachineMemOperand :: MOLoad , MemTy , inferAlignFromPtrInfo ( MF , MPO ) ) ; MIRBuilder . buildLoad ( ValVReg , Addr , * MMO ) ; } </s>

An overload which takes an ArgInfo if additional information about the arg is needed .


<s> bool NyuziAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode , raw_ostream & O ) { if ( ExtraCode && ExtraCode [ 0 ] ) return AsmPrinter :: PrintAsmOperand ( MI , OpNo , AsmVariant , ExtraCode , O ) ; const MachineOperand & MO = MI -> getOperand ( OpNo ) ; if ( MO . getType ( ) == MachineOperand :: MO_Register ) { O << NyuziInstPrinter :: getRegisterName ( MO . getReg ( ) ) ; return false ; } else if ( MO . getType ( ) == MachineOperand :: MO_Immediate ) { O << MO . getImm ( ) ; return false ; } return true ; } </s>

PrintAsmOperand - Print out an operand for an inline asm expression .


<s> int TPCFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , unsigned & FrameReg ) const { const TPCTargetLowering & TL = * MF . getSubtarget < TPCSubtarget > ( ) . getTargetLowering ( ) ; FrameReg = TL . getZeroReg ( ) ; if ( static_cast < unsigned > ( FI ) < FrameObjects . size ( ) && ! FrameObjects [ FI ] . isEmpty ( ) ) return getFrameObjectOffset ( FI ) ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; return MFI . getObjectOffset ( FI ) ; } </s>


<s> bool MSP430AsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { if ( MF . getFunction ( ) . hasFnAttribute ( "interrupt" ) ) { EmitInterruptVectorSection ( MF ) ; } SetupMachineFunction ( MF ) ; EmitFunctionBody ( ) ; return false ; } </s>


"AArch64 FastISel doesn't support types larger than i64"

This is a wrapper around getRegForValue that also takes care of truncating or sign-extending the given getelementptr index value .


<s> std :: pair < unsigned , const TargetRegisterClass * > AArch64TargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'r' : if ( VT . getSizeInBits ( ) <= 32 ) return std :: make_pair ( 0U , & AArch64 :: GPR32RegClass ) ; else if ( VT == MVT :: i64 ) return std :: make_pair ( 0U , & AArch64 :: GPR64RegClass ) ; break ; case 'w' : if ( VT == MVT :: f16 ) return std :: make_pair ( 0U , & AArch64 :: FPR16RegClass ) ; else if ( VT == MVT :: f32 ) return std :: make_pair ( 0U , & AArch64 :: FPR32RegClass ) ; else if ( VT == MVT :: f64 ) return std :: make_pair ( 0U , & AArch64 :: FPR64RegClass ) ; else if ( VT . getSizeInBits ( ) == 64 ) return std :: make_pair ( 0U , & AArch64 :: VPR64RegClass ) ; else if ( VT == MVT :: f128 ) return std :: make_pair ( 0U , & AArch64 :: FPR128RegClass ) ; else if ( VT . getSizeInBits ( ) == 128 ) return std :: make_pair ( 0U , & AArch64 :: VPR128RegClass ) ; break ; } } return TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s>
static
char
*
match_identifier
(
void
)
{
int
lastpos
=
pos
1
;
while
(
lastpos
<
LINELEN
1
&&
(
isalnum
(
linebuf
[
lastpos
+
1
]
)
||
linebuf
[
lastpos
+
1
]
==
'_'
)
)
++
lastpos
;
if
(
lastpos
>=
LINELEN
1
)
{
diag
(
lastpos
,
"line length overrun.\n"
)
;
exit
(
1
)
;
}
if
(
lastpos
<
pos
)
return
0
;
char
*
buf
=
(
char
*
)
malloc
(
lastpos
pos
+
2
)
;
memcpy
(
buf
,
&
linebuf
[
pos
]
,
lastpos
pos
+
1
)
;
buf
[
lastpos
pos
+
1
]
=
'\0'
;
pos
=
lastpos
+
1
;
return
buf
;
}
</s>

Match an identifier , returning NULL on failure , else a pointer to a buffer containing the identifier .


<s> bool WebAssemblyInstrInfo :: analyzeBranch ( MachineBasicBlock & MBB , MachineBasicBlock * & TBB , MachineBasicBlock * & FBB , SmallVectorImpl < MachineOperand > & Cond , bool ) const { bool HaveCond = false ; for ( MachineInstr & MI : MBB . terminators ( ) ) { switch ( MI . getOpcode ( ) ) { default : return true ; case WebAssembly :: BR_IF : if ( HaveCond ) return true ; if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; Cond . push_back ( MachineOperand :: CreateImm ( true ) ) ; Cond . push_back ( MI . getOperand ( 1 ) ) ; TBB = MI . getOperand ( 0 ) . getMBB ( ) ; HaveCond = true ; break ; case WebAssembly :: BR_UNLESS : if ( HaveCond ) return true ; if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; Cond . push_back ( MachineOperand :: CreateImm ( false ) ) ; Cond . push_back ( MI . getOperand ( 1 ) ) ; TBB = MI . getOperand ( 0 ) . getMBB ( ) ; HaveCond = true ; break ; case WebAssembly :: BR : if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; if ( ! HaveCond ) TBB = MI . getOperand ( 0 ) . getMBB ( ) ; else FBB = MI . getOperand ( 0 ) . getMBB ( ) ; break ; case WebAssembly :: BR_ON_EXN : if ( HaveCond ) return true ; if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; Cond . push_back ( MachineOperand :: CreateImm ( true ) ) ; Cond . push_back ( MI . getOperand ( 2 ) ) ; TBB = MI . getOperand ( 0 ) . getMBB ( ) ; HaveCond = true ; break ; } if ( MI . isBarrier ( ) ) break ; } return false ; } </s>

analyzeBranch - Analyze the branching code at the end of MBB , returning true if it can not be understood ( e.g .


<s> static void arm_set_default_type_attributes ( tree type ) { if ( TREE_CODE ( type ) == FUNCTION_TYPE || TREE_CODE ( type ) == METHOD_TYPE ) { tree type_attr_list , attr_name ; type_attr_list = TYPE_ATTRIBUTES ( type ) ; if ( arm_pragma_long_calls == LONG ) attr_name = get_identifier ( "long_call" ) ; else if ( arm_pragma_long_calls == SHORT ) attr_name = get_identifier ( "short_call" ) ; else return ; type_attr_list = tree_cons ( attr_name , NULL_TREE , type_attr_list ) ; TYPE_ATTRIBUTES ( type ) = type_attr_list ; } } </s>

Assigns default attributes to newly defined type . This is used to set short_call/long_call attributes for function types of functions defined inside corresponding # pragma scopes .


<s> unsigned DLXMCCodeEmitter :: getBranchTargetOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const { const MCOperand & MCOp = Inst . getOperand ( OpNo ) ; if ( MCOp . isReg ( ) || MCOp . isImm ( ) ) return getMachineOpValue ( Inst , MCOp , Fixups , SubtargetInfo ) ; Fixups . push_back ( MCFixup :: create ( 0 , MCOp . getExpr ( ) , static_cast < MCFixupKind > ( DLX :: FIXUP_DLX_25 ) ) ) ; return 0 ; } </s>

getBranchTargetOpValue - Return binary encoding of the branch target operand .


<s> MCObjectWriter * createObjectWriter ( raw_pwrite_stream & OS ) const override { uint8_t OSABI = MCELFObjectTargetWriter :: getOSABI ( OSType ) ; return createSparcELFObjectWriter ( OS , Is64Bit , IsLittleEndian , OSABI ) ; } </s>

Create a new MCObjectWriter instance for use by the assembler backend to emit the final object file .


<s>
bool
SIRegisterInfo
::
eliminateSGPRToVGPRSpillFrameIndex
(
MachineBasicBlock
::
iterator
MI
,
int
FI
,
RegScavenger
*
RS
)
const
{
switch
(
MI
->
getOpcode
(
)
)
{
case
AMDGPU
::
SI_SPILL_S512_SAVE
:
case
AMDGPU
::
SI_SPILL_S256_SAVE
:
case
AMDGPU
::
SI_SPILL_S128_SAVE
:
case
AMDGPU
::
SI_SPILL_S64_SAVE
:
case
AMDGPU
::
SI_SPILL_S32_SAVE
:
return
spillSGPR
(
MI
,
FI
,
RS
,
true
)
;
case
AMDGPU
::
SI_SPILL_S512_RESTORE
:
case
AMDGPU
::
SI_SPILL_S256_RESTORE
:
case
AMDGPU
::
SI_SPILL_S128_RESTORE
:
case
AMDGPU
::
SI_SPILL_S64_RESTORE
:
case
AMDGPU
::
SI_SPILL_S32_RESTORE
:
return
restoreSGPR
(
MI
,
FI
,
RS
,
true
)
;
default
:
llvm_unreachable
(
"not an SGPR spill instruction"
)
;
}
}
</s>


<s> void X86FrameLowering :: orderFrameObjects ( const MachineFunction & MF , SmallVectorImpl < int > & ObjectsToAllocate ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; if ( ObjectsToAllocate . empty ( ) ) return ; std :: vector < X86FrameSortingObject > SortingObjects ( MFI . getObjectIndexEnd ( ) ) ; for ( auto & Obj : ObjectsToAllocate ) { SortingObjects [ Obj ] . IsValid = true ; SortingObjects [ Obj ] . ObjectIndex = Obj ; SortingObjects [ Obj ] . ObjectAlignment = MFI . getObjectAlign ( Obj ) ; int ObjectSize = MFI . getObjectSize ( Obj ) ; if ( ObjectSize == 0 ) SortingObjects [ Obj ] . ObjectSize = 4 ; else SortingObjects [ Obj ] . ObjectSize = ObjectSize ; } for ( auto & MBB : MF ) { for ( auto & MI : MBB ) { if ( MI . isDebugInstr ( ) ) continue ; for ( const MachineOperand & MO : MI . operands ( ) ) { if ( ! MO . isFI ( ) ) continue ; int Index = MO . getIndex ( ) ; if ( Index >= 0 && Index < MFI . getObjectIndexEnd ( ) && SortingObjects [ Index ] . IsValid ) SortingObjects [ Index ] . ObjectNumUses ++ ; } } } llvm :: stable_sort ( SortingObjects , X86FrameSortingComparator ( ) ) ; int i = 0 ; for ( auto & Obj : SortingObjects ) { if ( ! Obj . IsValid ) break ; ObjectsToAllocate [ i ++ ] = Obj . ObjectIndex ; } if ( ! TRI -> needsStackRealignment ( MF ) && hasFP ( MF ) ) std :: reverse ( ObjectsToAllocate . begin ( ) , ObjectsToAllocate . end ( ) ) ; } </s>


<s> static unsigned s390_loop_unroll_adjust ( unsigned nunroll , struct loop * loop ) { basic_block * bbs ; rtx_insn * insn ; unsigned i ; unsigned mem_count = 0 ; if ( s390_tune < PROCESSOR_2097_Z10 ) return nunroll ; bbs = get_loop_body ( loop ) ; subrtx_iterator :: array_type array ; for ( i = 0 ; i < loop -> num_nodes ; i ++ ) FOR_BB_INSNS ( bbs [ i ] , insn ) if ( INSN_P ( insn ) && INSN_CODE ( insn ) != - 1 ) { rtx set ; if ( s390_tune >= PROCESSOR_2964_Z13 && loop -> ninsns <= BLOCK_MEM_OPS_LOOP_INSNS && ( ( set = single_set ( insn ) ) != NULL_RTX ) && ( ( GET_MODE ( SET_DEST ( set ) ) == BLKmode && ( GET_MODE ( SET_SRC ( set ) ) == BLKmode || SET_SRC ( set ) == const0_rtx ) ) || ( GET_CODE ( SET_SRC ( set ) ) == COMPARE && GET_MODE ( XEXP ( SET_SRC ( set ) , 0 ) ) == BLKmode && GET_MODE ( XEXP ( SET_SRC ( set ) , 1 ) ) == BLKmode ) ) ) { free ( bbs ) ; return 1 ; } FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( MEM_P ( * iter ) ) mem_count += 1 ; } free ( bbs ) ; if ( mem_count == 0 ) return nunroll ; switch ( loop_depth ( loop ) ) { case 1 : return MIN ( nunroll , 28 / mem_count ) ; case 2 : return MIN ( nunroll , 22 / mem_count ) ; default : return MIN ( nunroll , 16 / mem_count ) ; } } </s>

This target hook implementation for TARGET_LOOP_UNROLL_ADJUST calculates a new number struct loop * loop should be unrolled if tuned for cpus with a built-in stride prefetcher . The loop is analyzed for memory accesses by calling check_dpu for each rtx of the loop . Depending on the loop_depth and the amount of memory accesses a new number < =nunroll is returned to improve the behaviour of the hardware prefetch unit .


<s> int log2constp ( unsigned HOST_WIDE_INT c ) { c &= 0xFFFFFFFF ; return c != 0 && ( c & ( c - 1 ) ) == 0 ; } </s>

Return nonzero iff C has exactly one bit set if it is interpreted as a 32 bit constant .


<s>
void
ARMCallLowering
::
splitToValueTypes
(
const
ArgInfo
&
OrigArg
,
SmallVectorImpl
<
ArgInfo
>
&
SplitArgs
,
const
DataLayout
&
DL
,
MachineRegisterInfo
&
MRI
)
const
{
const
ARMTargetLowering
&
TLI
=
*
getTLI
<
ARMTargetLowering
>
(
)
;
LLVMContext
&
Ctx
=
OrigArg
.
Ty
->
getContext
(
)
;
SmallVector
<
EVT
,
4
>
SplitVTs
;
SmallVector
<
uint64_t
,
4
>
Offsets
;
ComputeValueVTs
(
TLI
,
DL
,
OrigArg
.
Ty
,
SplitVTs
,
&
Offsets
,
0
)
;
assert
(
SplitVTs
.
size
(
)
==
1
&&
"Unsupported type"
)
;
SplitArgs
.
emplace_back
(
OrigArg
.
Reg
,
SplitVTs
[
0
]
.
getTypeForEVT
(
Ctx
)
,
OrigArg
.
Flags
,
OrigArg
.
IsFixed
)
;
}
</s>

Break OrigArgInfo into one or more pieces the calling convention can process , returned in SplitArgs .


<s> unsigned HexagonRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getTarget ( ) . getFrameLowering ( ) ; if ( TFI -> hasFP ( MF ) ) { return Hexagon :: R30 ; } return Hexagon :: R29 ; } </s>


Return the opcode of the special instruction to be used to load the constant X .


<s> unsigned char X86Subtarget :: classifyGlobalReference ( const GlobalValue * GV , const Module & M ) const { if ( TM . getCodeModel ( ) == CodeModel :: Large && ! isPositionIndependent ( ) ) return X86II :: MO_NO_FLAG ; if ( GV ) { if ( Optional < ConstantRange > CR = GV -> getAbsoluteSymbolRange ( ) ) { if ( CR -> getUnsignedMax ( ) . ult ( 128 ) ) return X86II :: MO_ABS8 ; else return X86II :: MO_NO_FLAG ; } } if ( TM . shouldAssumeDSOLocal ( M , GV ) ) return classifyLocalReference ( GV ) ; if ( isTargetCOFF ( ) ) return X86II :: MO_DLLIMPORT ; if ( is64Bit ( ) ) { if ( TM . getCodeModel ( ) == CodeModel :: Large ) return isTargetELF ( ) ? X86II :: MO_GOT : X86II :: MO_NO_FLAG ; return X86II :: MO_GOTPCREL ; } if ( isTargetDarwin ( ) ) { if ( ! isPositionIndependent ( ) ) return X86II :: MO_DARWIN_NONLAZY ; return X86II :: MO_DARWIN_NONLAZY_PIC_BASE ; } return X86II :: MO_GOT ; } </s>

Classify a global variable reference for the current subtarget according to how we should reference it in a non-pcrel context .


<s> bool usesPhysRegsForValues ( ) const override { return false ; } </s>

True if the target uses physical regs ( as nearly all targets do ) .


<s> void print_operand_address ( FILE * file , rtx addr ) { rtx breg ; rtx offset ; int again = 0 ; retry : switch ( GET_CODE ( addr ) ) { case MEM : if ( TARGET_UNIX_ASM ) fprintf ( file , "*" ) ; else fprintf ( file , "@" ) ; addr = XEXP ( addr , 0 ) ; again = 1 ; goto retry ; case REG : fprintf ( file , "(%s)" , reg_names [ REGNO ( addr ) ] ) ; break ; case PRE_MODIFY : case PRE_DEC : fprintf ( file , "-(%s)" , reg_names [ REGNO ( XEXP ( addr , 0 ) ) ] ) ; break ; case POST_MODIFY : case POST_INC : fprintf ( file , "(%s)+" , reg_names [ REGNO ( XEXP ( addr , 0 ) ) ] ) ; break ; case PLUS : breg = 0 ; offset = 0 ; if ( CONSTANT_ADDRESS_P ( XEXP ( addr , 0 ) ) || GET_CODE ( XEXP ( addr , 0 ) ) == MEM ) { offset = XEXP ( addr , 0 ) ; addr = XEXP ( addr , 1 ) ; } else if ( CONSTANT_ADDRESS_P ( XEXP ( addr , 1 ) ) || GET_CODE ( XEXP ( addr , 1 ) ) == MEM ) { offset = XEXP ( addr , 1 ) ; addr = XEXP ( addr , 0 ) ; } if ( GET_CODE ( addr ) != PLUS ) ; else if ( GET_CODE ( XEXP ( addr , 0 ) ) == REG ) { breg = XEXP ( addr , 0 ) ; addr = XEXP ( addr , 1 ) ; } else if ( GET_CODE ( XEXP ( addr , 1 ) ) == REG ) { breg = XEXP ( addr , 1 ) ; addr = XEXP ( addr , 0 ) ; } if ( GET_CODE ( addr ) == REG ) { gcc_assert ( breg == 0 ) ; breg = addr ; addr = 0 ; } if ( offset != 0 ) { gcc_assert ( addr == 0 ) ; addr = offset ; } if ( addr != 0 ) output_addr_const_pdp11 ( file , addr ) ; if ( breg != 0 ) { gcc_assert ( GET_CODE ( breg ) == REG ) ; fprintf ( file , "(%s)" , reg_names [ REGNO ( breg ) ] ) ; } break ; default : if ( ! again && GET_CODE ( addr ) == CONST_INT ) { if ( TARGET_DEC_ASM ) fprintf ( file , "@#" ) ; else if ( ! TARGET_UNIX_ASM ) fprintf ( file , "@$" ) ; } output_addr_const_pdp11 ( file , addr ) ; } } </s>

Print the operand address represented by the rtx addr


<s> static void ix86_emit_restore_regs_using_mov ( HOST_WIDE_INT cfa_offset , bool maybe_eh_return ) { struct machine_function * m = cfun -> machine ; unsigned int regno ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , maybe_eh_return ) ) { rtx reg = gen_rtx_REG ( word_mode , regno ) ; rtx mem ; rtx_insn * insn ; mem = choose_baseaddr ( cfa_offset ) ; mem = gen_frame_mem ( word_mode , mem ) ; insn = emit_move_insn ( reg , mem ) ; if ( m -> fs . cfa_reg == crtl -> drap_reg && regno == REGNO ( crtl -> drap_reg ) ) { add_reg_note ( insn , REG_CFA_DEF_CFA , reg ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; m -> fs . drap_valid = true ; } else ix86_add_cfa_restore_note ( NULL , reg , cfa_offset ) ; cfa_offset -= UNITS_PER_WORD ; } } </s>

Emit code to restore saved registers using MOV insns . First register is restored from POINTER + OFFSET .


<s> rtx mips_subword ( rtx op , int high_p ) { unsigned int byte ; enum machine_mode mode ; mode = GET_MODE ( op ) ; if ( mode == VOIDmode ) mode = DImode ; if ( TARGET_BIG_ENDIAN ? ! high_p : high_p ) byte = UNITS_PER_WORD ; else byte = 0 ; if ( REG_P ( op ) ) { if ( FP_REG_P ( REGNO ( op ) ) ) return gen_rtx_REG ( word_mode , high_p ? REGNO ( op ) + 1 : REGNO ( op ) ) ; if ( ACC_HI_REG_P ( REGNO ( op ) ) ) return gen_rtx_REG ( word_mode , high_p ? REGNO ( op ) : REGNO ( op ) + 1 ) ; } if ( MEM_P ( op ) ) return mips_rewrite_small_data ( adjust_address ( op , word_mode , byte ) ) ; return simplify_gen_subreg ( word_mode , op , mode , byte ) ; } </s>

Return one word of double-word value OP , taking into account the fixed endianness of certain registers . HIGH_P is true to select the high part , false to select the low part .


<s> bool NVPTXSplitBBatBar :: runOnFunction ( Function & F ) { SmallVector < Instruction * , 4 > SplitPoints ; bool changed = false ; for ( Function :: iterator BI = F . begin ( ) , BE = F . end ( ) ; BI != BE ; ++ BI ) { BasicBlock :: iterator IB = BI -> begin ( ) ; BasicBlock :: iterator II = IB ; BasicBlock :: iterator IE = BI -> end ( ) ; while ( II != IE ) { if ( IntrinsicInst * inst = dyn_cast < IntrinsicInst > ( II ) ) { Intrinsic :: ID id = inst -> getIntrinsicID ( ) ; if ( llvm :: isBarrierIntrinsic ( id ) ) { if ( II != IB ) SplitPoints . push_back ( II ) ; II ++ ; if ( ( II != IE ) && ( ! II -> isTerminator ( ) ) ) { SplitPoints . push_back ( II ) ; II ++ ; } continue ; } } II ++ ; } } for ( unsigned i = 0 ; i != SplitPoints . size ( ) ; i ++ ) { changed = true ; Instruction * inst = SplitPoints [ i ] ; inst -> getParent ( ) -> splitBasicBlock ( inst , "bar_split" ) ; } return changed ; } </s>

runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass .


<s> bool AVRAsmParser :: emit ( MCInst & Inst , SMLoc const & Loc , MCStreamer & Out ) const { Inst . setLoc ( Loc ) ; Out . emitInstruction ( Inst , STI ) ; return false ; } </s>

Output the remark via the diagnostic handler and to the optimization record file .


<s> bool SystemZInstrInfo :: isPredicable ( MachineInstr * MI ) const { unsigned Opcode = MI -> getOpcode ( ) ; if ( TM . getSubtargetImpl ( ) -> hasLoadStoreOnCond ( ) && getConditionalMove ( Opcode ) ) return true ; return false ; } </s>

Return true if the specified instruction can be predicated .


<s> PreservedAnalyses BPFAbstractMemberAccessPass :: run ( Function & F , FunctionAnalysisManager & AM ) { return BPFAbstractMemberAccess ( TM ) . run ( F ) ? PreservedAnalyses :: none ( ) : PreservedAnalyses :: all ( ) ; } </s>

Run the analysis pass over a function and produce a dominator tree .


<s> static void emit_movsi ( rtx operands [ 2 ] ) { operands [ 0 ] = copy_operand ( operands [ 0 ] , SImode ) ; operands [ 1 ] = copy_operand ( operands [ 1 ] , SImode ) ; emit_insn ( gen_movsi ( operands [ 0 ] , operands [ 1 ] ) ) ; } </s>

Emit rtl code for moving operands [ 1 ] into operands [ 0 ] as a fullword .


<s> unsigned getPointerSize ( ) const { return 2 ; } </s>

Layout pointer size in bytes , rounded up to a whole number of bytes .


<s> static void ix86_reorg ( void ) { if ( TARGET_ATHLON_K8 && optimize && ! optimize_size ) ix86_pad_returns ( ) ; if ( TARGET_FOUR_JUMP_LIMIT && optimize && ! optimize_size ) ix86_avoid_jump_misspredicts ( ) ; } </s>

Implement machine specific optimizations . We implement padding of returns for K8 CPUs and pass to avoid 4 jumps in the single 16 byte window .


<s> static void loongarch_adjust_block_mem ( rtx mem , HOST_WIDE_INT length , rtx * loop_reg , rtx * loop_mem ) { * loop_reg = copy_addr_to_reg ( XEXP ( mem , 0 ) ) ; * loop_mem = change_address ( mem , BLKmode , * loop_reg ) ; set_mem_align ( * loop_mem , MIN ( MEM_ALIGN ( mem ) , length * BITS_PER_UNIT ) ) ; } </s>

Helper function for doing a loop-based block operation on memory reference MEM . Each iteration of the loop will operate on LENGTH bytes of MEM . Create a new base register for use within the loop and point it to the start of MEM . Create a new memory reference that uses this register . Store them in * LOOP_REG and * LOOP_MEM respectively .


<s> ARMSubtarget :: ARMSubtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const ARMBaseTargetMachine & TM , bool IsLittle ) : ARMGenSubtargetInfo ( TT , CPU , FS ) , UseMulOps ( UseFusedMulOps ) , GenExecuteOnly ( EnableExecuteOnly ) , CPUString ( CPU ) , IsLittle ( IsLittle ) , TargetTriple ( TT ) , Options ( TM . Options ) , TM ( TM ) , FrameLowering ( initializeFrameLowering ( CPU , FS ) ) , InstrInfo ( isThumb1Only ( ) ? ( ARMBaseInstrInfo * ) new Thumb1InstrInfo ( * this ) : ! isThumb ( ) ? ( ARMBaseInstrInfo * ) new ARMInstrInfo ( * this ) : ( ARMBaseInstrInfo * ) new Thumb2InstrInfo ( * this ) ) , TLInfo ( TM , * this ) , GISel ( ) { } </s>

This constructor initializes the data members to match that of the specified triple .


<s> static int get_epiphany_condition_code ( rtx comparison ) { switch ( GET_MODE ( XEXP ( comparison , 0 ) ) ) { case E_CCmode : switch ( GET_CODE ( comparison ) ) { case EQ : return 0 ; case NE : return 1 ; case LTU : return 2 ; case GEU : return 3 ; case GT : return 4 ; case LE : return 5 ; case GE : return 6 ; case LT : return 7 ; case GTU : return 8 ; case LEU : return 9 ; default : gcc_unreachable ( ) ; } case E_CC_N_NEmode : switch ( GET_CODE ( comparison ) ) { case EQ : return 6 ; case NE : return 7 ; default : gcc_unreachable ( ) ; } case E_CC_C_LTUmode : switch ( GET_CODE ( comparison ) ) { case GEU : return 2 ; case LTU : return 3 ; default : gcc_unreachable ( ) ; } case E_CC_C_GTUmode : switch ( GET_CODE ( comparison ) ) { case LEU : return 3 ; case GTU : return 2 ; default : gcc_unreachable ( ) ; } case E_CC_FPmode : switch ( GET_CODE ( comparison ) ) { case EQ : return 10 ; case NE : return 11 ; case LT : return 12 ; case LE : return 13 ; default : gcc_unreachable ( ) ; } case E_CC_FP_EQmode : switch ( GET_CODE ( comparison ) ) { case EQ : return 0 ; case NE : return 1 ; default : gcc_unreachable ( ) ; } case E_CC_FP_GTEmode : switch ( GET_CODE ( comparison ) ) { case EQ : return 0 ; case NE : return 1 ; case GT : return 4 ; case GE : return 6 ; case UNLE : return 5 ; case UNLT : return 7 ; default : gcc_unreachable ( ) ; } case E_CC_FP_ORDmode : switch ( GET_CODE ( comparison ) ) { case ORDERED : return 9 ; case UNORDERED : return 8 ; default : gcc_unreachable ( ) ; } case E_CC_FP_UNEQmode : switch ( GET_CODE ( comparison ) ) { case UNEQ : return 9 ; case LTGT : return 8 ; default : gcc_unreachable ( ) ; } default : gcc_unreachable ( ) ; } return ( 42 ) ; } </s>

Returns the index of the EPIPHANY condition code string in ` epiphany_condition_codes ' . COMPARISON should be an rtx like ` ( eq ( ... ) ( ... ) ) ' .


<s> static std :: unique_ptr < MipsOperand > CreateReg ( unsigned Index , StringRef Str , RegKind RegKind , const MCRegisterInfo * RegInfo , SMLoc S , SMLoc E , MipsAsmParser & Parser ) { auto Op = std :: make_unique < MipsOperand > ( k_RegisterIndex , Parser ) ; Op -> RegIdx . Index = Index ; Op -> RegIdx . RegInfo = RegInfo ; Op -> RegIdx . Kind = RegKind ; Op -> RegIdx . Tok . Data = Str . data ( ) ; Op -> RegIdx . Tok . Length = Str . size ( ) ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>

CreateReg - Allocate a single virtual register for the given type .


<s> unsigned AMDGPUSubtarget :: getMaxLocalMemSizeWithWaveCount ( unsigned NWaves , const Function & F ) const { if ( NWaves == 1 ) return getLocalMemorySize ( ) ; unsigned WorkGroupSize = getFlatWorkGroupSizes ( F ) . second ; unsigned WorkGroupsPerCu = getMaxWorkGroupsPerCU ( WorkGroupSize ) ; unsigned MaxWaves = getMaxWavesPerEU ( ) ; return getLocalMemorySize ( ) * MaxWaves / WorkGroupsPerCu / NWaves ; } </s>

Return the amount of LDS that can be used that will not restrict the occupancy lower than WaveCount .


<s> static void find_constant ( rtx in_rtx , imm_info * imm_values ) { if ( INSN_P ( in_rtx ) ) in_rtx = PATTERN ( in_rtx ) ; subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , in_rtx , ALL ) if ( const_rtx x = * iter ) switch ( GET_CODE ( x ) ) { case CONST : case SYMBOL_REF : case CONST_INT : ( imm_values -> imm ) ++ ; if ( x86_64_immediate_operand ( CONST_CAST_RTX ( x ) , SImode ) ) ( imm_values -> imm32 ) ++ ; else ( imm_values -> imm64 ) ++ ; break ; case CONST_DOUBLE : ( imm_values -> imm ) ++ ; ( imm_values -> imm64 ) ++ ; break ; case CODE_LABEL : if ( LABEL_KIND ( x ) == LABEL_NORMAL ) { ( imm_values -> imm ) ++ ; ( imm_values -> imm32 ) ++ ; } break ; default : break ; } } </s>

Compute number of immediate operands of an instruction .


<s> static void rs6000_split_logical_inner ( rtx dest , rtx op1 , rtx op2 , enum rtx_code code , machine_mode mode , bool complement_final_p , bool complement_op1_p , bool complement_op2_p ) { rtx bool_rtx ; if ( op2 && GET_CODE ( op2 ) == CONST_INT && ( mode == SImode || ( mode == DImode && TARGET_POWERPC64 ) ) && ! complement_final_p && ! complement_op1_p && ! complement_op2_p ) { HOST_WIDE_INT mask = GET_MODE_MASK ( mode ) ; HOST_WIDE_INT value = INTVAL ( op2 ) & mask ; if ( code == AND ) { if ( value == 0 ) { emit_insn ( gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ) ; return ; } else if ( value == mask ) { if ( ! rtx_equal_p ( dest , op1 ) ) emit_insn ( gen_rtx_SET ( VOIDmode , dest , op1 ) ) ; return ; } } else if ( code == IOR || code == XOR ) { if ( value == 0 ) { if ( ! rtx_equal_p ( dest , op1 ) ) emit_insn ( gen_rtx_SET ( VOIDmode , dest , op1 ) ) ; return ; } } } if ( code == AND && mode == SImode && ! complement_final_p && ! complement_op1_p && ! complement_op2_p ) { emit_insn ( gen_andsi3 ( dest , op1 , op2 ) ) ; return ; } if ( complement_op1_p ) op1 = gen_rtx_NOT ( mode , op1 ) ; if ( complement_op2_p ) op2 = gen_rtx_NOT ( mode , op2 ) ; if ( ! complement_op1_p && complement_op2_p ) std :: swap ( op1 , op2 ) ; bool_rtx = ( ( code == NOT ) ? gen_rtx_NOT ( mode , op1 ) : gen_rtx_fmt_ee ( code , mode , op1 , op2 ) ) ; if ( complement_final_p ) bool_rtx = gen_rtx_NOT ( mode , bool_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , bool_rtx ) ) ; } </s>

Helper function for rs6000_split_logical to emit a logical instruction after spliting the operation to single GPR registers . DEST is the destination register . OP1 and OP2 are the input source registers . CODE is the base operation ( AND , IOR , XOR , NOT ) . MODE is the machine mode . If COMPLEMENT_FINAL_P is true , wrap the whole operation with NOT . If COMPLEMENT_OP1_P is true , wrap operand1 with NOT . If COMPLEMENT_OP2_P is true , wrap operand2 with NOT .


<s> void PPCPassConfig :: addIRPasses ( ) { if ( TM -> getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCBoolRetToIntPass ( ) ) ; addPass ( createAtomicExpandPass ( ) ) ; bool UsePrefetching = TM -> getTargetTriple ( ) . getVendor ( ) == Triple :: BGQ && getOptLevel ( ) != CodeGenOpt :: None ; if ( EnablePrefetch . getNumOccurrences ( ) > 0 ) UsePrefetching = EnablePrefetch ; if ( UsePrefetching ) addPass ( createLoopDataPrefetchPass ( ) ) ; if ( TM -> getOptLevel ( ) >= CodeGenOpt :: Default && EnableGEPOpt ) { addPass ( createSeparateConstOffsetFromGEPPass ( TM , true ) ) ; addPass ( createEarlyCSEPass ( ) ) ; addPass ( createLICMPass ( ) ) ; } TargetPassConfig :: addIRPasses ( ) ; } </s>

Add common target configurable passes that perform LLVM IR to IR transforms following machine independent optimization .


<s> bool SIInstrInfo :: usesConstantBus ( const MachineRegisterInfo & MRI , const MachineOperand & MO ) const { if ( isLiteralConstant ( MO ) ) return true ; if ( ! MO . isReg ( ) || ! MO . isUse ( ) ) return false ; if ( TargetRegisterInfo :: isVirtualRegister ( MO . getReg ( ) ) ) return RI . isSGPRClass ( MRI . getRegClass ( MO . getReg ( ) ) ) ; if ( ! MO . isImplicit ( ) && ( MO . getReg ( ) == AMDGPU :: FLAT_SCR ) ) return true ; if ( ! MO . isImplicit ( ) && MO . getReg ( ) == AMDGPU :: EXEC ) return true ; if ( MO . getReg ( ) == AMDGPU :: M0 || MO . getReg ( ) == AMDGPU :: VCC || ( ! MO . isImplicit ( ) && ( AMDGPU :: SGPR_32RegClass . contains ( MO . getReg ( ) ) || AMDGPU :: SGPR_64RegClass . contains ( MO . getReg ( ) ) ) ) ) { return true ; } return false ; } </s>

Returns true if this operand uses the constant bus .


<s>
void
PatmosInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
unsigned
Opc
;
if
(
Patmos
::
RRegsRegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
Opc
=
Patmos
::
MOV
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DestReg
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
if
(
Patmos
::
PRegsRegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
Opc
=
Patmos
::
PMOV
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DestReg
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
.
addImm
(
0
)
;
}
else
if
(
Patmos
::
SRegsRegClass
.
contains
(
DestReg
)
)
{
assert
(
Patmos
::
RRegsRegClass
.
contains
(
SrcReg
)
)
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
Patmos
::
MTS
)
,
DestReg
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
if
(
Patmos
::
SRegsRegClass
.
contains
(
SrcReg
)
)
{
assert
(
Patmos
::
RRegsRegClass
.
contains
(
DestReg
)
)
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
Patmos
::
MFS
)
,
DestReg
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
{
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
}
</s>

Patmos
Patmos
Patmos::RRegsRegClass
Patmos::MOV
Patmos::PRegsRegClass
Patmos::PMOV
0
Patmos::SRegsRegClass
Patmos::RRegsRegClass
Patmos::MTS
Patmos::SRegsRegClass
Patmos::RRegsRegClass
Patmos::MFS
"Impossible reg-to-reg copy"


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const override { uint64_t NumNops = Count / 4 ; for ( uint64_t i = 0 ; i != NumNops ; ++ i ) OW -> Write32 ( 0x60000000 ) ; switch ( Count % 4 ) { default : break ; case 1 : OW -> Write8 ( 0 ) ; break ; case 2 : OW -> Write16 ( 0 ) ; break ; case 3 : OW -> Write16 ( 0 ) ; OW -> Write8 ( 0 ) ; break ; } return true ; } </s>

Write an ( optimal ) nop sequence of Count bytes to the given output .


<s> TargetPassConfig * NVPTXTargetMachine :: createPassConfig ( PassManagerBase & PM ) { return new NVPTXPassConfig ( * this , PM ) ; } </s>

Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of CodeGen passes .


<s> TargetLoweringBase :: LegalizeTypeAction X86TargetLowering :: getPreferredVectorAction ( MVT VT ) const { if ( ( VT == MVT :: v32i1 || VT == MVT :: v64i1 ) && Subtarget . hasAVX512 ( ) && ! Subtarget . hasBWI ( ) ) return TypeSplitVector ; if ( ! VT . isScalableVector ( ) && VT . getVectorNumElements ( ) != 1 && VT . getVectorElementType ( ) != MVT :: i1 ) return TypeWidenVector ; return TargetLoweringBase :: getPreferredVectorAction ( VT ) ; } </s>

Customize the preferred legalization strategy for certain types .


<s> bool NVPTXReplaceImageHandles :: runOnMachineFunction ( MachineFunction & MF ) { bool Changed = false ; InstrsToRemove . clear ( ) ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { for ( MachineBasicBlock :: iterator I = ( * BI ) . begin ( ) , E = ( * BI ) . end ( ) ; I != E ; ++ I ) { MachineInstr & MI = * I ; Changed |= processInstr ( MI ) ; } } for ( DenseSet < MachineInstr * > :: iterator I = InstrsToRemove . begin ( ) , E = InstrsToRemove . end ( ) ; I != E ; ++ I ) { ( * I ) -> eraseFromParent ( ) ; } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool rs6000_emit_set_const ( rtx dest , rtx source ) { machine_mode mode = GET_MODE ( dest ) ; rtx temp , set ; rtx_insn * insn ; HOST_WIDE_INT c ; gcc_checking_assert ( CONST_INT_P ( source ) ) ; c = INTVAL ( source ) ; switch ( mode ) { case E_QImode : case E_HImode : emit_insn ( gen_rtx_SET ( dest , source ) ) ; return true ; case E_SImode : temp = ! can_create_pseudo_p ( ) ? dest : gen_reg_rtx ( SImode ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( temp ) , GEN_INT ( c & ~ ( HOST_WIDE_INT ) 0xffff ) ) ) ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_IOR ( SImode , copy_rtx ( temp ) , GEN_INT ( c & 0xffff ) ) ) ) ; break ; case E_DImode : if ( ! TARGET_POWERPC64 ) { rtx hi , lo ; hi = operand_subword_force ( copy_rtx ( dest ) , WORDS_BIG_ENDIAN == 0 , DImode ) ; lo = operand_subword_force ( dest , WORDS_BIG_ENDIAN != 0 , DImode ) ; emit_move_insn ( hi , GEN_INT ( c >> 32 ) ) ; c = ( ( c & 0xffffffff ) ^ 0x80000000 ) - 0x80000000 ; emit_move_insn ( lo , GEN_INT ( c ) ) ; } else rs6000_emit_set_long_const ( dest , c ) ; break ; default : gcc_unreachable ( ) ; } insn = get_last_insn ( ) ; set = single_set ( insn ) ; if ( ! CONSTANT_P ( SET_SRC ( set ) ) ) set_unique_reg_note ( insn , REG_EQUAL , GEN_INT ( c ) ) ; return true ; } </s>

Try to output insns to set TARGET equal to the constant C if it can be done in less than N insns . Do all computations in MODE . Returns the place where the output has been placed if it can be done and the insns have been emitted . If it would take more than N insns , zero is returned and no insns and emitted .


<s> void SystemZInstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , unsigned DestReg , int FrameIdx , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; unsigned LoadOpcode , StoreOpcode ; getLoadStoreOpcodes ( RC , LoadOpcode , StoreOpcode ) ; addFrameReference ( BuildMI ( MBB , MBBI , DL , get ( LoadOpcode ) , DestReg ) , FrameIdx ) ; } </s>

Load the specified register of the given register class from the specified stack frame index .


"All AArch64 cmps should have 2 operands"

analyzeCompare - For a comparison instruction , return the source registers in SrcReg and SrcReg2 if having two register operands , and the value it compares against in CmpValue .


<s> void arm_split_atomic_op ( enum rtx_code code , rtx old_out , rtx new_out , rtx mem , rtx value , rtx model_rtx , rtx cond ) { enum memmodel model = ( enum memmodel ) INTVAL ( model_rtx ) ; machine_mode mode = GET_MODE ( mem ) ; machine_mode wmode = ( mode == DImode ? DImode : SImode ) ; rtx_code_label * label ; rtx x ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( model == MEMMODEL_RELAXED || model == MEMMODEL_CONSUME || model == MEMMODEL_RELEASE ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( model == MEMMODEL_RELAXED || model == MEMMODEL_CONSUME || model == MEMMODEL_ACQUIRE ) ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( model ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ; if ( new_out ) new_out = gen_lowpart ( wmode , new_out ) ; if ( old_out ) old_out = gen_lowpart ( wmode , old_out ) ; else old_out = new_out ; value = simplify_gen_subreg ( wmode , value , mode , 0 ) ; arm_emit_load_exclusive ( mode , old_out , mem , use_acquire ) ; switch ( code ) { case SET : new_out = value ; break ; case NOT : x = gen_rtx_AND ( wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( VOIDmode , new_out , x ) ) ; x = gen_rtx_NOT ( wmode , new_out ) ; emit_insn ( gen_rtx_SET ( VOIDmode , new_out , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( value ) ) { value = GEN_INT ( - INTVAL ( value ) ) ; code = PLUS ; } case PLUS : if ( mode == DImode ) { emit_move_insn ( new_out , old_out ) ; if ( code == PLUS ) x = gen_adddi3 ( new_out , new_out , value ) ; else x = gen_subdi3 ( new_out , new_out , value ) ; emit_insn ( x ) ; break ; } default : x = gen_rtx_fmt_ee ( code , wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( VOIDmode , new_out , x ) ) ; break ; } arm_emit_store_exclusive ( mode , cond , mem , gen_lowpart ( mode , new_out ) , use_release ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; emit_unlikely_jump ( gen_cbranchsi4 ( x , cond , const0_rtx , label ) ) ; if ( ! ( use_acquire || use_release ) ) arm_post_atomic_barrier ( model ) ; } </s>

Split an atomic operation pattern . Operation is given by CODE and is one of PLUS , MINUS , IOR , XOR , SET ( for an exchange operation ) or NOT ( for a nand operation ) . Operation is performed on the content at MEM and on VALUE following the memory model MODEL_RTX . The content at MEM before and after the operation is returned in OLD_OUT and NEW_OUT respectively while the success of the operation is returned in COND . Using a scratch register or an operand register for these determines what result is returned for that pattern .


<s> void GBZ80FrameLowering :: emitPrologue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; CallingConv :: ID CallConv = MF . getFunction ( ) . getCallingConv ( ) ; DebugLoc DL = ( MBBI != MBB . end ( ) ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; const GBZ80Subtarget & STI = MF . getSubtarget < GBZ80Subtarget > ( ) ; const GBZ80InstrInfo & TII = * STI . getInstrInfo ( ) ; bool HasFP = hasFP ( MF ) ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const GBZ80MachineFunctionInfo * AFI = MF . getInfo < GBZ80MachineFunctionInfo > ( ) ; int FrameSize = MFI . getStackSize ( ) - AFI -> getCalleeSavedFrameSize ( ) ; while ( ( MBBI != MBB . end ( ) ) && MBBI -> getFlag ( MachineInstr :: FrameSetup ) && ( MBBI -> getOpcode ( ) == GB :: PUSH ) ) { ++ MBBI ; } if ( ! FrameSize ) { return ; } while ( FrameSize != 0 ) { int ToSubtract = std :: min ( 128 , FrameSize ) ; MachineInstr * MI = BuildMI ( MBB , MBBI , DL , TII . get ( GB :: ADD_SP_e ) ) . addImm ( - ToSubtract ) . setMIFlag ( MachineInstr :: FrameSetup ) ; MI -> findRegisterDefOperand ( GB :: RF ) -> setIsDead ( ) ; FrameSize -= ToSubtract ; } } </s>

emitProlog/emitEpilog - These methods insert prolog and epilog code into the function .

GBZ80 GB GB GB GB GB GB GB::PUSH 0 128 GB::ADD_SP_e GB::RF


<s>
const
char
*
vax_output_int_move
(
rtx
insn
ATTRIBUTE_UNUSED
,
rtx
*
operands
,
enum
machine_mode
mode
)
{
switch
(
mode
)
{
case
SImode
:
if
(
GET_CODE
(
operands
[
1
]
)
==
SYMBOL_REF
||
GET_CODE
(
operands
[
1
]
)
==
CONST
)
{
if
(
push_operand
(
operands
[
0
]
,
SImode
)
)
return
"pushab %a1"
;
return
"movab %a1,%0"
;
}
if
(
operands
[
1
]
==
const0_rtx
)
return
"clrl %0"
;
if
(
GET_CODE
(
operands
[
1
]
)
==
CONST_INT
&&
(
unsigned
)
INTVAL
(
operands
[
1
]
)
>=
64
)
{
int
i
=
INTVAL
(
operands
[
1
]
)
;
if
(
(
unsigned
)
(
~
i
)
<
64
)
return
"mcoml %N1,%0"
;
if
(
(
unsigned
)
i
<
0x100
)
return
"movzbl %1,%0"
;
if
(
i
>=
0x80
&&
i
<
0
)
return
"cvtbl %1,%0"
;
if
(
(
unsigned
)
i
<
0x10000
)
return
"movzwl %1,%0"
;
if
(
i
>=
0x8000
&&
i
<
0
)
return
"cvtwl %1,%0"
;
}
if
(
push_operand
(
operands
[
0
]
,
SImode
)
)
return
"pushl %1"
;
return
"movl %1,%0"
;
case
HImode
:
if
(
GET_CODE
(
operands
[
1
]
)
==
CONST_INT
)
{
int
i
=
INTVAL
(
operands
[
1
]
)
;
if
(
i
==
0
)
return
"clrw %0"
;
else
if
(
(
unsigned
int
)
i
<
64
)
return
"movw %1,%0"
;
else
if
(
(
unsigned
int
)
~
i
<
64
)
return
"mcomw %H1,%0"
;
else
if
(
(
unsigned
int
)
i
<
256
)
return
"movzbw %1,%0"
;
}
return
"movw %1,%0"
;
case
QImode
:
if
(
GET_CODE
(
operands
[
1
]
)
==
CONST_INT
)
{
int
i
=
INTVAL
(
operands
[
1
]
)
;
if
(
i
==
0
)
return
"clrb %0"
;
else
if
(
(
unsigned
int
)
~
i
<
64
)
return
"mcomb %B1,%0"
;
}
return
"movb %1,%0"
;
default
:
gcc_unreachable
(
)
;
}
}
</s>


<s> int mips_class_max_nregs ( enum reg_class rclass , machine_mode mode ) { int size ; HARD_REG_SET left ; size = 0x8000 ; left = reg_class_contents [ rclass ] ; if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) ST_REGS ] ) ) { if ( mips_hard_regno_mode_ok ( ST_REG_FIRST , mode ) ) size = MIN ( size , 4 ) ; left &= ~ reg_class_contents [ ST_REGS ] ; } if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FP_REGS ] ) ) { if ( mips_hard_regno_mode_ok ( FP_REG_FIRST , mode ) ) { if ( MSA_SUPPORTED_MODE_P ( mode ) ) size = MIN ( size , UNITS_PER_MSA_REG ) ; else size = MIN ( size , UNITS_PER_FPREG ) ; } left &= ~ reg_class_contents [ FP_REGS ] ; } if ( ! hard_reg_set_empty_p ( left ) ) size = MIN ( size , UNITS_PER_WORD ) ; return ( GET_MODE_SIZE ( mode ) + size - 1 ) / size ; } </s>

Implement CLASS_MAX_NREGS . Usually all registers are word-sized . The only supported exception is -mgp64 -msingle-float , which has 64-bit words but 32-bit float registers . A word-based calculation is correct even in that case , since -msingle-float disallows multi-FPR values . The FP status registers are an exception to this rule . They are always 4 bytes wide as they only hold condition code modes , and CCmode is always considered to be 4 bytes wide .


<s>
static
void
x86_print_call_or_nop
(
FILE
*
file
,
const
char
*
target
)
{
if
(
flag_nop_mcount
)
fprintf
(
file
,
"1:\tnopl 0x00(%%eax,%%eax,1)\n"
)
;
else
fprintf
(
file
,
"1:\tcall\t%s\n"
,
target
)
;
}
</s>


<s> const char * mips_output_jump ( rtx * operands , int target_opno , int size_opno , bool link_p ) { static char buffer [ 300 ] ; char * s = buffer ; bool reg_p = REG_P ( operands [ target_opno ] ) ; const char * and_link = link_p ? "al" : "" ; const char * reg = reg_p ? "r" : "" ; const char * compact = "" ; const char * nop = "%/" ; const char * short_delay = link_p ? "%!" : "" ; const char * insn_name = TARGET_CB_NEVER || reg_p ? "j" : "b" ; if ( ! final_sequence && ( TARGET_CB_MAYBE || ( ISA_HAS_JRC && ! link_p && reg_p ) ) ) { compact = "c" ; nop = "" ; } if ( TARGET_USE_GOT && ! TARGET_EXPLICIT_RELOCS ) sprintf ( s , "%%*%s%s\t%%%d%%/" , insn_name , and_link , target_opno ) ; else { if ( ! reg_p && TARGET_ABICALLS_PIC2 ) s += sprintf ( s , ".option\tpic0\n\t" ) ; if ( reg_p && mips_get_pic_call_symbol ( operands , size_opno ) ) { s += sprintf ( s , "%%*.reloc\t1f,R_MIPS_JALR,%%%d\n1:\t" , size_opno ) ; short_delay = "" ; } else s += sprintf ( s , "%%*" ) ; s += sprintf ( s , "%s%s%s%s%s\t%%%d%s" , insn_name , and_link , reg , compact , short_delay , target_opno , nop ) ; if ( ! reg_p && TARGET_ABICALLS_PIC2 ) s += sprintf ( s , "\n\t.option\tpic2" ) ; } return buffer ; } </s>

Return the asm template for a call . OPERANDS are the operands , TARGET_OPNO is the operand number of the target . SIZE_OPNO is the operand number of the argument size operand that can optionally hold the call attributes . If SIZE_OPNO is not -1 and the call is indirect , use the function symbol from the call attributes to attach a R_MIPS_JALR relocation to the call . LINK_P indicates whether the jump is a call and needs to set the link register . When generating GOT code without explicit relocation operators , all calls should use assembly macros . Otherwise , all indirect calls should use `` jr '' or `` jalr '' ; we will arrange to restore $ gp afterwards if necessary . Finally , we can only generate direct calls for -mabicalls by temporarily switching to non-PIC mode . For microMIPS jal ( r ) , we try to generate jal ( r ) s when a 16-bit instruction is in the delay slot of jal ( r ) . Where compact branches are available , we try to use them if the delay slot has a NOP ( or equivalently delay slots were not enabled for the instruction anyway ) .


<s> int direct_return ( void ) { if ( reload_completed ) { rs6000_stack_t * info = rs6000_stack_info ( ) ; if ( info -> first_gp_reg_save == 32 && info -> first_fp_reg_save == 64 && info -> first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1 && ! info -> lr_save_p && ! info -> cr_save_p && info -> vrsave_size == 0 && ! info -> push_p ) return 1 ; } return 0 ; } </s>

Return non-zero if this function is known to have a null epilogue .


<s> rtx nvptx_expand_compare ( rtx compare ) { rtx pred = gen_reg_rtx ( BImode ) ; rtx cmp = gen_rtx_fmt_ee ( GET_CODE ( compare ) , BImode , XEXP ( compare , 0 ) , XEXP ( compare , 1 ) ) ; emit_insn ( gen_rtx_SET ( pred , cmp ) ) ; return gen_rtx_NE ( BImode , pred , const0_rtx ) ; } </s>

Emit a comparison COMPARE , and return the new test to be used in the jump .


<s> bool ix86_match_ccmode ( rtx insn , machine_mode req_mode ) { rtx set ; machine_mode set_mode ; set = PATTERN ( insn ) ; if ( GET_CODE ( set ) == PARALLEL ) set = XVECEXP ( set , 0 , 0 ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; gcc_assert ( GET_CODE ( SET_SRC ( set ) ) == COMPARE ) ; set_mode = GET_MODE ( SET_DEST ( set ) ) ; switch ( set_mode ) { case CCNOmode : if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , 1 ) != const0_rtx ) ) return false ; break ; case CCmode : if ( req_mode == CCGCmode ) return false ; case CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return false ; case CCGOCmode : if ( req_mode == CCZmode ) return false ; case CCZmode : break ; case CCAmode : case CCCmode : case CCOmode : case CCSmode : if ( set_mode != req_mode ) return false ; break ; default : gcc_unreachable ( ) ; } return GET_MODE ( SET_SRC ( set ) ) == set_mode ; } </s>

Return TRUE or FALSE depending on whether the first SET in INSN has source and destination with matching CC modes , and that the CC mode is at least as constrained as REQ_MODE .


<s> static rtx altivec_expand_vec_set_builtin ( tree arglist ) { enum machine_mode tmode , mode1 ; tree arg0 , arg1 , arg2 ; int elt ; rtx op0 , op1 ; arg0 = TREE_VALUE ( arglist ) ; arg1 = TREE_VALUE ( TREE_CHAIN ( arglist ) ) ; arg2 = TREE_VALUE ( TREE_CHAIN ( TREE_CHAIN ( arglist ) ) ) ; tmode = TYPE_MODE ( TREE_TYPE ( arg0 ) ) ; mode1 = TYPE_MODE ( TREE_TYPE ( TREE_TYPE ( arg0 ) ) ) ; gcc_assert ( VECTOR_MODE_P ( tmode ) ) ; op0 = expand_expr ( arg0 , NULL_RTX , tmode , 0 ) ; op1 = expand_expr ( arg1 , NULL_RTX , mode1 , 0 ) ; elt = get_element_number ( TREE_TYPE ( arg0 ) , arg2 ) ; if ( GET_MODE ( op1 ) != mode1 && GET_MODE ( op1 ) != VOIDmode ) op1 = convert_modes ( mode1 , GET_MODE ( op1 ) , op1 , true ) ; op0 = force_reg ( tmode , op0 ) ; op1 = force_reg ( mode1 , op1 ) ; rs6000_expand_vector_set ( op0 , op1 , elt ) ; return op0 ; } </s>


<s> void MipsSEInstrInfo :: adjustStackPtr ( unsigned SP , int64_t Amount , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { const MipsSubtarget & STI = TM . getSubtarget < MipsSubtarget > ( ) ; DebugLoc DL = I != MBB . end ( ) ? I -> getDebugLoc ( ) : DebugLoc ( ) ; unsigned ADDu = STI . isABI_N64 ( ) ? Mips :: DADDu : Mips :: ADDu ; unsigned ADDiu = STI . isABI_N64 ( ) ? Mips :: DADDiu : Mips :: ADDiu ; if ( isInt < 16 > ( Amount ) ) BuildMI ( MBB , I , DL , get ( ADDiu ) , SP ) . addReg ( SP ) . addImm ( Amount ) ; else { MBB . getParent ( ) -> getInfo < MipsFunctionInfo > ( ) -> setEmitNOAT ( ) ; unsigned Reg = loadImmediate ( Amount , MBB , I , DL , 0 ) ; BuildMI ( MBB , I , DL , get ( ADDu ) , SP ) . addReg ( SP ) . addReg ( Reg ) ; } } </s>

Mips Mips Mips Mips Mips::DADDu Mips::ADDu Mips::DADDiu Mips::ADDiu 16 Mips 0


<s> int riscv_const_insns ( rtx x ) { enum riscv_symbol_type symbol_type ; rtx offset ; switch ( GET_CODE ( x ) ) { case HIGH : if ( ! riscv_symbolic_constant_p ( XEXP ( x , 0 ) , & symbol_type ) || ! riscv_split_symbol_type ( symbol_type ) ) return 0 ; return 1 ; case CONST_INT : { int cost = riscv_integer_cost ( INTVAL ( x ) ) ; return cost < 4 ? cost : 0 ; } case CONST_DOUBLE : case CONST_VECTOR : return x == CONST0_RTX ( GET_MODE ( x ) ) ? 1 : 0 ; case CONST : if ( riscv_symbolic_constant_p ( x , & symbol_type ) ) return riscv_symbol_insns ( symbol_type ) ; split_const ( x , & x , & offset ) ; if ( offset != 0 ) { int n = riscv_const_insns ( x ) ; if ( n != 0 ) return n + riscv_integer_cost ( INTVAL ( offset ) ) ; } return 0 ; case SYMBOL_REF : case LABEL_REF : return riscv_symbol_insns ( riscv_classify_symbol ( x ) ) ; case CONST_POLY_INT : return 4 ; default : return 0 ; } } </s>

Return the number of instructions needed to load constant X . Return 0 if X is n't a valid constant .


<s> PatmosTargetLowering :: ConstraintType PatmosTargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'R' : case 'S' : case 'P' : return C_RegisterClass ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

Given a constraint letter , return the type of constraint for this target .


<s>
void
ARMBaseRegisterInfo
::
emitLoadConstPool
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
&
MBBI
,
DebugLoc
dl
,
unsigned
DestReg
,
unsigned
SubIdx
,
int
Val
,
ARMCC
::
CondCodes
Pred
,
unsigned
PredReg
,
unsigned
MIFlags
)
const
{
assert
(
!
FlagSfiDisableCP
&&
"unexpected call to emitLoadConstPool"
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
MachineConstantPool
*
ConstantPool
=
MF
.
getConstantPool
(
)
;
const
Constant
*
C
=
ConstantInt
::
get
(
Type
::
getInt32Ty
(
MF
.
getFunction
(
)
->
getContext
(
)
)
,
Val
)
;
unsigned
Idx
=
ConstantPool
->
getConstantPoolIndex
(
C
,
4
)
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
ARM
::
LDRcp
)
)
.
addReg
(
DestReg
,
getDefRegState
(
true
)
,
SubIdx
)
.
addConstantPoolIndex
(
Idx
)
.
addImm
(
0
)
.
addImm
(
Pred
)
.
addReg
(
PredReg
)
.
setMIFlags
(
MIFlags
)
;
}
</s>

emitLoadConstPool - Emits a load from constpool to materialize the specified immediate .

ARM
ARM
ARMCC::CondCodes
"unexpected call to emitLoadConstPool"
4
ARM::LDRcp
0


<s> Register MCS51RegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; if ( TFI -> hasFP ( MF ) ) { return MCS51 :: R28 ; } return MCS51 :: SP ; } </s>


<s> MachineInstr * ARMBaseInstrInfo :: duplicate ( MachineInstr & Orig , MachineFunction & MF ) const { MachineInstr * MI = TargetInstrInfo :: duplicate ( Orig , MF ) ; switch ( Orig . getOpcode ( ) ) { case ARM :: tLDRpci_pic : case ARM :: t2LDRpci_pic : { unsigned CPI = Orig . getOperand ( 1 ) . getIndex ( ) ; unsigned PCLabelId = duplicateCPV ( MF , CPI ) ; Orig . getOperand ( 1 ) . setIndex ( CPI ) ; Orig . getOperand ( 2 ) . setImm ( PCLabelId ) ; break ; } } return MI ; } </s>

Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore .


<s> std :: pair < unsigned , unsigned > X86InstrInfo :: decomposeMachineOperandsTargetFlags ( unsigned TF ) const { return std :: make_pair ( TF , 0u ) ; } </s>

Decompose the machine operand 's target flags into two values - the direct target flag value and any of bit flags that are applied .


<s> MCFragment * Z80BrCCMCExpr :: findAssociatedFragment ( ) const { return nullptr ; } </s>

Find the `` associated section '' for this expression , which is currently defined as the absolute section for constants , or otherwise the section associated with the first defined symbol in the expression .


<s> DLXSubtarget & DLXSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { initSubtargetFeatures ( CPU , FS ) ; return * this ; } </s>

initializeSubtargetDependencies - Initializes using a CPU , a TuneCPU , and feature string so that we can use initializer lists for subtarget initialization .


<s> void MipsInstPrinter :: printInst ( const MCInst * MI , raw_ostream & O , StringRef Annot ) { printInstruction ( MI , O ) ; printAnnotation ( O , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


<s> bool writeNopData ( uint64_t , MCObjectWriter * ) const override { return true ; } </s>

Write an ( optimal ) nop sequence of Count bytes to the given output .


<s> bool MBlazeFrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || MFI -> hasVarSizedObjects ( ) ; } </s>

hasFP - Return true if the specified function should have a dedicated frame pointer register .


<s> static HOST_WIDE_INT rounded_frame_size ( int pushed ) { HOST_WIDE_INT size = get_frame_size ( ) ; HOST_WIDE_INT align = STACK_BOUNDARY / BITS_PER_UNIT ; if ( ACCUMULATE_OUTGOING_ARGS ) size += crtl -> outgoing_args_size ; return ( ( size + pushed + align - 1 ) & - align ) - pushed ; } </s>

PUSHED is the number of bytes that are bing pushed on the stack for register saves . Return the frame size , padded appropriately so that the stack stays properly aligned .


<s> static void ix86_autovectorize_vector_sizes ( vector_sizes * sizes ) { if ( TARGET_AVX512F && ! TARGET_PREFER_AVX256 ) { sizes -> safe_push ( 64 ) ; sizes -> safe_push ( 32 ) ; sizes -> safe_push ( 16 ) ; } else if ( TARGET_AVX && ! TARGET_PREFER_AVX128 ) { sizes -> safe_push ( 32 ) ; sizes -> safe_push ( 16 ) ; } } </s>

If AVX is enabled then try vectorizing with both 256bit and 128bit vectors . If AVX512F is enabled then try vectorizing with 512bit , 256bit and 128bit vectors .


<s>
StringRef
getPassName
(
)
const
override
{
return
"SI Load Store Optimizer"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s>
void
BlackfinInstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
SrcReg
,
bool
isKill
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
DebugLoc
DL
=
I
!=
MBB
.
end
(
)
I
->
getDebugLoc
(
)
:
DebugLoc
(
)
;
if
(
inClass
(
BF
::
DPRegClass
,
SrcReg
,
RC
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
BF
::
STORE32fi
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
;
return
;
}
if
(
inClass
(
BF
::
D16RegClass
,
SrcReg
,
RC
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
BF
::
STORE16fi
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
;
return
;
}
if
(
inClass
(
BF
::
AnyCCRegClass
,
SrcReg
,
RC
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
BF
::
STORE8fi
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
;
return
;
}
llvm_unreachable
(
(
std
::
string
(
"Cannot store regclass to stack slot: "
)
+
RC
->
getName
(
)
)
.
c_str
(
)
)
;
}
</s>

Store the specified register of the given register class to the specified stack frame index .


<s> bool NEONMoveFixPass :: runOnMachineFunction ( MachineFunction & Fn ) { ARMFunctionInfo * AFI = Fn . getInfo < ARMFunctionInfo > ( ) ; const TargetMachine & TM = Fn . getTarget ( ) ; if ( AFI -> isThumb1OnlyFunction ( ) ) return false ; TRI = TM . getRegisterInfo ( ) ; TII = static_cast < const ARMBaseInstrInfo * > ( TM . getInstrInfo ( ) ) ; bool Modified = false ; for ( MachineFunction :: iterator MFI = Fn . begin ( ) , E = Fn . end ( ) ; MFI != E ; ++ MFI ) { MachineBasicBlock & MBB = * MFI ; Modified |= InsertMoves ( MBB ) ; } return Modified ; } </s>

runOnMachineFunction - Emit the function body .


<s>
bool
Emitter
<
CodeEmitter
>
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
MMI
=
&
getAnalysis
<
MachineModuleInfo
>
(
)
;
MCE
.
setModuleInfo
(
MMI
)
;
II
=
TM
.
getInstrInfo
(
)
;
TD
=
TM
.
getTargetData
(
)
;
Is64BitMode
=
TM
.
getSubtarget
<
X86Subtarget
>
(
)
.
is64Bit
(
)
;
IsPIC
=
TM
.
getRelocationModel
(
)
==
Reloc
::
PIC_
;
do
{
DEBUG
(
dbgs
(
)
<<
"JITTing function '"
<<
MF
.
getName
(
)
<<
"'\n"
)
;
MCE
.
startFunction
(
MF
)
;
for
(
MachineFunction
::
iterator
MBB
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
MBB
!=
E
;
++
MBB
)
{
MCE
.
StartMachineBasicBlock
(
MBB
)
;
for
(
MachineBasicBlock
::
iterator
I
=
MBB
->
begin
(
)
,
E
=
MBB
->
end
(
)
;
I
!=
E
;
++
I
)
{
const
MCInstrDesc
&
Desc
=
I
->
getDesc
(
)
;
emitInstruction
(
*
I
,
&
Desc
)
;
if
(
Desc
.
getOpcode
(
)
==
X86
::
MOVPC32r
)
emitInstruction
(
*
I
,
&
II
->
get
(
X86
::
POP32r
)
)
;
++
NumEmitted
;
}
}
}
while
(
MCE
.
finishFunction
(
MF
)
)
;
return
false
;
}
</s>


<s> static void visium_setup_incoming_varargs ( cumulative_args_t pcum_v , enum machine_mode mode , tree type , int * pretend_size ATTRIBUTE_UNUSED , int no_rtl ) { cumulative_args_t local_args_so_far ; CUMULATIVE_ARGS local_copy ; CUMULATIVE_ARGS * locargs ; int gp_saved , fp_saved , size ; local_args_so_far . p = & local_copy ; locargs = get_cumulative_args ( pcum_v ) ; local_args_so_far . magic = CUMULATIVE_ARGS_MAGIC ; local_copy . grcount = locargs -> grcount ; local_copy . frcount = locargs -> frcount ; local_copy . stack_words = locargs -> stack_words ; TARGET_FUNCTION_ARG_ADVANCE ( local_args_so_far , mode , type , 1 ) ; locargs = get_cumulative_args ( local_args_so_far ) ; gp_saved = MAX_ARGS_IN_GP_REGISTERS - locargs -> grcount ; fp_saved = ( TARGET_FPU ? MAX_ARGS_IN_FP_REGISTERS - locargs -> frcount : 0 ) ; size = ( gp_saved * UNITS_PER_WORD ) + ( fp_saved * UNITS_PER_HWFPVALUE ) ; if ( ! no_rtl && size > 0 ) { rtx ptr = force_reg ( Pmode , plus_constant ( Pmode , virtual_incoming_args_rtx , - size ) ) ; if ( gp_saved > 0 ) { rtx mem = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , ptr , fp_saved * UNITS_PER_HWFPVALUE ) ) ; MEM_NOTRAP_P ( mem ) = 1 ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; move_block_from_reg ( locargs -> grcount + GP_ARG_FIRST , mem , gp_saved ) ; } if ( fp_saved > 0 ) { rtx mem = gen_rtx_MEM ( BLKmode , ptr ) ; MEM_NOTRAP_P ( mem ) = 1 ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; gcc_assert ( UNITS_PER_WORD == UNITS_PER_HWFPVALUE ) ; move_block_from_reg ( locargs -> frcount + FP_ARG_FIRST , mem , fp_saved ) ; } } visium_reg_parm_save_area_size = size ; } </s>

Store the anonymous register arguments into the stack so that all the arguments appear to have been passed consecutively on the stack .


"%qs and floating point or vector arguments"


<s> bool SPUTargetLowering :: isLegalICmpImmediate ( int64_t Imm ) const { return isInt < 10 > ( Imm ) ; } </s>

Return true if the specified immediate is legal icmp immediate , that is the target has icmp instructions which can compare a register against the immediate without having to materialize the immediate into a register .


<s>
static
SDValue
getTargetNode
(
SDValue
Op
,
SelectionDAG
&
DAG
,
unsigned
Flag
)
{
EVT
Ty
=
Op
.
getValueType
(
)
;
if
(
GlobalAddressSDNode
*
N
=
dyn_cast
<
GlobalAddressSDNode
>
(
Op
)
)
return
DAG
.
getTargetGlobalAddress
(
N
->
getGlobal
(
)
,
Op
.
getDebugLoc
(
)
,
Ty
,
0
,
Flag
)
;
if
(
ExternalSymbolSDNode
*
N
=
dyn_cast
<
ExternalSymbolSDNode
>
(
Op
)
)
return
DAG
.
getTargetExternalSymbol
(
N
->
getSymbol
(
)
,
Ty
,
Flag
)
;
if
(
BlockAddressSDNode
*
N
=
dyn_cast
<
BlockAddressSDNode
>
(
Op
)
)
return
DAG
.
getTargetBlockAddress
(
N
->
getBlockAddress
(
)
,
Ty
,
0
,
Flag
)
;
if
(
JumpTableSDNode
*
N
=
dyn_cast
<
JumpTableSDNode
>
(
Op
)
)
return
DAG
.
getTargetJumpTable
(
N
->
getIndex
(
)
,
Ty
,
Flag
)
;
if
(
ConstantPoolSDNode
*
N
=
dyn_cast
<
ConstantPoolSDNode
>
(
Op
)
)
return
DAG
.
getTargetConstantPool
(
N
->
getConstVal
(
)
,
Ty
,
N
->
getAlignment
(
)
,
N
->
getOffset
(
)
,
Flag
)
;
llvm_unreachable
(
"Unexpected node type."
)
;
return
SDValue
(
)
;
}
</s>

Retrieve the target node this edge connects to .


<s> int aarch64_host_wide_int_compare ( const void * x , const void * y ) { return wi :: cmps ( * ( ( const HOST_WIDE_INT * ) x ) , * ( ( const HOST_WIDE_INT * ) y ) ) ; } </s>

Taking X and Y to be HOST_WIDE_INT pointers , return the result of a comparison between the two .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Hexagon Assembly Printer"
;
}
</s>


<s>
MachineBasicBlock
*
OR1KTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
*
MI
,
MachineBasicBlock
*
BB
)
const
{
unsigned
Opc
=
MI
->
getOpcode
(
)
;
const
TargetInstrInfo
&
TII
=
*
getTargetMachine
(
)
.
getInstrInfo
(
)
;
DebugLoc
dl
=
MI
->
getDebugLoc
(
)
;
assert
(
(
Opc
==
OR1K
::
Select
||
Opc
==
OR1K
::
Selectf32
)
&&
"Unexpected instr type to insert"
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
MachineFunction
::
iterator
I
=
BB
;
++
I
;
MachineBasicBlock
*
thisMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
copy0MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
copy1MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
F
->
insert
(
I
,
copy0MBB
)
;
F
->
insert
(
I
,
copy1MBB
)
;
copy1MBB
->
splice
(
copy1MBB
->
begin
(
)
,
BB
,
llvm
::
next
(
MachineBasicBlock
::
iterator
(
MI
)
)
,
BB
->
end
(
)
)
;
copy1MBB
->
transferSuccessorsAndUpdatePHIs
(
BB
)
;
BB
->
addSuccessor
(
copy0MBB
)
;
BB
->
addSuccessor
(
copy1MBB
)
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
OR1K
::
BF
)
)
.
addMBB
(
copy1MBB
)
;
BB
=
copy0MBB
;
BB
->
addSuccessor
(
copy1MBB
)
;
BB
=
copy1MBB
;
BuildMI
(
*
BB
,
BB
->
begin
(
)
,
dl
,
TII
.
get
(
OR1K
::
PHI
)
,
MI
->
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
->
getOperand
(
2
)
.
getReg
(
)
)
.
addMBB
(
copy0MBB
)
.
addReg
(
MI
->
getOperand
(
1
)
.
getReg
(
)
)
.
addMBB
(
thisMBB
)
;
MI
->
eraseFromParent
(
)
;
return
BB
;
}
</s>

This method should be implemented by targets that mark instructions with the 'usesCustomInserter ' flag .


"failed to perform tail call elimination on a call "

This hook must be implemented to lower calls into the specified DAG .


<s> static void aarch64_set_current_function ( tree fndecl ) { if ( ! fndecl || fndecl == aarch64_previous_fndecl ) return ; tree old_tree = ( aarch64_previous_fndecl ? DECL_FUNCTION_SPECIFIC_TARGET ( aarch64_previous_fndecl ) : NULL_TREE ) ; tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( ! new_tree && old_tree ) new_tree = target_option_default_node ; if ( old_tree == new_tree ) return ; aarch64_previous_fndecl = fndecl ; cl_target_option_restore ( & global_options , TREE_TARGET_OPTION ( new_tree ) ) ; aarch64_save_restore_target_globals ( new_tree ) ; } </s>

Implement TARGET_SET_CURRENT_FUNCTION . Unpack the codegen decisions like tuning and ISA features from the DECL_FUNCTION_SPECIFIC_TARGET of the function , if such exists . This function may be called multiple times on a single function so use aarch64_previous_fndecl to avoid setting up identical state .


<s> MachineInstrBuilder MipsInstrInfo :: genInstrWithNewOpc ( unsigned NewOpc , MachineBasicBlock :: iterator I ) const { MachineInstrBuilder MIB ; bool BranchWithZeroOperand = ( I -> isBranch ( ) && ! I -> isPseudo ( ) && I -> getOperand ( 1 ) . isReg ( ) && ( I -> getOperand ( 1 ) . getReg ( ) == Mips :: ZERO || I -> getOperand ( 1 ) . getReg ( ) == Mips :: ZERO_64 ) ) ; if ( BranchWithZeroOperand ) { switch ( NewOpc ) { case Mips :: BEQC : NewOpc = Mips :: BEQZC ; break ; case Mips :: BNEC : NewOpc = Mips :: BNEZC ; break ; case Mips :: BGEC : NewOpc = Mips :: BGEZC ; break ; case Mips :: BLTC : NewOpc = Mips :: BLTZC ; break ; } } MIB = BuildMI ( * I -> getParent ( ) , I , I -> getDebugLoc ( ) , get ( NewOpc ) ) ; if ( NewOpc == Mips :: JIC || NewOpc == Mips :: JIALC || NewOpc == Mips :: JIC64 || NewOpc == Mips :: JIALC64 ) { if ( NewOpc == Mips :: JIALC || NewOpc == Mips :: JIALC64 ) MIB -> RemoveOperand ( 0 ) ; for ( unsigned J = 0 , E = I -> getDesc ( ) . getNumOperands ( ) ; J < E ; ++ J ) { MIB . addOperand ( I -> getOperand ( J ) ) ; } MIB . addImm ( 0 ) ; } else if ( BranchWithZeroOperand ) { MIB . addOperand ( I -> getOperand ( 0 ) ) ; for ( unsigned J = 2 , E = I -> getDesc ( ) . getNumOperands ( ) ; J < E ; ++ J ) { MIB . addOperand ( I -> getOperand ( J ) ) ; } } else { for ( unsigned J = 0 , E = I -> getDesc ( ) . getNumOperands ( ) ; J < E ; ++ J ) { MIB . addOperand ( I -> getOperand ( J ) ) ; } } MIB . copyImplicitOps ( * I ) ; MIB . setMemRefs ( I -> memoperands_begin ( ) , I -> memoperands_end ( ) ) ; return MIB ; } </s>

Create an instruction which has the same operands and memory operands as MI but has a new opcode .


<s> void BT :: reset ( ) { EdgeExec . clear ( ) ; InstrExec . clear ( ) ; Map . clear ( ) ; } </s>

Reset an existing scalar value for Def and a given Instance .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addPreserved < MachineFunctionAnalysis > ( ) ; AU . addRequired < MachineFunctionAnalysis > ( ) ; AU . addRequired < MachineDominatorTree > ( ) ; AU . addRequired < MachinePostDominatorTree > ( ) ; AU . addRequired < MachineLoopInfo > ( ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> void X86PassConfig :: addPreEmitPass ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( new X86ExecutionDomainFix ( ) ) ; addPass ( createBreakFalseDeps ( ) ) ; } addPass ( createX86IndirectBranchTrackingPass ( ) ) ; if ( UseVZeroUpper ) addPass ( createX86IssueVZeroUpperPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86FixupBWInsts ( ) ) ; addPass ( createX86PadShortFunctions ( ) ) ; addPass ( createX86FixupLEAs ( ) ) ; addPass ( createX86EvexToVexInsts ( ) ) ; } addPass ( createX86DiscriminateMemOpsPass ( ) ) ; addPass ( createX86InsertPrefetchPass ( ) ) ; } </s>

This pass may be implemented by targets that want to run passes immediately before machine code is emitted .


"wrong number of m88k branch conditions"

Reverses the branch condition of the specified condition list , returning false on success and true if it can not be reversed .


<s> bool R600InstrInfo :: isPredicated ( const MachineInstr * MI ) const { int idx = MI -> findFirstPredOperandIdx ( ) ; if ( idx < 0 ) return false ; unsigned Reg = MI -> getOperand ( idx ) . getReg ( ) ; switch ( Reg ) { default : return false ; case AMDGPU :: PRED_SEL_ONE : case AMDGPU :: PRED_SEL_ZERO : case AMDGPU :: PREDICATE_BIT : return true ; } } </s>

Returns true if the instruction is already predicated .


<s> static void h8300_file_start ( void ) { default_file_start ( ) ; if ( TARGET_H8300SX ) fputs ( TARGET_NORMAL_MODE ? "\t.h8300sxn\n" : "\t.h8300sx\n" , asm_out_file ) ; else if ( TARGET_H8300S ) fputs ( TARGET_NORMAL_MODE ? "\t.h8300sn\n" : "\t.h8300s\n" , asm_out_file ) ; else if ( TARGET_H8300H ) fputs ( TARGET_NORMAL_MODE ? "\t.h8300hn\n" : "\t.h8300h\n" , asm_out_file ) ; } </s>

Output assembly code for the start of the file .


".relax_hint %%1\n\tsethi $r0, hi20(%%0)\n\t"

".relax_hint %%1\n\tadd $r0, $r0, $gp\n\t"

Auxiliary function for output TLS patterns .


<s> static void moxie_compute_frame ( void ) { int stack_alignment = STACK_BOUNDARY / BITS_PER_UNIT ; int padding_locals ; int regno ; cfun -> machine -> local_vars_size = get_frame_size ( ) ; padding_locals = cfun -> machine -> local_vars_size % stack_alignment ; if ( padding_locals ) padding_locals = stack_alignment - padding_locals ; cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = 0 ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ( ! call_used_regs [ regno ] ) ) cfun -> machine -> callee_saved_reg_size += 4 ; cfun -> machine -> size_for_adjusting_sp = crtl -> args . pretend_args_size + cfun -> machine -> local_vars_size + ( ACCUMULATE_OUTGOING_ARGS ? crtl -> outgoing_args_size : 0 ) ; } </s>

Compute the size of the local area and the size to be adjusted by the * prologue and epilogue .


<s> RISCVTargetLowering :: ConstraintType RISCVTargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'f' : case 'v' : return C_RegisterClass ; case 'I' : case 'J' : case 'K' : return C_Immediate ; case 'A' : return C_Memory ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

Given a constraint letter , return the type of constraint for this target .


<s> bool M680x0AsmBackend :: mayNeedRelaxation ( const MCInst & Inst , const MCSubtargetInfo & STI ) const { if ( getRelaxedOpcodeBranch ( Inst ) != Inst . getOpcode ( ) ) return true ; if ( getRelaxedOpcodeArith ( Inst ) == Inst . getOpcode ( ) ) return false ; unsigned RelaxableOp = Inst . getNumOperands ( ) - 1 ; if ( Inst . getOperand ( RelaxableOp ) . isExpr ( ) ) return true ; return false ; } </s>

Check whether the given instruction may need relaxation .


<s> bool PPCCTRLoops :: runOnFunction ( Function & F ) { LI = & getAnalysis < LoopInfo > ( ) ; SE = & getAnalysis < ScalarEvolution > ( ) ; DT = & getAnalysis < DominatorTree > ( ) ; TD = getAnalysisIfAvailable < DataLayout > ( ) ; LibInfo = getAnalysisIfAvailable < TargetLibraryInfo > ( ) ; bool MadeChange = false ; for ( LoopInfo :: iterator I = LI -> begin ( ) , E = LI -> end ( ) ; I != E ; ++ I ) { Loop * L = * I ; if ( ! L -> getParentLoop ( ) ) MadeChange |= convertToCTRLoop ( L ) ; } return MadeChange ; } </s>

runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass .


<s> static void csky_reorg ( void ) { if ( TARGET_CONSTANT_POOL ) csky_emit_constant_pools ( ) ; } </s>

Implement TARGET_MACHINE_DEPENDENT_REORG . This handles -mconstpool output .


<s> static void * ia64_alloc_sched_context ( void ) { return xmalloc ( sizeof ( struct _ia64_sched_context ) ) ; } </s>


<s> SMLoc getStartLoc ( ) const override { return StartLoc ; } </s>

getStartLoc - Get the location of the first token of this operand .


<s> static bool sh_function_ok_for_sibcall ( tree decl , tree exp ATTRIBUTE_UNUSED ) { return ( 1 && ! sh_cfun_interrupt_handler_p ( ) && ( ! flag_pic || TARGET_FDPIC || ( decl && ! ( TREE_PUBLIC ( decl ) || DECL_WEAK ( decl ) ) ) || ( decl && DECL_VISIBILITY ( decl ) != VISIBILITY_DEFAULT ) ) ) ; } </s>

If PIC , we can not make sibling calls to global functions because the PLT requires r12 to be live .


"TargetInstrInfo::findCommutedOpIndices() can't handle bundles"

Returns true iff the routine could find two commutable operands in the given machine instruction .


<s> void ARMElfTargetObjectFile :: Initialize ( MCContext & Ctx , const TargetMachine & TM ) { bool isAAPCS_ABI = TM . getSubtarget < ARMSubtarget > ( ) . isAAPCS_ABI ( ) ; TargetLoweringObjectFileELF :: Initialize ( Ctx , TM ) ; InitializeELF ( isAAPCS_ABI ) ; if ( isAAPCS_ABI ) { LSDASection = NULL ; } AttributesSection = getContext ( ) . getELFSection ( ".ARM.attributes" , ELF :: SHT_ARM_ATTRIBUTES , 0 , SectionKind :: getMetadata ( ) ) ; } </s>

This method must be called before any actual lowering is done .


"Missing call preserved mask for calling convention"

This function fills Ops , which is the list of operands that will later be used when a function call node is created .


<s>
void
assignValueToReg
(
unsigned
ValVReg
,
unsigned
PhysReg
,
CCValAssign
&
VA
)
override
{
assert
(
VA
.
isRegLoc
(
)
&&
"Value shouldn't be assigned to reg"
)
;
assert
(
VA
.
getLocReg
(
)
==
PhysReg
&&
"Assigning to the wrong reg?"
)
;
assert
(
VA
.
getValVT
(
)
.
getSizeInBits
(
)
<=
64
&&
"Unsupported value size"
)
;
assert
(
VA
.
getLocVT
(
)
.
getSizeInBits
(
)
<=
64
&&
"Unsupported location size"
)
;
MIRBuilder
.
getMBB
(
)
.
addLiveIn
(
PhysReg
)
;
MIRBuilder
.
buildCopy
(
ValVReg
,
PhysReg
)
;
}
</s>

The specified value has been assigned to a physical register , handle the appropriate COPY ( either to or from ) and mark any relevant uses/defines as needed .

ARM
"Value shouldn't be assigned to reg"
"Assigning to the wrong reg?"
64
"Unsupported value size"
64
"Unsupported location size"


<s> bool isImm ( ) const override { return Kind == Immediate ; } </s>


<s>
const
char
*
pa_output_millicode_call
(
rtx_insn
*
insn
,
rtx
call_dest
)
{
int
attr_length
=
get_attr_length
(
insn
)
;
int
seq_length
=
dbr_sequence_length
(
)
;
rtx
xoperands
[
3
]
;
xoperands
[
0
]
=
call_dest
;
xoperands
[
2
]
=
gen_rtx_REG
(
Pmode
,
TARGET_64BIT
2
:
31
)
;
if
(
!
TARGET_LONG_CALLS
&&
(
attr_length
==
8
||
(
attr_length
==
28
&&
get_attr_type
(
insn
)
==
TYPE_SH_FUNC_ADRS
)
)
)
{
output_asm_insn
(
"{bl|b,l} %0,%2"
,
xoperands
)
;
}
else
{
if
(
TARGET_64BIT
)
{
output_asm_insn
(
"b,l .+8,%%r1"
,
xoperands
)
;
if
(
TARGET_GAS
)
{
output_asm_insn
(
"addil L'%0-$PIC_pcrel$0+4,%%r1"
,
xoperands
)
;
output_asm_insn
(
"ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1"
,
xoperands
)
;
}
else
{
xoperands
[
1
]
=
gen_label_rtx
(
)
;
output_asm_insn
(
"addil L'%0-%l1,%%r1"
,
xoperands
)
;
targetm
.
asm_out
.
internal_label
(
asm_out_file
,
"L"
,
CODE_LABEL_NUMBER
(
xoperands
[
1
]
)
)
;
output_asm_insn
(
"ldo R'%0-%l1(%%r1),%%r1"
,
xoperands
)
;
}
output_asm_insn
(
"bve,l (%%r1),%%r2"
,
xoperands
)
;
}
else
if
(
TARGET_PORTABLE_RUNTIME
)
{
output_asm_insn
(
"ldil L'%0,%%r1"
,
xoperands
)
;
output_asm_insn
(
"ldo R'%0(%%r1),%%r1"
,
xoperands
)
;
output_asm_insn
(
"{bl|b,l} .+8,%%r31"
,
xoperands
)
;
output_asm_insn
(
"addi 8,%%r31,%%r31"
,
xoperands
)
;
output_asm_insn
(
"bv %%r0(%%r1)"
,
xoperands
)
;
}
else
if
(
!
flag_pic
)
{
output_asm_insn
(
"ldil L'%0,%%r1"
,
xoperands
)
;
if
(
TARGET_PA_20
)
output_asm_insn
(
"be,l R'%0(%%sr4,%%r1),%%sr0,%%r31"
,
xoperands
)
;
else
output_asm_insn
(
"ble R'%0(%%sr4,%%r1)"
,
xoperands
)
;
}
else
{
output_asm_insn
(
"{bl|b,l} .+8,%%r1"
,
xoperands
)
;
output_asm_insn
(
"addi 16,%%r1,%%r31"
,
xoperands
)
;
if
(
TARGET_SOM
||
!
TARGET_GAS
)
{
xoperands
[
1
]
=
gen_label_rtx
(
)
;
targetm
.
asm_out
.
internal_label
(
asm_out_file
,
"L"
,
CODE_LABEL_NUMBER
(
xoperands
[
1
]
)
)
;
output_asm_insn
(
"addil L'%0-%l1,%%r1"
,
xoperands
)
;
output_asm_insn
(
"ldo R'%0-%l1(%%r1),%%r1"
,
xoperands
)
;
}
else
{
output_asm_insn
(
"addil L'%0-$PIC_pcrel$0+8,%%r1"
,
xoperands
)
;
output_asm_insn
(
"ldo R'%0-$PIC_pcrel$0+12(%%r1),%%r1"
,
xoperands
)
;
}
output_asm_insn
(
"bv %%r0(%%r1)"
,
xoperands
)
;
}
}
if
(
seq_length
==
0
)
output_asm_insn
(
"nop"
,
xoperands
)
;
return
""
;
}
</s>

INSN is a function call . CALL_DEST is the routine we are calling .


<s> static rtx arc_legitimize_address_0 ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ) { rtx addr , inner ; addr = x ; if ( GET_CODE ( addr ) == CONST ) addr = XEXP ( addr , 0 ) ; if ( GET_CODE ( addr ) == PLUS && CONST_INT_P ( XEXP ( addr , 1 ) ) && ( ( GET_CODE ( XEXP ( addr , 0 ) ) == SYMBOL_REF && ! SYMBOL_REF_FUNCTION_P ( XEXP ( addr , 0 ) ) ) || ( REG_P ( XEXP ( addr , 0 ) ) && ( INTVAL ( XEXP ( addr , 1 ) ) & 252 ) ) ) ) { HOST_WIDE_INT offs , upper ; int size = GET_MODE_SIZE ( mode ) ; offs = INTVAL ( XEXP ( addr , 1 ) ) ; upper = ( offs + 256 * size ) & ~ 511 * size ; inner = plus_constant ( Pmode , XEXP ( addr , 0 ) , upper ) ; if ( GET_CODE ( x ) == CONST ) inner = gen_rtx_CONST ( Pmode , inner ) ; addr = plus_constant ( Pmode , force_reg ( Pmode , inner ) , offs - upper ) ; x = addr ; } else if ( GET_CODE ( addr ) == SYMBOL_REF && ! SYMBOL_REF_FUNCTION_P ( addr ) ) x = force_reg ( Pmode , x ) ; if ( memory_address_p ( ( machine_mode ) mode , x ) ) return x ; return NULL_RTX ; } </s>

This is like the hook , but returns NULL when it ca n't / wo n't generate a legitimate address .