<s> void ix86_expand_clear ( rtx dest ) { rtx tmp ; gcc_assert ( reload_completed ) ; if ( GET_MODE_SIZE ( GET_MODE ( dest ) ) < 4 ) dest = gen_rtx_REG ( SImode , REGNO ( dest ) ) ; tmp = gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ; if ( ! TARGET_USE_MOV0 || optimize_insn_for_size_p ( ) ) { rtx clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , tmp , clob ) ) ; } emit_insn ( tmp ) ; } </s>

Generate either `` mov $ 0 , reg '' or `` xor reg , reg '' , as appropriate for the target .


<s> static unsigned ix86_add_stmt_cost ( void * data , int count , enum vect_cost_for_stmt kind , struct _stmt_vec_info * stmt_info , int misalign , enum vect_cost_model_location where ) { unsigned * cost = ( unsigned * ) data ; unsigned retval = 0 ; tree vectype = stmt_info ? stmt_vectype ( stmt_info ) : NULL_TREE ; int stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( stmt_info ) ) count *= 50 ; retval = ( unsigned ) ( count * stmt_cost ) ; if ( TARGET_SILVERMONT || TARGET_INTEL ) if ( stmt_info && stmt_info -> stmt ) { tree lhs_op = gimple_get_lhs ( stmt_info -> stmt ) ; if ( lhs_op && TREE_CODE ( TREE_TYPE ( lhs_op ) ) == INTEGER_TYPE ) retval = ( retval * 17 ) / 10 ; } cost [ where ] += retval ; return retval ; } </s>


<s> bool isLittleEndian ( ) const { return IsLittleEndian ; } </s>

Tests whether the target triple is little endian .


<s> void fr30_expand_epilogue ( ) { int regno ; if ( ! current_frame_info . initialised ) abort ( ) ; if ( current_frame_info . frame_size > 0 ) { if ( current_frame_info . save_fp && frame_pointer_needed ) { emit_insn ( gen_leave_func ( ) ) ; current_frame_info . save_fp = 0 ; } else if ( current_frame_info . frame_size <= 508 ) emit_insn ( gen_add_to_stack ( GEN_INT ( current_frame_info . frame_size ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( current_frame_info . frame_size ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } if ( current_frame_info . save_fp ) emit_insn ( gen_movsi_pop ( frame_pointer_rtx ) ) ; if ( current_frame_info . save_rp ) emit_insn ( gen_movsi_pop ( gen_rtx_REG ( Pmode , RETURN_POINTER_REGNUM ) ) ) ; for ( regno = 0 ; regno < STACK_POINTER_REGNUM ; regno ++ ) if ( current_frame_info . gmask & ( 1 << regno ) ) emit_insn ( gen_movsi_pop ( gen_rtx_REG ( Pmode , regno ) ) ) ; if ( current_frame_info . pretend_size ) emit_insn ( gen_add_to_stack ( GEN_INT ( current_frame_info . pretend_size ) ) ) ; current_frame_info = zero_frame_info ; emit_jump_insn ( gen_return_from_func ( ) ) ; } </s>

Called after register allocation to add any instructions needed for the epilogue . Using an epilogue insn is favored compared to putting all of the instructions in output_function_epilogue ( ) , since it allows the scheduler to intermix instructions with the restores of the caller saved registers . In some cases , it might be necessary to emit a barrier instruction as the first insn to prevent such scheduling .


"Unable to build a return instruction?!"

This hook behaves as the extended lowerReturn function , but for targets that do not support swifterror value promotion .


<s> void createdInstr ( MachineInstr & MI ) override { NewInsts . push_back ( & MI ) ; } </s>

An instruction has been created and inserted into the function .


<s> static HOST_WIDE_INT mips_starting_frame_offset ( void ) { if ( FRAME_GROWS_DOWNWARD ) return 0 ; return crtl -> outgoing_args_size + MIPS_GP_SAVE_AREA_SIZE ; } </s>

Implement TARGET_STARTING_FRAME_OFFSET . See mips_compute_frame_info for details about the frame layout .


<s> static bool visium_print_operand_punct_valid_p ( unsigned char code ) { return code == '#' ; } </s>


<s> unsigned getMaxSupportedInterleaveFactor ( ) const override { return 4 ; } </s>

Get the maximum supported factor for interleaved memory accesses .


<s> SDValue AArch64TargetLowering :: BuildSDIVPow2 ( SDNode * N , const APInt & Divisor , SelectionDAG & DAG , std :: vector < SDNode * > * Created ) const { EVT VT = N -> getValueType ( 0 ) ; if ( ( VT != MVT :: i32 && VT != MVT :: i64 ) || ! ( Divisor . isPowerOf2 ( ) || ( - Divisor ) . isPowerOf2 ( ) ) ) return SDValue ( ) ; SDLoc DL ( N ) ; SDValue N0 = N -> getOperand ( 0 ) ; unsigned Lg2 = Divisor . countTrailingZeros ( ) ; SDValue Zero = DAG . getConstant ( 0 , VT ) ; SDValue Pow2MinusOne = DAG . getConstant ( ( 1 << Lg2 ) - 1 , VT ) ; SDValue CCVal ; SDValue Cmp = getAArch64Cmp ( N0 , Zero , ISD :: SETLT , CCVal , DAG , DL ) ; SDValue Add = DAG . getNode ( ISD :: ADD , DL , VT , N0 , Pow2MinusOne ) ; SDValue CSel = DAG . getNode ( AArch64ISD :: CSEL , DL , VT , Add , N0 , CCVal , Cmp ) ; if ( Created ) { Created -> push_back ( Cmp . getNode ( ) ) ; Created -> push_back ( Add . getNode ( ) ) ; Created -> push_back ( CSel . getNode ( ) ) ; } SDValue SRA = DAG . getNode ( ISD :: SRA , DL , VT , CSel , DAG . getConstant ( Lg2 , MVT :: i64 ) ) ; if ( Divisor . isNonNegative ( ) ) return SRA ; if ( Created ) Created -> push_back ( SRA . getNode ( ) ) ; return DAG . getNode ( ISD :: SUB , DL , VT , DAG . getConstant ( 0 , VT ) , SRA ) ; } </s>

Targets may override this function to provide custom SDIV lowering for power-of-2 denominators .


<s> static inline bool reg_ok_for_base_p ( const_rtx x , bool strict ) { return ( ( ! strict && ! HARD_REGISTER_P ( x ) ) || REGNO_OK_FOR_BASE_P ( REGNO ( x ) ) ) ; } </s>

Nonzero if X is a hard reg that can be used as an index .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Hexagon Split Const32s and Const64s"
;
}
</s>

getPassName - Return a nice clean name for a pass .

Hexagon
"Hexagon Split Const32s and Const64s"


<s> static bool tilegx_function_value_regno_p ( const unsigned int regno ) { return regno < TILEGX_NUM_RETURN_REGS ; } </s>


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

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


<s> static void mips_prepare_pch_save ( void ) { mips_set_compression_mode ( 0 ) ; mips16_globals = 0 ; micromips_globals = 0 ; } </s>


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

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


<s> void mmix_conditional_register_usage ( ) { int i ; if ( TARGET_ABI_GNU ) { static const int gnu_abi_reg_alloc_order [ ] = MMIX_GNU_ABI_REG_ALLOC_ORDER ; for ( i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) reg_alloc_order [ i ] = gnu_abi_reg_alloc_order [ i ] ; for ( i = 15 ; i <= 30 ; i ++ ) call_used_regs [ i ] = 0 ; for ( i = MMIX_RESERVED_GNU_ARG_0_REGNUM ; i < MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS ; i ++ ) fixed_regs [ i ] = 0 ; } if ( ! TARGET_TOPLEVEL_SYMBOLS ) for ( i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( reg_names [ i ] [ 0 ] == ':' ) reg_names [ i ] ++ ; } </s>


spillCalleeSavedRegisters - Issues instruction ( s ) to spill all callee saved registers and returns true if it is n't possible / profitable to do so by issuing a series of store instructions via storeRegToStackSlot ( ) .


<s> bool cris_cc0_user_requires_cmp ( rtx insn ) { rtx_insn * cc0_user = NULL ; rtx body ; rtx set ; gcc_assert ( insn != NULL ) ; if ( ! TARGET_V32 ) return false ; cc0_user = next_cc0_user ( insn ) ; if ( cc0_user == NULL ) return false ; body = PATTERN ( cc0_user ) ; set = single_set ( cc0_user ) ; if ( JUMP_P ( cc0_user ) && GET_CODE ( body ) == SET && SET_DEST ( body ) == pc_rtx && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE && XEXP ( XEXP ( SET_SRC ( body ) , 0 ) , 0 ) == cc0_rtx ) { return GET_CODE ( XEXP ( SET_SRC ( body ) , 0 ) ) == GT || GET_CODE ( XEXP ( SET_SRC ( body ) , 0 ) ) == LE ; } else if ( set ) { return GET_CODE ( SET_SRC ( body ) ) == GT || GET_CODE ( SET_SRC ( body ) ) == LE ; } gcc_unreachable ( ) ; } </s>

Whether next_cc0_user of insn is LE or GT or requires a real compare insn for other reasons .


<s> static int pop_reg ( rtx reg ) { rtx stkslot = gen_rtx_MEM ( GET_MODE ( reg ) , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ; rtx insn = emit_move_insn ( reg , stkslot ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , GET_MODE_SIZE ( GET_MODE ( reg ) ) ) ) ) ; return GET_MODE_SIZE ( GET_MODE ( reg ) ) ; } </s>

Helper used when restoring AUX regs during ISR .


<s> unsigned MMIXMCCodeEmitter :: getJumpTargetOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const { const MCOperand & MCOp = Inst . getOperand ( OpNo ) ; MCFixupKind Kind = static_cast < MCFixupKind > ( MMIX :: fixup_mmix_rel_24 ) ; Fixups . push_back ( MCFixup :: create ( 0 , MCOp . getExpr ( ) , Kind ) ) ; return 0 ; } </s>

getJumpTargetOpValue - Return binary encoding of the jump target operand .


<s>
bool
ARMCallLowering
::
lowerFormalArguments
(
MachineIRBuilder
&
MIRBuilder
,
const
Function
&
F
,
ArrayRef
<
ArrayRef
<
Register
>>
VRegs
)
const
{
auto
&
TLI
=
*
getTLI
<
ARMTargetLowering
>
(
)
;
auto
Subtarget
=
TLI
.
getSubtarget
(
)
;
if
(
Subtarget
->
isThumb1Only
(
)
)
return
false
;
if
(
F
.
arg_empty
(
)
)
return
true
;
if
(
F
.
isVarArg
(
)
)
return
false
;
auto
&
MF
=
MIRBuilder
.
getMF
(
)
;
auto
&
MBB
=
MIRBuilder
.
getMBB
(
)
;
auto
DL
=
MF
.
getDataLayout
(
)
;
for
(
auto
&
Arg
:
F
.
args
(
)
)
{
if
(
!
isSupportedType
(
DL
,
TLI
,
Arg
.
getType
(
)
)
)
return
false
;
if
(
Arg
.
hasByValOrInAllocaAttr
(
)
)
return
false
;
}
CCAssignFn
*
AssignFn
=
TLI
.
CCAssignFnForCall
(
F
.
getCallingConv
(
)
,
F
.
isVarArg
(
)
)
;
FormalArgHandler
ArgHandler
(
MIRBuilder
,
MIRBuilder
.
getMF
(
)
.
getRegInfo
(
)
,
AssignFn
)
;
SmallVector
<
ArgInfo
,
8
>
SplitArgInfos
;
unsigned
Idx
=
0
;
for
(
auto
&
Arg
:
F
.
args
(
)
)
{
ArgInfo
OrigArgInfo
(
VRegs
[
Idx
]
,
Arg
.
getType
(
)
)
;
setArgFlags
(
OrigArgInfo
,
Idx
+
AttributeList
::
FirstArgIndex
,
DL
,
F
)
;
splitToValueTypes
(
OrigArgInfo
,
SplitArgInfos
,
MF
,
[
&
]
(
Register
Reg
)
{
llvm_unreachable
(
"Args should already be split"
)
;
}
)
;
Idx
++
;
}
if
(
!
MBB
.
empty
(
)
)
MIRBuilder
.
setInstr
(
*
MBB
.
begin
(
)
)
;
if
(
!
handleAssignments
(
MIRBuilder
,
SplitArgInfos
,
ArgHandler
)
)
return
false
;
MIRBuilder
.
setMBB
(
MBB
)
;
return
true
;
}
</s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by VRegs , for GlobalISel .

ARM
ARM
ARM
8
0
"Args should already be split"


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

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


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

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


<s> std :: pair < unsigned , const TargetRegisterClass * > LanaiTargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) switch ( Constraint [ 0 ] ) { case 'r' : return std :: make_pair ( 0U , & Lanai :: GPRRegClass ) ; default : break ; } return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> unsigned RISCVInstrInfo :: isLoadFromStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : return 0 ; case RISCV :: LB : case RISCV :: LBU : case RISCV :: LH : case RISCV :: LHU : case RISCV :: FLH : case RISCV :: LW : case RISCV :: FLW : case RISCV :: LWU : case RISCV :: LD : case RISCV :: FLD : break ; } 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>

isLoadFromStackSlot - If the specified machine instruction is a direct load from a stack slot , return the virtual or physical register number of the destination along with the FrameIndex of the loaded stack slot .


<s>
void
RISCVOperand
::
print
(
raw_ostream
&
OS
)
const
{
llvm_unreachable
(
"Not implemented"
)
;
}
</s>

print - Print a debug representation of the operand to the given stream .


<s> bool HexagonCopyToCombine :: runOnMachineFunction ( MachineFunction & MF ) { if ( IsCombinesDisabled ) return false ; bool HasChanged = false ; TRI = MF . getSubtarget ( ) . getRegisterInfo ( ) ; TII = MF . getSubtarget < HexagonSubtarget > ( ) . getInstrInfo ( ) ; const Function * F = MF . getFunction ( ) ; bool OptForSize = F -> hasFnAttribute ( Attribute :: OptimizeForSize ) ; ShouldCombineAggressively = MF . getTarget ( ) . getOptLevel ( ) <= CodeGenOpt :: Default ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { PotentiallyNewifiableTFR . clear ( ) ; findPotentialNewifiableTFRs ( * BI ) ; for ( MachineBasicBlock :: iterator MI = BI -> begin ( ) , End = BI -> end ( ) ; MI != End ; ) { MachineInstr * I1 = MI ++ ; if ( I1 -> isDebugValue ( ) ) continue ; if ( ShouldCombineAggressively && PotentiallyNewifiableTFR . count ( I1 ) ) continue ; if ( ! isCombinableInstType ( I1 , TII , ShouldCombineAggressively ) ) continue ; bool DoInsertAtI1 = false ; DbgMItoMove . clear ( ) ; MachineInstr * I2 = findPairable ( I1 , DoInsertAtI1 , OptForSize ) ; if ( I2 ) { HasChanged = true ; combine ( I1 , I2 , MI , DoInsertAtI1 , OptForSize ) ; } } } return HasChanged ; } </s>

runOnMachineFunction - Emit the function body .


<s>
ScheduleHazardRecognizer
::
HazardType
TMS320C64XHazardRecognizer
::
getHazardType
(
SUnit
*
SU
,
int
stalls
)
{
if
(
isPseudo
(
SU
)
)
return
NoHazard
;
if
(
isMove
(
SU
)
)
return
getMoveHazard
(
SU
)
;
fixResources
(
SU
)
;
unsigned
idx
=
getUnitIndex
(
SU
)
;
if
(
Hzd
->
isUnitBusy
(
idx
)
)
{
DEBUG
(
dbgUnitBusy
(
SU
,
idx
)
)
;
return
NoopHazard
;
}
unsigned
xuse
=
getExtraUse
(
SU
)
;
if
(
Hzd
->
isXResBusy
(
xuse
)
)
{
DEBUG
(
dbgExtraBusy
(
SU
,
xuse
)
)
;
return
NoopHazard
;
}
DEBUG
(
dbgs
(
)
<<
"--no hazard\n"
)
;
return
NoHazard
;
}
</s>

getHazardType - Return the hazard type of emitting this node .


"invalid conversion from type %<bfloat16_t%>"

"invalid conversion to type %<bfloat16_t%>"

Return the diagnostic message string if conversion from FROMTYPE to TOTYPE is not allowed , NULL otherwise .


<s>
void
Hexagon_CCState
::
AnalyzeReturn
(
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
Hexagon_CCAssignFn
Fn
,
unsigned
SretValueInRegs
)
{
if
(
SretValueInRegs
!=
0
)
{
if
(
SretValueInRegs
<=
32
)
{
unsigned
Reg
=
Hexagon
::
R0
;
addLoc
(
CCValAssign
::
getReg
(
0
,
MVT
::
i32
,
Reg
,
MVT
::
i32
,
CCValAssign
::
Full
)
)
;
return
;
}
if
(
SretValueInRegs
<=
64
)
{
unsigned
Reg
=
Hexagon
::
D0
;
addLoc
(
CCValAssign
::
getReg
(
0
,
MVT
::
i64
,
Reg
,
MVT
::
i64
,
CCValAssign
::
Full
)
)
;
return
;
}
}
for
(
unsigned
i
=
0
,
e
=
Outs
.
size
(
)
;
i
!=
e
;
++
i
)
{
EVT
VT
=
Outs
[
i
]
.
VT
;
ISD
::
ArgFlagsTy
ArgFlags
=
Outs
[
i
]
.
Flags
;
if
(
Fn
(
i
,
VT
,
VT
,
CCValAssign
::
Full
,
ArgFlags
,
*
this
,
1
,
1
,
false
)
)
{
dbgs
(
)
<<
"Return operand #"
<<
i
<<
" has unhandled type "
<<
VT
.
getEVTString
(
)
<<
"\n"
;
abort
(
)
;
}
}
}
</s>

AnalyzeReturn - Analyze the returned values of a return , incorporating info about the result values into this state .


<s> static bool need_to_save ( unsigned int regno ) { if ( is_interrupt_func ( cfun -> decl ) ) { if ( regno < 8 ) return true ; if ( regno > 23 ) return false ; if ( ! crtl -> is_leaf && call_used_regs [ regno ] && regno < 22 ) return true ; return df_regs_ever_live_p ( regno ) ; } if ( regno == FRAME_POINTER_REGNUM && ( frame_pointer_needed || df_regs_ever_live_p ( regno ) ) ) return true ; if ( fixed_regs [ regno ] ) return false ; if ( crtl -> calls_eh_return ) return true ; if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return true ; return false ; } </s>

Returns true if the given register needs to be saved by the current function .


<s> virtual bool runOnMachineFunction ( MachineFunction & MF ) { LIS = & getAnalysis < LiveIntervals > ( ) ; TM = static_cast < const PPCTargetMachine * > ( & MF . getTarget ( ) ) ; TII = TM -> getInstrInfo ( ) ; bool Changed = false ; if ( DisableVSXFMAMutate ) return Changed ; for ( MachineFunction :: iterator I = MF . begin ( ) ; I != MF . end ( ) ; ) { MachineBasicBlock & B = * I ++ ; if ( processBlock ( B ) ) Changed = true ; } return Changed ; } </s>


<s> const char * SparcTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( ( SPISD :: NodeType ) Opcode ) { case SPISD :: FIRST_NUMBER : break ; case SPISD :: CMPICC : return "SPISD::CMPICC" ; case SPISD :: CMPFCC : return "SPISD::CMPFCC" ; case SPISD :: BRICC : return "SPISD::BRICC" ; case SPISD :: BRXCC : return "SPISD::BRXCC" ; case SPISD :: BRFCC : return "SPISD::BRFCC" ; case SPISD :: SELECT_ICC : return "SPISD::SELECT_ICC" ; case SPISD :: SELECT_XCC : return "SPISD::SELECT_XCC" ; case SPISD :: SELECT_FCC : return "SPISD::SELECT_FCC" ; case SPISD :: Hi : return "SPISD::Hi" ; case SPISD :: Lo : return "SPISD::Lo" ; case SPISD :: FTOI : return "SPISD::FTOI" ; case SPISD :: ITOF : return "SPISD::ITOF" ; case SPISD :: FTOX : return "SPISD::FTOX" ; case SPISD :: XTOF : return "SPISD::XTOF" ; case SPISD :: CALL : return "SPISD::CALL" ; case SPISD :: RET_FLAG : return "SPISD::RET_FLAG" ; case SPISD :: GLOBAL_BASE_REG : return "SPISD::GLOBAL_BASE_REG" ; case SPISD :: FLUSHW : return "SPISD::FLUSHW" ; case SPISD :: TLS_ADD : return "SPISD::TLS_ADD" ; case SPISD :: TLS_LD : return "SPISD::TLS_LD" ; case SPISD :: TLS_CALL : return "SPISD::TLS_CALL" ; case SPISD :: TAIL_CALL : return "SPISD::TAIL_CALL" ; } return nullptr ; } </s>

