<s> uint32_t size ( ) const { return Map . size ( ) ; } </s>

The number of name/type pairs is returned .


<s> const char * getPassName ( ) const override { return STPSUPPRESS_PASS_NAME ; } </s>

getPassName - Return a nice clean name for a pass .


<s> void HexagonPassConfig :: addPreRegAlloc ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) if ( ! DisableHardwareLoops ) addPass ( createHexagonHardwareLoops ( ) , false ) ; } </s>

This method may be implemented by targets that want to run passes immediately before register allocation .


<s> string CostTree :: printTree ( ) { string val = "" ; for ( auto & Node1 : VectorNode ) val += Node1 -> printHeadLeaf ( ) ; for ( auto & Node1 : VectorNode ) Node1 -> setVisit ( false ) ; val += printTreeVal ( Root ) ; return val ; } </s>


<s> virtual const DataLayout * getDataLayout ( ) const { return & DL ; } </s>

Return the DataLayout associated with the module this SCEV instance is operating on .


<s>
void
HexagonMCShuffler
::
init
(
MCInst
&
MCB
)
{
if
(
HexagonMCInstrInfo
::
isBundle
(
MCB
)
)
{
MCInst
const
*
Extender
=
nullptr
;
for
(
const
auto
&
I
:
HexagonMCInstrInfo
::
bundleInstructions
(
MCB
)
)
{
MCInst
&
MI
=
*
const_cast
<
MCInst
*
>
(
I
.
getInst
(
)
)
;
DEBUG
(
dbgs
(
)
<<
"Shuffling: "
<<
MCII
.
getName
(
MI
.
getOpcode
(
)
)
<<
'\n'
)
;
assert
(
!
HexagonMCInstrInfo
::
getDesc
(
MCII
,
MI
)
.
isPseudo
(
)
)
;
if
(
!
HexagonMCInstrInfo
::
isImmext
(
MI
)
)
{
append
(
MI
,
Extender
,
HexagonMCInstrInfo
::
getUnits
(
MCII
,
STI
,
MI
)
)
;
Extender
=
nullptr
;
}
else
Extender
=
&
MI
;
}
}
Loc
=
MCB
.
getLoc
(
)
;
BundleFlags
=
MCB
.
getOperand
(
0
)
.
getImm
(
)
;
}
</s>

Initialize the machine model for instruction scheduling .

Hexagon
Hexagon
Hexagon
Hexagon
"Shuffling: "
Hexagon
Hexagon
Hexagon
0


<s> void m32r_init_expanders ( ) { } </s>

Do anything needed before RTL is emitted for each function .


<s> unsigned Cpu0FunctionInfo :: getGlobalBaseReg ( ) { if ( GlobalBaseReg ) return GlobalBaseReg ; if ( FixGlobalBaseReg ) return GlobalBaseReg = Cpu0 :: GP ; const TargetRegisterClass * RC ; RC = ( const TargetRegisterClass * ) & Cpu0 :: CPURegsRegClass ; return GlobalBaseReg = MF . getRegInfo ( ) . createVirtualRegister ( RC ) ; } </s>

getGlobalBaseReg - Return a virtual register initialized with the the global base register value .


<s> static inline bool mode_supports_pre_modify_p ( machine_mode mode ) { return ( ( reg_addr [ mode ] . addr_mask [ RELOAD_REG_ANY ] & RELOAD_REG_PRE_MODIFY ) != 0 ) ; } </s>

Helper function to say whether a mode supports PRE_MODIFY .


<s> unsigned TeeRISCInstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { assert ( 0 ) ; if ( MI -> getOpcode ( ) == TeeRISC :: ST ) { if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isImm ( ) && MI -> getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

isStoreToStackSlot - If the specified machine instruction is a direct store to a stack slot , return the virtual or physical register number of the source reg along with the FrameIndex of the loaded stack slot .


"failed to perform tail call elimination on a call "

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


"getRegForInlineAsmConstraint Unhandled data type"

Given a physical register constraint ( e.g .


<s> bool Cpu0TargetObjectFile :: IsGlobalInSmallSection ( const GlobalValue * GV , const TargetMachine & TM , SectionKind Kind ) const { const Cpu0Subtarget & Subtarget = TM . getSubtarget < Cpu0Subtarget > ( ) ; if ( Subtarget . isLinux ( ) ) return false ; const GlobalVariable * GVA = dyn_cast < GlobalVariable > ( GV ) ; if ( ! GVA ) return false ; if ( ! Kind . isBSS ( ) && ! Kind . isDataRel ( ) ) return false ; if ( Kind . isMergeable1ByteCString ( ) ) return false ; Type * Ty = GV -> getType ( ) -> getElementType ( ) ; return IsInSmallSection ( TM . getDataLayout ( ) -> getTypeAllocSize ( Ty ) ) ; } </s>

Return true if this global address should be placed into small data/bss section .


<s> bool ARM_MC :: isPredicated ( const MCInst & MI , const MCInstrInfo * MCII ) { const MCInstrDesc & Desc = MCII -> get ( MI . getOpcode ( ) ) ; int PredOpIdx = Desc . findFirstPredOperandIdx ( ) ; return PredOpIdx != - 1 && MI . getOperand ( PredOpIdx ) . getImm ( ) != ARMCC :: AL ; } </s>

Returns true if the instruction is already predicated .


Return an array that contains the direct target flag values and their names .


<s> unsigned XtensaRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { return Xtensa :: INVALID ; } </s>


<s> int initial_elimination_offset ( int from , int to ) { if ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return 0 ; else { int offset = frame_pointer_needed ? 2 : 0 ; offset += avr_regs_to_save ( NULL ) ; return get_frame_size ( ) + 2 + 1 + offset ; } } </s>

Define the offset between two registers , one to be eliminated , and the other its replacement , at the start of a routine .


"Vector argument passed to unprototyped function"

The VX ABI differs for vararg functions . Therefore we need the prototype of the callee to be available when passing vector type values .


"Blackfin DAG->DAG Pattern Instruction Selection"


<s> bool canMergeStoresTo ( unsigned AddressSpace , EVT MemVT , const SelectionDAG & DAG ) const override { bool NoFloat = DAG . getMachineFunction ( ) . getFunction ( ) -> hasFnAttribute ( Attribute :: NoImplicitFloat ) ; if ( NoFloat ) return ( MemVT . getSizeInBits ( ) <= 64 ) ; return true ; } </s>

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


<s> static int insert_bundle_state ( struct bundle_state * bundle_state ) { struct bundle_state * * entry_ptr ; entry_ptr = bundle_state_table -> find_slot ( bundle_state , INSERT ) ; if ( * entry_ptr == NULL ) { bundle_state -> next = index_to_bundle_states [ bundle_state -> insn_num ] ; index_to_bundle_states [ bundle_state -> insn_num ] = bundle_state ; * entry_ptr = bundle_state ; return TRUE ; } else if ( bundle_state -> cost < ( * entry_ptr ) -> cost || ( bundle_state -> cost == ( * entry_ptr ) -> cost && ( ( * entry_ptr ) -> accumulated_insns_num > bundle_state -> accumulated_insns_num || ( ( * entry_ptr ) -> accumulated_insns_num == bundle_state -> accumulated_insns_num && ( ( * entry_ptr ) -> branch_deviation > bundle_state -> branch_deviation || ( ( * entry_ptr ) -> branch_deviation == bundle_state -> branch_deviation && ( * entry_ptr ) -> middle_bundle_stops > bundle_state -> middle_bundle_stops ) ) ) ) ) ) { struct bundle_state temp ; temp = * * entry_ptr ; * * entry_ptr = * bundle_state ; ( * entry_ptr ) -> next = temp . next ; * bundle_state = temp ; } return FALSE ; } </s>

The function inserts the BUNDLE_STATE into the hash table . The function returns nonzero if the bundle has been inserted into the table . The table contains the best bundle state with given key .


<s> bool AArch64RegisterInfo :: requiresRegisterScavenging ( const MachineFunction & MF ) const { return true ; } </s>

Returns true if the target requires ( and can make use of ) the register scavenger .


<s> bool SIInstrInfo :: isIgnorableUse ( const MachineOperand & MO ) const { return MO . getReg ( ) == AMDGPU :: EXEC && MO . isImplicit ( ) && isVALU ( * MO . getParent ( ) ) && ! resultDependsOnExec ( * MO . getParent ( ) ) ; } </s>

Given MO is a PhysReg use return if it can be ignored for the purpose of instruction rematerialization or sinking .


<s> void MCS51PassConfig :: addPreRegAlloc ( ) { addPass ( createMCS51DynAllocaSRPass ( ) ) ; } </s>

This method may be implemented by targets that want to run passes immediately before register allocation .


<s> bool PPCTargetLowering :: SelectAddressRegRegOnly ( SDValue N , SDValue & Base , SDValue & Index , SelectionDAG & DAG ) const { if ( SelectAddressRegReg ( N , Base , Index , DAG ) ) return true ; if ( N . getOpcode ( ) == ISD :: ADD ) { Base = N . getOperand ( 0 ) ; Index = N . getOperand ( 1 ) ; return true ; } Base = DAG . getRegister ( PPCSubTarget . isPPC64 ( ) ? PPC :: ZERO8 : PPC :: ZERO , N . getValueType ( ) ) ; Index = N ; return true ; } </s>

SelectAddressRegRegOnly - Given the specified addressed , force it to be represented as an indexed [ r+r ] operation .

PowerPC PPC ISD::ADD 0 1 PPC PPC PPC::ZERO8 PPC::ZERO


<s> bool RISCVRegisterInfo :: isConstantPhysReg ( MCRegister PhysReg ) const { return PhysReg == RISCV :: X0 ; } </s>

Returns true if PhysReg is unallocatable and constant throughout the function .


<s> static bool pa_assemble_integer ( rtx x , unsigned int size , int aligned_p ) { bool result ; tree decl = NULL ; if ( GET_CODE ( x ) == SYMBOL_REF ) { decl = SYMBOL_REF_DECL ( x ) ; if ( decl ) { assemble_external ( decl ) ; SET_SYMBOL_REF_DECL ( x , NULL ) ; } } if ( size == UNITS_PER_WORD && aligned_p && function_label_operand ( x , VOIDmode ) ) { fputs ( size == 8 ? "\t.dword\t" : "\t.word\t" , asm_out_file ) ; if ( ! TARGET_FAST_INDIRECT_CALLS ) fputs ( "P%" , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputc ( '\n' , asm_out_file ) ; result = true ; } else result = default_assemble_integer ( x , size , aligned_p ) ; if ( decl ) SET_SYMBOL_REF_DECL ( x , decl ) ; return result ; } </s>

Target hook for assembling integer objects . This code handles aligned SI and DI integers specially , since function references must be preceded by P % .


<s> void s390_expand_vec_compare_cc ( rtx target , enum rtx_code code , rtx cmp1 , rtx cmp2 , bool all_p ) { machine_mode cc_producer_mode , cc_consumer_mode , scratch_mode ; rtx tmp_reg = gen_reg_rtx ( SImode ) ; bool swap_p = false ; if ( GET_MODE_CLASS ( GET_MODE ( cmp1 ) ) == MODE_VECTOR_INT ) { switch ( code ) { case EQ : case NE : cc_producer_mode = CCVEQmode ; break ; case GE : case LT : code = swap_condition ( code ) ; swap_p = true ; case GT : case LE : cc_producer_mode = CCVIHmode ; break ; case GEU : case LTU : code = swap_condition ( code ) ; swap_p = true ; case GTU : case LEU : cc_producer_mode = CCVIHUmode ; break ; default : gcc_unreachable ( ) ; } scratch_mode = GET_MODE ( cmp1 ) ; if ( code == NE || code == LE || code == LEU ) all_p = ! all_p ; cc_consumer_mode = all_p ? CCVIALLmode : CCVIANYmode ; } else if ( GET_MODE_CLASS ( GET_MODE ( cmp1 ) ) == MODE_VECTOR_FLOAT ) { bool inv_p = false ; switch ( code ) { case EQ : cc_producer_mode = CCVEQmode ; break ; case NE : cc_producer_mode = CCVEQmode ; inv_p = true ; break ; case GT : cc_producer_mode = CCVFHmode ; break ; case GE : cc_producer_mode = CCVFHEmode ; break ; case UNLE : cc_producer_mode = CCVFHmode ; inv_p = true ; break ; case UNLT : cc_producer_mode = CCVFHEmode ; inv_p = true ; break ; case LT : cc_producer_mode = CCVFHmode ; code = GT ; swap_p = true ; break ; case LE : cc_producer_mode = CCVFHEmode ; code = GE ; swap_p = true ; break ; default : gcc_unreachable ( ) ; } scratch_mode = mode_for_int_vector ( GET_MODE ( cmp1 ) ) . require ( ) ; if ( inv_p ) all_p = ! all_p ; cc_consumer_mode = all_p ? CCVFALLmode : CCVFANYmode ; } else gcc_unreachable ( ) ; if ( swap_p ) { rtx tmp = cmp2 ; cmp2 = cmp1 ; cmp1 = tmp ; } emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , gen_rtx_SET ( gen_rtx_REG ( cc_producer_mode , CC_REGNUM ) , gen_rtx_COMPARE ( cc_producer_mode , cmp1 , cmp2 ) ) , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( scratch_mode ) ) ) ) ) ; emit_move_insn ( target , const0_rtx ) ; emit_move_insn ( tmp_reg , const1_rtx ) ; emit_move_insn ( target , gen_rtx_IF_THEN_ELSE ( SImode , gen_rtx_fmt_ee ( code , VOIDmode , gen_rtx_REG ( cc_consumer_mode , CC_REGNUM ) , const0_rtx ) , tmp_reg , target ) ) ; } </s>

Expand the comparison CODE of CMP1 and CMP2 and copy 1 or 0 into TARGET if either all ( ALL_P is true ) or any ( ALL_P is false ) of the elements in CMP1 and CMP2 fulfill the comparison .