getTargetNodeName - This method returns the name of a target specific


<s> MachineInstrBuilder SIInstrInfo :: buildIndirectWrite ( MachineBasicBlock * MBB , MachineBasicBlock :: iterator I , unsigned ValueReg , unsigned Address , unsigned OffsetReg ) const { const DebugLoc & DL = MBB -> findDebugLoc ( I ) ; unsigned IndirectBaseReg = AMDGPU :: VGPR_32RegClass . getRegister ( getIndirectIndexBegin ( * MBB -> getParent ( ) ) ) ; return BuildMI ( * MBB , I , DL , get ( AMDGPU :: SI_INDIRECT_DST_V1 ) ) . addReg ( IndirectBaseReg , RegState :: Define ) . addOperand ( I -> getOperand ( 0 ) ) . addReg ( IndirectBaseReg ) . addReg ( OffsetReg ) . addImm ( 0 ) . addReg ( ValueReg ) ; } </s>

Build instruction ( s ) for an indirect register write .


<s> static rtx arm_function_value ( const_tree type , const_tree func , bool outgoing ATTRIBUTE_UNUSED ) { machine_mode mode ; int unsignedp ATTRIBUTE_UNUSED ; rtx r ATTRIBUTE_UNUSED ; mode = TYPE_MODE ( type ) ; if ( TARGET_AAPCS_BASED ) return aapcs_allocate_return_reg ( mode , type , func ) ; if ( INTEGRAL_TYPE_P ( type ) ) mode = arm_promote_function_mode ( type , mode , & unsignedp , func , 1 ) ; if ( arm_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( size % UNITS_PER_WORD != 0 ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , 0 ) ; } } return arm_libcall_value_1 ( mode ) ; } </s>

Define how to find the value returned by a function .


<s> unsigned getID ( ) const { return ID ; } </s>


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

The INIT_EXPANDERS worker sets the per-function-data initializer and mark functions .


<s> int riscv_regno_mode_ok_for_base_p ( int regno , enum machine_mode mode ATTRIBUTE_UNUSED , bool strict_p ) { if ( ! HARD_REGISTER_NUM_P ( regno ) ) { if ( ! strict_p ) return true ; regno = reg_renumber [ regno ] ; } if ( regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM ) return true ; return GP_REG_P ( regno ) ; } </s>

Return true if register REGNO is a valid base register for mode MODE . STRICT_P is true if REG_OK_STRICT is in effect .


<s> Optional < Instruction * > AArch64TTIImpl :: instCombineIntrinsic ( InstCombiner & IC , IntrinsicInst & II ) const { Intrinsic :: ID IID = II . getIntrinsicID ( ) ; switch ( IID ) { default : break ; case Intrinsic :: aarch64_sve_convert_from_svbool : return instCombineConvertFromSVBool ( IC , II ) ; case Intrinsic :: aarch64_sve_dup : return instCombineSVEDup ( IC , II ) ; case Intrinsic :: aarch64_sve_dup_x : return instCombineSVEDupX ( IC , II ) ; case Intrinsic :: aarch64_sve_cmpne : case Intrinsic :: aarch64_sve_cmpne_wide : return instCombineSVECmpNE ( IC , II ) ; case Intrinsic :: aarch64_sve_rdffr : return instCombineRDFFR ( IC , II ) ; case Intrinsic :: aarch64_sve_lasta : case Intrinsic :: aarch64_sve_lastb : return instCombineSVELast ( IC , II ) ; case Intrinsic :: aarch64_sve_cntd : return instCombineSVECntElts ( IC , II , 2 ) ; case Intrinsic :: aarch64_sve_cntw : return instCombineSVECntElts ( IC , II , 4 ) ; case Intrinsic :: aarch64_sve_cnth : return instCombineSVECntElts ( IC , II , 8 ) ; case Intrinsic :: aarch64_sve_cntb : return instCombineSVECntElts ( IC , II , 16 ) ; case Intrinsic :: aarch64_sve_ptest_any : case Intrinsic :: aarch64_sve_ptest_first : case Intrinsic :: aarch64_sve_ptest_last : return instCombineSVEPTest ( IC , II ) ; case Intrinsic :: aarch64_sve_mul : case Intrinsic :: aarch64_sve_fmul : return instCombineSVEVectorMul ( IC , II ) ; case Intrinsic :: aarch64_sve_tbl : return instCombineSVETBL ( IC , II ) ; case Intrinsic :: aarch64_sve_uunpkhi : case Intrinsic :: aarch64_sve_uunpklo : case Intrinsic :: aarch64_sve_sunpkhi : case Intrinsic :: aarch64_sve_sunpklo : return instCombineSVEUnpack ( IC , II ) ; case Intrinsic :: aarch64_sve_zip1 : case Intrinsic :: aarch64_sve_zip2 : return instCombineSVEZip ( IC , II ) ; } return None ; } </s>

Targets can implement their own combinations for target-specific intrinsics .


<s> static void ix86_output_jmp_thunk_or_indirect ( const char * thunk_name , const int regno ) { if ( thunk_name != NULL ) { if ( REX_INT_REGNO_P ( regno ) && ix86_indirect_branch_cs_prefix ) fprintf ( asm_out_file , "\tcs\n" ) ; fprintf ( asm_out_file , "\tjmp\t" ) ; assemble_name ( asm_out_file , thunk_name ) ; putc ( '\n' , asm_out_file ) ; if ( ( ix86_harden_sls & harden_sls_indirect_jmp ) ) fputs ( "\tint3\n" , asm_out_file ) ; } else output_indirect_thunk ( regno ) ; } </s>


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"TMS320C64X Delay Slot Filler"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool TPCRegisterInfo :: getRegAllocationHints ( unsigned VirtReg , ArrayRef < MCPhysReg > Order , SmallVectorImpl < MCPhysReg > & Hints , const MachineFunction & MF , const VirtRegMap * VRM , const LiveRegMatrix * Matrix ) const { const MachineRegisterInfo * MRI = & MF . getRegInfo ( ) ; const TargetRegisterInfo * TRI = MF . getSubtarget ( ) . getRegisterInfo ( ) ; const TargetRegisterClass * RC = MRI -> getRegClass ( VirtReg ) ; SmallSet < unsigned , 4 > ConnectedPhysRegs ; for ( auto & Use : MRI -> use_instructions ( VirtReg ) ) { if ( Use . isCopy ( ) ) { Register PhysReg ; MachineOperand & DstMO = Use . getOperand ( 0 ) ; MachineOperand & SrcMO = Use . getOperand ( 1 ) ; MachineOperand * VirtRegMO = nullptr ; if ( DstMO . getReg ( ) . isPhysical ( ) ) { PhysReg = DstMO . getReg ( ) ; if ( DstMO . getSubReg ( ) ) PhysReg = TRI -> getSubReg ( PhysReg , DstMO . getSubReg ( ) ) ; VirtRegMO = & SrcMO ; } else if ( SrcMO . getReg ( ) . isPhysical ( ) ) { PhysReg = SrcMO . getReg ( ) ; if ( SrcMO . getSubReg ( ) ) PhysReg = TRI -> getSubReg ( PhysReg , SrcMO . getSubReg ( ) ) ; VirtRegMO = & DstMO ; } if ( ! PhysReg ) continue ; if ( RC -> contains ( PhysReg ) ) { ConnectedPhysRegs . insert ( PhysReg ) ; continue ; } if ( VirtRegMO -> getSubReg ( ) != TPC :: NoSubRegister ) { if ( unsigned SuperReg = TRI -> getMatchingSuperReg ( PhysReg , VirtRegMO -> getSubReg ( ) , RC ) ) ConnectedPhysRegs . insert ( SuperReg ) ; } } } if ( ! ConnectedPhysRegs . empty ( ) ) { for ( MCPhysReg Reg : Order ) if ( ConnectedPhysRegs . count ( Reg ) && ! MRI -> isReserved ( Reg ) ) Hints . push_back ( Reg ) ; } return TargetRegisterInfo :: getRegAllocationHints ( VirtReg , Order , Hints , MF , VRM ) ; } </s>

Get a list of 'hint ' registers that the register allocator should try first when allocating a physical register for the virtual register VirtReg .


<s> int group1_reg_operand ( rtx op , enum machine_mode mode ) { if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return 0 ; if ( GET_CODE ( op ) == SUBREG ) op = SUBREG_REG ( op ) ; return REG_P ( op ) && ( ! reload_completed || IS_GROUP1_REG ( op ) ) ; } </s>

The following predicates are used for instruction scheduling .


<s> static tree ATTRIBUTE_UNUSED rs6000_stack_protect_fail ( void ) { return ( DEFAULT_ABI == ABI_V4 && TARGET_SECURE_PLT && flag_pic ) ? default_hidden_stack_protect_fail ( ) : default_external_stack_protect_fail ( ) ; } </s>

For TARGET_SECURE_PLT 32-bit PIC code we can save PIC register setup by using __stack_chk_fail_local hidden function instead of calling __stack_chk_fail directly . Otherwise it is better to call __stack_chk_fail directly .


"Unmatched number of shufflevectors and indices"

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


"sret virtual register not created in the entry block"

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


<s> static rtx ix86_expand_vec_init_builtin ( tree type , tree exp , rtx target ) { machine_mode tmode = TYPE_MODE ( type ) ; machine_mode inner_mode = GET_MODE_INNER ( tmode ) ; int i , n_elt = GET_MODE_NUNITS ( tmode ) ; rtvec v = rtvec_alloc ( n_elt ) ; gcc_assert ( VECTOR_MODE_P ( tmode ) ) ; gcc_assert ( call_expr_nargs ( exp ) == n_elt ) ; for ( i = 0 ; i < n_elt ; ++ i ) { rtx x = expand_normal ( CALL_EXPR_ARG ( exp , i ) ) ; RTVEC_ELT ( v , i ) = gen_lowpart ( inner_mode , x ) ; } if ( ! target || ! register_operand ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; ix86_expand_vector_init ( true , target , gen_rtx_PARALLEL ( tmode , v ) ) ; return target ; } </s>

A subroutine of ix86_expand_builtin . These builtins are a wrapper around ix86_expand_vector_init . We DO have language-level syntax for this , in the form of ( type ) { init-list } . Except that since we ca n't place emms instructions from inside the compiler , we ca n't allow the use of MMX registers unless the user explicitly asks for it . So we do * not * define vec_set/vec_extract/vec_init patterns for MMX modes in mmx.md . Instead we have builtins invoked by mmintrin.h that gives us license to emit these sorts of instructions .


<s> bool ix86_cannot_change_mode_class ( machine_mode from , machine_mode to , enum reg_class regclass ) { if ( from == to ) return false ; if ( MAYBE_FLOAT_CLASS_P ( regclass ) ) return true ; if ( MAYBE_SSE_CLASS_P ( regclass ) || MAYBE_MMX_CLASS_P ( regclass ) ) { if ( GET_MODE_SIZE ( from ) < 4 ) return true ; } return false ; } </s>

Return true if the registers in CLASS can not represent the change from modes FROM to TO .


<s> bool PPCTTIImpl :: isHardwareLoopProfitable ( Loop * L , ScalarEvolution & SE , AssumptionCache & AC , TargetLibraryInfo * LibInfo , HardwareLoopInfo & HWLoopInfo ) { const PPCTargetMachine & TM = ST -> getTargetMachine ( ) ; TargetSchedModel SchedModel ; SchedModel . init ( ST ) ; unsigned ConstTripCount = SE . getSmallConstantTripCount ( L ) ; if ( ConstTripCount && ConstTripCount < SmallCTRLoopThreshold ) { SmallPtrSet < const Value * , 32 > EphValues ; CodeMetrics :: collectEphemeralValues ( L , & AC , EphValues ) ; CodeMetrics Metrics ; for ( BasicBlock * BB : L -> blocks ( ) ) Metrics . analyzeBasicBlock ( BB , * this , EphValues ) ; if ( Metrics . NumInsts <= ( 6 * SchedModel . getIssueWidth ( ) ) ) return false ; } SmallPtrSet < const Value * , 4 > Visited ; for ( Loop :: block_iterator I = L -> block_begin ( ) , IE = L -> block_end ( ) ; I != IE ; ++ I ) if ( mightUseCTR ( * I , LibInfo , Visited ) ) return false ; SmallVector < BasicBlock * , 4 > ExitingBlocks ; L -> getExitingBlocks ( ExitingBlocks ) ; for ( auto & BB : ExitingBlocks ) { Instruction * TI = BB -> getTerminator ( ) ; if ( ! TI ) continue ; if ( BranchInst * BI = dyn_cast < BranchInst > ( TI ) ) { uint64_t TrueWeight = 0 , FalseWeight = 0 ; if ( ! BI -> isConditional ( ) || ! BI -> extractProfMetadata ( TrueWeight , FalseWeight ) ) continue ; bool TrueIsExit = ! L -> contains ( BI -> getSuccessor ( 0 ) ) ; if ( ( TrueIsExit && FalseWeight < TrueWeight ) || ( ! TrueIsExit && FalseWeight > TrueWeight ) ) return false ; } } LLVMContext & C = L -> getHeader ( ) -> getContext ( ) ; HWLoopInfo . CountType = TM . isPPC64 ( ) ? Type :: getInt64Ty ( C ) : Type :: getInt32Ty ( C ) ; HWLoopInfo . LoopDecrement = ConstantInt :: get ( HWLoopInfo . CountType , 1 ) ; return true ; } </s>

Query the target whether it would be profitable to convert the given loop into a hardware loop .


<s> static bool tilegx_emit_setcc_internal ( rtx res , enum rtx_code code , rtx op0 , rtx op1 , machine_mode cmp_mode ) { rtx tmp ; bool swap = false ; if ( cmp_mode == SFmode || cmp_mode == DFmode ) return tilegx_emit_fp_setcc ( res , code , cmp_mode , op0 , op1 ) ; switch ( code ) { case EQ : case NE : case LE : case LT : case LEU : case LTU : break ; case GE : case GT : case GEU : case GTU : swap = true ; break ; default : gcc_unreachable ( ) ; } if ( swap ) { code = swap_condition ( code ) ; tmp = op0 , op0 = op1 , op1 = tmp ; } if ( ! reg_or_0_operand ( op0 , cmp_mode ) ) op0 = force_reg ( cmp_mode , op0 ) ; if ( ! CONST_INT_P ( op1 ) && ! register_operand ( op1 , cmp_mode ) ) op1 = force_reg ( cmp_mode , op1 ) ; emit_insn ( gen_rtx_SET ( res , gen_rtx_fmt_ee ( code , DImode , op0 , op1 ) ) ) ; return true ; } </s>

Certain simplifications can be done to make invalid setcc operations valid . Return the final comparison , or NULL if we ca n't work .


<s> void ix86_call_abi_override ( const_tree fndecl ) { cfun -> machine -> call_abi = ix86_function_abi ( fndecl ) ; } </s>

Implementation of call abi switching target hook . Specific to FNDECL the specific call register sets are set . See also ix86_conditional_register_usage for more details .


<s> void VEInstPrinter :: printRegName ( raw_ostream & OS , unsigned RegNo ) const { unsigned AltIdx = VE :: AsmName ; if ( MRI . getRegClass ( VE :: MISCRegClassID ) . contains ( RegNo ) ) AltIdx = VE :: NoRegAltName ; OS << '%' << getRegisterName ( RegNo , AltIdx ) ; } </s>

VE VE VE::AsmName VE::MISCRegClassID VE::NoRegAltName


<s> bool ARMBaseInstrInfo :: SubsumesPredicate ( const SmallVectorImpl < MachineOperand > & Pred1 , const SmallVectorImpl < MachineOperand > & Pred2 ) const { if ( Pred1 . size ( ) > 2 || Pred2 . size ( ) > 2 ) return false ; ARMCC :: CondCodes CC1 = ( ARMCC :: CondCodes ) Pred1 [ 0 ] . getImm ( ) ; ARMCC :: CondCodes CC2 = ( ARMCC :: CondCodes ) Pred2 [ 0 ] . getImm ( ) ; if ( CC1 == CC2 ) return true ; switch ( CC1 ) { default : return false ; case ARMCC :: AL : return true ; case ARMCC :: HS : return CC2 == ARMCC :: HI ; case ARMCC :: LS : return CC2 == ARMCC :: LO || CC2 == ARMCC :: EQ ; case ARMCC :: GE : return CC2 == ARMCC :: GT ; case ARMCC :: LE : return CC2 == ARMCC :: LT ; } } </s>

Returns true if the first specified predicate subsumes the second , e.g .

ARM ARM 2 2 ARMCC::CondCodes ARMCC::CondCodes 0 ARMCC::CondCodes ARMCC::CondCodes 0 ARMCC::AL ARMCC::HS ARMCC::HI ARMCC::LS ARMCC::LO ARMCC::EQ ARMCC::GE ARMCC::GT ARMCC::LE ARMCC::LT


<s> bool ARMTargetLowering :: mayBeEmittedAsTailCall ( CallInst * CI ) const { if ( ! EnableARMTailCalls ) return false ; if ( ! CI -> isTailCall ( ) ) return false ; return ! Subtarget -> isThumb1Only ( ) ; } </s>

Return true if the target may be able emit the call instruction as a tail call .


<s> bool X86TileConfig :: runOnMachineFunction ( MachineFunction & mf ) { MF = & mf ; MRI = & mf . getRegInfo ( ) ; ST = & mf . getSubtarget < X86Subtarget > ( ) ; TRI = ST -> getRegisterInfo ( ) ; TII = mf . getSubtarget ( ) . getInstrInfo ( ) ; DomTree = & getAnalysis < MachineDominatorTree > ( ) ; VRM = & getAnalysis < VirtRegMap > ( ) ; LIS = & getAnalysis < LiveIntervals > ( ) ; if ( VRM -> isShapeMapEmpty ( ) ) return false ; tileConfig ( ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Mips Delay Slot Filler"
;
}
</s>


<s> unsigned AArch64TargetLowering :: getVaListSizeInBits ( const DataLayout & DL ) const { if ( Subtarget -> isTargetDarwin ( ) ) return getPointerTy ( DL ) . getSizeInBits ( ) ; return 3 * getPointerTy ( DL ) . getSizeInBits ( ) + 2 * 32 ; } </s>

Returns the size of the platform 's va_list object .


<s> void XtensaPassConfig :: addPreEmitPass ( ) { } </s>

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


<s> static void alpha_output_mi_thunk_osf ( FILE * file , tree thunk_fndecl ATTRIBUTE_UNUSED , HOST_WIDE_INT delta , HOST_WIDE_INT vcall_offset , tree function ) { HOST_WIDE_INT hi , lo ; rtx this_rtx , funexp ; rtx_insn * insn ; emit_insn ( gen_prologue_ldgp ( ) ) ; emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , 17 ) ; else this_rtx = gen_rtx_REG ( Pmode , 16 ) ; lo = ( ( delta & 0xffff ) ^ 0x8000 ) - 0x8000 ; hi = ( ( ( delta - lo ) & 0xffffffff ) ^ 0x80000000 ) - 0x80000000 ; if ( hi + lo == delta ) { if ( hi ) emit_insn ( gen_adddi3 ( this_rtx , this_rtx , GEN_INT ( hi ) ) ) ; if ( lo ) emit_insn ( gen_adddi3 ( this_rtx , this_rtx , GEN_INT ( lo ) ) ) ; } else { rtx tmp = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , 0 ) , delta , - ( delta < 0 ) ) ; emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( vcall_offset ) { rtx tmp , tmp2 ; tmp = gen_rtx_REG ( Pmode , 0 ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , this_rtx ) ) ; lo = ( ( vcall_offset & 0xffff ) ^ 0x8000 ) - 0x8000 ; hi = ( ( ( vcall_offset - lo ) & 0xffffffff ) ^ 0x80000000 ) - 0x80000000 ; if ( hi + lo == vcall_offset ) { if ( hi ) emit_insn ( gen_adddi3 ( tmp , tmp , GEN_INT ( hi ) ) ) ; } else { tmp2 = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , 1 ) , vcall_offset , - ( vcall_offset < 0 ) ) ; emit_insn ( gen_adddi3 ( tmp , tmp , tmp2 ) ) ; lo = 0 ; } if ( lo ) tmp2 = gen_rtx_PLUS ( Pmode , tmp , GEN_INT ( lo ) ) ; else tmp2 = tmp ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp2 ) ) ; emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = 1 ; } funexp = XEXP ( DECL_RTL ( function ) , 0 ) ; funexp = gen_rtx_MEM ( FUNCTION_MODE , funexp ) ; insn = emit_call_insn ( gen_sibcall ( funexp , const0_rtx ) ) ; SIBLING_CALL_P ( insn ) = 1 ; insn = get_insns ( ) ; shorten_branches ( insn ) ; final_start_function ( insn , file , 1 ) ; final ( insn , file , 1 ) ; final_end_function ( ) ; } </s>

Emit a tail call to FUNCTION after adjusting THIS by DELTA . In order to avoid the hordes of differences between generated code with and without TARGET_EXPLICIT_RELOCS , and to avoid duplicating lots of code loading up large constants , generate rtl and emit it instead of going straight to text . Not sure why this idea has n't been explored before ...


<s>
void
Hexagon_CCState
::
AnalyzeFormalArguments
(
const
SmallVectorImpl
<
ISD
::
InputArg
>
&
Ins
,
Hexagon_CCAssignFn
Fn
,
unsigned
SretValueInRegs
)
{
unsigned
NumArgs
=
Ins
.
size
(
)
;
unsigned
i
=
0
;
if
(
SretValueInRegs
!=
0
)
{
++
i
;
}
for
(
;
i
!=
NumArgs
;
++
i
)
{
EVT
ArgVT
=
Ins
[
i
]
.
VT
;
ISD
::
ArgFlagsTy
ArgFlags
=
Ins
[
i
]
.
Flags
;
if
(
Fn
(
i
,
ArgVT
,
ArgVT
,
CCValAssign
::
Full
,
ArgFlags
,
*
this
,
0
,
0
,
false
)
)
{
dbgs
(
)
<<
"Formal argument #"
<<
i
<<
" has unhandled type "
<<
ArgVT
.
getEVTString
(
)
<<
"\n"
;
abort
(
)
;
}
}
}
</s>

AnalyzeFormalArguments - Analyze an array of argument values , incorporating info about the formals into this state .

Hexagon
Hexagon
ISD::InputArg
Hexagon
0
0
ISD::ArgFlagsTy
0
0
"Formal argument #"
" has unhandled type "
"\n"


<s> machreg_t semctl ( machreg_t semid , machreg_t semnum , machreg_t cmd , machreg_t arg ) { return _semctl ( semid , semnum , cmd , arg << SHIFT_BITS ) ; } </s>

< sys/sem.h > has int semctl ( int , int , int , ... ) ; where the variadic argument is union semun if used . union semun contains an int and two pointers , so the union is already 64 bits wide under the N64 ABI and alignment is not an issue .


"Instr doesn't have FrameIndex operand!"