<s> const char * PPCTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return 0 ; case PPCISD :: FSEL : return "PPCISD::FSEL" ; case PPCISD :: FCFID : return "PPCISD::FCFID" ; case PPCISD :: FCTIDZ : return "PPCISD::FCTIDZ" ; case PPCISD :: FCTIWZ : return "PPCISD::FCTIWZ" ; case PPCISD :: STFIWX : return "PPCISD::STFIWX" ; case PPCISD :: VMADDFP : return "PPCISD::VMADDFP" ; case PPCISD :: VNMSUBFP : return "PPCISD::VNMSUBFP" ; case PPCISD :: VPERM : return "PPCISD::VPERM" ; case PPCISD :: Hi : return "PPCISD::Hi" ; case PPCISD :: Lo : return "PPCISD::Lo" ; case PPCISD :: TOC_ENTRY : return "PPCISD::TOC_ENTRY" ; case PPCISD :: TOC_RESTORE : return "PPCISD::TOC_RESTORE" ; case PPCISD :: LOAD : return "PPCISD::LOAD" ; case PPCISD :: LOAD_TOC : return "PPCISD::LOAD_TOC" ; case PPCISD :: DYNALLOC : return "PPCISD::DYNALLOC" ; case PPCISD :: GlobalBaseReg : return "PPCISD::GlobalBaseReg" ; case PPCISD :: SRL : return "PPCISD::SRL" ; case PPCISD :: SRA : return "PPCISD::SRA" ; case PPCISD :: SHL : return "PPCISD::SHL" ; case PPCISD :: EXTSW_32 : return "PPCISD::EXTSW_32" ; case PPCISD :: STD_32 : return "PPCISD::STD_32" ; case PPCISD :: CALL_SVR4 : return "PPCISD::CALL_SVR4" ; case PPCISD :: CALL_NOP_SVR4 : return "PPCISD::CALL_NOP_SVR4" ; case PPCISD :: CALL_Darwin : return "PPCISD::CALL_Darwin" ; case PPCISD :: NOP : return "PPCISD::NOP" ; case PPCISD :: MTCTR : return "PPCISD::MTCTR" ; case PPCISD :: BCTRL_Darwin : return "PPCISD::BCTRL_Darwin" ; case PPCISD :: BCTRL_SVR4 : return "PPCISD::BCTRL_SVR4" ; case PPCISD :: RET_FLAG : return "PPCISD::RET_FLAG" ; case PPCISD :: MFCR : return "PPCISD::MFCR" ; case PPCISD :: VCMP : return "PPCISD::VCMP" ; case PPCISD :: VCMPo : return "PPCISD::VCMPo" ; case PPCISD :: LBRX : return "PPCISD::LBRX" ; case PPCISD :: STBRX : return "PPCISD::STBRX" ; case PPCISD :: LARX : return "PPCISD::LARX" ; case PPCISD :: STCX : return "PPCISD::STCX" ; case PPCISD :: COND_BRANCH : return "PPCISD::COND_BRANCH" ; case PPCISD :: MFFS : return "PPCISD::MFFS" ; case PPCISD :: MTFSB0 : return "PPCISD::MTFSB0" ; case PPCISD :: MTFSB1 : return "PPCISD::MTFSB1" ; case PPCISD :: FADDRTZ : return "PPCISD::FADDRTZ" ; case PPCISD :: MTFSF : return "PPCISD::MTFSF" ; case PPCISD :: TC_RETURN : return "PPCISD::TC_RETURN" ; case PPCISD :: CR6SET : return "PPCISD::CR6SET" ; case PPCISD :: CR6UNSET : return "PPCISD::CR6UNSET" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


<s> const TargetRegisterInfo & getRegisterInfo ( ) const { return RI ; } </s>

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> bool AMDGPUInstrInfo :: expandPostRAPseudo ( MachineBasicBlock :: iterator MI ) const { MachineBasicBlock * MBB = MI -> getParent ( ) ; if ( isRegisterLoad ( * MI ) ) { unsigned RegIndex = MI -> getOperand ( 2 ) . getImm ( ) ; unsigned Channel = MI -> getOperand ( 3 ) . getImm ( ) ; unsigned Address = calculateIndirectAddress ( RegIndex , Channel ) ; unsigned OffsetReg = MI -> getOperand ( 1 ) . getReg ( ) ; if ( OffsetReg == AMDGPU :: INDIRECT_BASE_ADDR ) { buildMovInstr ( MBB , MI , MI -> getOperand ( 0 ) . getReg ( ) , getIndirectAddrRegClass ( ) -> getRegister ( Address ) ) ; } else { buildIndirectRead ( MBB , MI , MI -> getOperand ( 0 ) . getReg ( ) , Address , OffsetReg ) ; } } else if ( isRegisterStore ( * MI ) ) { unsigned RegIndex = MI -> getOperand ( 2 ) . getImm ( ) ; unsigned Channel = MI -> getOperand ( 3 ) . getImm ( ) ; unsigned Address = calculateIndirectAddress ( RegIndex , Channel ) ; unsigned OffsetReg = MI -> getOperand ( 1 ) . getReg ( ) ; if ( OffsetReg == AMDGPU :: INDIRECT_BASE_ADDR ) { buildMovInstr ( MBB , MI , getIndirectAddrRegClass ( ) -> getRegister ( Address ) , MI -> getOperand ( 0 ) . getReg ( ) ) ; } else { buildIndirectWrite ( MBB , MI , MI -> getOperand ( 0 ) . getReg ( ) , calculateIndirectAddress ( RegIndex , Channel ) , OffsetReg ) ; } } else { return false ; } MBB -> erase ( MI ) ; return true ; } </s>

This function is called for all pseudo instructions that remain after register allocation .


<s> XCoreSubtarget :: XCoreSubtarget ( const std :: string & TT , const std :: string & FS ) { } </s>

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


"XtensaInstPrinter::printInst not yet implemented\n"


<s> void X86PassConfig :: addPreRegAlloc ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86FixupSetCC ( ) ) ; addPass ( createX86OptimizeLEAs ( ) ) ; } addPass ( createX86CallFrameOptimization ( ) ) ; addPass ( createX86WinAllocaExpander ( ) ) ; } </s>


<s> static void add_insn_window ( rtx_insn * insn , dispatch_windows * window_list , int num_uops ) { int byte_len = ix86_min_insn_size ( insn ) ; int num_insn = window_list -> num_insn ; int imm_size ; sched_insn_info * window = window_list -> window ; enum dispatch_group group = get_insn_group ( insn ) ; enum insn_path path = get_insn_path ( insn ) ; int num_imm_operand ; int num_imm32_operand ; int num_imm64_operand ; if ( ! window_list -> violation && group != disp_cmp && ! fits_dispatch_window ( insn ) ) window_list -> violation = true ; imm_size = get_num_immediates ( insn , & num_imm_operand , & num_imm32_operand , & num_imm64_operand ) ; window [ num_insn ] . insn = insn ; window [ num_insn ] . byte_len = byte_len ; window [ num_insn ] . group = group ; window [ num_insn ] . path = path ; window [ num_insn ] . imm_bytes = imm_size ; window_list -> window_size += byte_len ; window_list -> num_insn = num_insn + 1 ; window_list -> num_uops = window_list -> num_uops + num_uops ; window_list -> imm_size += imm_size ; window_list -> num_imm += num_imm_operand ; window_list -> num_imm_32 += num_imm32_operand ; window_list -> num_imm_64 += num_imm64_operand ; if ( group == disp_store ) window_list -> num_stores += 1 ; else if ( group == disp_load || group == disp_prefetch ) window_list -> num_loads += 1 ; else if ( group == disp_load_store ) { window_list -> num_stores += 1 ; window_list -> num_loads += 1 ; } } </s>

Add an instruction INSN with NUM_UOPS micro-operations to the dispatch window WINDOW_LIST .


<s> bool RISCVPassConfig :: addRegBankSelect ( ) { addPass ( new RegBankSelect ( ) ) ; return false ; } </s>

This method should install a register bank selector pass , which assigns register banks to virtual registers without a register class or register banks .


<s> int GCNTTIImpl :: getIntrinsicInstrCost ( const IntrinsicCostAttributes & ICA , TTI :: TargetCostKind CostKind ) { if ( ICA . getID ( ) == Intrinsic :: fabs ) return 0 ; if ( ! intrinsicHasPackedVectorBenefit ( ICA . getID ( ) ) ) return BaseT :: getIntrinsicInstrCost ( ICA , CostKind ) ; Type * RetTy = ICA . getReturnType ( ) ; EVT OrigTy = TLI -> getValueType ( DL , RetTy ) ; if ( ! OrigTy . isSimple ( ) ) { return BaseT :: getIntrinsicInstrCost ( ICA , CostKind ) ; } std :: pair < int , MVT > LT = TLI -> getTypeLegalizationCost ( DL , RetTy ) ; unsigned NElts = LT . second . isVector ( ) ? LT . second . getVectorNumElements ( ) : 1 ; MVT :: SimpleValueType SLT = LT . second . getScalarType ( ) . SimpleTy ; if ( SLT == MVT :: f64 ) return LT . first * NElts * get64BitInstrCost ( ) ; if ( ST -> has16BitInsts ( ) && SLT == MVT :: f16 ) NElts = ( NElts + 1 ) / 2 ; unsigned InstRate = getQuarterRateInstrCost ( ) ; if ( ICA . getID ( ) == Intrinsic :: fma ) { InstRate = ST -> hasFastFMAF32 ( ) ? getHalfRateInstrCost ( ) : getQuarterRateInstrCost ( ) ; } return LT . first * NElts * InstRate ; } </s>


<s>
const
char
*
nds32_output_stack_push
(
rtx
par_rtx
)
{
char
pattern
[
100
]
;
rtx
operands
[
3
]
;
int
rb_va_args
=
cfun
->
machine
->
va_args_first_regno
;
int
re_va_args
=
cfun
->
machine
->
va_args_last_regno
;
int
last_argument_regno
=
NDS32_FIRST_GPR_REGNUM
+
NDS32_MAX_GPR_REGS_FOR_ARGS
1
;
int
rb_callee_saved
=
cfun
->
machine
->
callee_saved_first_gpr_regno
;
int
re_callee_saved
=
cfun
->
machine
->
callee_saved_last_gpr_regno
;
if
(
reg_mentioned_p
(
gen_rtx_REG
(
SImode
,
last_argument_regno
)
,
par_rtx
)
)
{
operands
[
0
]
=
gen_rtx_REG
(
SImode
,
rb_va_args
)
;
operands
[
1
]
=
gen_rtx_REG
(
SImode
,
re_va_args
)
;
snprintf
(
pattern
,
sizeof
(
pattern
)
,
"push.s\t%s"
,
"%0, %1, { }"
)
;
output_asm_insn
(
pattern
,
operands
)
;
return
""
;
}
if
(
TARGET_V3PUSH
&&
!
nds32_isr_function_p
(
current_function_decl
)
&&
(
cfun
->
machine
->
va_args_size
==
0
)
)
{
int
sp_adjust
;
operands
[
0
]
=
gen_rtx_REG
(
SImode
,
re_callee_saved
)
;
sp_adjust
=
cfun
->
machine
->
local_size
+
cfun
->
machine
->
out_args_size
+
cfun
->
machine
->
callee_saved_area_gpr_padding_bytes
;
if
(
satisfies_constraint_Iu08
(
GEN_INT
(
sp_adjust
)
)
&&
NDS32_DOUBLE_WORD_ALIGN_P
(
sp_adjust
)
)
operands
[
1
]
=
GEN_INT
(
sp_adjust
)
;
else
operands
[
1
]
=
GEN_INT
(
0
)
;
snprintf
(
pattern
,
sizeof
(
pattern
)
,
"push25\t%%0, %%1"
)
;
}
else
{
int
push_en4_only_p
=
0
;
operands
[
0
]
=
gen_rtx_REG
(
SImode
,
rb_callee_saved
)
;
operands
[
1
]
=
gen_rtx_REG
(
SImode
,
re_callee_saved
)
;
if
(
!
cfun
->
machine
->
fp_size
&&
!
cfun
->
machine
->
gp_size
&&
!
cfun
->
machine
->
lp_size
&&
REGNO
(
operands
[
0
]
)
==
SP_REGNUM
&&
REGNO
(
operands
[
1
]
)
==
SP_REGNUM
)
{
return
""
;
}
else
{
if
(
REGNO
(
operands
[
0
]
)
==
SP_REGNUM
&&
REGNO
(
operands
[
1
]
)
==
SP_REGNUM
)
push_en4_only_p
=
1
;
snprintf
(
pattern
,
sizeof
(
pattern
)
,
"push.s\t%s{%s%s%s }"
,
push_en4_only_p
""
:
"%0, %1, "
,
cfun
->
machine
->
fp_size
" $fp"
:
""
,
cfun
->
machine
->
gp_size
" $gp"
:
""
,
cfun
->
machine
->
lp_size
" $lp"
:
""
)
;
}
}
output_asm_insn
(
pattern
,
operands
)
;
return
""
;
}
</s>

Function to output stack push operation . We need to deal with normal stack push multiple or stack v3push .


<s> bool RISCVTargetLowering :: isDesirableToCommuteWithShift ( const SDNode * N , CombineLevel Level ) const { SDValue N0 = N -> getOperand ( 0 ) ; EVT Ty = N0 . getValueType ( ) ; if ( Ty . isScalarInteger ( ) && ( N0 . getOpcode ( ) == ISD :: ADD || N0 . getOpcode ( ) == ISD :: OR ) ) { auto * C1 = dyn_cast < ConstantSDNode > ( N0 -> getOperand ( 1 ) ) ; auto * C2 = dyn_cast < ConstantSDNode > ( N -> getOperand ( 1 ) ) ; if ( C1 && C2 ) { const APInt & C1Int = C1 -> getAPIntValue ( ) ; APInt ShiftedC1Int = C1Int << C2 -> getAPIntValue ( ) ; if ( ShiftedC1Int . getMinSignedBits ( ) <= 64 && isLegalAddImmediate ( ShiftedC1Int . getSExtValue ( ) ) ) return true ; if ( C1Int . getMinSignedBits ( ) <= 64 && isLegalAddImmediate ( C1Int . getSExtValue ( ) ) ) return false ; int C1Cost = RISCVMatInt :: getIntMatCost ( C1Int , Ty . getSizeInBits ( ) , Subtarget . getFeatureBits ( ) , true ) ; int ShiftedC1Cost = RISCVMatInt :: getIntMatCost ( ShiftedC1Int , Ty . getSizeInBits ( ) , Subtarget . getFeatureBits ( ) , true ) ; if ( C1Cost < ShiftedC1Cost ) return false ; } } return true ; } </s>

Return true if it is profitable to move this shift by a constant amount through its operand , adjusting any immediate operands as necessary to preserve semantics .


<s> static void mmix_encode_section_info ( tree decl , rtx rtl , int first ) { if ( ( TREE_CODE ( decl ) == VAR_DECL && ( DECL_EXTERNAL ( decl ) || TREE_PUBLIC ( decl ) ) ) || ( TREE_CODE ( decl ) == FUNCTION_DECL && TREE_PUBLIC ( decl ) ) ) ; else if ( first && DECL_P ( decl ) ) { const char * str = XSTR ( XEXP ( rtl , 0 ) , 0 ) ; int len = strlen ( str ) ; char * newstr ; newstr = ( char * ) ggc_alloc_string ( "" , len + 1 ) ; strcpy ( newstr + 1 , str ) ; * newstr = '@' ; XSTR ( XEXP ( rtl , 0 ) , 0 ) = newstr ; } if ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CONSTANT ( decl ) || ( TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && ( ! DECL_INITIAL ( decl ) || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) ) SYMBOL_REF_FLAG ( XEXP ( rtl , 0 ) ) = 1 ; } </s>


<s> unsigned SIRegisterInfo :: reservedPrivateSegmentBufferReg ( const MachineFunction & MF ) const { const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; unsigned BaseIdx = alignDown ( ST . getMaxNumSGPRs ( MF ) , 4 ) - 4 ; unsigned BaseReg ( AMDGPU :: SGPR_32RegClass . getRegister ( BaseIdx ) ) ; return getMatchingSuperReg ( BaseReg , AMDGPU :: sub0 , & AMDGPU :: SGPR_128RegClass ) ; } </s>

Return the end register initially reserved for the scratch buffer in case spilling is needed .


<s>
bool
TVMFrameLowering
::
hasReservedCallFrame
(
const
MachineFunction
&
MF
)
const
{
assert
(
!
MF
.
getFrameInfo
(
)
.
hasVarSizedObjects
(
)
&&
"Var arg is not supported yet"
)
;
return
false
;
}
</s>

hasReservedCallFrame - Under normal circumstances , when a frame pointer is not required , we reserve argument space for call sites in the function immediately on entry to the current function .