This method must be overriden to eliminate abstract frame indices from instructions which may use them .


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
override
{
const
static
MCFixupKindInfo
Infos
[
MMIX
::
NumTargetFixupKinds
]
=
{
{
"fixup_mmix_rel_16"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_mmix_rel_24"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_mmix_h"
,
0
,
16
,
0
}
,
{
"fixup_mmix_mh"
,
0
,
16
,
0
}
,
{
"fixup_mmix_ml"
,
0
,
16
,
0
}
,
{
"fixup_mmix_l"
,
0
,
16
,
0
}
}
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


"%s as it already contains this value\n"

Generate and emit a move of ( register ) FROM into TO . if WHERE is not NULL then if BEFORE is true then emit the insn before WHERE , otherwise emit it after WHERE . If TO already contains FROM then do nothing . Returns TO if BEFORE is true , FROM otherwise .


<s>
StringRef
getPassName
(
)
const
override
{
return
"ARC Expand Pseudos"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> MCObjectWriter * createObjectWriter ( raw_ostream & OS ) const override { return createARMMachObjectWriter ( OS , false , MachO :: CPU_TYPE_ARM , Subtype ) ; } </s>

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


<s> static void ix86_finish_cost ( void * data , unsigned * prologue_cost , unsigned * body_cost , unsigned * epilogue_cost ) { unsigned * cost = ( unsigned * ) data ; * prologue_cost = cost [ vect_prologue ] ; * body_cost = cost [ vect_body ] ; * epilogue_cost = cost [ vect_epilogue ] ; } </s>


<s> static bool rs6000_discover_homogeneous_aggregate ( machine_mode mode , const_tree type , machine_mode * elt_mode , int * n_elts ) { if ( DEFAULT_ABI == ABI_ELFv2 && type && AGGREGATE_TYPE_P ( type ) ) { machine_mode field_mode = VOIDmode ; int field_count = rs6000_aggregate_candidate ( type , & field_mode ) ; if ( field_count > 0 ) { int n_regs = ( SCALAR_FLOAT_MODE_P ( field_mode ) ? ( GET_MODE_SIZE ( field_mode ) + 7 ) >> 3 : 1 ) ; if ( field_count * n_regs <= AGGR_ARG_NUM_REG ) { if ( elt_mode ) * elt_mode = field_mode ; if ( n_elts ) * n_elts = field_count ; return true ; } } } if ( elt_mode ) * elt_mode = mode ; if ( n_elts ) * n_elts = 1 ; return false ; } </s>

If an argument , whose type is described by TYPE and MODE , is a homogeneous float or vector aggregate that shall be passed in FP/vector registers according to the ELFv2 ABI , return the homogeneous element mode in * ELT_MODE and the number of elements in * N_ELTS , and return TRUE . Otherwise , set * ELT_MODE to MODE and * N_ELTS to 1 , and return FALSE .


"TOY DAG->DAG Pattern Instruction Selection"


<s> virtual int getInstrLatency ( const InstrItineraryData * ItinData , SDNode * Node ) const { return 1 ; } </s>

Compute the instruction latency of a given instruction .


<s> bool X86ATTAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getIdentifier ( ) ; if ( IDVal == ".word" ) return ParseDirectiveWord ( 2 , DirectiveID . getLoc ( ) ) ; else if ( IDVal . startswith ( ".code" ) ) return ParseDirectiveCode ( IDVal , DirectiveID . getLoc ( ) ) ; return true ; } </s>

ParseDirective - Parse a target specific assembler directive This method is deprecated , use 'parseDirective ' instead .


<s> bool Error ( SMLoc L , const Twine & Msg ) { return Parser . Error ( L , Msg ) ; } </s>

Return an error at the location L , with the message Msg .


"Can't store this register to stack slot"

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


<s> MachineInstrBuilder SIInstrInfo :: getAddNoCarry ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , const DebugLoc & DL , unsigned DestReg ) const { MachineRegisterInfo & MRI = MBB . getParent ( ) -> getRegInfo ( ) ; unsigned UnusedCarry = MRI . createVirtualRegister ( & AMDGPU :: SReg_64RegClass ) ; return BuildMI ( MBB , I , DL , get ( AMDGPU :: V_ADD_I32_e64 ) , DestReg ) . addReg ( UnusedCarry , RegState :: Define | RegState :: Dead ) ; } </s>

Return a partially built integer add instruction without carry .


"internal compiler error.  Incorrect shift:"

8bit logic shift right ( ( unsigned char ) x > > i )


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) { rtx x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ; rtx_insn * insn = emit_jump_insn ( gen_rtx_SET ( pc_rtx , x ) ) ; add_reg_br_prob_note ( insn , profile_probability :: very_unlikely ( ) ) ; } </s>

Mark the previous jump instruction as unlikely .


<s> TargetLowering :: ConstraintWeight AArch64TargetLowering :: getSingleConstraintMatchWeight ( AsmOperandInfo & info , const char * constraint ) const { ConstraintWeight weight = CW_Invalid ; Value * CallOperandVal = info . CallOperandVal ; if ( ! CallOperandVal ) return CW_Default ; Type * type = CallOperandVal -> getType ( ) ; switch ( * constraint ) { default : weight = TargetLowering :: getSingleConstraintMatchWeight ( info , constraint ) ; break ; case 'x' : case 'w' : case 'y' : if ( type -> isFloatingPointTy ( ) || type -> isVectorTy ( ) ) weight = CW_Register ; break ; case 'z' : weight = CW_Constant ; break ; case 'U' : if ( parsePredicateConstraint ( constraint ) != PredicateConstraint :: Invalid ) weight = CW_Register ; break ; } return weight ; } </s>

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


<s>
Type
*
getParamType
(
unsigned
Param
)
const
{
assert
(
AllParams
.
count
(
Param
)
==
1
&&
"Param has not been defined!"
)
;
return
ParamTypes
.
find
(
Param
)
->
second
;
}
</s>


<s> Register X86TargetLowering :: getExceptionSelectorRegister ( const Constant * PersonalityFn ) const { if ( isFuncletEHPersonality ( classifyEHPersonality ( PersonalityFn ) ) ) return X86 :: NoRegister ; return Subtarget . isTarget64BitLP64 ( ) ? X86 :: RDX : X86 :: EDX ; } </s>

If a physical register , this returns the register that receives the exception typeid on entry to a landing pad .


<s> bool rs6000_output_addr_const_extra ( FILE * file , rtx x ) { if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , 1 ) ) { case UNSPEC_TOCREL : gcc_checking_assert ( SYMBOL_REF_P ( XVECEXP ( x , 0 , 0 ) ) && REG_P ( XVECEXP ( x , 0 , 1 ) ) && REGNO ( XVECEXP ( x , 0 , 1 ) ) == TOC_REGISTER ) ; output_addr_const ( file , XVECEXP ( x , 0 , 0 ) ) ; if ( x == tocrel_base_oac && tocrel_offset_oac != const0_rtx ) { if ( INTVAL ( tocrel_offset_oac ) >= 0 ) fprintf ( file , "+" ) ; output_addr_const ( file , CONST_CAST_RTX ( tocrel_offset_oac ) ) ; } if ( ! TARGET_AIX || ( TARGET_ELF && TARGET_MINIMAL_TOC ) ) { putc ( '-' , file ) ; assemble_name ( file , toc_label_name ) ; need_toc_init = 1 ; } else if ( TARGET_ELF ) fputs ( "@toc" , file ) ; return true ; case UNSPEC_MACHOPIC_OFFSET : output_addr_const ( file , XVECEXP ( x , 0 , 0 ) ) ; putc ( '-' , file ) ; machopic_output_function_base_name ( file ) ; return true ; } return false ; } </s>


<s> Register VERegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { return VE :: SX9 ; } </s>


" Instructions Emitted in this clause\n"

ScheduleDAGMI has scheduled an instruction - tell HazardRec about it .


<s>
bool
ARMBaseInstrInfo
::
getInsertSubregLikeInputs
(
const
MachineInstr
&
MI
,
unsigned
DefIdx
,
RegSubRegPair
&
BaseReg
,
RegSubRegPairAndIdx
&
InsertedReg
)
const
{
assert
(
DefIdx
<
MI
.
getDesc
(
)
.
getNumDefs
(
)
&&
"Invalid definition index"
)
;
assert
(
MI
.
isInsertSubregLike
(
)
&&
"Invalid kind of instruction"
)
;
switch
(
MI
.
getOpcode
(
)
)
{
case
ARM
::
VSETLNi32
:
const
MachineOperand
&
MOBaseReg
=
MI
.
getOperand
(
1
)
;
const
MachineOperand
&
MOInsertedReg
=
MI
.
getOperand
(
2
)
;
const
MachineOperand
&
MOIndex
=
MI
.
getOperand
(
3
)
;
BaseReg
.
Reg
=
MOBaseReg
.
getReg
(
)
;
BaseReg
.
SubReg
=
MOBaseReg
.
getSubReg
(
)
;
InsertedReg
.
Reg
=
MOInsertedReg
.
getReg
(
)
;
InsertedReg
.
SubReg
=
MOInsertedReg
.
getSubReg
(
)
;
InsertedReg
.
SubIdx
=
MOIndex
.
getImm
(
)
==
0
ARM
::
ssub_0
:
ARM
::
ssub_1
;
return
true
;
}
llvm_unreachable
(
"Target dependent opcode missing"
)
;
}
</s>

Target-dependent implementation of getInsertSubregInputs .


"Unexpected data type for Gather/Scatter"

Calculate the cost of Gather / Scatter operation .


<s> static vector_costs * rs6000_vectorize_create_costs ( vec_info * vinfo , bool costing_for_scalar ) { return new rs6000_cost_data ( vinfo , costing_for_scalar ) ; } </s>


<s> static const char * get_round_mode_suffix ( ) { enum attr_round_suffix s = get_attr_round_suffix ( current_output_insn ) ; switch ( s ) { case ROUND_SUFFIX_NONE : return NULL ; case ROUND_SUFFIX_NORMAL : switch ( alpha_fprm ) { case ALPHA_FPRM_NORM : return NULL ; case ALPHA_FPRM_MINF : return "m" ; case ALPHA_FPRM_CHOP : return "c" ; case ALPHA_FPRM_DYN : return "d" ; } break ; case ROUND_SUFFIX_C : return "c" ; } abort ( ) ; } </s>

Return the rounding mode suffix applicable to the current instruction , or NULL .


<s> static rtx safe_vector_operand ( rtx x , enum machine_mode mode ) { if ( x != const0_rtx ) return x ; x = gen_reg_rtx ( mode ) ; emit_insn ( gen_iwmmxt_clrdi ( mode == DImode ? x : gen_rtx_SUBREG ( DImode , x , 0 ) ) ) ; return x ; } </s>

Errors in the source file can cause expand_expr to return const0_rtx where we expect a vector . To avoid crashing , use one of the vector clear instructions .


<s> void LEGInstPrinter :: printRegName ( raw_ostream & OS , unsigned RegNo ) const { OS << StringRef ( getRegisterName ( RegNo ) ) . lower ( ) ; } </s>


<s> int MipsSEFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MipsABIInfo ABI = STI . getABI ( ) ; if ( MFI . isFixedObjectIndex ( FI ) ) FrameReg = hasFP ( MF ) ? ABI . GetFramePtr ( ) : ABI . GetStackPtr ( ) ; else FrameReg = hasBP ( MF ) ? ABI . GetBasePtr ( ) : ABI . GetStackPtr ( ) ; return MFI . getObjectOffset ( FI ) + MFI . getStackSize ( ) - getOffsetOfLocalArea ( ) + MFI . getOffsetAdjustment ( ) ; } </s>

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


<s> bool doInitialization ( Module & M ) override { return false ; } </s>

Set up the AsmPrinter when we are working on a new module .


<s> void TGSIInstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const DebugLoc & DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { if ( TGSI :: IRegsRegClass . contains ( DestReg , SrcReg ) ) BuildMI ( MBB , MI , DL , get ( TGSI :: MOVis ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; else if ( TGSI :: IVRegsRegClass . contains ( DestReg , SrcReg ) ) BuildMI ( MBB , MI , DL , get ( TGSI :: MOViv ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; else assert ( 0 ) ; } </s>

TGSI TGSI TGSI::IRegsRegClass TGSI::MOVis TGSI::IVRegsRegClass TGSI::MOViv 0


<s> void aarch64_expand_sve_vcond ( machine_mode data_mode , machine_mode cmp_mode , rtx * ops ) { machine_mode pred_mode = aarch64_get_mask_mode ( cmp_mode ) . require ( ) ; rtx pred = gen_reg_rtx ( pred_mode ) ; if ( FLOAT_MODE_P ( cmp_mode ) ) { if ( aarch64_expand_sve_vec_cmp_float ( pred , GET_CODE ( ops [ 3 ] ) , ops [ 4 ] , ops [ 5 ] , true ) ) std :: swap ( ops [ 1 ] , ops [ 2 ] ) ; } else aarch64_expand_sve_vec_cmp_int ( pred , GET_CODE ( ops [ 3 ] ) , ops [ 4 ] , ops [ 5 ] ) ; if ( ! aarch64_sve_reg_or_dup_imm ( ops [ 1 ] , data_mode ) ) ops [ 1 ] = force_reg ( data_mode , ops [ 1 ] ) ; if ( register_operand ( ops [ 1 ] , data_mode ) || ! aarch64_simd_reg_or_zero ( ops [ 2 ] , data_mode ) ) ops [ 2 ] = force_reg ( data_mode , ops [ 2 ] ) ; rtvec vec = gen_rtvec ( 3 , pred , ops [ 1 ] , ops [ 2 ] ) ; emit_set_insn ( ops [ 0 ] , gen_rtx_UNSPEC ( data_mode , vec , UNSPEC_SEL ) ) ; } </s>

Expand an SVE vcond pattern with operands OPS . DATA_MODE is the mode of the data being selected and CMP_MODE is the mode of the values being compared .


<s> EVT X86TargetLowering :: getOptimalMemOpType ( uint64_t Size , unsigned DstAlign , unsigned SrcAlign , bool IsMemset , bool ZeroMemset , bool MemcpyStrSrc , MachineFunction & MF ) const { const Function * F = MF . getFunction ( ) ; if ( ( ! IsMemset || ZeroMemset ) && ! F -> hasFnAttribute ( Attribute :: NoImplicitFloat ) ) { if ( Size >= 16 && ( ! Subtarget . isUnalignedMem16Slow ( ) || ( ( DstAlign == 0 || DstAlign >= 16 ) && ( SrcAlign == 0 || SrcAlign >= 16 ) ) ) ) { if ( Size >= 32 ) { if ( Subtarget . hasInt256 ( ) ) return MVT :: v8i32 ; if ( Subtarget . hasFp256 ( ) ) return MVT :: v8f32 ; } if ( Subtarget . hasSSE2 ( ) ) return MVT :: v4i32 ; if ( Subtarget . hasSSE1 ( ) ) return MVT :: v4f32 ; } else if ( ! MemcpyStrSrc && Size >= 8 && ! Subtarget . is64Bit ( ) && Subtarget . hasSSE2 ( ) ) { return MVT :: f64 ; } } if ( Subtarget . is64Bit ( ) && Size >= 8 ) return MVT :: i64 ; return MVT :: i32 ; } </s>

It returns EVT : :Other if the type should be determined using generic target-independent logic .


<s> bool R600TargetLowering :: canMergeStoresTo ( unsigned AS , EVT MemVT , const MachineFunction & MF ) const { if ( ( AS == AMDGPUAS :: LOCAL_ADDRESS || AS == AMDGPUAS :: PRIVATE_ADDRESS ) ) { return ( MemVT . getSizeInBits ( ) <= 32 ) ; } return true ; } </s>

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


<s>
StringRef
getPassName
(
)
const
override
{
return
"SystemZ Long Branch"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool MSP430InstrInfo :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) BuildMI ( MBB , MI , DL , get ( MSP430 :: POP16r ) , CSI [ i ] . getReg ( ) ) ; return true ; } </s>

restoreCalleeSavedRegisters - Issues instruction ( s ) to restore all callee saved registers and returns true if it is n't possible / profitable to do so by issuing a series of load instructions via loadRegToStackSlot ( ) .


<s>
unsigned
MipsCodeEmitter
::
getJumpOffset16OpValue
(
const
MachineInstr
&
MI
,
unsigned
OpNo
)
const
{
llvm_unreachable
(
"Unimplemented function."
)
;
return
0
;
}
</s>

getJumpOffset16OpValue - Return binary encoding of the jump target operand .


<s> static bool rs6000_aix_precompute_tls_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { return tls_referenced_p ( x ) ; } </s>

Implement TARGET_PRECOMPUTE_TLS_P . On the AIX , TLS symbols are in the TOC , which is maintained in the constant pool . AIX TOC TLS symbols need to be pre-computed , but must be considered legitimate constants .


<s> bool hasDelayAlu ( ) const { return GFX11Insts ; } </s>

Return true if the target has the S_DELAY_ALU instruction .


<s> static void loongarch_legitimize_const_move ( machine_mode mode , rtx dest , rtx src ) { rtx base , offset ; if ( splittable_const_int_operand ( src , mode ) ) { loongarch_move_integer ( dest , dest , INTVAL ( src ) ) ; return ; } if ( loongarch_tls_symbol_p ( src ) ) { loongarch_emit_move ( dest , loongarch_legitimize_tls_address ( src ) ) ; return ; } split_const ( src , & base , & offset ) ; if ( offset != const0_rtx && ( targetm . cannot_force_const_mem ( mode , src ) || ( can_create_pseudo_p ( ) ) ) ) { base = loongarch_force_temporary ( dest , base ) ; loongarch_emit_move ( dest , loongarch_add_offset ( NULL , base , INTVAL ( offset ) ) ) ; return ; } src = force_const_mem ( mode , src ) ; loongarch_emit_move ( dest , src ) ; } </s>

Subroutine of loongarch_legitimize_move . Move constant SRC into register DEST given that SRC satisfies immediate_operand but does n't satisfy move_operand .


<s> tree ix86_veclibabi_svml ( combined_fn fn , tree type_out , tree type_in ) { char name [ 20 ] ; tree fntype , new_fndecl , args ; unsigned arity ; const char * bname ; machine_mode el_mode , in_mode ; int n , in_n ; if ( ! flag_unsafe_math_optimizations ) return NULL_TREE ; el_mode = TYPE_MODE ( TREE_TYPE ( type_out ) ) ; n = TYPE_VECTOR_SUBPARTS ( type_out ) ; in_mode = TYPE_MODE ( TREE_TYPE ( type_in ) ) ; in_n = TYPE_VECTOR_SUBPARTS ( type_in ) ; if ( el_mode != in_mode || n != in_n ) return NULL_TREE ; switch ( fn ) { CASE_CFN_EXP : CASE_CFN_LOG : CASE_CFN_LOG10 : CASE_CFN_POW : CASE_CFN_TANH : CASE_CFN_TAN : CASE_CFN_ATAN : CASE_CFN_ATAN2 : CASE_CFN_ATANH : CASE_CFN_CBRT : CASE_CFN_SINH : CASE_CFN_SIN : CASE_CFN_ASINH : CASE_CFN_ASIN : CASE_CFN_COSH : CASE_CFN_COS : CASE_CFN_ACOSH : CASE_CFN_ACOS : if ( ( el_mode != DFmode || n != 2 ) && ( el_mode != SFmode || n != 4 ) ) return NULL_TREE ; break ; default : return NULL_TREE ; } tree fndecl = mathfn_built_in ( el_mode == DFmode ? double_type_node : float_type_node , fn ) ; bname = IDENTIFIER_POINTER ( DECL_NAME ( fndecl ) ) ; if ( DECL_FUNCTION_CODE ( fndecl ) == BUILT_IN_LOGF ) strcpy ( name , "vmlsLn4" ) ; else if ( DECL_FUNCTION_CODE ( fndecl ) == BUILT_IN_LOG ) strcpy ( name , "vmldLn2" ) ; else if ( n == 4 ) { sprintf ( name , "vmls%s" , bname + 10 ) ; name [ strlen ( name ) - 1 ] = '4' ; } else sprintf ( name , "vmld%s2" , bname + 10 ) ; name [ 4 ] &= ~ 0x20 ; arity = 0 ; for ( args = DECL_ARGUMENTS ( fndecl ) ; args ; args = TREE_CHAIN ( args ) ) arity ++ ; if ( arity == 1 ) fntype = build_function_type_list ( type_out , type_in , NULL ) ; else fntype = build_function_type_list ( type_out , type_in , type_in , NULL ) ; new_fndecl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , get_identifier ( name ) , fntype ) ; TREE_PUBLIC ( new_fndecl ) = 1 ; DECL_EXTERNAL ( new_fndecl ) = 1 ; DECL_IS_NOVOPS ( new_fndecl ) = 1 ; TREE_READONLY ( new_fndecl ) = 1 ; return new_fndecl ; } </s>

Handler for an SVML-style interface to a library with vectorized intrinsics .


<s> SDValue ARM64TargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { SelectionDAG & DAG = DCI . DAG ; switch ( N -> getOpcode ( ) ) { default : break ; case ISD :: ADD : case ISD :: SUB : return performAddSubLongCombine ( N , DCI , DAG ) ; case ISD :: XOR : return performXorCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: MUL : return performMulCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SINT_TO_FP : case ISD :: UINT_TO_FP : return performIntToFpCombine ( N , DAG ) ; case ISD :: OR : return performORCombine ( N , DCI , Subtarget ) ; case ISD :: INTRINSIC_WO_CHAIN : return performIntrinsicCombine ( N , DCI , Subtarget ) ; case ISD :: ANY_EXTEND : case ISD :: ZERO_EXTEND : case ISD :: SIGN_EXTEND : return performExtendCombine ( N , DCI , DAG ) ; case ISD :: BITCAST : return performBitcastCombine ( N , DCI , DAG ) ; case ISD :: CONCAT_VECTORS : return performConcatVectorsCombine ( N , DCI , DAG ) ; case ISD :: VSELECT : return performVSelectCombine ( N , DCI . DAG ) ; case ISD :: STORE : return performSTORECombine ( N , DCI , DAG , Subtarget ) ; case ARM64ISD :: BRCOND : return performBRCONDCombine ( N , DCI , DAG ) ; } return SDValue ( ) ; } </s>

This method will be invoked for all target nodes and for any target-independent nodes that the target has registered with invoke it for .


<s> bool Z80PassConfig :: addGlobalInstructionSelect ( ) { return true ; } </s>

This method should install a ( global ) instruction selector pass , which converts possibly generic instructions to fully target-specific instructions , thereby constraining all generic virtual registers to register classes .


<s> unsigned PPCAsmParser :: validateTargetOperandClass ( MCParsedAsmOperand & AsmOp , unsigned Kind ) { int64_t ImmVal ; switch ( Kind ) { case MCK_0 : ImmVal = 0 ; break ; case MCK_1 : ImmVal = 1 ; break ; case MCK_2 : ImmVal = 2 ; break ; case MCK_3 : ImmVal = 3 ; break ; case MCK_4 : ImmVal = 4 ; break ; case MCK_5 : ImmVal = 5 ; break ; case MCK_6 : ImmVal = 6 ; break ; case MCK_7 : ImmVal = 7 ; break ; default : return Match_InvalidOperand ; } PPCOperand & Op = static_cast < PPCOperand & > ( AsmOp ) ; if ( Op . isImm ( ) && Op . getImm ( ) == ImmVal ) return Match_Success ; return Match_InvalidOperand ; } </s>

Allow a target to add special case operand matching for things that tblgen doesn't/ca n't handle effectively .


<s> static void nvptx_print_operand_address ( FILE * file , rtx addr ) { nvptx_print_address_operand ( file , addr , VOIDmode ) ; } </s>

Write assembly language output for the address ADDR to FILE .


<s> static bool arm_needs_doubleword_align ( machine_mode mode , const_tree type ) { return ( GET_MODE_ALIGNMENT ( mode ) > PARM_BOUNDARY || ( type && TYPE_ALIGN ( type ) > PARM_BOUNDARY ) ) ; } </s>

Return 1 if double word alignment is required for argument passing . Return -1 if double word alignment used to be required for argument passing before PR77728 ABI fix , but is not required anymore . Return 0 if double word alignment is not required and was n't requried before either .


<s> std :: pair < unsigned , unsigned > AMDGPUSubtarget :: getWavesPerEU ( const Function & F ) const { std :: pair < unsigned , unsigned > Default ( 1 , getMaxWavesPerEU ( ) ) ; std :: pair < unsigned , unsigned > FlatWorkGroupSizes = getFlatWorkGroupSizes ( F ) ; unsigned MinImpliedByFlatWorkGroupSize = getWavesPerEUForWorkGroup ( FlatWorkGroupSizes . second ) ; Default . first = MinImpliedByFlatWorkGroupSize ; bool RequestedFlatWorkGroupSize = F . hasFnAttribute ( "amdgpu-flat-work-group-size" ) ; std :: pair < unsigned , unsigned > Requested = AMDGPU :: getIntegerPairAttribute ( F , "amdgpu-waves-per-eu" , Default , true ) ; if ( Requested . second && Requested . first > Requested . second ) return Default ; if ( Requested . first < getMinWavesPerEU ( ) || Requested . second > getMaxWavesPerEU ( ) ) return Default ; if ( RequestedFlatWorkGroupSize && Requested . first < MinImpliedByFlatWorkGroupSize ) return Default ; return Requested ; } </s>

Overload which uses the specified values for the flat work group sizes , rather than querying the function itself .

AMDGPU AMDGPU 1 "amdgpu-flat-work-group-size" AMDGPU::getIntegerPairAttribute "amdgpu-waves-per-eu"


<s> void a29k_compute_reg_names ( ) { int i ; compute_regstack_size ( ) ; for ( i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) a29k_debug_reg_map [ i ] = i ; reg_names [ FRAME_POINTER_REGNUM ] = reg_names [ R_LR ( a29k_regstack_size - 1 ) ] ; a29k_debug_reg_map [ FRAME_POINTER_REGNUM ] = R_LR ( a29k_regstack_size - 1 ) ; for ( i = 0 ; i < 16 ; i ++ ) { reg_names [ R_AR ( i ) ] = reg_names [ R_LR ( a29k_regstack_size + i + 2 ) ] ; a29k_debug_reg_map [ R_AR ( i ) ] = R_LR ( a29k_regstack_size + i + 2 ) ; } if ( TARGET_KERNEL_REGISTERS ) for ( i = 0 ; i < 32 ; i ++ ) { int tem = a29k_debug_reg_map [ i ] ; a29k_debug_reg_map [ i ] = a29k_debug_reg_map [ R_KR ( i ) ] ; a29k_debug_reg_map [ R_KR ( i ) ] = tem ; } } </s>

Sets register names for incoming arguments and frame pointer . This ca n't be computed until after register allocation .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . setPreservesCFG ( ) ; AU . addRequired < LiveIntervals > ( ) ; AU . addPreserved < MachineBlockFrequencyInfo > ( ) ; AU . addPreserved < SlotIndexes > ( ) ; AU . addPreserved < LiveIntervals > ( ) ; AU . addPreservedID ( LiveVariablesID ) ; AU . addPreservedID ( MachineDominatorsID ) ; MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


"Can't load this register from stack slot"

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


<s> static rtx nvptx_expand_builtin ( tree exp , rtx target , rtx ARG_UNUSED ( subtarget ) , machine_mode mode , int ignore ) { tree fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , 0 ) ; switch ( DECL_MD_FUNCTION_CODE ( fndecl ) ) { case NVPTX_BUILTIN_SHUFFLE : case NVPTX_BUILTIN_SHUFFLELL : return nvptx_expand_shuffle ( exp , target , mode , ignore ) ; case NVPTX_BUILTIN_WORKER_ADDR : return nvptx_expand_shared_addr ( exp , target , mode , ignore , false ) ; case NVPTX_BUILTIN_VECTOR_ADDR : return nvptx_expand_shared_addr ( exp , target , mode , ignore , true ) ; case NVPTX_BUILTIN_CMP_SWAP : case NVPTX_BUILTIN_CMP_SWAPLL : return nvptx_expand_cmp_swap ( exp , target , mode , ignore ) ; case NVPTX_BUILTIN_MEMBAR_GL : emit_insn ( gen_nvptx_membar_gl ( ) ) ; return NULL_RTX ; case NVPTX_BUILTIN_MEMBAR_CTA : emit_insn ( gen_nvptx_membar_cta ( ) ) ; return NULL_RTX ; case NVPTX_BUILTIN_BAR_RED_AND : case NVPTX_BUILTIN_BAR_RED_OR : case NVPTX_BUILTIN_BAR_RED_POPC : return nvptx_expand_bar_red ( exp , target , mode , ignore ) ; default : gcc_unreachable ( ) ; } } </s>

Expand an expression EXP that calls a built-in function , with result going to TARGET if that 's convenient ( and in mode MODE if that 's convenient ) . SUBTARGET may be used as the target for computing one of EXP 's operands . IGNORE is nonzero if the value is to be ignored .


<s> void mips_split_move_insn ( rtx dest , rtx src , rtx insn ) { mips_split_move ( dest , src , mips_insn_split_type ( insn ) ) ; } </s>

Split a move from SRC to DEST in INSN , given that mips_split_move_insn_p holds .