<s> void x86_order_regs_for_local_alloc ( void ) { int pos = 0 ; int i ; for ( i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( GENERAL_REGNO_P ( i ) && call_used_regs [ i ] ) reg_alloc_order [ pos ++ ] = i ; for ( i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( GENERAL_REGNO_P ( i ) && ! call_used_regs [ i ] ) reg_alloc_order [ pos ++ ] = i ; if ( ! TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_SSE_REG ; i <= LAST_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_MASK_REG ; i <= LAST_MASK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_BND_REG ; i <= LAST_BND_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; if ( TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_MMX_REG ; i <= LAST_MMX_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; while ( pos < FIRST_PSEUDO_REGISTER ) reg_alloc_order [ pos ++ ] = 0 ; } </s>

Order the registers for register allocator .


<s> bool MipsAsmParser :: MatchAndEmitInstruction ( SMLoc IDLoc , SmallVectorImpl < MCParsedAsmOperand * > & Operands , MCStreamer & Out ) { return true ; } </s>

MatchAndEmitInstruction - Recognize a series of operands of a parsed instruction as an actual MCInst and emit it to the specified MCStreamer .


<s> static bool nios2_valid_addr_expr_p ( rtx base , rtx offset , bool strict_p ) { if ( ! strict_p && GET_CODE ( base ) == SUBREG ) base = SUBREG_REG ( base ) ; return ( REG_P ( base ) && nios2_regno_ok_for_base_p ( REGNO ( base ) , strict_p ) && ( offset == NULL_RTX || nios2_valid_addr_offset_p ( offset ) || nios2_unspec_reloc_p ( offset ) ) ) ; } </s>

Return true if the address expression formed by BASE + OFFSET is valid .


<s> rtx rs6000_got_register ( rtx value ATTRIBUTE_UNUSED ) { if ( ! can_create_pseudo_p ( ) && ! df_regs_ever_live_p ( RS6000_PIC_OFFSET_TABLE_REGNUM ) ) df_set_regs_ever_live ( RS6000_PIC_OFFSET_TABLE_REGNUM , true ) ; crtl -> uses_pic_offset_table = 1 ; return pic_offset_table_rtx ; } </s>


<s> static int frv_cond_flags ( rtx cond ) { gcc_assert ( ( GET_CODE ( cond ) == EQ || GET_CODE ( cond ) == NE ) && GET_CODE ( XEXP ( cond , 0 ) ) == REG && CR_P ( REGNO ( XEXP ( cond , 0 ) ) ) && XEXP ( cond , 1 ) == const0_rtx ) ; return ( ( REGNO ( XEXP ( cond , 0 ) ) - CR_FIRST ) | ( GET_CODE ( cond ) == NE ? REGSTATE_IF_TRUE : REGSTATE_IF_FALSE ) ) ; } </s>

Return the regstate_t flags for the given COND_EXEC condition . Abort if the condition is n't in the right form .


<s> void X86InstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , unsigned DestReg , int FrameIdx , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { const MachineFunction & MF = * MBB . getParent ( ) ; unsigned Alignment = std :: max < uint32_t > ( TRI -> getSpillSize ( * RC ) , 16 ) ; bool isAligned = ( Subtarget . getFrameLowering ( ) -> getStackAlignment ( ) >= Alignment ) || RI . canRealignStack ( MF ) ; unsigned Opc = getLoadRegOpcode ( DestReg , RC , isAligned , Subtarget ) ; addFrameReference ( BuildMI ( MBB , MI , DebugLoc ( ) , get ( Opc ) , DestReg ) , FrameIdx ) ; } </s>

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


<s> MCELFStreamer & RISCVTargetELFStreamer :: getStreamer ( ) { return static_cast < MCELFStreamer & > ( Streamer ) ; } </s>

Return the output streamer for the assembler .


<s> static rtx ix86_expand_vec_set_builtin ( tree exp ) { machine_mode tmode , mode1 ; tree arg0 , arg1 , arg2 ; int elt ; rtx op0 , op1 , target ; arg0 = CALL_EXPR_ARG ( exp , 0 ) ; arg1 = CALL_EXPR_ARG ( exp , 1 ) ; arg2 = CALL_EXPR_ARG ( exp , 2 ) ; 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 , EXPAND_NORMAL ) ; op1 = expand_expr ( arg1 , NULL_RTX , mode1 , EXPAND_NORMAL ) ; elt = get_element_number ( TREE_TYPE ( arg0 ) , arg2 ) ; if ( GET_MODE ( op1 ) != mode1 ) op1 = convert_modes ( mode1 , GET_MODE ( op1 ) , op1 , true ) ; op0 = force_reg ( tmode , op0 ) ; op1 = force_reg ( mode1 , op1 ) ; target = gen_reg_rtx ( tmode ) ; emit_move_insn ( target , op0 ) ; ix86_expand_vector_set ( true , target , op1 , elt ) ; return target ; } </s>

A subroutine of ix86_expand_builtin . These builtins are a wrapper around ix86_expand_vector_set . They would be redundant ( for non-MMX ) if we had a language-level syntax for referencing vector elements .


<s> SDValue AMDGPUTargetLowering :: getRecipEstimate ( SDValue Operand , SelectionDAG & DAG , int Enabled , int & RefinementSteps ) const { EVT VT = Operand . getValueType ( ) ; if ( VT == MVT :: f32 ) { RefinementSteps = 0 ; return DAG . getNode ( AMDGPUISD :: RCP , SDLoc ( Operand ) , VT , Operand ) ; } return SDValue ( ) ; } </s>

Return a reciprocal estimate value for the input operand .


"immediate operand must be an expression evaluating "

"to a value between 0 and 255 inclusive"

"expression expected after left parenthesis"

"expression expected after left bracket"

ParseInstruction - Parse one assembly instruction .


<s> void BPFTargetMachine :: registerPassBuilderCallbacks ( PassBuilder & PB , bool DebugPassManager ) { PB . registerPipelineStartEPCallback ( [ = ] ( ModulePassManager & MPM , PassBuilder :: OptimizationLevel ) { FunctionPassManager FPM ( DebugPassManager ) ; FPM . addPass ( BPFAbstractMemberAccessPass ( this ) ) ; FPM . addPass ( BPFPreserveDITypePass ( ) ) ; MPM . addPass ( createModuleToFunctionPassAdaptor ( std :: move ( FPM ) ) ) ; } ) ; PB . registerPeepholeEPCallback ( [ = ] ( FunctionPassManager & FPM , PassBuilder :: OptimizationLevel Level ) { FPM . addPass ( SimplifyCFGPass ( SimplifyCFGOptions ( ) . hoistCommonInsts ( true ) ) ) ; } ) ; } </s>

Invoke the PassBuilder callback registration .


<s> void visium_split_double_move ( rtx * operands , machine_mode mode ) { bool swap = false ; if ( GET_CODE ( operands [ 0 ] ) == REG && GET_CODE ( operands [ 1 ] ) == REG && REGNO ( operands [ 0 ] ) == REGNO ( operands [ 1 ] ) + 1 ) swap = true ; if ( GET_CODE ( operands [ 0 ] ) == REG && GET_CODE ( operands [ 1 ] ) == MEM ) { rtx op = XEXP ( operands [ 1 ] , 0 ) ; if ( GET_CODE ( op ) == SUBREG ) op = SUBREG_REG ( op ) ; if ( GET_CODE ( op ) == REG && REGNO ( op ) == REGNO ( operands [ 0 ] ) ) swap = true ; if ( GET_CODE ( op ) == PLUS ) { rtx x = XEXP ( op , 0 ) ; rtx y = XEXP ( op , 1 ) ; if ( GET_CODE ( x ) == REG && REGNO ( x ) == REGNO ( operands [ 0 ] ) ) swap = true ; if ( GET_CODE ( y ) == REG && REGNO ( y ) == REGNO ( operands [ 0 ] ) ) swap = true ; } } if ( swap ) { operands [ 2 ] = operand_subword ( operands [ 0 ] , 1 , 1 , mode ) ; operands [ 3 ] = operand_subword ( operands [ 1 ] , 1 , 1 , mode ) ; operands [ 4 ] = operand_subword ( operands [ 0 ] , 0 , 1 , mode ) ; operands [ 5 ] = operand_subword ( operands [ 1 ] , 0 , 1 , mode ) ; } else { operands [ 2 ] = operand_subword ( operands [ 0 ] , 0 , 1 , mode ) ; operands [ 3 ] = operand_subword ( operands [ 1 ] , 0 , 1 , mode ) ; operands [ 4 ] = operand_subword ( operands [ 0 ] , 1 , 1 , mode ) ; operands [ 5 ] = operand_subword ( operands [ 1 ] , 1 , 1 , mode ) ; } } </s>

Split a double move of OPERANDS in MODE .


<s>
MipsSubtarget
::
MipsSubtarget
(
const
std
::
string
&
TT
,
const
std
::
string
&
CPU
,
const
std
::
string
&
FS
,
bool
little
,
Reloc
::
Model
_RM
)
:
MipsGenSubtargetInfo
(
TT
,
CPU
,
FS
)
,
MipsArchVersion
(
Mips32
)
,
MipsABI
(
UnknownABI
)
,
IsLittle
(
little
)
,
IsSingleFloat
(
false
)
,
IsFP64bit
(
false
)
,
IsGP64bit
(
false
)
,
HasVFPU
(
false
)
,
IsLinux
(
true
)
,
HasSEInReg
(
false
)
,
HasCondMov
(
false
)
,
HasSwap
(
false
)
,
HasBitCount
(
false
)
,
HasFPIdx
(
false
)
,
InMips16Mode
(
false
)
,
InMicroMipsMode
(
false
)
,
HasDSP
(
false
)
,
HasDSPR2
(
false
)
,
IsAndroid
(
false
)
,
RM
(
_RM
)
{
std
::
string
CPUName
=
CPU
;
if
(
CPUName
.
empty
(
)
)
CPUName
=
"mips32"
;
ParseSubtargetFeatures
(
CPUName
,
FS
)
;
InstrItins
=
getInstrItineraryForCPU
(
CPUName
)
;
if
(
MipsABI
==
UnknownABI
)
MipsABI
=
hasMips64
(
)
N64
:
O32
;
assert
(
(
(
!
hasMips64
(
)
&&
(
isABI_O32
(
)
||
isABI_EABI
(
)
)
)
||
(
hasMips64
(
)
&&
(
isABI_N32
(
)
||
isABI_N64
(
)
)
)
)
&&
"Invalid  Arch & ABI pair."
)
;
if
(
TT
.
find
(
"linux"
)
==
std
::
string
::
npos
)
IsLinux
=
false
;
UseSmallSection
=
!
IsLinux
&&
(
RM
==
Reloc
::
Static
)
;
}
</s>

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

Mips
Mips
Mips
Mips
Mips
Mips
Mips
Mips
Mips
"mips32"
Mips
Mips
Mips
Mips
Mips
"Invalid  Arch & ABI pair."
"linux"


runOnMachineFunction - Emit the function body .


<s> bool isProfitableForNoCSROpt ( const Function & F ) const override { return false ; } </s>

Check if the no-CSR optimisation is profitable for the given function .


"AGC DAG->DAG Pattern Instruction Selection"

getPassName - Return a nice clean name for a pass .


<s> bool aarch64_offset_7bit_signed_scaled_p ( machine_mode mode , HOST_WIDE_INT offset ) { return ( offset >= - 64 * GET_MODE_SIZE ( mode ) && offset < 64 * GET_MODE_SIZE ( mode ) && offset % GET_MODE_SIZE ( mode ) == 0 ) ; } </s>

Return true if OFFSET is a signed 7-bit value multiplied by the size of MODE .


<s> M68kSubtarget :: M68kSubtarget ( const Triple & TT , StringRef CPU , StringRef FS , const M68kTargetMachine & TM ) : M68kGenSubtargetInfo ( TT , CPU , CPU , FS ) , UserReservedRegister ( M68k :: NUM_TARGET_REGS ) , TM ( TM ) , TSInfo ( ) , InstrInfo ( initializeSubtargetDependencies ( CPU , TT , FS , TM ) ) , FrameLowering ( * this , this -> getStackAlignment ( ) ) , TLInfo ( TM , * this ) , TargetTriple ( TT ) { CallLoweringInfo . reset ( new M68kCallLowering ( * getTargetLowering ( ) ) ) ; Legalizer . reset ( new M68kLegalizerInfo ( * this ) ) ; auto * RBI = new M68kRegisterBankInfo ( * getRegisterInfo ( ) ) ; RegBankInfo . reset ( RBI ) ; InstSelector . reset ( createM68kInstructionSelector ( TM , * this , * RBI ) ) ; } </s>


<s> bool HexagonTargetLowering :: isFMAFasterThanFMulAndFAdd ( const MachineFunction & MF , EVT VT ) const { return isOperationLegalOrCustom ( ISD :: FMA , VT ) ; } </s>

Return true if an FMA operation is faster than a pair of fmul and fadd instructions .


<s> void function_builder :: add_overloaded_functions ( const function_group_info & group , mode_suffix_index mode ) { unsigned int explicit_type0 = ( * group . shape ) -> explicit_type_suffix_p ( 0 ) ; unsigned int explicit_type1 = ( * group . shape ) -> explicit_type_suffix_p ( 1 ) ; for ( unsigned int pi = 0 ; group . preds [ pi ] != NUM_PREDS ; ++ pi ) { if ( ! explicit_type0 && ! explicit_type1 ) { function_instance instance ( group . base_name , * group . base , * group . shape , mode , types_none [ 0 ] , group . preds [ pi ] ) ; add_overloaded_function ( instance , group . required_extensions ) ; } else for ( unsigned int ti = 0 ; group . types [ ti ] [ 0 ] != NUM_TYPE_SUFFIXES ; ++ ti ) { type_suffix_pair types = { explicit_type0 ? group . types [ ti ] [ 0 ] : NUM_TYPE_SUFFIXES , explicit_type1 ? group . types [ ti ] [ 1 ] : NUM_TYPE_SUFFIXES } ; function_instance instance ( group . base_name , * group . base , * group . shape , mode , types , group . preds [ pi ] ) ; add_overloaded_function ( instance , group . required_extensions ) ; } } } </s>

If we are using manual overload resolution , add one function decl for each overloaded function in GROUP . Take the function base name from GROUP and the mode from MODE .


<s> std :: unique_ptr < 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 ConstantPool :: empty ( ) { return Entries . empty ( ) ; } </s>

Determine whether this version information is empty ( e.g. , all version components are zero ) .


<s> int ARMTTIImpl :: getIntImmCost ( const APInt & Imm , Type * Ty ) { assert ( Ty -> isIntegerTy ( ) ) ; unsigned Bits = Ty -> getPrimitiveSizeInBits ( ) ; if ( Bits == 0 || Bits > 32 ) return 4 ; int32_t SImmVal = Imm . getSExtValue ( ) ; uint32_t ZImmVal = Imm . getZExtValue ( ) ; if ( ! ST -> isThumb ( ) ) { if ( ( SImmVal >= 0 && SImmVal < 65536 ) || ( ARM_AM :: getSOImmVal ( ZImmVal ) != - 1 ) || ( ARM_AM :: getSOImmVal ( ~ ZImmVal ) != - 1 ) ) return 1 ; return ST -> hasV6T2Ops ( ) ? 2 : 3 ; } if ( ST -> isThumb2 ( ) ) { if ( ( SImmVal >= 0 && SImmVal < 65536 ) || ( ARM_AM :: getT2SOImmVal ( ZImmVal ) != - 1 ) || ( ARM_AM :: getT2SOImmVal ( ~ ZImmVal ) != - 1 ) ) return 1 ; return ST -> hasV6T2Ops ( ) ? 2 : 3 ; } if ( SImmVal >= 0 && SImmVal < 256 ) return 1 ; if ( ( ~ ZImmVal < 256 ) || ARM_AM :: isThumbImmShiftedVal ( ZImmVal ) ) return 2 ; return 3 ; } </s>

Calculate the cost of materializing a 64-bit value .


<s> const PPCMCExpr * PPCMCExpr :: create ( VariantKind Kind , const MCExpr * Expr , bool isDarwin , MCContext & Ctx ) { return new ( Ctx ) PPCMCExpr ( Kind , Expr , isDarwin ) ; } </s>


<s>
void
RISCVMCCodeEmitter
::
encodeInstruction
(
const
MCInst
&
MI
,
raw_ostream
&
OS
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
const
{
verifyInstructionPredicates
(
MI
,
computeAvailableFeatures
(
STI
.
getFeatureBits
(
)
)
)
;
const
MCInstrDesc
&
Desc
=
MCII
.
get
(
MI
.
getOpcode
(
)
)
;
unsigned
Size
=
Desc
.
getSize
(
)
;
if
(
MI
.
getOpcode
(
)
==
RISCV
::
PseudoCALLReg
||
MI
.
getOpcode
(
)
==
RISCV
::
PseudoCALL
||
MI
.
getOpcode
(
)
==
RISCV
::
PseudoTAIL
||
MI
.
getOpcode
(
)
==
RISCV
::
PseudoJump
)
{
expandFunctionCall
(
MI
,
OS
,
Fixups
,
STI
)
;
MCNumEmitted
+=
2
;
return
;
}
if
(
MI
.
getOpcode
(
)
==
RISCV
::
PseudoAddTPRel
)
{
expandAddTPRel
(
MI
,
OS
,
Fixups
,
STI
)
;
MCNumEmitted
+=
1
;
return
;
}
switch
(
Size
)
{
default
:
llvm_unreachable
(
"Unhandled encodeInstruction length!"
)
;
case
2
:
{
uint16_t
Bits
=
getBinaryCodeForInstr
(
MI
,
Fixups
,
STI
)
;
support
::
endian
::
write
<
uint16_t
>
(
OS
,
Bits
,
support
::
little
)
;
break
;
}
case
4
:
{
uint32_t
Bits
=
getBinaryCodeForInstr
(
MI
,
Fixups
,
STI
)
;
support
::
endian
::
write
(
OS
,
Bits
,
support
::
little
)
;
break
;
}
}
++
MCNumEmitted
;
}
</s>

Encode the given Inst to bytes and append to CB .

RI5CY
RISCV
RISCV::PseudoCALLReg
RISCV::PseudoCALL
RISCV::PseudoTAIL
RISCV::PseudoJump
2
RISCV::PseudoAddTPRel
1
"Unhandled encodeInstruction length!"
2
support::endian
support::little
4
support::endian
support::little


<s> static enum reg_class rs6000_secondary_reload_class ( enum reg_class rclass , machine_mode mode , rtx in ) { int regno ; if ( TARGET_ELF || ( DEFAULT_ABI == ABI_DARWIN && MACHOPIC_INDIRECT ) ) { if ( rclass != BASE_REGS && ( GET_CODE ( in ) == SYMBOL_REF || GET_CODE ( in ) == HIGH || GET_CODE ( in ) == LABEL_REF || GET_CODE ( in ) == CONST ) ) return BASE_REGS ; } if ( GET_CODE ( in ) == REG ) { regno = REGNO ( in ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) { regno = true_regnum ( in ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) regno = - 1 ; } } else if ( GET_CODE ( in ) == SUBREG ) { regno = true_regnum ( in ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) regno = - 1 ; } else regno = - 1 ; if ( TARGET_VSX && GET_MODE_SIZE ( mode ) < 16 && ! mode_supports_vmx_dform ( mode ) && ( ( ( rclass == GENERAL_REGS || rclass == BASE_REGS ) && ( regno >= 0 && ALTIVEC_REGNO_P ( regno ) ) ) || ( ( rclass == VSX_REGS || rclass == ALTIVEC_REGS ) && ( regno >= 0 && INT_REGNO_P ( regno ) ) ) ) ) return FLOAT_REGS ; if ( rclass == GENERAL_REGS || rclass == BASE_REGS || ( regno >= 0 && INT_REGNO_P ( regno ) ) ) return NO_REGS ; if ( rclass == VSX_REGS && ( regno == - 1 || VSX_REGNO_P ( regno ) ) ) return NO_REGS ; if ( ( regno == - 1 || FP_REGNO_P ( regno ) ) && ( rclass == FLOAT_REGS || rclass == NON_SPECIAL_REGS ) ) return ( mode != SDmode || lra_in_progress ) ? NO_REGS : GENERAL_REGS ; if ( ( regno == - 1 || ALTIVEC_REGNO_P ( regno ) ) && rclass == ALTIVEC_REGS ) return NO_REGS ; if ( ( rclass == CR_REGS || rclass == CR0_REGS ) && regno >= 0 && CR_REGNO_P ( regno ) ) return NO_REGS ; return GENERAL_REGS ; } </s>

Return the register class of a scratch register needed to copy IN into or out of a register in RCLASS in MODE . If it can be done directly , NO_REGS is returned .


<s> bool isLegalMaskedScatter ( Type * DataType , Align Alignment ) { return isLegalMaskedGatherScatter ( DataType , Alignment ) ; } </s>

Return true if the target supports masked scatter .


<s> static void rs6000_set_up_by_prologue ( struct hard_reg_set_container * set ) { if ( ! TARGET_SINGLE_PIC_BASE && TARGET_TOC && TARGET_MINIMAL_TOC && ! constant_pool_empty_p ( ) ) add_to_hard_reg_set ( & set -> set , Pmode , RS6000_PIC_OFFSET_TABLE_REGNUM ) ; if ( cfun -> machine -> split_stack_argp_used ) add_to_hard_reg_set ( & set -> set , Pmode , 12 ) ; } </s>

Add r30 to hard reg set if the prologue sets it up and it is not pic_offset_table_rtx .


"Virtual function multiversioning not supported"

Generate the dispatching code body to dispatch multi-versioned function DECL . The target hook is called to process the `` target '' attributes and provide the code to dispatch the right function at run-time . NODE points to the dispatcher decl whose body will be created .


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

Print the specified MCInst to the specified raw_ostream .


<s> static rtx_insn * emit_frame_save ( rtx frame_reg , machine_mode mode , unsigned int regno , int offset , HOST_WIDE_INT frame_reg_to_sp ) { rtx reg ; gcc_checking_assert ( ! ( TARGET_ALTIVEC_ABI && ALTIVEC_VECTOR_MODE ( mode ) ) || ( TARGET_VSX && ALTIVEC_OR_VSX_VECTOR_MODE ( mode ) ) ) ; reg = gen_rtx_REG ( mode , regno ) ; rtx_insn * insn = emit_insn ( gen_frame_store ( reg , frame_reg , offset ) ) ; return rs6000_frame_related ( insn , frame_reg , frame_reg_to_sp , NULL_RTX , NULL_RTX ) ; } </s>

Save a register into the frame , and emit RTX_FRAME_RELATED_P notes . Save REGNO into [ FRAME_REG + OFFSET ] in mode MODE .


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


<s> static void nds32_emit_stack_v3push ( rtx Rb , rtx Re , rtx En4 ATTRIBUTE_UNUSED , rtx imm8u ) { int regno ; int num_use_regs ; int par_index ; int offset ; rtx reg ; rtx mem ; rtx push_rtx ; rtx adjust_sp_rtx ; rtx parallel_insn ; num_use_regs = REGNO ( Re ) - REGNO ( Rb ) + 1 + 3 ; parallel_insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_use_regs + 1 ) ) ; par_index = 0 ; offset = - ( num_use_regs * 4 ) ; for ( regno = REGNO ( Rb ) ; regno <= ( int ) REGNO ( Re ) ; regno ++ ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; push_rtx = gen_rtx_SET ( VOIDmode , mem , reg ) ; XVECEXP ( parallel_insn , 0 , par_index ) = push_rtx ; RTX_FRAME_RELATED_P ( push_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; } reg = gen_rtx_REG ( SImode , FP_REGNUM ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; push_rtx = gen_rtx_SET ( VOIDmode , mem , reg ) ; XVECEXP ( parallel_insn , 0 , par_index ) = push_rtx ; RTX_FRAME_RELATED_P ( push_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; reg = gen_rtx_REG ( SImode , GP_REGNUM ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; push_rtx = gen_rtx_SET ( VOIDmode , mem , reg ) ; XVECEXP ( parallel_insn , 0 , par_index ) = push_rtx ; RTX_FRAME_RELATED_P ( push_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; reg = gen_rtx_REG ( SImode , LP_REGNUM ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; push_rtx = gen_rtx_SET ( VOIDmode , mem , reg ) ; XVECEXP ( parallel_insn , 0 , par_index ) = push_rtx ; RTX_FRAME_RELATED_P ( push_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; offset = - ( num_use_regs * 4 ) ; adjust_sp_rtx = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , offset - INTVAL ( imm8u ) ) ) ; XVECEXP ( parallel_insn , 0 , par_index ) = adjust_sp_rtx ; RTX_FRAME_RELATED_P ( adjust_sp_rtx ) = 1 ; parallel_insn = emit_insn ( parallel_insn ) ; RTX_FRAME_RELATED_P ( parallel_insn ) = 1 ; } </s>

Function to create a parallel rtx pattern which presents stack v3push behavior . The overall concept are : `` push registers to memory '' , `` adjust stack pointer '' .


<s> bool X86TTIImpl :: isLegalMaskedScatter ( Type * DataType , MaybeAlign Alignment ) { if ( ! ST -> hasAVX512 ( ) ) return false ; return isLegalMaskedGather ( DataType , Alignment ) ; } </s>


<s> void BTFDebug :: beginInstruction ( const MachineInstr * MI ) { DebugHandlerBase :: beginInstruction ( MI ) ; if ( SkipInstruction || MI -> isMetaInstruction ( ) || MI -> getFlag ( MachineInstr :: FrameSetup ) ) return ; if ( MI -> isInlineAsm ( ) ) { unsigned NumDefs = 0 ; for ( ; MI -> getOperand ( NumDefs ) . isReg ( ) && MI -> getOperand ( NumDefs ) . isDef ( ) ; ++ NumDefs ) ; const char * AsmStr = MI -> getOperand ( NumDefs ) . getSymbolName ( ) ; if ( AsmStr [ 0 ] == 0 ) return ; } if ( MI -> getOpcode ( ) == BPF :: LD_imm64 ) { processReloc ( MI -> getOperand ( 1 ) ) ; } else if ( MI -> getOpcode ( ) == BPF :: CORE_MEM || MI -> getOpcode ( ) == BPF :: CORE_ALU32_MEM || MI -> getOpcode ( ) == BPF :: CORE_SHIFT ) { processReloc ( MI -> getOperand ( 3 ) ) ; } else if ( MI -> getOpcode ( ) == BPF :: JAL ) { const MachineOperand & MO = MI -> getOperand ( 0 ) ; if ( MO . isGlobal ( ) ) { processFuncPrototypes ( dyn_cast < Function > ( MO . getGlobal ( ) ) ) ; } } if ( ! CurMI ) return ; const DebugLoc & DL = MI -> getDebugLoc ( ) ; if ( ! DL || PrevInstLoc == DL ) { if ( LineInfoGenerated == false ) { auto * S = MI -> getMF ( ) -> getFunction ( ) . getSubprogram ( ) ; MCSymbol * FuncLabel = Asm -> getFunctionBegin ( ) ; constructLineInfo ( S , FuncLabel , S -> getLine ( ) , 0 ) ; LineInfoGenerated = true ; } return ; } MCSymbol * LineSym = OS . getContext ( ) . createTempSymbol ( ) ; OS . emitLabel ( LineSym ) ; auto SP = DL . get ( ) -> getScope ( ) -> getSubprogram ( ) ; constructLineInfo ( SP , LineSym , DL . getLine ( ) , DL . getCol ( ) ) ; LineInfoGenerated = true ; PrevInstLoc = DL ; } </s>


<s> bool X86AsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & MF . getSubtarget < X86Subtarget > ( ) ; SMShadowTracker . startFunction ( MF ) ; SetupMachineFunction ( MF ) ; if ( Subtarget -> isTargetCOFF ( ) ) { bool Intrn = MF . getFunction ( ) -> hasInternalLinkage ( ) ; OutStreamer . BeginCOFFSymbolDef ( CurrentFnSym ) ; OutStreamer . EmitCOFFSymbolStorageClass ( Intrn ? COFF :: IMAGE_SYM_CLASS_STATIC : COFF :: IMAGE_SYM_CLASS_EXTERNAL ) ; OutStreamer . EmitCOFFSymbolType ( COFF :: IMAGE_SYM_DTYPE_FUNCTION << COFF :: SCT_COMPLEX_TYPE_SHIFT ) ; OutStreamer . EndCOFFSymbolDef ( ) ; } EmitFunctionBody ( ) ; return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> void X86FrameLowering :: processFunctionBeforeFrameFinalized ( MachineFunction & MF , RegScavenger * RS ) const { MF . setHasWinCFI ( false ) ; if ( MF . getTarget ( ) . getMCAsmInfo ( ) -> usesWindowsCFI ( ) ) MF . getFrameInfo ( ) . ensureMaxAlignment ( Align ( SlotSize ) ) ; if ( STI . is64Bit ( ) && MF . hasEHFunclets ( ) && classifyEHPersonality ( MF . getFunction ( ) . getPersonalityFn ( ) ) == EHPersonality :: MSVC_CXX ) { adjustFrameForMsvcCxxEh ( MF ) ; } } </s>

processFunctionBeforeFrameFinalized - This method is called immediately before the specified function 's frame layout ( MF.getFrameInfo ( ) ) is finalized .


<s> PPCSubtarget :: PPCSubtarget ( const std :: string & TT , const std :: string & CPU , const std :: string & FS , const PPCTargetMachine & TM ) : PPCGenSubtargetInfo ( TT , CPU , FS ) , TargetTriple ( TT ) , IsPPC64 ( TargetTriple . getArch ( ) == Triple :: ppc64 || TargetTriple . getArch ( ) == Triple :: ppc64le ) , TargetABI ( PPC_ABI_UNKNOWN ) , FrameLowering ( initializeSubtargetDependencies ( CPU , FS ) ) , InstrInfo ( * this ) , TLInfo ( TM , * this ) , TSInfo ( TM . getDataLayout ( ) ) { } </s>

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


<s> bool TGSIAlwaysInline :: runOnModule ( Module & M ) { std :: vector < GlobalAlias * > AliasesToRemove ; std :: vector < Function * > FuncsToClone ; for ( GlobalAlias & A : M . aliases ( ) ) { if ( Function * F = dyn_cast < Function > ( A . getAliasee ( ) ) ) { A . replaceAllUsesWith ( F ) ; AliasesToRemove . push_back ( & A ) ; } } for ( GlobalAlias * A : AliasesToRemove ) { A -> eraseFromParent ( ) ; } for ( Function & F : M ) { if ( ! F . hasLocalLinkage ( ) && ! F . isDeclaration ( ) && ! F . use_empty ( ) && ! F . hasFnAttribute ( Attribute :: NoInline ) ) FuncsToClone . push_back ( & F ) ; } for ( Function * F : FuncsToClone ) { ValueToValueMapTy VMap ; Function * NewFunc = CloneFunction ( F , VMap ) ; NewFunc -> setLinkage ( GlobalValue :: InternalLinkage ) ; F -> replaceAllUsesWith ( NewFunc ) ; } for ( Function & F : M ) { if ( F . hasLocalLinkage ( ) && ! F . hasFnAttribute ( Attribute :: NoInline ) ) { F . addFnAttr ( Attribute :: AlwaysInline ) ; } } return false ; } </s>

runOnModule - Virtual method overriden by subclasses to process the module being operated on .


<s> bool PatmosSinglePathInfo :: isEnabled ( const MachineFunction & MF ) { return isRoot ( MF ) || isReachable ( MF ) || isMaybe ( MF ) ; } </s>


<s> bool isKMasked ( ) const { return ( Attributes & ( X86FMA3KMergeMasked | X86FMA3KZeroMasked ) ) != 0 ; } </s>

Returns true iff the group of FMA opcodes holds any of k-masked opcodes .


"Can't load this register from stack slot"

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


<s> unsigned ARMBaseInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : break ; case ARM :: STRrs : case ARM :: t2STRs : if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 2 ) . isReg ( ) && MI . getOperand ( 3 ) . isImm ( ) && MI . getOperand ( 2 ) . getReg ( ) == 0 && MI . getOperand ( 3 ) . getImm ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: STRi12 : case ARM :: t2STRi12 : case ARM :: tSTRspi : case ARM :: VSTRD : case ARM :: VSTRS : case ARM :: VSTR_P0_off : case ARM :: MVE_VSTRWU32 : if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 2 ) . isImm ( ) && MI . getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: VST1q64 : case ARM :: VST1d64TPseudo : case ARM :: VST1d64QPseudo : if ( MI . getOperand ( 0 ) . isFI ( ) && MI . getOperand ( 2 ) . getSubReg ( ) == 0 ) { FrameIndex = MI . getOperand ( 0 ) . getIndex ( ) ; return MI . getOperand ( 2 ) . getReg ( ) ; } break ; case ARM :: VSTMQIA : if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 0 ) . getSubReg ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

isStoreToStackSlot - If the specified machine instruction is a direct store to a stack slot , return the virtual or physical register number of the source reg along with the FrameIndex of the loaded stack slot .


<s>
bool
GBZ80PostPEI
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
bool
Modified
=
false
;
this
->
MF
=
&
MF
;
const
GBZ80Subtarget
&
STI
=
MF
.
getSubtarget
<
GBZ80Subtarget
>
(
)
;
TRI
=
STI
.
getRegisterInfo
(
)
;
TII
=
STI
.
getInstrInfo
(
)
;
LI
=
&
getAnalysis
<
LiveIntervals
>
(
)
;
RS
=
new
RegScavenger
(
)
;
Accesses
.
clear
(
)
;
OutgoingAdjustments
.
clear
(
)
;
CollectFrameAccesses
(
)
;
for
(
auto
&
A
:
Accesses
)
{
A
.
MI
->
dump
(
)
;
errs
(
)
<<
"Stack adj: "
<<
A
.
StackAdjustment
<<
"\n"
;
errs
(
)
<<
"Must save: "
<<
A
.
MustSaveHL
<<
"\n\n"
;
}
TransformFrameAccesses
(
)
;
delete
RS
;
return
!
Accesses
.
empty
(
)
;
}
</s>

GBZ80
GB
GB
GB
"Stack adj: "
"\n"
"Must save: "
"\n\n"


<s> unsigned MOSRegisterInfo :: getCSRFirstUseCost ( const MachineFunction & MF ) const { if ( MF . getFunction ( ) . doesNotRecurse ( ) ) { return 15 * 16384 / 10 ; } return 5 * 16384 / 10 ; } </s>

Allow the target to override the cost of using a callee-saved register for the first time .


<s>
bool
AArch64TargetLowering
::
shouldFoldConstantShiftPairToMask
(
const
SDNode
*
N
,
CombineLevel
Level
)
const
{
assert
(
(
(
N
->
getOpcode
(
)
==
ISD
::
SHL
&&
N
->
getOperand
(
0
)
.
getOpcode
(
)
==
ISD
::
SRL
)
||
(
N
->
getOpcode
(
)
==
ISD
::
SRL
&&
N
->
getOperand
(
0
)
.
getOpcode
(
)
==
ISD
::
SHL
)
)
&&
"Expected shift-shift mask"
)
;
return
N
->
getOperand
(
0
)
->
hasOneUse
(
)
;
}
</s>

Return true if it is profitable to fold a pair of shifts into a mask .


<s> int avr_progmem_p ( tree decl , tree attributes ) { tree a ; if ( TREE_CODE ( decl ) != VAR_DECL ) return 0 ; if ( NULL_TREE != lookup_attribute ( "progmem" , attributes ) ) return 1 ; a = decl ; do a = TREE_TYPE ( a ) ; while ( TREE_CODE ( a ) == ARRAY_TYPE ) ; if ( a == error_mark_node ) return 0 ; if ( NULL_TREE != lookup_attribute ( "progmem" , TYPE_ATTRIBUTES ( a ) ) ) return 1 ; return 0 ; } </s>

Look for attribute ` progmem ' in DECL if found return 1 , otherwise 0 .


<s> SDValue MipsTargetLowering :: LowerOperation ( SDValue Op , SelectionDAG & DAG ) const { switch ( Op . getOpcode ( ) ) { case ISD :: BR_JT : return lowerBR_JT ( Op , DAG ) ; case ISD :: BRCOND : return lowerBRCOND ( Op , DAG ) ; case ISD :: ConstantPool : return lowerConstantPool ( Op , DAG ) ; case ISD :: GlobalAddress : return lowerGlobalAddress ( Op , DAG ) ; case ISD :: BlockAddress : return lowerBlockAddress ( Op , DAG ) ; case ISD :: GlobalTLSAddress : return lowerGlobalTLSAddress ( Op , DAG ) ; case ISD :: JumpTable : return lowerJumpTable ( Op , DAG ) ; case ISD :: SELECT : return lowerSELECT ( Op , DAG ) ; case ISD :: SELECT_CC : return lowerSELECT_CC ( Op , DAG ) ; case ISD :: SETCC : return lowerSETCC ( Op , DAG ) ; case ISD :: VASTART : return lowerVASTART ( Op , DAG ) ; case ISD :: VAARG : return lowerVAARG ( Op , DAG ) ; case ISD :: FCOPYSIGN : return lowerFCOPYSIGN ( Op , DAG ) ; case ISD :: FRAMEADDR : return lowerFRAMEADDR ( Op , DAG ) ; case ISD :: RETURNADDR : return lowerRETURNADDR ( Op , DAG ) ; case ISD :: EH_RETURN : return lowerEH_RETURN ( Op , DAG ) ; case ISD :: ATOMIC_FENCE : return lowerATOMIC_FENCE ( Op , DAG ) ; case ISD :: SHL_PARTS : return lowerShiftLeftParts ( Op , DAG ) ; case ISD :: SRA_PARTS : return lowerShiftRightParts ( Op , DAG , true ) ; case ISD :: SRL_PARTS : return lowerShiftRightParts ( Op , DAG , false ) ; case ISD :: LOAD : return lowerLOAD ( Op , DAG ) ; case ISD :: STORE : return lowerSTORE ( Op , DAG ) ; case ISD :: ADD : return lowerADD ( Op , DAG ) ; case ISD :: FP_TO_SINT : return lowerFP_TO_SINT ( Op , DAG ) ; } return SDValue ( ) ; } </s>

LowerOperation - Provide custom lowering hooks for some operations .

Mips Mips ISD::BR_JT ISD::BRCOND ISD::ConstantPool ISD::GlobalAddress ISD::BlockAddress ISD::GlobalTLSAddress ISD::JumpTable ISD::SELECT ISD::SELECT_CC ISD::SETCC ISD::VASTART ISD::VAARG ISD::FCOPYSIGN ISD::FRAMEADDR ISD::RETURNADDR ISD::EH_RETURN ISD::ATOMIC_FENCE ISD::SHL_PARTS ISD::SRA_PARTS ISD::SRL_PARTS ISD::LOAD ISD::STORE ISD::ADD ISD::FP_TO_SINT


<s> void HexagonPassConfig :: addPreEmitPass ( ) { bool NoOpt = ( getOptLevel ( ) == CodeGenOpt :: None ) ; if ( ! NoOpt ) addPass ( createHexagonNewValueJump ( ) ) ; addPass ( createHexagonBranchRelaxation ( ) ) ; if ( ! NoOpt ) { if ( ! DisableHardwareLoops ) addPass ( createHexagonFixupHwLoops ( ) ) ; if ( EnableGenMux ) addPass ( createHexagonGenMux ( ) ) ; } addPass ( createHexagonGatherPacketize ( ) , false ) ; if ( ! NoOpt ) addPass ( createHexagonPacketizer ( ) , false ) ; if ( EnableVectorPrint ) addPass ( createHexagonVectorPrint ( ) , false ) ; addPass ( createHexagonCallFrameInformation ( ) , false ) ; } </s>

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

Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon


<s> int flags_in_68881 ( ) { return cc_status . flags & CC_IN_68881 ; } </s>

Return nonzero if flags are currently in the 68881 flag register .


<s>
SDValue
X86TargetLowering
::
LowerCallResult
(
SDValue
Chain
,
SDValue
InFlag
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
InputArg
>
&
Ins
,
SDLoc
dl
,
SelectionDAG
&
DAG
,
SmallVectorImpl
<
SDValue
>
&
InVals
)
const
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
bool
Is64Bit
=
Subtarget
->
is64Bit
(
)
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
DAG
.
getMachineFunction
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeCallResult
(
Ins
,
RetCC_X86
)
;
for
(
unsigned
i
=
0
,
e
=
RVLocs
.
size
(
)
;
i
!=
e
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
EVT
CopyVT
=
VA
.
getLocVT
(
)
;
if
(
(
CopyVT
==
MVT
::
f32
||
CopyVT
==
MVT
::
f64
||
CopyVT
==
MVT
::
f128
)
&&
(
(
Is64Bit
||
Ins
[
i
]
.
Flags
.
isInReg
(
)
)
&&
!
Subtarget
->
hasSSE1
(
)
)
)
{
report_fatal_error
(
"SSE register return with SSE disabled"
)
;
}
bool
RoundAfterCopy
=
false
;
if
(
(
VA
.
getLocReg
(
)
==
X86
::
FP0
||
VA
.
getLocReg
(
)
==
X86
::
FP1
)
&&
isScalarFPTypeInSSEReg
(
VA
.
getValVT
(
)
)
)
{
CopyVT
=
MVT
::
f80
;
RoundAfterCopy
=
(
CopyVT
!=
VA
.
getLocVT
(
)
)
;
}
Chain
=
DAG
.
getCopyFromReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
CopyVT
,
InFlag
)
.
getValue
(
1
)
;
SDValue
Val
=
Chain
.
getValue
(
0
)
;
if
(
RoundAfterCopy
)
Val
=
DAG
.
getNode
(
ISD
::
FP_ROUND
,
dl
,
VA
.
getValVT
(
)
,
Val
,
DAG
.
getIntPtrConstant
(
1
,
dl
)
)
;
if
(
VA
.
isExtInLoc
(
)
&&
VA
.
getValVT
(
)
.
getScalarType
(
)
==
MVT
::
i1
)
Val
=
DAG
.
getNode
(
ISD
::
TRUNCATE
,
dl
,
VA
.
getValVT
(
)
,
Val
)
;
InFlag
=
Chain
.
getValue
(
2
)
;
InVals
.
push_back
(
Val
)
;
}
return
Chain
;
}
</s>

LowerCallResult - Lower the result values of an ISD : :CALL into the appropriate copies out of appropriate physical registers .


<s> SDValue WebAssemblySelectionDAGInfo :: EmitTargetCodeForMemcpy ( SelectionDAG & DAG , const SDLoc & DL , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , Align Alignment , bool IsVolatile , bool AlwaysInline , bool MustPreserveCheriCapabilities , MachinePointerInfo DstPtrInfo , MachinePointerInfo SrcPtrInfo ) const { auto & ST = DAG . getMachineFunction ( ) . getSubtarget < WebAssemblySubtarget > ( ) ; if ( ! ST . hasBulkMemory ( ) ) return SDValue ( ) ; SDValue MemIdx = DAG . getConstant ( 0 , DL , MVT :: i32 ) ; auto LenMVT = ST . hasAddr64 ( ) ? MVT :: i64 : MVT :: i32 ; return DAG . getNode ( WebAssemblyISD :: MEMORY_COPY , DL , MVT :: Other , { Chain , MemIdx , MemIdx , Dst , Src , DAG . getZExtOrTrunc ( Size , DL , LenMVT ) } ) ; } </s>

Emit target-specific code that performs a memcpy .


<s> void PPCPassConfig :: addMachineSSAOptimization ( ) { if ( EnableBranchCoalescing && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCBranchCoalescingPass ( ) ) ; TargetPassConfig :: addMachineSSAOptimization ( ) ; if ( TM -> getTargetTriple ( ) . getArch ( ) == Triple :: ppc64le && ! DisableVSXSwapRemoval ) addPass ( createPPCVSXSwapRemovalPass ( ) ) ; if ( ReduceCRLogical && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCReduceCRLogicalsPass ( ) ) ; if ( ! DisableMIPeephole ) { addPass ( createPPCMIPeepholePass ( ) ) ; addPass ( & DeadMachineInstructionElimID ) ; } } </s>

Methods with trivial inline returns are convenient points in the common codegen pass pipeline where targets may insert passes .


<s> virtual SDNode * PostISelFolding ( MachineSDNode * N , SelectionDAG & DAG ) const { return N ; } </s>

Fold the instructions after selecting them .


<s> bool requiresRegisterScavenging ( const MachineFunction & MF ) const override { return true ; } </s>

Returns true if the target requires ( and can make use of ) the register scavenger .


<s> int arc_decl_pretend_args ( tree decl ) { gcc_assert ( decl == current_function_decl ) ; return crtl -> args . pretend_args_size ; } </s>

Return the size of the pretend args for DECL .


"instruction requires a CPU feature not currently enabled"

MatchAndEmitInstruction - Recognize a series of operands of a parsed instruction as an actual MCInst and emit it to the specified MCStreamer .


<s> bool PPCTargetLowering :: splitValueIntoRegisterParts ( SelectionDAG & DAG , const SDLoc & DL , SDValue Val , SDValue * Parts , unsigned NumParts , MVT PartVT , Optional < CallingConv :: ID > CC ) const { EVT ValVT = Val . getValueType ( ) ; if ( PartVT == MVT :: f64 && ( ValVT == MVT :: i32 || ValVT == MVT :: i16 || ValVT == MVT :: i8 ) ) { Val = DAG . getNode ( ISD :: ZERO_EXTEND , DL , MVT :: i64 , Val ) ; Val = DAG . getNode ( ISD :: BITCAST , DL , MVT :: f64 , Val ) ; Parts [ 0 ] = Val ; return true ; } return false ; } </s>

Target-specific splitting of values into parts that fit a register storing a legal type .


<s> unsigned PPCTargetLowering :: getNumRegistersForCallingConv ( LLVMContext & Context , CallingConv :: ID CC , EVT VT ) const { if ( Subtarget . hasSPE ( ) && VT == MVT :: f64 ) return 2 ; return PPCTargetLowering :: getNumRegisters ( Context , VT ) ; } </s>

Certain targets require unusual breakdowns of certain types .


<s>
void
ARMBaseInstrInfo
::
buildOutlinedFrame
(
MachineBasicBlock
&
MBB
,
MachineFunction
&
MF
,
const
outliner
::
OutlinedFunction
&
OF
)
const
{
if
(
OF
.
FrameConstructionID
==
MachineOutlinerThunk
)
{
MachineInstr
*
Call
=
&
*
MBB
.
instr_end
(
)
;
bool
isThumb
=
Subtarget
.
isThumb
(
)
;
unsigned
FuncOp
=
isThumb
2
:
0
;
unsigned
Opc
=
Call
->
getOperand
(
FuncOp
)
.
isReg
(
)
isThumb
ARM
::
tTAILJMPr
:
ARM
::
TAILJMPr
:
isThumb
Subtarget
.
isTargetMachO
(
)
ARM
::
tTAILJMPd
:
ARM
::
tTAILJMPdND
:
ARM
::
TAILJMPd
;
MachineInstrBuilder
MIB
=
BuildMI
(
MBB
,
MBB
.
end
(
)
,
DebugLoc
(
)
,
get
(
Opc
)
)
.
add
(
Call
->
getOperand
(
FuncOp
)
)
;
if
(
isThumb
&&
!
Call
->
getOperand
(
FuncOp
)
.
isReg
(
)
)
MIB
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
Call
->
eraseFromParent
(
)
;
}
auto
IsNonTailCall
=
[
]
(
MachineInstr
&
MI
)
{
return
MI
.
isCall
(
)
&&
!
MI
.
isReturn
(
)
;
}
;
if
(
llvm
::
any_of
(
MBB
.
instrs
(
)
,
IsNonTailCall
)
)
{
MachineBasicBlock
::
iterator
It
=
MBB
.
begin
(
)
;
MachineBasicBlock
::
iterator
Et
=
MBB
.
end
(
)
;
if
(
OF
.
FrameConstructionID
==
MachineOutlinerTailCall
||
OF
.
FrameConstructionID
==
MachineOutlinerThunk
)
Et
=
std
::
prev
(
MBB
.
end
(
)
)
;
if
(
!
MBB
.
isLiveIn
(
ARM
::
LR
)
)
MBB
.
addLiveIn
(
ARM
::
LR
)
;
saveLROnStack
(
MBB
,
It
)
;
emitCFIForLRSaveOnStack
(
MBB
,
It
)
;
assert
(
OF
.
FrameConstructionID
!=
MachineOutlinerDefault
&&
"Can only fix up stack references once"
)
;
fixupPostOutline
(
MBB
)
;
restoreLRFromStack
(
MBB
,
Et
)
;
emitCFIForLRRestoreFromStack
(
MBB
,
Et
)
;
}
if
(
OF
.
FrameConstructionID
==
MachineOutlinerTailCall
||
OF
.
FrameConstructionID
==
MachineOutlinerThunk
)
return
;
BuildMI
(
MBB
,
MBB
.
end
(
)
,
DebugLoc
(
)
,
get
(
Subtarget
.
getReturnOpcode
(
)
)
)
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
if
(
OF
.
FrameConstructionID
!=
MachineOutlinerDefault
&&
OF
.
Candidates
[
0
]
.
CallConstructionID
!=
MachineOutlinerDefault
)
return
;
fixupPostOutline
(
MBB
)
;
}
</s>

Insert a custom frame for outlined functions .

ARM
ARM
2
0
ARM::tTAILJMPr
ARM::TAILJMPr
ARM::tTAILJMPd
ARM::tTAILJMPdND
ARM::TAILJMPd
ARMCC::AL
ARM::LR
ARM::LR
"Can only fix up stack references once"
ARMCC::AL
0


<s> const uint32_t * VERegisterInfo :: getNoPreservedMask ( ) const { return CSR_NoRegs_RegMask ; } </s>

Return a register mask that clobbers everything .


<s> void sparc64_initialize_trampoline ( rtx tramp , rtx fnaddr , rtx cxt ) { emit_move_insn ( gen_rtx_MEM ( SImode , tramp ) , GEN_INT ( trunc_int_for_mode ( 0x83414000 , SImode ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( tramp , 4 ) ) , GEN_INT ( trunc_int_for_mode ( 0xca586018 , SImode ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( tramp , 8 ) ) , GEN_INT ( trunc_int_for_mode ( 0x81c14000 , SImode ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( tramp , 12 ) ) , GEN_INT ( trunc_int_for_mode ( 0xca586010 , SImode ) ) ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( tramp , 16 ) ) , cxt ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( tramp , 24 ) ) , fnaddr ) ; emit_insn ( gen_flushdi ( validize_mem ( gen_rtx_MEM ( DImode , tramp ) ) ) ) ; if ( sparc_cpu != PROCESSOR_ULTRASPARC && sparc_cpu != PROCESSOR_ULTRASPARC3 ) emit_insn ( gen_flushdi ( validize_mem ( gen_rtx_MEM ( DImode , plus_constant ( tramp , 8 ) ) ) ) ) ; emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , "__enable_execute_stack" ) , LCT_NORMAL , VOIDmode , 1 , tramp , Pmode ) ; } </s>

The 64 bit version is simpler because it makes more sense to load the values as `` immediate '' data out of the trampoline . It 's also easier since we can read the PC without clobbering a register .


<s> bool TLCS900FrameLowering :: hasReservedCallFrame ( const MachineFunction & MF ) const { return ! MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ; } </s>

hasReservedCallFrame - Under normal circumstances , when a frame pointer is not required , we reserve argument space for call sites in the function immediately on entry to the current function .


<s> bool AMDGPUTTIImpl :: areInlineCompatible ( const Function * Caller , const Function * Callee ) const { const TargetMachine & TM = getTLI ( ) -> getTargetMachine ( ) ; const FeatureBitset & CallerBits = TM . getSubtargetImpl ( * Caller ) -> getFeatureBits ( ) ; const FeatureBitset & CalleeBits = TM . getSubtargetImpl ( * Callee ) -> getFeatureBits ( ) ; FeatureBitset RealCallerBits = CallerBits & ~ InlineFeatureIgnoreList ; FeatureBitset RealCalleeBits = CalleeBits & ~ InlineFeatureIgnoreList ; return ( ( RealCallerBits & RealCalleeBits ) == RealCalleeBits ) ; } </s>

Determine whether a callee with the given TLI can be inlined into caller with this TLI , based on 'nobuiltin ' attributes .


<s>
unsigned
getPointerSize
(
)
const
{
StringRef
Name
=
TheTarget
.
getName
(
)
;
if
(
Name
==
"ppc64"
)
return
8
;
assert
(
Name
==
"ppc32"
&&
"Unknown target name!"
)
;
return
4
;
}
</s>

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


<s> void TeakRegisterInfo :: resolveFrameIndex ( MachineInstr & MI , unsigned BaseReg , int64_t Offset ) const { dbgs ( ) << "resolveFrameIndex\n" ; MI . dump ( ) ; const MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineOperand * FIOp ; unsigned ImmOpIdx = 0 ; switch ( MI . getOpcode ( ) ) { default : return ; case Teak :: STORE_REG_TO_STACK_PSEUDO_16 : case Teak :: STORE_REG_TO_STACK_PSEUDO_TRUNC16 : case Teak :: STORE_REG_TO_STACK_PSEUDO_32 : FIOp = & MI . getOperand ( 1 ) ; ImmOpIdx = 2 ; break ; case Teak :: LOAD_REG_FROM_STACK_PSEUDO_16 : case Teak :: LOAD_REG_FROM_STACK_PSEUDO_16_SEXT40 : case Teak :: LOAD_REG_FROM_STACK_PSEUDO_16_ZEXT40 : case Teak :: LOAD_REG_FROM_STACK_PSEUDO_32_SEXT40 : FIOp = & MI . getOperand ( 1 ) ; ImmOpIdx = 2 ; break ; } MachineOperand & ImmOp = MI . getOperand ( ImmOpIdx ) ; FIOp -> ChangeToRegister ( BaseReg , false ) ; ImmOp . setImm ( Offset ) ; } </s>

Resolve a frame index operand of an instruction to reference the indicated base register plus offset instead .


<s>
bool
ARMTargetLowering
::
lowerInterleavedStore
(
StoreInst
*
SI
,
ShuffleVectorInst
*
SVI
,
unsigned
Factor
)
const
{
assert
(
Factor
>=
2
&&
Factor
<=
getMaxSupportedInterleaveFactor
(
)
&&
"Invalid interleave factor"
)
;
VectorType
*
VecTy
=
SVI
->
getType
(
)
;
assert
(
VecTy
->
getVectorNumElements
(
)
%
Factor
==
0
&&
"Invalid interleaved store"
)
;
unsigned
NumSubElts
=
VecTy
->
getVectorNumElements
(
)
/
Factor
;
Type
*
EltTy
=
VecTy
->
getVectorElementType
(
)
;
VectorType
*
SubVecTy
=
VectorType
::
get
(
EltTy
,
NumSubElts
)
;
const
DataLayout
&
DL
=
SI
->
getModule
(
)
->
getDataLayout
(
)
;
unsigned
SubVecSize
=
DL
.
getTypeAllocSizeInBits
(
SubVecTy
)
;
bool
EltIs64Bits
=
DL
.
getTypeAllocSizeInBits
(
EltTy
)
==
64
;
if
(
!
Subtarget
->
hasNEON
(
)
||
(
SubVecSize
!=
64
&&
SubVecSize
!=
128
)
||
EltIs64Bits
)
return
false
;
Value
*
Op0
=
SVI
->
getOperand
(
0
)
;
Value
*
Op1
=
SVI
->
getOperand
(
1
)
;
IRBuilder
<
>
Builder
(
SI
)
;
if
(
EltTy
->
isPointerTy
(
)
)
{
Type
*
IntTy
=
DL
.
getIntPtrType
(
EltTy
)
;
Type
*
IntVecTy
=
VectorType
::
get
(
IntTy
,
Op0
->
getType
(
)
->
getVectorNumElements
(
)
)
;
Op0
=
Builder
.
CreatePtrToInt
(
Op0
,
IntVecTy
)
;
Op1
=
Builder
.
CreatePtrToInt
(
Op1
,
IntVecTy
)
;
SubVecTy
=
VectorType
::
get
(
IntTy
,
NumSubElts
)
;
}
static
const
Intrinsic
::
ID
StoreInts
[
3
]
=
{
Intrinsic
::
arm_neon_vst2
,
Intrinsic
::
arm_neon_vst3
,
Intrinsic
::
arm_neon_vst4
}
;
SmallVector
<
Value
*
,
6
>
Ops
;
Type
*
Int8Ptr
=
Builder
.
getInt8PtrTy
(
SI
->
getPointerAddressSpace
(
)
)
;
Ops
.
push_back
(
Builder
.
CreateBitCast
(
SI
->
getPointerOperand
(
)
,
Int8Ptr
)
)
;
Type
*
Tys
[
]
=
{
Int8Ptr
,
SubVecTy
}
;
Function
*
VstNFunc
=
Intrinsic
::
getDeclaration
(
SI
->
getModule
(
)
,
StoreInts
[
Factor
2
]
,
Tys
)
;
for
(
unsigned
i
=
0
;
i
<
Factor
;
i
++
)
Ops
.
push_back
(
Builder
.
CreateShuffleVector
(
Op0
,
Op1
,
getSequentialMask
(
Builder
,
NumSubElts
*
i
,
NumSubElts
)
)
)
;
Ops
.
push_back
(
Builder
.
getInt32
(
SI
->
getAlignment
(
)
)
)
;
Builder
.
CreateCall
(
VstNFunc
,
Ops
)
;
return
true
;
}
</s>

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


<s>
bool
PPCInstrInfo
::
areMemAccessesTriviallyDisjoint
(
const
MachineInstr
&
MIa
,
const
MachineInstr
&
MIb
,
AliasAnalysis
*
)
const
{
assert
(
MIa
.
mayLoadOrStore
(
)
&&
"MIa must be a load or store."
)
;
assert
(
MIb
.
mayLoadOrStore
(
)
&&
"MIb must be a load or store."
)
;
if
(
MIa
.
hasUnmodeledSideEffects
(
)
||
MIb
.
hasUnmodeledSideEffects
(
)
||
MIa
.
hasOrderedMemoryRef
(
)
||
MIb
.
hasOrderedMemoryRef
(
)
)
return
false
;
const
TargetRegisterInfo
*
TRI
=
&
getRegisterInfo
(
)
;
const
MachineOperand
*
BaseOpA
=
nullptr
,
*
BaseOpB
=
nullptr
;
int64_t
OffsetA
=
0
,
OffsetB
=
0
;
unsigned
int
WidthA
=
0
,
WidthB
=
0
;
if
(
getMemOperandWithOffsetWidth
(
MIa
,
BaseOpA
,
OffsetA
,
WidthA
,
TRI
)
&&
getMemOperandWithOffsetWidth
(
MIb
,
BaseOpB
,
OffsetB
,
WidthB
,
TRI
)
)
{
if
(
BaseOpA
->
isIdenticalTo
(
*
BaseOpB
)
)
{
int
LowOffset
=
std
::
min
(
OffsetA
,
OffsetB
)
;
int
HighOffset
=
std
::
max
(
OffsetA
,
OffsetB
)
;
int
LowWidth
=
(
LowOffset
==
OffsetA
)
WidthA
:
WidthB
;
if
(
LowOffset
+
LowWidth
<=
HighOffset
)
return
true
;
}
}
return
false
;
}
</s>

Sometimes , it is possible for the target to tell , even without aliasing information , that two MIs access different memory addresses .


<s> void h8300_swap_out_of_er6 ( rtx addr ) { if ( REGNO ( addr ) != SP_REG ) emit_move_insn ( addr , hard_frame_pointer_rtx ) ; pop ( HARD_FRAME_POINTER_REGNUM ) ; } </s>

Move the current value of er6 into ADDR and pop its old value from the stack .


<s> static void emit_hard_tfmode_operation ( enum rtx_code code , rtx * operands ) { rtx op , dest ; if ( GET_RTX_CLASS ( code ) == RTX_UNARY ) { operands [ 1 ] = force_reg ( GET_MODE ( operands [ 1 ] ) , operands [ 1 ] ) ; op = gen_rtx_fmt_e ( code , GET_MODE ( operands [ 0 ] ) , operands [ 1 ] ) ; } else { operands [ 1 ] = force_reg ( GET_MODE ( operands [ 1 ] ) , operands [ 1 ] ) ; operands [ 2 ] = force_reg ( GET_MODE ( operands [ 2 ] ) , operands [ 2 ] ) ; op = gen_rtx_fmt_ee ( code , GET_MODE ( operands [ 0 ] ) , operands [ 1 ] , operands [ 2 ] ) ; } if ( register_operand ( operands [ 0 ] , VOIDmode ) ) dest = operands [ 0 ] ; else dest = gen_reg_rtx ( GET_MODE ( operands [ 0 ] ) ) ; emit_insn ( gen_rtx_SET ( dest , op ) ) ; if ( dest != operands [ 0 ] ) emit_move_insn ( operands [ 0 ] , dest ) ; } </s>

Expand a hard-float tfmode operation . All arguments must be in registers .


<s>
SDValue
ARMTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Don't know how to custom lower this!"
)
;
case
ISD
::
ConstantPool
:
return
LowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
Subtarget
->
isTargetDarwin
(
)
LowerGlobalAddressDarwin
(
Op
,
DAG
)
:
LowerGlobalAddressELF
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
return
LowerGlobalTLSAddress
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
,
Subtarget
)
;
case
ISD
::
BR_CC
:
return
LowerBR_CC
(
Op
,
DAG
,
Subtarget
)
;
case
ISD
::
BR_JT
:
return
LowerBR_JT
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
,
VarArgsFrameIndex
)
;
case
ISD
::
SINT_TO_FP
:
case
ISD
::
UINT_TO_FP
:
return
LowerINT_TO_FP
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_SINT
:
case
ISD
::
FP_TO_UINT
:
return
LowerFP_TO_INT
(
Op
,
DAG
)
;
case
ISD
::
FCOPYSIGN
:
return
LowerFCOPYSIGN
(
Op
,
DAG
)
;
case
ISD
::
RETURNADDR
:
break
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
GLOBAL_OFFSET_TABLE
:
return
LowerGLOBAL_OFFSET_TABLE
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_VOID
:
case
ISD
::
INTRINSIC_W_CHAIN
:
return
LowerINTRINSIC_W_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
BIT_CONVERT
:
return
ExpandBIT_CONVERT
(
Op
.
getNode
(
)
,
DAG
)
;
case
ISD
::
SHL
:
case
ISD
::
SRL
:
case
ISD
::
SRA
:
return
LowerShift
(
Op
.
getNode
(
)
,
DAG
,
Subtarget
)
;
case
ISD
::
VSETCC
:
return
LowerVSETCC
(
Op
,
DAG
)
;
case
ISD
::
BUILD_VECTOR
:
return
LowerBUILD_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
VECTOR_SHUFFLE
:
return
LowerVECTOR_SHUFFLE
(
Op
,
DAG
)
;
case
ISD
::
SCALAR_TO_VECTOR
:
return
LowerSCALAR_TO_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
EXTRACT_VECTOR_ELT
:
return
LowerEXTRACT_VECTOR_ELT
(
Op
,
DAG
)
;
case
ISD
::
CONCAT_VECTORS
:
return
LowerCONCAT_VECTORS
(
Op
,
DAG
)
;
}
return
SDValue
(
)
;
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> void aarch64_simd_emit_pair_result_insn ( machine_mode mode , rtx ( * intfn ) ( rtx , rtx , rtx ) , rtx destaddr , rtx op1 ) { rtx mem = gen_rtx_MEM ( mode , destaddr ) ; rtx tmp1 = gen_reg_rtx ( mode ) ; rtx tmp2 = gen_reg_rtx ( mode ) ; emit_insn ( intfn ( tmp1 , op1 , tmp2 ) ) ; emit_move_insn ( mem , tmp1 ) ; mem = adjust_address ( mem , mode , GET_MODE_SIZE ( mode ) ) ; emit_move_insn ( mem , tmp2 ) ; } </s>

Emit code to place a AdvSIMD pair result in memory locations ( with equal registers ) .


<s> bool VZeroUpperInserter :: runOnMachineFunction ( MachineFunction & MF ) { TII = MF . getTarget ( ) . getInstrInfo ( ) ; MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; bool EverMadeChange = false ; bool YMMUsed = false ; TargetRegisterClass * RC = X86 :: VR256RegisterClass ; for ( TargetRegisterClass :: iterator i = RC -> begin ( ) , e = RC -> end ( ) ; i != e ; i ++ ) { if ( MRI . isPhysRegUsed ( * i ) ) { YMMUsed = true ; break ; } } if ( ! YMMUsed ) return EverMadeChange ; FnHasLiveInYmm = checkFnHasLiveInYmm ( MRI ) ; assert ( BBState . empty ( ) ) ; BBState . resize ( MF . getNumBlockIDs ( ) , 0 ) ; BBSolved . resize ( MF . getNumBlockIDs ( ) , 0 ) ; while ( 1 ) { bool MadeChange = false ; for ( MachineFunction :: iterator I = MF . begin ( ) , E = MF . end ( ) ; I != E ; ++ I ) MadeChange |= processBasicBlock ( MF , * I ) ; if ( ! MadeChange ) break ; EverMadeChange = true ; } BBState . clear ( ) ; BBSolved . clear ( ) ; return EverMadeChange ; } </s>

runOnMachineFunction - Emit the function body .


<s> const uint16_t * X86RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { switch ( MF -> getFunction ( ) -> getCallingConv ( ) ) { case CallingConv :: GHC : case CallingConv :: HiPE : return CSR_NoRegs_SaveList ; case CallingConv :: WebKit_JS : return CSR_64_SaveList ; case CallingConv :: AnyReg : return CSR_MostRegs_64_SaveList ; case CallingConv :: Intel_OCL_BI : { bool HasAVX = TM . getSubtarget < X86Subtarget > ( ) . hasAVX ( ) ; bool HasAVX512 = TM . getSubtarget < X86Subtarget > ( ) . hasAVX512 ( ) ; if ( HasAVX512 && IsWin64 ) return CSR_Win64_Intel_OCL_BI_AVX512_SaveList ; if ( HasAVX512 && Is64Bit ) return CSR_64_Intel_OCL_BI_AVX512_SaveList ; if ( HasAVX && IsWin64 ) return CSR_Win64_Intel_OCL_BI_AVX_SaveList ; if ( HasAVX && Is64Bit ) return CSR_64_Intel_OCL_BI_AVX_SaveList ; if ( ! HasAVX && ! IsWin64 && Is64Bit ) return CSR_64_Intel_OCL_BI_SaveList ; break ; } case CallingConv :: Cold : if ( Is64Bit ) return CSR_MostRegs_64_SaveList ; break ; default : break ; } bool CallsEHReturn = MF -> getMMI ( ) . callsEHReturn ( ) ; if ( Is64Bit ) { if ( IsWin64 ) return CSR_Win64_SaveList ; if ( CallsEHReturn ) return CSR_64EHRet_SaveList ; return CSR_64_SaveList ; } if ( CallsEHReturn ) return CSR_32EHRet_SaveList ; return CSR_32_SaveList ; } </s>


<s> int X86TTIImpl :: getIntImmCost ( unsigned Opcode , unsigned Idx , const APInt & Imm , Type * Ty ) { assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 ) return TTI :: TCC_Free ; unsigned ImmIdx = ~ 0U ; switch ( Opcode ) { default : return TTI :: TCC_Free ; case Instruction :: GetElementPtr : if ( Idx == 0 ) return 2 * TTI :: TCC_Basic ; return TTI :: TCC_Free ; case Instruction :: Store : ImmIdx = 0 ; break ; case Instruction :: ICmp : if ( Idx == 1 && Imm . getBitWidth ( ) == 64 ) { uint64_t ImmVal = Imm . getZExtValue ( ) ; if ( ImmVal == 0x100000000ULL || ImmVal == 0xffffffff ) return TTI :: TCC_Free ; } ImmIdx = 1 ; break ; case Instruction :: And : if ( Idx == 1 && Imm . getBitWidth ( ) == 64 && isUInt < 32 > ( Imm . getZExtValue ( ) ) ) return TTI :: TCC_Free ; case Instruction :: Add : case Instruction :: Sub : case Instruction :: Mul : case Instruction :: UDiv : case Instruction :: SDiv : case Instruction :: URem : case Instruction :: SRem : case Instruction :: Or : case Instruction :: Xor : ImmIdx = 1 ; break ; case Instruction :: Shl : case Instruction :: LShr : case Instruction :: AShr : if ( Idx == 1 ) return TTI :: TCC_Free ; break ; case Instruction :: Trunc : case Instruction :: ZExt : case Instruction :: SExt : case Instruction :: IntToPtr : case Instruction :: PtrToInt : case Instruction :: BitCast : case Instruction :: PHI : case Instruction :: Call : case Instruction :: Select : case Instruction :: Ret : case Instruction :: Load : break ; } if ( Idx == ImmIdx ) { int NumConstants = ( BitSize + 63 ) / 64 ; int Cost = X86TTIImpl :: getIntImmCost ( Imm , Ty ) ; return ( Cost <= NumConstants * TTI :: TCC_Basic ) ? static_cast < int > ( TTI :: TCC_Free ) : Cost ; } return X86TTIImpl :: getIntImmCost ( Imm , Ty ) ; } </s>

Calculate the cost of materializing a 64-bit value .


<s> static rtx_insn * emit_sp_adjust ( int offset , int * next_scratch_regno , bool frame_related , rtx reg_notes ) { rtx to_add ; rtx imm_rtx = gen_int_si ( offset ) ; rtx_insn * insn ; if ( satisfies_constraint_J ( imm_rtx ) ) { to_add = imm_rtx ; } else { rtx tmp = gen_rtx_REG ( Pmode , ( * next_scratch_regno ) -- ) ; tilepro_expand_set_const32 ( tmp , imm_rtx ) ; to_add = tmp ; } insn = emit_insn ( gen_sp_adjust ( stack_pointer_rtx , stack_pointer_rtx , to_add ) ) ; REG_NOTES ( insn ) = reg_notes ; if ( frame_related ) { rtx real = gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , imm_rtx ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , real ) ; } return insn ; } </s>

This emits code for 'sp += offset ' . The ABI only allows us to modify 'sp ' in a single 'addi ' or 'addli ' , so the backtracer understands it . Larger amounts can not use those instructions , so are added by placing the offset into a large register and using 'add ' . This happens after reload , so we need to expand it ourselves .


<s> NVPTXSubtarget & NVPTXSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { TargetName = std :: string ( CPU . empty ( ) ? "sm_20" : CPU ) ; ParseSubtargetFeatures ( TargetName , TargetName , FS ) ; if ( PTXVersion == 0 ) { PTXVersion = 32 ; } 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 XtensaMCInstLower :: Initialize ( MCContext * C ) { Ctx = C ; } </s>

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


<s> unsigned AMDGPUInstrInfo :: getOpcodeAfterMemoryUnfold ( unsigned Opc , bool UnfoldLoad , bool UnfoldStore , unsigned * LoadRegIndex ) const { return 0 ; } </s>

getOpcodeAfterMemoryUnfold - Returns the opcode of the would be new instruction after load / store are unfolded from an instruction of the specified opcode .


<s> static unsigned ix86_loop_unroll_adjust ( unsigned nunroll , class loop * loop ) { basic_block * bbs ; rtx_insn * insn ; unsigned i ; unsigned mem_count = 0 ; if ( ! TARGET_ADJUST_UNROLL ) return nunroll ; subrtx_iterator :: array_type array ; bbs = get_loop_body ( loop ) ; for ( i = 0 ; i < loop -> num_nodes ; i ++ ) FOR_BB_INSNS ( bbs [ i ] , insn ) if ( NONDEBUG_INSN_P ( insn ) ) FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( const_rtx x = * iter ) if ( MEM_P ( x ) ) { machine_mode mode = GET_MODE ( x ) ; unsigned int n_words = GET_MODE_SIZE ( mode ) / UNITS_PER_WORD ; if ( n_words > 4 ) mem_count += 2 ; else mem_count += 1 ; } free ( bbs ) ; if ( mem_count && mem_count <= 32 ) return MIN ( nunroll , 32 / mem_count ) ; return nunroll ; } </s>

This function adjusts the unroll factor based on the hardware capabilities . For ex , bdver3 has a loop buffer which makes unrolling of smaller loops less important . This function decides the unroll factor using number of memory references ( value 32 is used ) as a heuristic .


<s> bool MipsAsmPrinter :: isBlockOnlyReachableByFallthrough ( const MachineBasicBlock * MBB ) const { const MachineBasicBlock * Pred = * MBB -> pred_begin ( ) ; if ( const BasicBlock * bb = Pred -> getBasicBlock ( ) ) if ( isa < SwitchInst > ( bb -> getTerminator ( ) ) ) return false ; return AsmPrinter :: isBlockOnlyReachableByFallthrough ( MBB ) ; } </s>

isBlockOnlyReachableByFallthough - Return true if the basic block has exactly one predecessor and the control transfer mechanism between the predecessor and this block is a fall-through .


<s> static bool loongarch_save_reg_p ( unsigned int regno ) { bool call_saved = ! global_regs [ regno ] && ! call_used_regs [ regno ] ; bool might_clobber = crtl -> saves_all_registers || df_regs_ever_live_p ( regno ) ; if ( call_saved && might_clobber ) return true ; if ( regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed ) return true ; if ( regno == RETURN_ADDR_REGNUM && crtl -> calls_eh_return ) return true ; return false ; } </s>

Return true if the current function must save register REGNO .


<s>
void
machopic_output_stub
(
FILE
*
file
,
const
char
*
symb
,
const
char
*
stub
)
{
unsigned
int
length
;
char
*
symbol_name
,
*
lazy_ptr_name
;
char
*
local_label_0
;
static
unsigned
label
=
0
;
symb
=
(
*
targetm
.
strip_name_encoding
)
(
symb
)
;
length
=
strlen
(
symb
)
;
symbol_name
=
XALLOCAVEC
(
char
,
length
+
32
)
;
GEN_SYMBOL_NAME_FOR_SYMBOL
(
symbol_name
,
symb
,
length
)
;
lazy_ptr_name
=
XALLOCAVEC
(
char
,
length
+
32
)
;
GEN_LAZY_PTR_NAME_FOR_SYMBOL
(
lazy_ptr_name
,
symb
,
length
)
;
if
(
MACHOPIC_PURE
)
{
switch_to_section
(
darwin_sections
[
machopic_picsymbol_stub1_section
]
)
;
fprintf
(
file
,
"\t.align 5\n"
)
;
fprintf
(
file
,
"%s:\n"
,
stub
)
;
fprintf
(
file
,
"\t.indirect_symbol %s\n"
,
symbol_name
)
;
label
++
;
local_label_0
=
XALLOCAVEC
(
char
,
16
)
;
sprintf
(
local_label_0
,
"L%u$spb"
,
label
)
;
fprintf
(
file
,
"\tmflr r0\n"
)
;
fprintf
(
file
,
"\tbcl 20,31,%s\n"
,
local_label_0
)
;
fprintf
(
file
,
"%s:\n\tmflr r11\n"
,
local_label_0
)
;
fprintf
(
file
,
"\taddis r11,r11,ha16(%s-%s)\n"
,
lazy_ptr_name
,
local_label_0
)
;
fprintf
(
file
,
"\tmtlr r0\n"
)
;
fprintf
(
file
,
"\t%s r12,lo16(%s-%s)(r11)\n"
,
(
TARGET_64BIT
"ldu"
:
"lwzu"
)
,
lazy_ptr_name
,
local_label_0
)
;
fprintf
(
file
,
"\tmtctr r12\n"
)
;
fprintf
(
file
,
"\tbctr\n"
)
;
}
else
{
switch_to_section
(
darwin_sections
[
machopic_symbol_stub1_section
]
)
;
fprintf
(
file
,
"\t.align 4\n"
)
;
fprintf
(
file
,
"%s:\n"
,
stub
)
;
fprintf
(
file
,
"\t.indirect_symbol %s\n"
,
symbol_name
)
;
fprintf
(
file
,
"\tlis r11,ha16(%s)\n"
,
lazy_ptr_name
)
;
fprintf
(
file
,
"\t%s r12,lo16(%s)(r11)\n"
,
(
TARGET_64BIT
"ldu"
:
"lwzu"
)
,
lazy_ptr_name
)
;
fprintf
(
file
,
"\tmtctr r12\n"
)
;
fprintf
(
file
,
"\tbctr\n"
)
;
}
switch_to_section
(
darwin_sections
[
machopic_lazy_symbol_ptr_section
]
)
;
fprintf
(
file
,
"%s:\n"
,
lazy_ptr_name
)
;
fprintf
(
file
,
"\t.indirect_symbol %s\n"
,
symbol_name
)
;
fprintf
(
file
,
"%sdyld_stub_binding_helper\n"
,
(
TARGET_64BIT
DOUBLE_INT_ASM_OP
:
"\t.long\t"
)
)
;
}
</s>

Generate external symbol indirection stubs ( PIC and non-PIC ) .

rs6000
0
32
32
"\t.align 5\n"
"%s:\n"
"\t.indirect_symbol %s\n"
16
"L%u$spb"
"\tmflr r0\n"
"\tbcl 20,31,%s\n"
"%s:\n\tmflr r11\n"
"\taddis r11,r11,ha16(%s-%s)\n"
"\tmtlr r0\n"
"\t%s r12,lo16(%s-%s)(r11)\n"
"ldu"
"lwzu"
"\tmtctr r12\n"
"\tbctr\n"
"\t.align 4\n"
"%s:\n"
"\t.indirect_symbol %s\n"
"\tlis r11,ha16(%s)\n"
"\t%s r12,lo16(%s)(r11)\n"
"ldu"
"lwzu"
"\tmtctr r12\n"
"\tbctr\n"
"%s:\n"
"\t.indirect_symbol %s\n"
"%sdyld_stub_binding_helper\n"
"\t.long\t"


<s> TargetLowering :: ConstraintWeight ARMTargetLowering :: getSingleConstraintMatchWeight ( AsmOperandInfo & info , const char * constraint ) const { ConstraintWeight weight = CW_Invalid ; Value * CallOperandVal = info . CallOperandVal ; if ( CallOperandVal == NULL ) return CW_Default ; const Type * type = CallOperandVal -> getType ( ) ; switch ( * constraint ) { default : weight = TargetLowering :: getSingleConstraintMatchWeight ( info , constraint ) ; break ; case 'l' : if ( type -> isIntegerTy ( ) ) { if ( Subtarget -> isThumb ( ) ) weight = CW_SpecificReg ; else weight = CW_Register ; } break ; case 'w' : if ( type -> isFloatingPointTy ( ) ) weight = CW_Register ; break ; } return weight ; } </s>

Examine constraint string and operand type and determine a weight value .


<s>
void
HexagonFrameLowering
::
processFunctionBeforeFrameFinalized
(
MachineFunction
&
MF
,
RegScavenger
*
RS
)
const
{
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
bool
HasAlloca
=
MFI
.
hasVarSizedObjects
(
)
;
bool
NeedsAlign
=
(
MFI
.
getMaxAlignment
(
)
>
getStackAlignment
(
)
)
;
if
(
!
HasAlloca
||
!
NeedsAlign
)
return
;
unsigned
LFS
=
MFI
.
getLocalFrameSize
(
)
;
for
(
int
i
=
0
,
e
=
MFI
.
getObjectIndexEnd
(
)
;
i
!=
e
;
++
i
)
{
if
(
!
MFI
.
isSpillSlotObjectIndex
(
i
)
||
MFI
.
isDeadObjectIndex
(
i
)
)
continue
;
unsigned
S
=
MFI
.
getObjectSize
(
i
)
;
unsigned
A
=
std
::
max
(
MFI
.
getObjectAlignment
(
i
)
,
8U
)
;
MFI
.
setObjectAlignment
(
i
,
8
)
;
LFS
=
alignTo
(
LFS
+
S
,
A
)
;
MFI
.
mapLocalFrameObject
(
i
,
LFS
)
;
}
MFI
.
setLocalFrameSize
(
LFS
)
;
Align
A
=
MFI
.
getLocalFrameMaxAlign
(
)
;
assert
(
A
<=
8
&&
"Unexpected local frame alignment"
)
;
if
(
A
==
1
)
MFI
.
setLocalFrameMaxAlign
(
Align
(
8
)
)
;
MFI
.
setUseLocalStackAllocationBlock
(
true
)
;
unsigned
AP
=
0
;
if
(
const
MachineInstr
*
AI
=
getAlignaInstr
(
MF
)
)
AP
=
AI
->
getOperand
(
0
)
.
getReg
(
)
;
auto
&
HMFI
=
*
MF
.
getInfo
<
HexagonMachineFunctionInfo
>
(
)
;
HMFI
.
setStackAlignBasePhysReg
(
AP
)
;
}
</s>

processFunctionBeforeFrameFinalized - This method is called immediately before the specified function 's frame layout ( MF.getFrameInfo ( ) ) is finalized .


<s> BitVector F2003fRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( F2003f :: F5 ) ; Reserved . set ( F2003f :: XX ) ; return Reserved ; } </s>

getReservedRegs - Returns a bitset indexed by physical register number indicating if a register is a special register that has particular uses and should be considered unavailable at all times , e.g .


"LOAD_STACK_GUARD currently supported only for MachO."

This function is called for all pseudo instructions that remain after register allocation .


<s> static int microblaze_must_save_register ( int regno ) { if ( pic_offset_table_rtx && ( regno == MB_ABI_PIC_ADDR_REGNUM ) && df_regs_ever_live_p ( regno ) ) return 1 ; if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return 1 ; if ( frame_pointer_needed && ( regno == HARD_FRAME_POINTER_REGNUM ) ) return 1 ; if ( crtl -> calls_eh_return && regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return 1 ; if ( ! crtl -> is_leaf ) { if ( regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return 1 ; if ( ( microblaze_is_interrupt_variant ( ) || save_volatiles ) && ( regno >= 3 && regno <= 12 ) ) return 1 ; } if ( microblaze_is_interrupt_variant ( ) ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_MSR_SAVE_REG || ( interrupt_handler && ( regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) ) ) return 1 ; } if ( save_volatiles ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) return 1 ; } if ( crtl -> calls_eh_return && ( regno == EH_RETURN_DATA_REGNO ( 0 ) || regno == EH_RETURN_DATA_REGNO ( 1 ) ) ) return 1 ; return 0 ; } </s>

Determine of register must be saved/restored in call .


<s> MachineInstrBuilder R600InstrInfo :: buildDefaultInstruction ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned Opcode , unsigned DstReg , unsigned Src0Reg , unsigned Src1Reg ) const { MachineInstrBuilder MIB = BuildMI ( MBB , I , MBB . findDebugLoc ( I ) , get ( Opcode ) , DstReg ) ; if ( Src1Reg ) { MIB . addImm ( 0 ) . addImm ( 0 ) ; } MIB . addImm ( 1 ) . addImm ( 0 ) . addImm ( 0 ) . addImm ( 0 ) . addReg ( Src0Reg ) . addImm ( 0 ) . addImm ( 0 ) . addImm ( 0 ) . addImm ( - 1 ) ; if ( Src1Reg ) { MIB . addReg ( Src1Reg ) . addImm ( 0 ) . addImm ( 0 ) . addImm ( 0 ) . addImm ( - 1 ) ; } MIB . addImm ( 1 ) . addReg ( AMDGPU :: PRED_SEL_OFF ) . addImm ( 0 ) ; return MIB ; } </s>

buildDefaultInstruction - This function returns a MachineInstr with all the instruction modifiers initialized to their default values .


<s> static rtx_insn * frame_emit_load ( int regno , rtx addr , rtx * cfa_restores ) { rtx reg = gen_rtx_REG ( DImode , regno ) ; rtx mem = gen_frame_mem ( DImode , addr ) ; if ( cfa_restores ) * cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , reg , * cfa_restores ) ; return emit_insn ( gen_movdi ( reg , mem ) ) ; } </s>

Emit a load in the stack frame to load REGNO from address ADDR . Add a REG_CFA_RESTORE note to CFA_RESTORES if CFA_RESTORES is non-null . Return the emitted insn .


"StoreResults expects liveness tracking"

runOnMachineFunction - Emit the function body .


<s> const TargetRegisterClass * AArch64RegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return & AArch64 :: GPR64spRegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s> static void mips_for_each_saved_acc ( HOST_WIDE_INT sp_offset , mips_save_restore_fn fn ) { HOST_WIDE_INT offset ; int regno ; offset = cfun -> machine -> frame . acc_sp_offset - sp_offset ; if ( BITSET_P ( cfun -> machine -> frame . acc_mask , 0 ) ) { mips_save_restore_reg ( word_mode , LO_REGNUM , offset , fn ) ; offset -= UNITS_PER_WORD ; mips_save_restore_reg ( word_mode , HI_REGNUM , offset , fn ) ; offset -= UNITS_PER_WORD ; } for ( regno = DSP_ACC_REG_FIRST ; regno <= DSP_ACC_REG_LAST ; regno ++ ) if ( BITSET_P ( cfun -> machine -> frame . acc_mask , ( ( regno - DSP_ACC_REG_FIRST ) / 2 ) + 1 ) ) { mips_save_restore_reg ( word_mode , regno , offset , fn ) ; offset -= UNITS_PER_WORD ; } } </s>

Call FN for each accumlator that is saved by the current function . SP_OFFSET is the offset of the current stack pointer from the start of the frame .


<s> void GBZ80TargetStreamer :: finish ( ) { } </s>

finish - after all the new live ranges have been created , compute the remaining live range , and rewrite instructions to use the new registers .


<s> bool X86TargetLowering :: isLoadBitCastBeneficial ( EVT LoadVT , EVT BitcastVT ) const { if ( ! Subtarget . hasAVX512 ( ) && ! LoadVT . isVector ( ) && BitcastVT . isVector ( ) && BitcastVT . getVectorElementType ( ) == MVT :: i1 ) return false ; if ( ! Subtarget . hasDQI ( ) && BitcastVT == MVT :: v8i1 && LoadVT == MVT :: i8 ) return false ; return TargetLowering :: isLoadBitCastBeneficial ( LoadVT , BitcastVT ) ; } </s>

Return true if the following transform is beneficial : fold ( conv ( load x ) ) - > ( load ( conv * ) x ) On architectures that do n't natively support some vector loads efficiently , casting the load to a smaller vector of larger types and loading is more efficient , however , this can be undone by optimizations in dag combiner .


<s> bool TPCDAGToDAGISel :: SelectInlineAsmMemoryOperand ( const SDValue & Op , unsigned ConstraintID , std :: vector < SDValue > & OutOps ) { return false ; } </s>

SelectInlineAsmMemoryOperand - Select the specified address as a target addressing mode , according to the specified constraint .


<s>
MCSymbol
*
Z80MCInstLower
::
GetExternalSymbolSymbol
(
const
MachineOperand
&
MO
)
const
{
assert
(
!
MO
.
getTargetFlags
(
)
&&
"Unknown target flag on GV operand"
)
;
return
AsmPrinter
.
GetExternalSymbolSymbol
(
MO
.
getSymbolName
(
)
)
;
}
</s>

Return the MCSymbol for the specified ExternalSymbol .


<s>
static
void
process_epilogue
(
FILE
*
out_file
,
rtx
insn
ATTRIBUTE_UNUSED
,
bool
unwind
,
bool
frame
ATTRIBUTE_UNUSED
)
{
if
(
!
last_block
)
{
if
(
unwind
)
fprintf
(
out_file
,
"\t.label_state %d\n"
,
++
cfun
->
machine
->
state_num
)
;
need_copy_state
=
true
;
}
if
(
unwind
)
fprintf
(
out_file
,
"\t.restore sp\n"
)
;
}
</s>

The function emits unwind directives for the start of an epilogue .

ia64
"\t.label_state %d\n"
"\t.restore sp\n"


<s> static bool s390_hard_regno_scratch_ok ( unsigned int regno ) { if ( GENERAL_REGNO_P ( regno ) && ! call_used_regs [ regno ] && cfun_gpr_save_slot ( regno ) == SAVE_SLOT_NONE ) return false ; return true ; } </s>

Return nonzero if register REGNO can be used as a scratch register in peephole2 .


<s> bool AArch64FastISel :: fastSelectInstruction ( const Instruction * I ) { switch ( I -> getOpcode ( ) ) { default : break ; case Instruction :: Add : case Instruction :: Sub : return selectAddSub ( I ) ; case Instruction :: Mul : if ( ! selectBinaryOp ( I , ISD :: MUL ) ) return selectMul ( I ) ; return true ; case Instruction :: SRem : if ( ! selectBinaryOp ( I , ISD :: SREM ) ) return selectRem ( I , ISD :: SREM ) ; return true ; case Instruction :: URem : if ( ! selectBinaryOp ( I , ISD :: UREM ) ) return selectRem ( I , ISD :: UREM ) ; return true ; case Instruction :: Shl : case Instruction :: LShr : case Instruction :: AShr : return selectShift ( I ) ; case Instruction :: And : case Instruction :: Or : case Instruction :: Xor : return selectLogicalOp ( I ) ; case Instruction :: Br : return selectBranch ( I ) ; case Instruction :: IndirectBr : return selectIndirectBr ( I ) ; case Instruction :: BitCast : if ( ! FastISel :: selectBitCast ( I ) ) return selectBitCast ( I ) ; return true ; case Instruction :: FPToSI : if ( ! selectCast ( I , ISD :: FP_TO_SINT ) ) return selectFPToInt ( I , true ) ; return true ; case Instruction :: FPToUI : return selectFPToInt ( I , false ) ; case Instruction :: ZExt : if ( ! selectCast ( I , ISD :: ZERO_EXTEND ) ) return selectIntExt ( I ) ; return true ; case Instruction :: SExt : if ( ! selectCast ( I , ISD :: SIGN_EXTEND ) ) return selectIntExt ( I ) ; return true ; case Instruction :: Trunc : if ( ! selectCast ( I , ISD :: TRUNCATE ) ) return selectTrunc ( I ) ; return true ; case Instruction :: FPExt : return selectFPExt ( I ) ; case Instruction :: FPTrunc : return selectFPTrunc ( I ) ; case Instruction :: SIToFP : if ( ! selectCast ( I , ISD :: SINT_TO_FP ) ) return selectIntToFP ( I , true ) ; return true ; case Instruction :: UIToFP : return selectIntToFP ( I , false ) ; case Instruction :: Load : return selectLoad ( I ) ; case Instruction :: Store : return selectStore ( I ) ; case Instruction :: FCmp : case Instruction :: ICmp : return selectCmp ( I ) ; case Instruction :: Select : return selectSelect ( I ) ; case Instruction :: Ret : return selectRet ( I ) ; case Instruction :: FRem : return selectFRem ( I ) ; } return selectOperator ( I , I -> getOpcode ( ) ) ; ( void ) & CC_AArch64_DarwinPCS_VarArg ; } </s>

This method is called by target-independent code when the normal FastISel process fails to select an instruction .


<s> unsigned MipsRegisterInfo :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { switch ( RC -> getID ( ) ) { default : return 0 ; case Mips :: GPR32RegClassID : case Mips :: GPR64RegClassID : case Mips :: DSPRRegClassID : { const TargetFrameLowering * TFI = Subtarget . getFrameLowering ( ) ; return 28 - TFI -> hasFP ( MF ) ; } case Mips :: FGR32RegClassID : return 32 ; case Mips :: AFGR64RegClassID : return 16 ; case Mips :: FGR64RegClassID : return 32 ; } } </s>

Return the register pressure `` high water mark '' for the specific register class .


<s>
bool
WebAssemblyCFGSort
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"********** CFG Sorting **********\n"
"********** Function: "
<<
MF
.
getName
(
)
<<
'\n'
)
;
const
auto
&
MLI
=
getAnalysis
<
MachineLoopInfo
>
(
)
;
auto
&
MDT
=
getAnalysis
<
MachineDominatorTree
>
(
)
;
MF
.
getRegInfo
(
)
.
invalidateLiveness
(
)
;
SortBlocks
(
MF
,
MLI
,
MDT
)
;
return
true
;
}
</s>

WebAssembly
WebAssembly
"********** CFG Sorting **********\n"
"********** Function: "


<s> void initialize ( Attributor & A ) override { Function * F = getAssociatedFunction ( ) ; CallingConv :: ID CC = F -> getCallingConv ( ) ; bool CallingConvSupportsAllImplicits = ( CC != CallingConv :: AMDGPU_Gfx ) ; if ( F -> isIntrinsic ( ) ) { indicatePessimisticFixpoint ( ) ; return ; } if ( AMDGPU :: isGraphics ( F -> getCallingConv ( ) ) ) { indicatePessimisticFixpoint ( ) ; return ; } for ( StringRef Attr : ImplicitAttrNames ) { if ( F -> hasFnAttribute ( Attr ) ) Attributes . insert ( Attr ) ; } if ( CallingConvSupportsAllImplicits && F -> hasAddressTaken ( nullptr , true , true , true ) ) { for ( StringRef AttrName : ImplicitAttrNames ) { Attributes . insert ( AttrName ) ; } } } </s>

Initialize the strategy after building the DAG for a new region .