<s> static tree mips_std_gimplify_va_arg_expr ( tree valist , tree type , gimple_seq * pre_p , gimple_seq * post_p ) { tree addr , t , type_size , rounded_size , valist_tmp ; unsigned HOST_WIDE_INT align , boundary ; bool indirect ; indirect = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( indirect ) type = build_pointer_type ( type ) ; align = PARM_BOUNDARY / BITS_PER_UNIT ; boundary = targetm . calls . function_arg_boundary ( TYPE_MODE ( type ) , type ) ; if ( boundary > MAX_SUPPORTED_STACK_ALIGNMENT ) boundary = MAX_SUPPORTED_STACK_ALIGNMENT ; boundary /= BITS_PER_UNIT ; valist_tmp = get_initialized_tmp_var ( valist , pre_p , NULL ) ; if ( boundary > align ) { t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build_pointer_plus_hwi ( valist_tmp , boundary - 1 ) ) ; gimplify_and_add ( t , pre_p ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build2 ( BIT_AND_EXPR , TREE_TYPE ( valist ) , valist_tmp , build_int_cst ( TREE_TYPE ( valist ) , - boundary ) ) ) ; gimplify_and_add ( t , pre_p ) ; } else boundary = align ; boundary *= BITS_PER_UNIT ; if ( boundary < TYPE_ALIGN ( type ) ) { type = build_variant_type_copy ( type ) ; TYPE_ALIGN ( type ) = boundary ; } type_size = size_in_bytes ( type ) ; rounded_size = round_up ( type_size , align ) ; gimplify_expr ( & rounded_size , pre_p , post_p , is_gimple_val , fb_rvalue ) ; addr = valist_tmp ; if ( PAD_VARARGS_DOWN && ! integer_zerop ( rounded_size ) ) { t = fold_build2_loc ( input_location , GT_EXPR , sizetype , rounded_size , size_int ( align ) ) ; t = fold_build3 ( COND_EXPR , sizetype , t , size_zero_node , size_binop ( MINUS_EXPR , rounded_size , type_size ) ) ; addr = fold_build_pointer_plus ( addr , t ) ; } t = fold_build_pointer_plus ( valist_tmp , rounded_size ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist , t ) ; gimplify_and_add ( t , pre_p ) ; addr = fold_convert ( build_pointer_type ( type ) , addr ) ; if ( indirect ) addr = build_va_arg_indirect_ref ( addr ) ; return build_va_arg_indirect_ref ( addr ) ; } </s>

Like std_gimplify_va_arg_expr , but apply alignment to zero-sized types as well .


<s> EVT X86TargetLowering :: getOptimalMemOpType ( uint64_t Size , unsigned DstAlign , unsigned SrcAlign , bool IsMemset , bool ZeroMemset , bool MemcpyStrSrc , MachineFunction & MF ) const { const Function * F = MF . getFunction ( ) ; if ( ! F -> hasFnAttribute ( Attribute :: NoImplicitFloat ) ) { if ( Size >= 16 && ( ! Subtarget . isUnalignedMem16Slow ( ) || ( ( DstAlign == 0 || DstAlign >= 16 ) && ( SrcAlign == 0 || SrcAlign >= 16 ) ) ) ) { if ( Size >= 32 && Subtarget . hasAVX ( ) ) { return MVT :: v32i8 ; } if ( Subtarget . hasSSE2 ( ) ) return MVT :: v16i8 ; if ( Subtarget . hasSSE1 ( ) ) return MVT :: v4f32 ; } else if ( ( ! IsMemset || ZeroMemset ) && ! MemcpyStrSrc && Size >= 8 && ! Subtarget . is64Bit ( ) && Subtarget . hasSSE2 ( ) ) { return MVT :: f64 ; } } if ( Subtarget . is64Bit ( ) && Size >= 8 ) return MVT :: i64 ; return MVT :: i32 ; } </s>

It returns EVT : :Other if the type should be determined using generic target-independent logic .


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

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


<s>
void
MipsInstrInfo
::
loadRegFromStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
DestReg
,
int
FI
,
const
TargetRegisterClass
*
RC
)
const
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
if
(
RC
==
Mips
::
CPURegsRegisterClass
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
LW
)
,
DestReg
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
else
if
(
RC
==
Mips
::
FGR32RegisterClass
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
LWC1
)
,
DestReg
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
else
if
(
RC
==
Mips
::
AFGR64RegisterClass
)
{
if
(
!
TM
.
getSubtarget
<
MipsSubtarget
>
(
)
.
isMips1
(
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
LDC1
)
,
DestReg
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
}
else
{
const
TargetRegisterInfo
*
TRI
=
MBB
.
getParent
(
)
->
getTarget
(
)
.
getRegisterInfo
(
)
;
const
unsigned
*
SubSet
=
TRI
->
getSubRegisters
(
DestReg
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
LWC1
)
,
SubSet
[
0
]
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
LWC1
)
,
SubSet
[
1
]
)
.
addImm
(
4
)
.
addFrameIndex
(
FI
)
;
}
}
else
llvm_unreachable
(
"Register class not handled!"
)
;
}
</s>


<s> static int c_prefix ( const char * str ) { static const char * const prefixes [ ] = { "attiny" , "atmega" , "atxmega" , "ata" , "at90" , "avr" } ; int i , n = ( int ) ( ARRAY_SIZE ( prefixes ) ) ; for ( i = 0 ; i < n ; i ++ ) if ( str_prefix_p ( str , prefixes [ i ] ) ) return i ; return n ; } </s>

Used by string comparator to group MCUs by their name prefix like `` attiny '' or `` atmega '' .

avr "attiny" "atmega" "atxmega" "ata" "at90" "avr" 0


<s> static void mips_setup_incoming_varargs ( cumulative_args_t cum , machine_mode mode , tree type , int * pretend_size ATTRIBUTE_UNUSED , int no_rtl ) { CUMULATIVE_ARGS local_cum ; int gp_saved , fp_saved ; local_cum = * get_cumulative_args ( cum ) ; mips_function_arg_advance ( pack_cumulative_args ( & local_cum ) , mode , type , true ) ; gp_saved = MAX_ARGS_IN_REGISTERS - local_cum . num_gprs ; fp_saved = ( EABI_FLOAT_VARARGS_P ? MAX_ARGS_IN_REGISTERS - local_cum . num_fprs : 0 ) ; if ( ! no_rtl ) { if ( gp_saved > 0 ) { rtx ptr , mem ; ptr = plus_constant ( Pmode , virtual_incoming_args_rtx , REG_PARM_STACK_SPACE ( cfun -> decl ) - gp_saved * UNITS_PER_WORD ) ; mem = gen_frame_mem ( BLKmode , ptr ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; move_block_from_reg ( local_cum . num_gprs + GP_ARG_FIRST , mem , gp_saved ) ; } if ( fp_saved > 0 ) { machine_mode mode ; int off , i ; off = ( - gp_saved * UNITS_PER_WORD ) & - UNITS_PER_FPVALUE ; off -= fp_saved * UNITS_PER_FPREG ; mode = TARGET_SINGLE_FLOAT ? SFmode : DFmode ; for ( i = local_cum . num_fprs ; i < MAX_ARGS_IN_REGISTERS ; i += MAX_FPRS_PER_FMT ) { rtx ptr , mem ; ptr = plus_constant ( Pmode , virtual_incoming_args_rtx , off ) ; mem = gen_frame_mem ( mode , ptr ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; mips_emit_move ( mem , gen_rtx_REG ( mode , FP_ARG_FIRST + i ) ) ; off += UNITS_PER_HWFPVALUE ; } } } if ( REG_PARM_STACK_SPACE ( cfun -> decl ) == 0 ) cfun -> machine -> varargs_size = ( gp_saved * UNITS_PER_WORD + fp_saved * UNITS_PER_FPREG ) ; } </s>


<s>
static
void
rs6000_va_start
(
tree
valist
,
rtx
nextarg
)
{
HOST_WIDE_INT
words
,
n_gpr
,
n_fpr
;
tree
f_gpr
,
f_fpr
,
f_res
,
f_ovf
,
f_sav
;
tree
gpr
,
fpr
,
ovf
,
sav
,
t
;
if
(
DEFAULT_ABI
!=
ABI_V4
)
{
std_expand_builtin_va_start
(
valist
,
nextarg
)
;
return
;
}
f_gpr
=
TYPE_FIELDS
(
TREE_TYPE
(
va_list_type_node
)
)
;
f_fpr
=
DECL_CHAIN
(
f_gpr
)
;
f_res
=
DECL_CHAIN
(
f_fpr
)
;
f_ovf
=
DECL_CHAIN
(
f_res
)
;
f_sav
=
DECL_CHAIN
(
f_ovf
)
;
valist
=
build_simple_mem_ref
(
valist
)
;
gpr
=
build3
(
COMPONENT_REF
,
TREE_TYPE
(
f_gpr
)
,
valist
,
f_gpr
,
NULL_TREE
)
;
fpr
=
build3
(
COMPONENT_REF
,
TREE_TYPE
(
f_fpr
)
,
unshare_expr
(
valist
)
,
f_fpr
,
NULL_TREE
)
;
ovf
=
build3
(
COMPONENT_REF
,
TREE_TYPE
(
f_ovf
)
,
unshare_expr
(
valist
)
,
f_ovf
,
NULL_TREE
)
;
sav
=
build3
(
COMPONENT_REF
,
TREE_TYPE
(
f_sav
)
,
unshare_expr
(
valist
)
,
f_sav
,
NULL_TREE
)
;
words
=
crtl
->
args
.
info
.
words
;
n_gpr
=
MIN
(
crtl
->
args
.
info
.
sysv_gregno
GP_ARG_MIN_REG
,
GP_ARG_NUM_REG
)
;
n_fpr
=
MIN
(
crtl
->
args
.
info
.
fregno
FP_ARG_MIN_REG
,
FP_ARG_NUM_REG
)
;
if
(
TARGET_DEBUG_ARG
)
fprintf
(
stderr
,
"va_start: words = "
HOST_WIDE_INT_PRINT_DEC
", n_gpr = "
HOST_WIDE_INT_PRINT_DEC
", n_fpr = "
HOST_WIDE_INT_PRINT_DEC
"\n"
,
words
,
n_gpr
,
n_fpr
)
;
if
(
cfun
->
va_list_gpr_size
)
{
t
=
build2
(
MODIFY_EXPR
,
TREE_TYPE
(
gpr
)
,
gpr
,
build_int_cst
(
NULL_TREE
,
n_gpr
)
)
;
TREE_SIDE_EFFECTS
(
t
)
=
1
;
expand_expr
(
t
,
const0_rtx
,
VOIDmode
,
EXPAND_NORMAL
)
;
}
if
(
cfun
->
va_list_fpr_size
)
{
t
=
build2
(
MODIFY_EXPR
,
TREE_TYPE
(
fpr
)
,
fpr
,
build_int_cst
(
NULL_TREE
,
n_fpr
)
)
;
TREE_SIDE_EFFECTS
(
t
)
=
1
;
expand_expr
(
t
,
const0_rtx
,
VOIDmode
,
EXPAND_NORMAL
)
;
if
(
call_ABI_of_interest
(
cfun
->
decl
)
)
rs6000_passes_float
=
true
;
}
t
=
make_tree
(
TREE_TYPE
(
ovf
)
,
virtual_incoming_args_rtx
)
;
if
(
words
!=
0
)
t
=
fold_build_pointer_plus_hwi
(
t
,
words
*
MIN_UNITS_PER_WORD
)
;
t
=
build2
(
MODIFY_EXPR
,
TREE_TYPE
(
ovf
)
,
ovf
,
t
)
;
TREE_SIDE_EFFECTS
(
t
)
=
1
;
expand_expr
(
t
,
const0_rtx
,
VOIDmode
,
EXPAND_NORMAL
)
;
if
(
!
cfun
->
va_list_gpr_size
&&
!
cfun
->
va_list_fpr_size
&&
n_gpr
<
GP_ARG_NUM_REG
&&
n_fpr
<
FP_ARG_V4_MAX_REG
)
return
;
t
=
make_tree
(
TREE_TYPE
(
sav
)
,
virtual_stack_vars_rtx
)
;
if
(
cfun
->
machine
->
varargs_save_offset
)
t
=
fold_build_pointer_plus_hwi
(
t
,
cfun
->
machine
->
varargs_save_offset
)
;
t
=
build2
(
MODIFY_EXPR
,
TREE_TYPE
(
sav
)
,
sav
,
t
)
;
TREE_SIDE_EFFECTS
(
t
)
=
1
;
expand_expr
(
t
,
const0_rtx
,
VOIDmode
,
EXPAND_NORMAL
)
;
}
</s>


<s> static bool arm_evpc_neon_vzip ( struct expand_vec_perm_d * d ) { unsigned int i , high , mask , nelt = d -> perm . length ( ) ; rtx out0 , out1 , in0 , in1 ; int first_elem ; bool is_swapped ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= 8 ) return false ; is_swapped = BYTES_BIG_ENDIAN ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , 0 ) ^ is_swapped ] ; high = nelt / 2 ; if ( first_elem == neon_endian_lane_map ( d -> vmode , high ) ) ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , 0 ) ) high = 0 ; else return false ; mask = ( d -> one_vector_p ? nelt - 1 : 2 * nelt - 1 ) ; for ( i = 0 ; i < nelt / 2 ; i ++ ) { unsigned elt = neon_pair_endian_lane_map ( d -> vmode , i + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , 2 * i + is_swapped ) ] != elt ) return false ; elt = neon_pair_endian_lane_map ( d -> vmode , i + nelt + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , 2 * i + ! is_swapped ) ] != elt ) return false ; } if ( d -> testing_p ) return true ; in0 = d -> op0 ; in1 = d -> op1 ; if ( is_swapped ) std :: swap ( in0 , in1 ) ; out0 = d -> target ; out1 = gen_reg_rtx ( d -> vmode ) ; if ( high ) std :: swap ( out0 , out1 ) ; emit_insn ( gen_neon_vzip_internal ( d -> vmode , out0 , in0 , in1 , out1 ) ) ; return true ; } </s>


<s> bool Mips16FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; MachineBasicBlock * EntryBlock = MF -> begin ( ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; bool IsRAAndRetAddrIsTaken = ( Reg == Mips :: RA ) && MF -> getFrameInfo ( ) -> isReturnAddressTaken ( ) ; if ( ! IsRAAndRetAddrIsTaken ) EntryBlock -> addLiveIn ( Reg ) ; } return true ; } </s>

spillCalleeSavedRegisters - Issues instruction ( s ) to spill all callee saved registers and returns true if it is n't possible / profitable to do so by issuing a series of store instructions via storeRegToStackSlot ( ) .


<s> static inline bool quad_address_offset_p ( HOST_WIDE_INT offset ) { return ( IN_RANGE ( offset , - 32768 , 32767 ) && ( ( offset ) & 0xf ) == 0 ) ; } </s>

Return true if the OFFSET is valid for the quad address instructions that use d-form ( register + offset ) addressing .


<s> void MipsAsmBackend :: applyFixup ( const MCFixup & Fixup , char * Data , unsigned DataSize , uint64_t Value , bool IsPCRel , MCContext & Ctx ) const { MCFixupKind Kind = Fixup . getKind ( ) ; Value = adjustFixupValue ( Fixup , Value , Ctx ) ; if ( ! Value ) return ; unsigned Offset = Fixup . getOffset ( ) ; unsigned NumBytes = ( getFixupKindInfo ( Kind ) . TargetSize + 7 ) / 8 ; unsigned FullSize ; switch ( ( unsigned ) Kind ) { case FK_Data_2 : case Mips :: fixup_Mips_16 : case Mips :: fixup_MICROMIPS_PC10_S1 : FullSize = 2 ; break ; case FK_Data_8 : case Mips :: fixup_Mips_64 : FullSize = 8 ; break ; case FK_Data_4 : default : FullSize = 4 ; break ; } uint64_t CurVal = 0 ; bool microMipsLEByteOrder = needsMMLEByteOrder ( ( unsigned ) Kind ) ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = IsLittle ? ( microMipsLEByteOrder ? calculateMMLEIndex ( i ) : i ) : ( FullSize - 1 - i ) ; CurVal |= ( uint64_t ) ( ( uint8_t ) Data [ Offset + Idx ] ) << ( i * 8 ) ; } uint64_t Mask = ( ( uint64_t ) ( - 1 ) >> ( 64 - getFixupKindInfo ( Kind ) . TargetSize ) ) ; CurVal |= Value & Mask ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = IsLittle ? ( microMipsLEByteOrder ? calculateMMLEIndex ( i ) : i ) : ( FullSize - 1 - i ) ; Data [ Offset + Idx ] = ( uint8_t ) ( ( CurVal >> ( i * 8 ) ) & 0xff ) ; } } </s>

Apply the Value for given Fixup into the provided data fragment , at the offset specified by the fixup and following the fixup kind as appropriate .


<s>
bool
NVPTXAsmPrinter
::
doInitialization
(
Module
&
M
)
{
SmallString
<
128
>
Str1
;
raw_svector_ostream
OS1
(
Str1
)
;
MMI
=
getAnalysisIfAvailable
<
MachineModuleInfo
>
(
)
;
MMI
->
AnalyzeModule
(
M
)
;
const_cast
<
TargetLoweringObjectFile
&
>
(
getObjFileLowering
(
)
)
.
Initialize
(
OutContext
,
TM
)
;
Mang
=
new
Mangler
(
&
TM
)
;
emitHeader
(
M
,
OS1
)
;
OutStreamer
.
EmitRawText
(
OS1
.
str
(
)
)
;
if
(
!
M
.
getModuleInlineAsm
(
)
.
empty
(
)
)
{
OutStreamer
.
AddComment
(
"Start of file scope inline assembly"
)
;
OutStreamer
.
AddBlankLine
(
)
;
OutStreamer
.
EmitRawText
(
StringRef
(
M
.
getModuleInlineAsm
(
)
)
)
;
OutStreamer
.
AddBlankLine
(
)
;
OutStreamer
.
AddComment
(
"End of file scope inline assembly"
)
;
OutStreamer
.
AddBlankLine
(
)
;
}
if
(
nvptxSubtarget
.
getDrvInterface
(
)
==
NVPTX
::
CUDA
)
recordAndEmitFilenames
(
M
)
;
GlobalsEmitted
=
false
;
return
false
;
}
</s>

Set up the AsmPrinter when we are working on a new module .

NVPTX
NVPTX
128
"Start of file scope inline assembly"
"End of file scope inline assembly"
NVPTX::CUDA


<s> static bool zero_all_mm_registers ( HARD_REG_SET need_zeroed_hardregs , unsigned int ret_mmx_regno ) { bool need_zero_all_mm = false ; for ( unsigned int regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( STACK_REGNO_P ( regno ) && TEST_HARD_REG_BIT ( need_zeroed_hardregs , regno ) ) { need_zero_all_mm = true ; break ; } if ( ! need_zero_all_mm ) return false ; rtx zero_mmx = NULL_RTX ; machine_mode mode = V4HImode ; for ( unsigned int regno = FIRST_MMX_REG ; regno <= LAST_MMX_REG ; regno ++ ) if ( regno != ret_mmx_regno ) { rtx reg = gen_rtx_REG ( mode , regno ) ; if ( zero_mmx == NULL_RTX ) { zero_mmx = reg ; emit_insn ( gen_rtx_SET ( reg , CONST0_RTX ( mode ) ) ) ; } else emit_move_insn ( reg , zero_mmx ) ; } return true ; } </s>

When the routine exit in MMX mode , if any ST register needs to be zeroed , we should clear all MMX registers except the RET_MMX_REGNO that holds the return value .


<s> bool X86TargetLowering :: getTgtMemIntrinsic ( IntrinsicInfo & Info , const CallInst & I , MachineFunction & MF , unsigned Intrinsic ) const { const IntrinsicData * IntrData = getIntrinsicWithChain ( Intrinsic ) ; if ( ! IntrData ) return false ; Info . flags = MachineMemOperand :: MONone ; Info . offset = 0 ; switch ( IntrData -> Type ) { case TRUNCATE_TO_MEM_VI8 : case TRUNCATE_TO_MEM_VI16 : case TRUNCATE_TO_MEM_VI32 : { Info . opc = ISD :: INTRINSIC_VOID ; Info . ptrVal = I . getArgOperand ( 0 ) ; MVT VT = MVT :: getVT ( I . getArgOperand ( 1 ) -> getType ( ) ) ; MVT ScalarVT = MVT :: INVALID_SIMPLE_VALUE_TYPE ; if ( IntrData -> Type == TRUNCATE_TO_MEM_VI8 ) ScalarVT = MVT :: i8 ; else if ( IntrData -> Type == TRUNCATE_TO_MEM_VI16 ) ScalarVT = MVT :: i16 ; else if ( IntrData -> Type == TRUNCATE_TO_MEM_VI32 ) ScalarVT = MVT :: i32 ; Info . memVT = MVT :: getVectorVT ( ScalarVT , VT . getVectorNumElements ( ) ) ; Info . align = Align ( 1 ) ; Info . flags |= MachineMemOperand :: MOStore ; break ; } case GATHER : case GATHER_AVX2 : { Info . opc = ISD :: INTRINSIC_W_CHAIN ; Info . ptrVal = nullptr ; MVT DataVT = MVT :: getVT ( I . getType ( ) ) ; MVT IndexVT = MVT :: getVT ( I . getArgOperand ( 2 ) -> getType ( ) ) ; unsigned NumElts = std :: min ( DataVT . getVectorNumElements ( ) , IndexVT . getVectorNumElements ( ) ) ; Info . memVT = MVT :: getVectorVT ( DataVT . getVectorElementType ( ) , NumElts ) ; Info . align = Align ( 1 ) ; Info . flags |= MachineMemOperand :: MOLoad ; break ; } case SCATTER : { Info . opc = ISD :: INTRINSIC_VOID ; Info . ptrVal = nullptr ; MVT DataVT = MVT :: getVT ( I . getArgOperand ( 3 ) -> getType ( ) ) ; MVT IndexVT = MVT :: getVT ( I . getArgOperand ( 2 ) -> getType ( ) ) ; unsigned NumElts = std :: min ( DataVT . getVectorNumElements ( ) , IndexVT . getVectorNumElements ( ) ) ; Info . memVT = MVT :: getVectorVT ( DataVT . getVectorElementType ( ) , NumElts ) ; Info . align = Align ( 1 ) ; Info . flags |= MachineMemOperand :: MOStore ; break ; } default : return false ; } return true ; } </s>

Given an intrinsic , checks if on the target the intrinsic will need to map to a MemIntrinsicNode ( touches memory ) .


<s> void PPCAIXAsmPrinter :: emitXXStructorList ( const DataLayout & DL , const Constant * List , bool IsCtor ) { SmallVector < Structor , 8 > Structors ; preprocessXXStructorList ( DL , List , Structors ) ; if ( Structors . empty ( ) ) return ; unsigned Index = 0 ; for ( Structor & S : Structors ) { if ( const ConstantExpr * CE = dyn_cast < ConstantExpr > ( S . Func ) ) S . Func = CE -> getOperand ( 0 ) ; llvm :: GlobalAlias :: create ( GlobalValue :: ExternalLinkage , ( IsCtor ? llvm :: Twine ( "__sinit" ) : llvm :: Twine ( "__sterm" ) ) + llvm :: Twine ( convertToSinitPriority ( S . Priority ) ) + llvm :: Twine ( "_" , FormatIndicatorAndUniqueModId ) + llvm :: Twine ( "_" , llvm :: utostr ( Index ++ ) ) , cast < Function > ( S . Func ) ) ; } } </s>

This method emits llvm.global_ctors or llvm.global_dtors list .


<s> bool LanaiMemAluCombiner :: runOnMachineFunction ( MachineFunction & MF ) { if ( DisableMemAluCombiner ) return false ; TII = MF . getSubtarget < LanaiSubtarget > ( ) . getInstrInfo ( ) ; bool Modified = false ; for ( MachineBasicBlock & MBB : MF ) Modified |= combineMemAluInBasicBlock ( & MBB ) ; return Modified ; } </s>

runOnMachineFunction - Emit the function body .


<s> unsigned SIRegisterInfo :: getRegPressureSetLimit ( const MachineFunction & MF , unsigned Idx ) const { const AMDGPUSubtarget & STI = MF . getSubtarget < AMDGPUSubtarget > ( ) ; unsigned SGPRLimit = getNumSGPRsAllowed ( STI . getGeneration ( ) , STI . getMaxWavesPerCU ( ) ) ; unsigned VGPRLimit = getNumVGPRsAllowed ( STI . getMaxWavesPerCU ( ) ) ; unsigned VSLimit = SGPRLimit + VGPRLimit ; for ( regclass_iterator I = regclass_begin ( ) , E = regclass_end ( ) ; I != E ; ++ I ) { const TargetRegisterClass * RC = * I ; unsigned NumSubRegs = std :: max ( ( int ) RC -> getSize ( ) / 4 , 1 ) ; unsigned Limit ; if ( isPseudoRegClass ( RC ) ) { Limit = VSLimit ; } else if ( isSGPRClass ( RC ) ) { Limit = SGPRLimit / NumSubRegs ; } else { Limit = VGPRLimit / NumSubRegs ; } const int * Sets = getRegClassPressureSets ( RC ) ; assert ( Sets ) ; for ( unsigned i = 0 ; Sets [ i ] != - 1 ; ++ i ) { if ( Sets [ i ] == ( int ) Idx ) return Limit ; } } return 256 ; } </s>

Get the register unit pressure limit for this dimension .


<s>
void
relaxInstruction
(
const
MCInst
&
Inst
,
MCInst
&
Res
)
const
override
{
assert
(
!
"Not implemented"
)
;
}
</s>

Relax the instruction in the given fragment to the next wider instruction .


<s> bool aarch64_sve_pred_dominates_p ( rtx * pred1 , rtx pred2 ) { machine_mode mode = GET_MODE ( pred2 ) ; gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_BOOL && mode == GET_MODE ( pred1 [ 0 ] ) && aarch64_sve_gp_strictness ( pred1 [ 1 ] , SImode ) ) ; return ( pred1 [ 0 ] == CONSTM1_RTX ( mode ) || INTVAL ( pred1 [ 1 ] ) == SVE_RELAXED_GP || rtx_equal_p ( pred1 [ 0 ] , pred2 ) ) ; } </s>

Return true if predicate PRED1 [ 0 ] is true whenever predicate PRED2 is true , or alternatively if we know that the operation predicated by PRED1 [ 0 ] is safe to perform whenever PRED2 is true . PRED1 [ 1 ] is a aarch64_sve_gp_strictness operand that describes the operation predicated by PRED1 [ 0 ] .


<s> void SIInstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , DebugLoc DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { assert ( DestReg != AMDGPU :: SCC && SrcReg != AMDGPU :: SCC ) ; if ( AMDGPU :: VReg_64RegClass . contains ( DestReg ) ) { assert ( AMDGPU :: VReg_64RegClass . contains ( SrcReg ) || AMDGPU :: SReg_64RegClass . contains ( SrcReg ) ) ; BuildMI ( MBB , MI , DL , get ( AMDGPU :: V_MOV_B32_e32 ) , RI . getSubReg ( DestReg , AMDGPU :: sub0 ) ) . addReg ( RI . getSubReg ( SrcReg , AMDGPU :: sub0 ) , getKillRegState ( KillSrc ) ) . addReg ( DestReg , RegState :: Define | RegState :: Implicit ) ; BuildMI ( MBB , MI , DL , get ( AMDGPU :: V_MOV_B32_e32 ) , RI . getSubReg ( DestReg , AMDGPU :: sub1 ) ) . addReg ( RI . getSubReg ( SrcReg , AMDGPU :: sub1 ) , getKillRegState ( KillSrc ) ) ; } else if ( AMDGPU :: SReg_64RegClass . contains ( DestReg ) ) { assert ( AMDGPU :: SReg_64RegClass . contains ( SrcReg ) ) ; BuildMI ( MBB , MI , DL , get ( AMDGPU :: S_MOV_B64 ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; } else if ( AMDGPU :: VReg_32RegClass . contains ( DestReg ) ) { assert ( AMDGPU :: VReg_32RegClass . contains ( SrcReg ) || AMDGPU :: SReg_32RegClass . contains ( SrcReg ) ) ; BuildMI ( MBB , MI , DL , get ( AMDGPU :: V_MOV_B32_e32 ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; } else { assert ( AMDGPU :: SReg_32RegClass . contains ( DestReg ) ) ; assert ( AMDGPU :: SReg_32RegClass . contains ( SrcReg ) ) ; BuildMI ( MBB , MI , DL , get ( AMDGPU :: S_MOV_B32 ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; } } </s>


"MMIX Internal: Last named vararg would not fit in a register"


<s> ARMBaseTargetMachine :: ARMBaseTargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , Optional < CodeModel :: Model > CM , CodeGenOpt :: Level OL , bool isLittle ) : LLVMTargetMachine ( T , computeDataLayout ( TT , CPU , Options , isLittle ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , RM ) , getEffectiveCodeModel ( CM , CodeModel :: Small ) , OL ) , TargetABI ( computeTargetABI ( TT , CPU , Options ) ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) , isLittle ( isLittle ) { if ( Options . FloatABIType == FloatABI :: Default ) { if ( isTargetHardFloat ( ) ) this -> Options . FloatABIType = FloatABI :: Hard ; else this -> Options . FloatABIType = FloatABI :: Soft ; } if ( Options . EABIVersion == EABI :: Default || Options . EABIVersion == EABI :: Unknown ) { if ( ( TargetTriple . getEnvironment ( ) == Triple :: GNUEABI || TargetTriple . getEnvironment ( ) == Triple :: GNUEABIHF || TargetTriple . getEnvironment ( ) == Triple :: MuslEABI || TargetTriple . getEnvironment ( ) == Triple :: MuslEABIHF ) && ! ( TargetTriple . isOSWindows ( ) || TargetTriple . isOSDarwin ( ) ) ) this -> Options . EABIVersion = EABI :: GNU ; else this -> Options . EABIVersion = EABI :: EABI5 ; } if ( TT . isOSBinFormatMachO ( ) ) { this -> Options . TrapUnreachable = true ; this -> Options . NoTrapAfterNoreturn = true ; } setSupportsDebugEntryValues ( true ) ; initAsmInfo ( ) ; setMachineOutliner ( true ) ; setSupportsDefaultOutlining ( true ) ; } </s>


<s> static std :: unique_ptr < MSP430Operand > CreateReg ( unsigned RegNum , SMLoc S , SMLoc E ) { return std :: make_unique < MSP430Operand > ( k_Reg , RegNum , S , E ) ; } </s>

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


<s> bool rs6000_sum_of_two_registers_p ( const_rtx expr ) { if ( GET_CODE ( expr ) == PLUS ) { const_rtx operand1 = XEXP ( expr , 0 ) ; const_rtx operand2 = XEXP ( expr , 1 ) ; return ( REG_P ( operand1 ) && REG_P ( operand2 ) ) ; } return false ; } </s>

Return true iff EXPR represents the sum of two registers .


"Caller should have handled 0-size case"

Emit target-specific code that performs a memcmp/bcmp , in cases where that is faster than a libcall .


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

WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly


<s> void ARM64Subtarget :: overrideSchedPolicy ( MachineSchedPolicy & Policy , MachineInstr * begin , MachineInstr * end , unsigned NumRegionInstrs ) const { Policy . OnlyTopDown = false ; Policy . OnlyBottomUp = false ; } </s>

Override generic scheduling policy within a region .


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


<s> FastISel * X86TargetLowering :: createFastISel ( MachineFunction & mf , DenseMap < const Value * , unsigned > & vm , DenseMap < const BasicBlock * , MachineBasicBlock * > & bm , DenseMap < const AllocaInst * , int > & am , SmallSet < const Instruction * , 8 > & cil ) { return X86 :: createFastISel ( mf , vm , bm , am , cil ) ; } </s>

This method returns a target specific FastISel object , or null if the target does not support `` fast '' ISel .


<s> static bool nios2_large_constant_allowed ( void ) { return ! ( cfun -> curr_properties & PROP_rtl_split_insns ) && ! reload_completed ; } </s>

Symbol references and other 32-bit constants are split into high/lo_sum pairs during the split1 pass . After that , they are not considered legitimate addresses . This function returns true if in a pre-split context where these constants are allowed .


<s>
void
AArch64TargetLowering
::
ReplaceNodeResults
(
SDNode
*
N
,
SmallVectorImpl
<
SDValue
>
&
Results
,
SelectionDAG
&
DAG
)
const
{
switch
(
N
->
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Don't know how to custom expand this"
)
;
case
ISD
::
BITCAST
:
ReplaceBITCASTResults
(
N
,
Results
,
DAG
)
;
return
;
case
ISD
::
VECREDUCE_ADD
:
case
ISD
::
VECREDUCE_SMAX
:
case
ISD
::
VECREDUCE_SMIN
:
case
ISD
::
VECREDUCE_UMAX
:
case
ISD
::
VECREDUCE_UMIN
:
Results
.
push_back
(
LowerVECREDUCE
(
SDValue
(
N
,
0
)
,
DAG
)
)
;
return
;
case
AArch64ISD
::
SADDV
:
ReplaceReductionResults
(
N
,
Results
,
DAG
,
ISD
::
ADD
,
AArch64ISD
::
SADDV
)
;
return
;
case
AArch64ISD
::
UADDV
:
ReplaceReductionResults
(
N
,
Results
,
DAG
,
ISD
::
ADD
,
AArch64ISD
::
UADDV
)
;
return
;
case
AArch64ISD
::
SMINV
:
ReplaceReductionResults
(
N
,
Results
,
DAG
,
ISD
::
SMIN
,
AArch64ISD
::
SMINV
)
;
return
;
case
AArch64ISD
::
UMINV
:
ReplaceReductionResults
(
N
,
Results
,
DAG
,
ISD
::
UMIN
,
AArch64ISD
::
UMINV
)
;
return
;
case
AArch64ISD
::
SMAXV
:
ReplaceReductionResults
(
N
,
Results
,
DAG
,
ISD
::
SMAX
,
AArch64ISD
::
SMAXV
)
;
return
;
case
AArch64ISD
::
UMAXV
:
ReplaceReductionResults
(
N
,
Results
,
DAG
,
ISD
::
UMAX
,
AArch64ISD
::
UMAXV
)
;
return
;
case
ISD
::
FP_TO_UINT
:
case
ISD
::
FP_TO_SINT
:
assert
(
N
->
getValueType
(
0
)
==
MVT
::
i128
&&
"unexpected illegal conversion"
)
;
return
;
case
ISD
::
ATOMIC_CMP_SWAP
:
ReplaceCMP_SWAP_128Results
(
N
,
Results
,
DAG
,
Subtarget
)
;
return
;
}
}
</s>

ReplaceNodeResults - Replace the results of node with an illegal result type with new values built out of custom code .


"Copy one register into another with a different width"


<s> bool MipsSEInstrInfo :: isBranchWithImm ( unsigned Opc ) const { switch ( Opc ) { default : return false ; case Mips :: BBIT0 : case Mips :: BBIT1 : case Mips :: BBIT032 : case Mips :: BBIT132 : return true ; } } </s>

isBranchWithImm - Return true if the branch contains an immediate operand (


<s> const InstrItineraryData * getInstrItineraryData ( ) const override { return Subtarget . inMips16Mode ( ) ? nullptr : & InstrItins ; } </s>

getInstrItineraryData - Returns instruction itinerary data for the target or specific subtarget .


<s> static void alpha_builtin_function ( const char * name , tree ftype , enum alpha_builtin code , unsigned ecf ) { tree decl = add_builtin_function ( name , ftype , ( int ) code , BUILT_IN_MD , NULL , NULL_TREE ) ; if ( ecf & ECF_CONST ) TREE_READONLY ( decl ) = 1 ; if ( ecf & ECF_NOTHROW ) TREE_NOTHROW ( decl ) = 1 ; alpha_builtins [ ( int ) code ] = decl ; } </s>

Helper function of alpha_init_builtins . Add the built-in specified by NAME , TYPE , CODE , and ECF .


<s> unsigned SystemZTTIImpl :: getMinPrefetchStride ( unsigned NumMemAccesses , unsigned NumStridedMemAccesses , unsigned NumPrefetches , bool HasCall ) const { if ( NumPrefetches > 16 ) return UINT_MAX ; if ( NumStridedMemAccesses > 32 && NumStridedMemAccesses == NumMemAccesses && ! HasCall ) return 1 ; return ST -> hasMiscellaneousExtensions3 ( ) ? 8192 : 2048 ; } </s>

Some HW prefetchers can handle accesses up to a certain constant stride .


<s>
bool
TVMInstrInfo
::
reverseBranchCondition
(
SmallVectorImpl
<
MachineOperand
>
&
Cond
)
const
{
assert
(
Cond
.
size
(
)
==
2
&&
"Wrong Cond args size"
)
;
Cond
[
0
]
.
setImm
(
!
Cond
[
0
]
.
getImm
(
)
)
;
return
false
;
}
</s>

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


<s> virtual void getAnalysisUsage ( AnalysisUsage & AU ) const { AU . addRequired < MachineDominatorTree > ( ) ; AU . addPreserved < MachineDominatorTree > ( ) ; MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> unsigned DLXRegisterInfo :: getRARegister ( ) const { return DLX :: RA ; } </s>

This method should return the register where the return address can be found .


<s> XtensaSubtarget & XtensaSubtarget :: initializeSubtargetDependencies ( StringRef FS , StringRef CPUString ) { ParseSubtargetFeatures ( CPUString , FS ) ; return * this ; } </s>

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


"builtin function %qs is only valid for the cell processor"

"builtin function %qs requires the %qs option"

"builtin function %qs requires the %qs and %qs options"

"builtin function %qs requires ISA 3.0 IEEE 128-bit floating point"

"builtin function %qs requires the %qs (or newer), and "

"builtin function %qs is not supported with the current options"

Raise an error message for a builtin function that is called without the appropriate target options being set .


<s> unsigned AArch64RegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; return TFI -> hasFP ( MF ) ? AArch64 :: FP : AArch64 :: SP ; } </s>


<s> MachineInstr * foldMemoryOperandImpl ( MachineFunction & MF , MachineInstr * MI , const SmallVectorImpl < unsigned > & Ops , MachineInstr * LoadMI ) const override { return nullptr ; } </s>

foldMemoryOperand - Same as the previous version except it allows folding of any load and store from / to any address , not just from a specific stack slot .


<s> bool PPCTTIImpl :: enableAggressiveInterleaving ( bool LoopHasReductions ) { if ( ST -> getMcpu ( ) == PPC :: MCPU_A2 ) return true ; return LoopHasReductions ; } </s>

Do n't restrict interleaved unrolling to small loops .


<s> void LanaiTargetLowering :: computeKnownBitsForTargetNode ( const SDValue Op , KnownBits & Known , const APInt & DemandedElts , const SelectionDAG & DAG , unsigned Depth ) const { unsigned BitWidth = Known . getBitWidth ( ) ; switch ( Op . getOpcode ( ) ) { default : break ; case LanaiISD :: SETCC : Known = KnownBits ( BitWidth ) ; Known . Zero . setBits ( 1 , BitWidth ) ; break ; case LanaiISD :: SELECT_CC : KnownBits Known2 ; Known = DAG . computeKnownBits ( Op -> getOperand ( 0 ) , Depth + 1 ) ; Known2 = DAG . computeKnownBits ( Op -> getOperand ( 1 ) , Depth + 1 ) ; Known = KnownBits :: commonBits ( Known , Known2 ) ; break ; } } </s>

Determine which of the bits specified in Mask are known to be either zero or one and return them in the KnownZero/KnownOne bitsets .


<s> static bool pdp11_rtx_costs ( rtx x , int code , int outer_code ATTRIBUTE_UNUSED , int opno ATTRIBUTE_UNUSED , int * total , bool speed ATTRIBUTE_UNUSED ) { switch ( code ) { case CONST_INT : if ( INTVAL ( x ) == 0 || INTVAL ( x ) == - 1 || INTVAL ( x ) == 1 ) { * total = 0 ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : * total = 2 ; return true ; case CONST_DOUBLE : * total = 4 ; return true ; case MULT : if ( optimize_size ) * total = COSTS_N_INSNS ( 2 ) ; else * total = COSTS_N_INSNS ( 11 ) ; return false ; case DIV : if ( optimize_size ) * total = COSTS_N_INSNS ( 2 ) ; else * total = COSTS_N_INSNS ( 25 ) ; return false ; case MOD : if ( optimize_size ) * total = COSTS_N_INSNS ( 2 ) ; else * total = COSTS_N_INSNS ( 26 ) ; return false ; case ABS : * total = COSTS_N_INSNS ( 3 ) ; return false ; case ZERO_EXTEND : * total = COSTS_N_INSNS ( 1 ) ; return false ; case SIGN_EXTEND : if ( GET_MODE ( x ) == HImode ) * total = COSTS_N_INSNS ( 1 ) ; else if ( GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( 6 ) ; else * total = COSTS_N_INSNS ( 2 ) ; return false ; case ASHIFT : case LSHIFTRT : case ASHIFTRT : if ( optimize_size ) * total = COSTS_N_INSNS ( 1 ) ; else if ( GET_MODE ( x ) == QImode ) { if ( GET_CODE ( XEXP ( x , 1 ) ) != CONST_INT ) * total = COSTS_N_INSNS ( 8 ) ; else * total = COSTS_N_INSNS ( INTVAL ( XEXP ( x , 1 ) ) ) ; } else if ( GET_MODE ( x ) == HImode ) { if ( GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT ) { if ( abs ( INTVAL ( XEXP ( x , 1 ) ) ) == 1 ) * total = COSTS_N_INSNS ( 1 ) ; else * total = COSTS_N_INSNS ( 2.5 + 0.5 * INTVAL ( XEXP ( x , 1 ) ) ) ; } else * total = COSTS_N_INSNS ( 10 ) ; } else if ( GET_MODE ( x ) == SImode ) { if ( GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT ) * total = COSTS_N_INSNS ( 2.5 + 0.5 * INTVAL ( XEXP ( x , 1 ) ) ) ; else * total = COSTS_N_INSNS ( 18 ) ; } return false ; default : return false ; } } </s>

This tries to approximate what pdp11_insn_cost would do , but without visibility into the actual instruction being generated it 's inevitably a rough approximation .


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

Return a register mask that clobbers everything .


<s> void ARMBaseInstrInfo :: reMaterialize ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned DestReg , unsigned SubIdx , const MachineInstr * Orig , const TargetRegisterInfo & TRI ) const { unsigned Opcode = Orig -> getOpcode ( ) ; switch ( Opcode ) { default : { MachineInstr * MI = MBB . getParent ( ) -> CloneMachineInstr ( Orig ) ; MI -> substituteRegister ( Orig -> getOperand ( 0 ) . getReg ( ) , DestReg , SubIdx , TRI ) ; MBB . insert ( I , MI ) ; break ; } case ARM :: tLDRpci_pic : case ARM :: t2LDRpci_pic : { MachineFunction & MF = * MBB . getParent ( ) ; unsigned CPI = Orig -> getOperand ( 1 ) . getIndex ( ) ; unsigned PCLabelId = duplicateCPV ( MF , CPI ) ; MachineInstrBuilder MIB = BuildMI ( MBB , I , Orig -> getDebugLoc ( ) , get ( Opcode ) , DestReg ) . addConstantPoolIndex ( CPI ) . addImm ( PCLabelId ) ; ( * MIB ) . setMemRefs ( Orig -> memoperands_begin ( ) , Orig -> memoperands_end ( ) ) ; break ; } } } </s>

Re-issue the specified 'original ' instruction at the specific location targeting a new destination register .