<s> bool X86InstrInfo :: isHighLatencyDef ( int opc ) const { switch ( opc ) { default : return false ; case X86 :: DIVSDrm : case X86 :: DIVSDrm_Int : case X86 :: DIVSDrr : case X86 :: DIVSDrr_Int : case X86 :: DIVSSrm : case X86 :: DIVSSrm_Int : case X86 :: DIVSSrr : case X86 :: DIVSSrr_Int : case X86 :: SQRTPDm : case X86 :: SQRTPDr : case X86 :: SQRTPSm : case X86 :: SQRTPSr : case X86 :: SQRTSDm : case X86 :: SQRTSDm_Int : case X86 :: SQRTSDr : case X86 :: SQRTSDr_Int : case X86 :: SQRTSSm : case X86 :: SQRTSSm_Int : case X86 :: SQRTSSr : case X86 :: SQRTSSr_Int : case X86 :: VDIVSDrm : case X86 :: VDIVSDrm_Int : case X86 :: VDIVSDrr : case X86 :: VDIVSDrr_Int : case X86 :: VDIVSSrm : case X86 :: VDIVSSrm_Int : case X86 :: VDIVSSrr : case X86 :: VDIVSSrr_Int : case X86 :: VSQRTPDm : case X86 :: VSQRTPDr : case X86 :: VSQRTPSm : case X86 :: VSQRTPSr : case X86 :: VSQRTSDm : case X86 :: VSQRTSDm_Int : case X86 :: VSQRTSDr : case X86 :: VSQRTSSm : case X86 :: VSQRTSSm_Int : case X86 :: VSQRTSSr : case X86 :: VSQRTPDZrm : case X86 :: VSQRTPDZrr : case X86 :: VSQRTPSZrm : case X86 :: VSQRTPSZrr : case X86 :: VSQRTSDZm : case X86 :: VSQRTSDZm_Int : case X86 :: VSQRTSDZr : case X86 :: VSQRTSSZm_Int : case X86 :: VSQRTSSZr : case X86 :: VSQRTSSZm : case X86 :: VDIVSDZrm : case X86 :: VDIVSDZrr : case X86 :: VDIVSSZrm : case X86 :: VDIVSSZrr : case X86 :: VGATHERQPSZrm : case X86 :: VGATHERQPDZrm : case X86 :: VGATHERDPDZrm : case X86 :: VGATHERDPSZrm : case X86 :: VPGATHERQDZrm : case X86 :: VPGATHERQQZrm : case X86 :: VPGATHERDDZrm : case X86 :: VPGATHERDQZrm : case X86 :: VSCATTERQPDZmr : case X86 :: VSCATTERQPSZmr : case X86 :: VSCATTERDPDZmr : case X86 :: VSCATTERDPSZmr : case X86 :: VPSCATTERQDZmr : case X86 :: VPSCATTERQQZmr : case X86 :: VPSCATTERDDZmr : case X86 :: VPSCATTERDQZmr : return true ; } } </s>

Return true if this opcode has high latency to its result .


<s> static inline tree def_builtin ( HOST_WIDE_INT mask , const char * name , enum ix86_builtin_func_type tcode , enum ix86_builtins code ) { tree decl = NULL_TREE ; if ( ! ( mask & OPTION_MASK_ISA_64BIT ) || TARGET_64BIT ) { ix86_builtins_isa [ ( int ) code ] . isa = mask ; mask &= ~ OPTION_MASK_ISA_64BIT ; if ( mask == 0 || ( mask & ix86_isa_flags ) != 0 || ( lang_hooks . builtin_function == lang_hooks . builtin_function_ext_scope ) ) { tree type = ix86_get_builtin_func_type ( tcode ) ; decl = add_builtin_function ( name , type , code , BUILT_IN_MD , NULL , NULL_TREE ) ; ix86_builtins [ ( int ) code ] = decl ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = false ; } else { deferred_isa_values |= mask ; ix86_builtins [ ( int ) code ] = NULL_TREE ; ix86_builtins_isa [ ( int ) code ] . tcode = tcode ; ix86_builtins_isa [ ( int ) code ] . name = name ; ix86_builtins_isa [ ( int ) code ] . leaf_p = false ; ix86_builtins_isa [ ( int ) code ] . nothrow_p = false ; ix86_builtins_isa [ ( int ) code ] . const_p = false ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = true ; } } return decl ; } </s>

Add a SPARC builtin function with NAME , ICODE , CODE and TYPE . Return the function decl or NULL_TREE if the builtin was not added .


<s> void avr_init_once ( ) { tmp_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + 1 * sizeof ( rtunion ) ) ; memset ( tmp_reg_rtx , 0 , sizeof ( struct rtx_def ) + 1 * sizeof ( rtunion ) ) ; PUT_CODE ( tmp_reg_rtx , REG ) ; PUT_MODE ( tmp_reg_rtx , QImode ) ; XINT ( tmp_reg_rtx , 0 ) = TMP_REGNO ; zero_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + 1 * sizeof ( rtunion ) ) ; memset ( zero_reg_rtx , 0 , sizeof ( struct rtx_def ) + 1 * sizeof ( rtunion ) ) ; PUT_CODE ( zero_reg_rtx , REG ) ; PUT_MODE ( zero_reg_rtx , QImode ) ; XINT ( zero_reg_rtx , 0 ) = ZERO_REGNO ; ldi_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + 1 * sizeof ( rtunion ) ) ; memset ( ldi_reg_rtx , 0 , sizeof ( struct rtx_def ) + 1 * sizeof ( rtunion ) ) ; PUT_CODE ( ldi_reg_rtx , REG ) ; PUT_MODE ( ldi_reg_rtx , QImode ) ; XINT ( ldi_reg_rtx , 0 ) = LDI_REG_REGNO ; } </s>


<s> void Thumb2InstrInfo :: storeRegToStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned SrcReg , bool isKill , int FI , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL ; if ( I != MBB . end ( ) ) DL = I -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FI ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FI ) , MFI . getObjectAlignment ( FI ) ) ; if ( RC == & ARM :: GPRRegClass || RC == & ARM :: tGPRRegClass || RC == & ARM :: tcGPRRegClass || RC == & ARM :: rGPRRegClass || RC == & ARM :: GPRnopcRegClass ) { AddDefaultPred ( BuildMI ( MBB , I , DL , get ( ARM :: t2STRi12 ) ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addMemOperand ( MMO ) ) ; return ; } if ( ARM :: GPRPairRegClass . hasSubClassEq ( RC ) ) { if ( TargetRegisterInfo :: isVirtualRegister ( SrcReg ) ) { MachineRegisterInfo * MRI = & MF . getRegInfo ( ) ; MRI -> constrainRegClass ( SrcReg , & ARM :: GPRPair_with_gsub_1_in_rGPRRegClass ) ; } MachineInstrBuilder MIB = BuildMI ( MBB , I , DL , get ( ARM :: t2STRDi8 ) ) ; AddDReg ( MIB , SrcReg , ARM :: gsub_0 , getKillRegState ( isKill ) , TRI ) ; AddDReg ( MIB , SrcReg , ARM :: gsub_1 , 0 , TRI ) ; MIB . addFrameIndex ( FI ) . addImm ( 0 ) . addMemOperand ( MMO ) ; AddDefaultPred ( MIB ) ; return ; } ARMBaseInstrInfo :: storeRegToStackSlot ( MBB , I , SrcReg , isKill , FI , RC , TRI ) ; } </s>

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


<s> bool X86TargetLowering :: SimplifyDemandedBitsForTargetNode ( SDValue Op , const APInt & OriginalDemandedBits , KnownBits & Known , TargetLoweringOpt & TLO , unsigned Depth ) const { unsigned Opc = Op . getOpcode ( ) ; switch ( Opc ) { case X86ISD :: PMULDQ : case X86ISD :: PMULUDQ : { KnownBits KnownOp ; SDValue LHS = Op . getOperand ( 0 ) ; SDValue RHS = Op . getOperand ( 1 ) ; APInt DemandedMask = APInt :: getLowBitsSet ( 64 , 32 ) ; if ( SimplifyDemandedBits ( LHS , DemandedMask , KnownOp , TLO , Depth + 1 ) ) return true ; if ( SimplifyDemandedBits ( RHS , DemandedMask , KnownOp , TLO , Depth + 1 ) ) return true ; break ; } } return TargetLowering :: SimplifyDemandedBitsForTargetNode ( Op , OriginalDemandedBits , Known , TLO , Depth ) ; } </s>

Attempt to simplify any target nodes based on the demanded bits/elts , returning true on success .


<s> static int supersparc_adjust_cost ( rtx_insn * insn , rtx link , rtx_insn * dep_insn , int cost ) { enum attr_type insn_type ; if ( recog_memoized ( insn ) < 0 ) return cost ; insn_type = get_attr_type ( insn ) ; if ( REG_NOTE_KIND ( link ) == 0 ) { if ( insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD ) return cost + 3 ; if ( insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE ) { rtx pat = PATTERN ( insn ) ; rtx dep_pat = PATTERN ( dep_insn ) ; if ( GET_CODE ( pat ) != SET || GET_CODE ( dep_pat ) != SET ) return cost ; if ( rtx_equal_p ( SET_DEST ( dep_pat ) , SET_SRC ( pat ) ) ) return cost ; return cost + 3 ; } if ( insn_type == TYPE_SHIFT ) return cost + 3 ; } else { if ( insn_type == TYPE_IALU || insn_type == TYPE_SHIFT ) return 0 ; } return cost ; } </s>

Adjust the cost of a scheduling dependency . Return the new cost of a dependency LINK or INSN on DEP_INSN . COST is the current cost .


<s> void assignValueToReg ( unsigned ValVReg , unsigned PhysReg , CCValAssign & VA ) override { MIB . addDef ( PhysReg , RegState :: Implicit ) ; MIRBuilder . buildCopy ( ValVReg , PhysReg ) ; } </s>

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


<s> const uint16_t * GBZ80RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { if ( MF -> getFunction ( ) . getFunctionType ( ) -> getNumParams ( ) <= 1 ) return CSR_0_1_SaveList ; else return CSR_2_SaveList ; } </s>


<s> void nds32_expand_prologue_v3push ( void ) { int fp_adjust ; int sp_adjust ; int fpr_space = 0 ; unsigned Rb , Re ; nds32_compute_stack_frame ( ) ; if ( cfun -> machine -> callee_saved_gpr_regs_size > 0 ) df_set_regs_ever_live ( FP_REGNUM , 1 ) ; if ( frame_pointer_needed ) cfun -> machine -> fp_as_gp_p = false ; if ( cfun -> machine -> naked_p && ! flag_pic ) return ; Rb = cfun -> machine -> callee_saved_first_gpr_regno ; Re = cfun -> machine -> callee_saved_last_gpr_regno ; sp_adjust = cfun -> machine -> local_size + cfun -> machine -> out_args_size + cfun -> machine -> callee_saved_area_gpr_padding_bytes + cfun -> machine -> callee_saved_fpr_regs_size ; if ( satisfies_constraint_Iu08 ( GEN_INT ( sp_adjust ) ) && NDS32_DOUBLE_WORD_ALIGN_P ( sp_adjust ) ) { nds32_emit_stack_v3push ( Rb , Re , sp_adjust ) ; if ( cfun -> machine -> callee_saved_first_fpr_regno != SP_REGNUM ) { int fpr_position = cfun -> machine -> local_size + cfun -> machine -> out_args_size ; nds32_emit_push_fpr_callee_saved ( fpr_position ) ; } if ( frame_pointer_needed ) { fp_adjust = cfun -> machine -> fp_size + cfun -> machine -> gp_size + cfun -> machine -> lp_size + cfun -> machine -> callee_saved_gpr_regs_size + sp_adjust ; nds32_emit_adjust_frame ( hard_frame_pointer_rtx , stack_pointer_rtx , fp_adjust ) ; } } else { if ( cfun -> machine -> callee_saved_first_fpr_regno != SP_REGNUM ) { fpr_space = cfun -> machine -> callee_saved_area_gpr_padding_bytes + cfun -> machine -> callee_saved_fpr_regs_size ; nds32_emit_stack_v3push ( Rb , Re , fpr_space ) ; nds32_emit_push_fpr_callee_saved ( 0 ) ; } else { nds32_emit_stack_v3push ( Rb , Re , 0 ) ; } if ( frame_pointer_needed ) { fp_adjust = cfun -> machine -> fp_size + cfun -> machine -> gp_size + cfun -> machine -> lp_size + cfun -> machine -> callee_saved_gpr_regs_size ; if ( cfun -> machine -> callee_saved_first_fpr_regno != SP_REGNUM ) { fp_adjust = fp_adjust + fpr_space ; } nds32_emit_adjust_frame ( hard_frame_pointer_rtx , stack_pointer_rtx , fp_adjust ) ; } if ( cfun -> machine -> callee_saved_first_fpr_regno != SP_REGNUM ) { sp_adjust = sp_adjust - fpr_space ; } nds32_emit_adjust_frame ( stack_pointer_rtx , stack_pointer_rtx , - 1 * sp_adjust ) ; } if ( flag_pic && df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) ) nds32_emit_load_gp ( ) ; emit_insn ( gen_blockage ( ) ) ; } </s>


<s> static bool riscv_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { unsigned int nregs = riscv_hard_regno_nregs ( regno , mode ) ; if ( GP_REG_P ( regno ) ) { if ( ! GP_REG_P ( regno + nregs - 1 ) ) return false ; } else if ( FP_REG_P ( regno ) ) { if ( ! FP_REG_P ( regno + nregs - 1 ) ) return false ; if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && GET_MODE_CLASS ( mode ) != MODE_COMPLEX_FLOAT ) return false ; if ( GET_MODE_UNIT_SIZE ( mode ) > UNITS_PER_FP_REG || ( ! call_used_or_fixed_reg_p ( regno ) && GET_MODE_UNIT_SIZE ( mode ) > UNITS_PER_FP_ARG ) ) return false ; } else return false ; for ( unsigned i = 1 ; i < nregs ; i ++ ) if ( call_used_or_fixed_reg_p ( regno ) != call_used_or_fixed_reg_p ( regno + i ) ) return false ; return true ; } </s>


"%qE attribute ignored without %<-mcmse%> "

"%qE attribute only applies to functions"

"%qE attribute has no effect on functions "

Called upon detection of the use of the cmse_nonsecure_entry attribute , this function will check whether the attribute is allowed here and will add the attribute to the function declaration tree or otherwise issue a warning .


<s>
PPCTTI
::
PopcntSupportKind
PPCTTI
::
getPopcntSupport
(
unsigned
TyWidth
)
const
{
assert
(
isPowerOf2_32
(
TyWidth
)
&&
"Ty width must be power of 2"
)
;
return
PSK_Software
;
}
</s>

Return hardware support for population count .

PowerPC
PPC
PPC
"Ty width must be power of 2"


<s> static inline bool current_function_has_lr_slot ( void ) { return current_frame_info . lr_slot != 0 ; } </s>

Accessor for current_frame_info.lr_slot .


<s> static void emit_load_locked ( enum machine_mode mode , rtx reg , rtx mem ) { rtx ( * fn ) ( rtx , rtx ) = NULL ; if ( mode == SImode ) fn = gen_load_locked_si ; else if ( mode == DImode ) fn = gen_load_locked_di ; emit_insn ( fn ( reg , mem ) ) ; } </s>

A subroutine of the atomic operation splitters . Emit a load-locked instruction in MODE . For QI/HImode , possibly use a pattern than includes the zero_extend operation .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . setPreservesCFG ( ) ; FunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> inline unsigned int function_instance :: elements_per_vq ( unsigned int i ) const { return 128 / type_suffix ( i ) . element_bits ; } </s>

Return the number of elements of type suffix I that fit within a 128-bit block .


<s> unsigned RISCVInstrInfo :: removeBranch ( MachineBasicBlock & MBB , int * BytesRemoved ) const { if ( BytesRemoved ) * BytesRemoved = 0 ; MachineBasicBlock :: iterator I = MBB . getLastNonDebugInstr ( ) ; if ( I == MBB . end ( ) ) return 0 ; if ( ! I -> getDesc ( ) . isUnconditionalBranch ( ) && ! I -> getDesc ( ) . isConditionalBranch ( ) ) return 0 ; I -> eraseFromParent ( ) ; if ( BytesRemoved ) * BytesRemoved += getInstSizeInBytes ( * I ) ; I = MBB . end ( ) ; if ( I == MBB . begin ( ) ) return 1 ; -- I ; if ( ! I -> getDesc ( ) . isConditionalBranch ( ) ) return 1 ; I -> eraseFromParent ( ) ; if ( BytesRemoved ) * BytesRemoved += getInstSizeInBytes ( * I ) ; return 2 ; } </s>

Remove the branching code at the end of the specific MBB .


<s>
const
char
*
PTXTargetLowering
::
getTargetNodeName
(
unsigned
Opcode
)
const
{
switch
(
Opcode
)
{
default
:
llvm_unreachable
(
"Unknown opcode"
)
;
case
PTXISD
::
COPY_ADDRESS
:
return
"PTXISD::COPY_ADDRESS"
;
case
PTXISD
::
LOAD_PARAM
:
return
"PTXISD::LOAD_PARAM"
;
case
PTXISD
::
STORE_PARAM
:
return
"PTXISD::STORE_PARAM"
;
case
PTXISD
::
READ_PARAM
:
return
"PTXISD::READ_PARAM"
;
case
PTXISD
::
WRITE_PARAM
:
return
"PTXISD::WRITE_PARAM"
;
case
PTXISD
::
EXIT
:
return
"PTXISD::EXIT"
;
case
PTXISD
::
RET
:
return
"PTXISD::RET"
;
case
PTXISD
::
CALL
:
return
"PTXISD::CALL"
;
}
}
</s>

getTargetNodeName - This method returns the name of a target specific


<s> void Thumb1FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { const Thumb1InstrInfo & TII = * static_cast < const Thumb1InstrInfo * > ( STI . getInstrInfo ( ) ) ; const ThumbRegisterInfo * RegInfo = static_cast < const ThumbRegisterInfo * > ( STI . getRegisterInfo ( ) ) ; if ( ! hasReservedCallFrame ( MF ) ) { MachineInstr * Old = I ; DebugLoc dl = Old -> getDebugLoc ( ) ; unsigned Amount = Old -> getOperand ( 0 ) . getImm ( ) ; if ( Amount != 0 ) { unsigned Align = getStackAlignment ( ) ; Amount = ( Amount + Align - 1 ) / Align * Align ; unsigned Opc = Old -> getOpcode ( ) ; if ( Opc == ARM :: ADJCALLSTACKDOWN || Opc == ARM :: tADJCALLSTACKDOWN ) { emitSPUpdate ( MBB , I , TII , dl , * RegInfo , - Amount ) ; } else { assert ( Opc == ARM :: ADJCALLSTACKUP || Opc == ARM :: tADJCALLSTACKUP ) ; emitSPUpdate ( MBB , I , TII , dl , * RegInfo , Amount ) ; } } } MBB . erase ( I ) ; } </s>

This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy pseudo instructions ( but only if the Target is using them ) .


<s>
static
bool
sizeless_type_p
(
const_tree
type
)
{
if
(
type
==
error_mark_node
)
return
NULL_TREE
;
return
lookup_attribute
(
"RVV sizeless type"
,
TYPE_ATTRIBUTES
(
type
)
)
;
}
</s>

Return true if TYPE is a sizeless type .


<s>
void
MipsSEInstrInfo
::
loadRegFromStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
DestReg
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
MachineMemOperand
*
MMO
=
GetMemOperand
(
MBB
,
FI
,
MachineMemOperand
::
MOLoad
)
;
unsigned
Opc
=
0
;
if
(
Mips
::
CPURegsRegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
LW_P8
:
Mips
::
LW
;
else
if
(
Mips
::
CPU64RegsRegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
LD_P8
:
Mips
::
LD
;
else
if
(
Mips
::
FGR32RegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
LWC1_P8
:
Mips
::
LWC1
;
else
if
(
Mips
::
AFGR64RegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
Mips
::
LDC1
;
else
if
(
Mips
::
FGR64RegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
LDC164_P8
:
Mips
::
LDC164
;
assert
(
Opc
&&
"Register class not handled!"
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DestReg
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
;
}
</s>

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


<s>
void
HexagonInstPrinter
::
printSymbol
(
MCInst
const
*
MI
,
unsigned
OpNo
,
raw_ostream
&
O
,
bool
hi
)
const
{
assert
(
MI
->
getOperand
(
OpNo
)
.
isImm
(
)
&&
"Unknown symbol operand"
)
;
O
<<
'#'
<<
(
hi
"HI"
:
"LO"
)
<<
'('
;
O
<<
'#'
;
printOperand
(
MI
,
OpNo
,
O
)
;
O
<<
')'
;
}
</s>

Hexagon
Hexagon
"Unknown symbol operand"
"HI"
"LO"


<s>
void
Z80AsmPrinter
::
emitHeader
(
Module
&
M
,
raw_ostream
&
os
)
{
os
<<
"; Compiled using LLVM Z80 backend\n"
;
}
</s>

Emit the header for this unit , not including the initial length field .


<s> bool X86TargetLowering :: getTgtMemIntrinsic ( IntrinsicInfo & Info , const CallInst & I , unsigned Intrinsic ) const { const IntrinsicData * IntrData = getIntrinsicWithChain ( Intrinsic ) ; if ( ! IntrData ) return false ; Info . opc = ISD :: INTRINSIC_W_CHAIN ; Info . readMem = false ; Info . writeMem = false ; Info . vol = false ; Info . offset = 0 ; switch ( IntrData -> Type ) { case EXPAND_FROM_MEM : { Info . ptrVal = I . getArgOperand ( 0 ) ; Info . memVT = MVT :: getVT ( I . getType ( ) ) ; Info . align = 1 ; Info . readMem = true ; break ; } case COMPRESS_TO_MEM : { Info . ptrVal = I . getArgOperand ( 0 ) ; Info . memVT = MVT :: getVT ( I . getArgOperand ( 1 ) -> getType ( ) ) ; Info . align = 1 ; Info . writeMem = true ; break ; } case TRUNCATE_TO_MEM_VI8 : case TRUNCATE_TO_MEM_VI16 : case TRUNCATE_TO_MEM_VI32 : { 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 = 1 ; Info . writeMem = true ; 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>
unsigned
getReg
(
)
const
override
{
assert
(
isReg
(
)
&&
"Invalid type access!"
)
;
return
Reg
.
RegNo
;
}
</s>

Returns the register associated with this edge .


<s> TargetLoweringBase :: LegalizeTypeAction SITargetLowering :: getPreferredVectorAction ( MVT VT ) const { if ( ! VT . isScalableVector ( ) && VT . getVectorNumElements ( ) != 1 && VT . getScalarType ( ) . bitsLE ( MVT :: i16 ) ) return VT . isPow2VectorType ( ) ? TypeSplitVector : TypeWidenVector ; return TargetLoweringBase :: getPreferredVectorAction ( VT ) ; } </s>

Customize the preferred legalization strategy for certain types .


"Lower aggregate copies/intrinsics into loops"

getPassName - Return a nice clean name for a pass .


<s> void AArch64PostSelectOptimize :: getAnalysisUsage ( AnalysisUsage & AU ) const { AU . addRequired < TargetPassConfig > ( ) ; AU . setPreservesCFG ( ) ; getSelectionDAGFallbackAnalysisUsage ( AU ) ; MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>


<s> virtual unsigned int execute ( function * ) { return execute_omp_gcn ( ) ; } </s>


<s> SDValue MipsSelectionDAGInfo :: EmitTargetCodeForMemcpy ( SelectionDAG & DAG , const SDLoc & dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , Align Alignment , bool isVolatile , bool AlwaysInline , bool MustPreserveCheriCapabilities , MachinePointerInfo DstPtrInfo , MachinePointerInfo SrcPtrInfo ) const { return EmitTargetCodeForMemOp ( DAG , dl , Chain , Dst , Src , Size , Alignment , isVolatile , AlwaysInline , MustPreserveCheriCapabilities , DstPtrInfo , SrcPtrInfo , true ) ; } </s>

Emit target-specific code that performs a memcpy .


<s> void HexagonRegisterInfo :: eliminateFrameIndex ( MachineBasicBlock :: iterator II , int SPAdj , unsigned FIOp , RegScavenger * RS ) const { assert ( SPAdj == 0 && "Unexpected" ) ; MachineInstr & MI = * II ; MachineBasicBlock & MB = * MI . getParent ( ) ; MachineFunction & MF = * MB . getParent ( ) ; auto & HST = MF . getSubtarget < HexagonSubtarget > ( ) ; auto & HII = * HST . getInstrInfo ( ) ; auto & HFI = * HST . getFrameLowering ( ) ; unsigned BP = 0 ; int FI = MI . getOperand ( FIOp ) . getIndex ( ) ; int Offset = HFI . getFrameIndexReference ( MF , FI , BP ) ; int RealOffset = Offset + MI . getOperand ( FIOp + 1 ) . getImm ( ) ; bool IsKill = false ; unsigned Opc = MI . getOpcode ( ) ; switch ( Opc ) { case Hexagon :: TFR_FIA : MI . setDesc ( HII . get ( Hexagon :: A2_addi ) ) ; MI . getOperand ( FIOp ) . ChangeToImmediate ( RealOffset ) ; MI . RemoveOperand ( FIOp + 1 ) ; return ; case Hexagon :: TFR_FI : MI . setDesc ( HII . get ( Hexagon :: A2_addi ) ) ; break ; } if ( ! HII . isValidOffset ( Opc , RealOffset ) ) { auto & MRI = MF . getRegInfo ( ) ; unsigned TmpR = MRI . createVirtualRegister ( & Hexagon :: IntRegsRegClass ) ; const DebugLoc & DL = MI . getDebugLoc ( ) ; BuildMI ( MB , II , DL , HII . get ( Hexagon :: A2_addi ) , TmpR ) . addReg ( BP ) . addImm ( RealOffset ) ; BP = TmpR ; RealOffset = 0 ; IsKill = true ; } MI . getOperand ( FIOp ) . ChangeToRegister ( BP , false , false , IsKill ) ; MI . getOperand ( FIOp + 1 ) . ChangeToImmediate ( RealOffset ) ; } </s>

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


<s> bool AMDGPUTargetLowering :: isNarrowingProfitable ( EVT SrcVT , EVT DestVT ) const { return SrcVT . getSizeInBits ( ) > 32 && DestVT . getSizeInBits ( ) == 32 ; } </s>

Return true if it 's profitable to narrow operations of type SrcVT to DestVT .


<s> AArch64Subtarget :: AArch64Subtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const TargetMachine & TM , bool LittleEndian ) : AArch64GenSubtargetInfo ( TT , CPU , FS ) , ReserveX18 ( TT . isOSDarwin ( ) || TT . isOSWindows ( ) ) , IsLittle ( LittleEndian ) , TargetTriple ( TT ) , FrameLowering ( ) , InstrInfo ( initializeSubtargetDependencies ( FS , CPU ) ) , TSInfo ( ) , TLInfo ( TM , * this ) , GISel ( ) { GISelAccessor * AArch64GISel = new GISelAccessor ( ) ; AArch64GISelActualAccessor * AArch64GISel = new AArch64GISelActualAccessor ( ) ; AArch64GISel -> CallLoweringInfo . reset ( new AArch64CallLowering ( * getTargetLowering ( ) ) ) ; AArch64GISel -> Legalizer . reset ( new AArch64LegalizerInfo ( ) ) ; auto * RBI = new AArch64RegisterBankInfo ( * getRegisterInfo ( ) ) ; AArch64GISel -> InstSelector . reset ( createAArch64InstructionSelector ( * static_cast < const AArch64TargetMachine * > ( & TM ) , * this , * RBI ) ) ; AArch64GISel -> RegBankInfo . reset ( RBI ) ; setGISelAccessor ( * AArch64GISel ) ; } </s>

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


<s> int HSAILFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , unsigned & FrameReg ) const { return MF . getFrameInfo ( ) -> getObjectOffset ( FI ) ; } </s>

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


<s>
bool
AArch64CallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
unsigned
VReg
)
const
{
MachineFunction
&
MF
=
MIRBuilder
.
getMF
(
)
;
const
Function
&
F
=
*
MF
.
getFunction
(
)
;
auto
MIB
=
MIRBuilder
.
buildInstrNoInsert
(
AArch64
::
RET_ReallyLR
)
;
assert
(
(
(
Val
&&
VReg
)
||
(
!
Val
&&
!
VReg
)
)
&&
"Return value without a vreg"
)
;
bool
Success
=
true
;
if
(
VReg
)
{
const
AArch64TargetLowering
&
TLI
=
*
getTLI
<
AArch64TargetLowering
>
(
)
;
CCAssignFn
*
AssignFn
=
TLI
.
CCAssignFnForReturn
(
F
.
getCallingConv
(
)
)
;
MachineRegisterInfo
&
MRI
=
MF
.
getRegInfo
(
)
;
auto
&
DL
=
F
.
getParent
(
)
->
getDataLayout
(
)
;
ArgInfo
OrigArg
{
VReg
,
Val
->
getType
(
)
}
;
setArgFlags
(
OrigArg
,
AttributeList
::
ReturnIndex
,
DL
,
F
)
;
SmallVector
<
ArgInfo
,
8
>
SplitArgs
;
splitToValueTypes
(
OrigArg
,
SplitArgs
,
DL
,
MRI
,
[
&
]
(
unsigned
Reg
,
uint64_t
Offset
)
{
MIRBuilder
.
buildExtract
(
Reg
,
VReg
,
Offset
)
;
}
)
;
OutgoingArgHandler
Handler
(
MIRBuilder
,
MRI
,
MIB
,
AssignFn
,
AssignFn
)
;
Success
=
handleAssignments
(
MIRBuilder
,
SplitArgs
,
Handler
)
;
}
MIRBuilder
.
insertInstr
(
MIB
)
;
return
Success
;
}
</s>

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


<s> rtx gen_easy_altivec_constant ( rtx op ) { machine_mode mode = GET_MODE ( op ) ; int nunits = GET_MODE_NUNITS ( mode ) ; rtx val = CONST_VECTOR_ELT ( op , BYTES_BIG_ENDIAN ? nunits - 1 : 0 ) ; unsigned step = nunits / 4 ; unsigned copies = 1 ; if ( vspltis_constant ( op , step , copies ) ) return gen_rtx_VEC_DUPLICATE ( V4SImode , gen_lowpart ( SImode , val ) ) ; if ( step == 1 ) copies <<= 1 ; else step >>= 1 ; if ( vspltis_constant ( op , step , copies ) ) return gen_rtx_VEC_DUPLICATE ( V8HImode , gen_lowpart ( HImode , val ) ) ; if ( step == 1 ) copies <<= 1 ; else step >>= 1 ; if ( vspltis_constant ( op , step , copies ) ) return gen_rtx_VEC_DUPLICATE ( V16QImode , gen_lowpart ( QImode , val ) ) ; gcc_unreachable ( ) ; } </s>

Generate a VEC_DUPLICATE representing a vspltis [ bhw ] instruction whose result is OP . Abort if it is not possible .


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { Subtarget = & MF . getSubtarget < PPCSubtarget > ( ) ; bool Changed = AsmPrinter :: runOnMachineFunction ( MF ) ; emitXRayTable ( ) ; return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> const InstrItineraryData & getInstrItineraryData ( ) const { return InstrItins ; } </s>

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


<s> bool AMDGPUPassConfig :: addPreSched2 ( ) { const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . getGeneration ( ) <= AMDGPUSubtarget :: NORTHERN_ISLANDS ) { addPass ( createR600EmitClauseMarkers ( * TM ) ) ; } addPass ( & IfConverterID ) ; return false ; } </s>

This method may be implemented by targets that want to run passes after prolog-epilog insertion and before the second instruction scheduling pass .


<s> bool HexagonTargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT ) const { return Subtarget . hasV5Ops ( ) ; } </s>

Returns true if the target can instruction select the specified FP immediate natively .


<s> int HexagonMCInstrInfo :: getMinValue ( MCInstrInfo const & MCII , MCInst const & MCI ) { const uint64_t F = HexagonMCInstrInfo :: getDesc ( MCII , MCI ) . TSFlags ; bool S = ( F >> HexagonII :: ExtentSignedPos ) & HexagonII :: ExtentSignedMask ; assert ( HexagonMCInstrInfo :: isExtendable ( MCII , MCI ) || HexagonMCInstrInfo :: isExtended ( MCII , MCI ) ) ; if ( S ) return - ( 1 << ( HexagonMCInstrInfo :: getExtentBits ( MCII , MCI ) - 1 ) ) ; return 0 ; } </s>

Return the minimal unsigned value possible given these KnownBits .

Hexagon Hexagon Hexagon HexagonII::ExtentSignedPos HexagonII::ExtentSignedMask Hexagon Hexagon 1 Hexagon 1 0


<s>
void
HexagonFrameLowering
::
emitPrologue
(
MachineFunction
&
MF
)
const
{
MachineBasicBlock
&
MBB
=
MF
.
front
(
)
;
MachineFrameInfo
*
MFI
=
MF
.
getFrameInfo
(
)
;
MachineBasicBlock
::
iterator
MBBI
=
MBB
.
begin
(
)
;
const
HexagonRegisterInfo
*
QRI
=
static_cast
<
const
HexagonRegisterInfo
*
>
(
MF
.
getSubtarget
(
)
.
getRegisterInfo
(
)
)
;
DebugLoc
dl
=
MBBI
!=
MBB
.
end
(
)
MBBI
->
getDebugLoc
(
)
:
DebugLoc
(
)
;
determineFrameLayout
(
MF
)
;
int
NumBytes
=
(
int
)
MFI
->
getStackSize
(
)
;
MachineBasicBlock
::
iterator
InsertPt
=
MBB
.
begin
(
)
;
HexagonMachineFunctionInfo
*
FuncInfo
=
MF
.
getInfo
<
HexagonMachineFunctionInfo
>
(
)
;
const
std
::
vector
<
MachineInstr
*
>
&
AdjustRegs
=
FuncInfo
->
getAllocaAdjustInsts
(
)
;
for
(
std
::
vector
<
MachineInstr
*
>
::
const_iterator
i
=
AdjustRegs
.
begin
(
)
,
e
=
AdjustRegs
.
end
(
)
;
i
!=
e
;
++
i
)
{
MachineInstr
*
MI
=
*
i
;
assert
(
(
MI
->
getOpcode
(
)
==
Hexagon
::
ADJDYNALLOC
)
&&
"Expected adjust alloca node"
)
;
MachineOperand
&
MO
=
MI
->
getOperand
(
2
)
;
assert
(
MO
.
isImm
(
)
&&
"Expected immediate"
)
;
MO
.
setImm
(
MFI
->
getMaxCallFrameSize
(
)
)
;
}
if
(
hasFP
(
MF
)
)
{
const
int
ALLOCFRAME_MAX
=
16384
;
const
TargetInstrInfo
&
TII
=
*
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
if
(
NumBytes
>=
ALLOCFRAME_MAX
)
{
BuildMI
(
MBB
,
InsertPt
,
dl
,
TII
.
get
(
Hexagon
::
ALLOCFRAME
)
)
.
addImm
(
0
)
;
BuildMI
(
MBB
,
InsertPt
,
dl
,
TII
.
get
(
Hexagon
::
CONST32_Int_Real
)
,
HEXAGON_RESERVED_REG_1
)
.
addImm
(
NumBytes
)
;
BuildMI
(
MBB
,
InsertPt
,
dl
,
TII
.
get
(
Hexagon
::
SUB_rr
)
,
QRI
->
getStackRegister
(
)
)
.
addReg
(
QRI
->
getStackRegister
(
)
)
.
addReg
(
HEXAGON_RESERVED_REG_1
)
;
}
else
{
BuildMI
(
MBB
,
InsertPt
,
dl
,
TII
.
get
(
Hexagon
::
ALLOCFRAME
)
)
.
addImm
(
NumBytes
)
;
}
}
}
</s>

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

Hexagon
Hexagon
Hexagon
Hexagon
Hexagon
Hexagon
Hexagon::ADJDYNALLOC
"Expected adjust alloca node"
2
"Expected immediate"
16384
Hexagon::ALLOCFRAME
0
Hexagon::CONST32_Int_Real
Hexagon::SUB_rr
Hexagon::ALLOCFRAME


"multiple fast interrupt routines seen: %qE and %qE"

Perform any actions necessary before starting to compile FNDECL . For the RX we use this to make sure that we have the correct set of register masks selected . If FNDECL is NULL then we are compiling top level things .


<s> bool AArch64TargetLowering :: isExtFreeImpl ( const Instruction * Ext ) const { if ( isa < FPExtInst > ( Ext ) ) return false ; if ( Ext -> getType ( ) -> isVectorTy ( ) ) return false ; for ( const Use & U : Ext -> uses ( ) ) { const Instruction * Instr = cast < Instruction > ( U . getUser ( ) ) ; switch ( Instr -> getOpcode ( ) ) { case Instruction :: Shl : if ( ! isa < ConstantInt > ( Instr -> getOperand ( 1 ) ) ) return false ; break ; case Instruction :: GetElementPtr : { gep_type_iterator GTI = gep_type_begin ( Instr ) ; auto & DL = Ext -> getModule ( ) -> getDataLayout ( ) ; std :: advance ( GTI , U . getOperandNo ( ) - 1 ) ; Type * IdxTy = GTI . getIndexedType ( ) ; uint64_t ShiftAmt = countTrailingZeros ( DL . getTypeStoreSizeInBits ( IdxTy ) . getFixedSize ( ) ) - 3 ; if ( ShiftAmt == 0 || ShiftAmt > 4 ) return false ; break ; } case Instruction :: Trunc : if ( Instr -> getType ( ) == Ext -> getOperand ( 0 ) -> getType ( ) ) continue ; LLVM_FALLTHROUGH ; default : return false ; } } return true ; } </s>

Return true if the extension represented by I is free .


<s> bool ARMFastISel :: fastLowerArguments ( ) { if ( ! FuncInfo . CanLowerReturn ) return false ; const Function * F = FuncInfo . Fn ; if ( F -> isVarArg ( ) ) return false ; CallingConv :: ID CC = F -> getCallingConv ( ) ; switch ( CC ) { default : return false ; case CallingConv :: Fast : case CallingConv :: C : case CallingConv :: ARM_AAPCS_VFP : case CallingConv :: ARM_AAPCS : case CallingConv :: ARM_APCS : break ; } unsigned Idx = 1 ; for ( Function :: const_arg_iterator I = F -> arg_begin ( ) , E = F -> arg_end ( ) ; I != E ; ++ I , ++ Idx ) { if ( Idx > 4 ) return false ; if ( F -> getAttributes ( ) . hasAttribute ( Idx , Attribute :: InReg ) || F -> getAttributes ( ) . hasAttribute ( Idx , Attribute :: StructRet ) || F -> getAttributes ( ) . hasAttribute ( Idx , Attribute :: ByVal ) ) return false ; Type * ArgTy = I -> getType ( ) ; if ( ArgTy -> isStructTy ( ) || ArgTy -> isArrayTy ( ) || ArgTy -> isVectorTy ( ) ) return false ; EVT ArgVT = TLI . getValueType ( ArgTy ) ; if ( ! ArgVT . isSimple ( ) ) return false ; switch ( ArgVT . getSimpleVT ( ) . SimpleTy ) { case MVT :: i8 : case MVT :: i16 : case MVT :: i32 : break ; default : return false ; } } static const uint16_t GPRArgRegs [ ] = { ARM :: R0 , ARM :: R1 , ARM :: R2 , ARM :: R3 } ; const TargetRegisterClass * RC = & ARM :: rGPRRegClass ; Idx = 0 ; for ( Function :: const_arg_iterator I = F -> arg_begin ( ) , E = F -> arg_end ( ) ; I != E ; ++ I , ++ Idx ) { unsigned SrcReg = GPRArgRegs [ Idx ] ; unsigned DstReg = FuncInfo . MF -> addLiveIn ( SrcReg , RC ) ; unsigned ResultReg = createResultReg ( RC ) ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( TargetOpcode :: COPY ) , ResultReg ) . addReg ( DstReg , getKillRegState ( true ) ) ; updateValueMap ( I , ResultReg ) ; } return true ; } </s>

This method is called by target-independent code to do target- specific argument lowering .


<s> bool SITargetLowering :: getAddrModeArguments ( IntrinsicInst * II , SmallVectorImpl < Value * > & Ops , Type * & AccessTy ) const { switch ( II -> getIntrinsicID ( ) ) { case Intrinsic :: amdgcn_atomic_inc : case Intrinsic :: amdgcn_atomic_dec : case Intrinsic :: amdgcn_ds_ordered_add : case Intrinsic :: amdgcn_ds_ordered_swap : case Intrinsic :: amdgcn_ds_append : case Intrinsic :: amdgcn_ds_consume : case Intrinsic :: amdgcn_ds_fadd : case Intrinsic :: amdgcn_ds_fmin : case Intrinsic :: amdgcn_ds_fmax : case Intrinsic :: amdgcn_global_atomic_fadd : case Intrinsic :: amdgcn_flat_atomic_fadd : case Intrinsic :: amdgcn_flat_atomic_fmin : case Intrinsic :: amdgcn_flat_atomic_fmax : case Intrinsic :: amdgcn_global_atomic_fadd_v2bf16 : case Intrinsic :: amdgcn_flat_atomic_fadd_v2bf16 : case Intrinsic :: amdgcn_global_atomic_csub : { Value * Ptr = II -> getArgOperand ( 0 ) ; AccessTy = II -> getType ( ) ; Ops . push_back ( Ptr ) ; return true ; } default : return false ; } } </s>

CodeGenPrepare sinks address calculations into the same BB as Load/Store instructions reading the address .


<s> void RISCVPassConfig :: addISelPrepare ( ) { TargetPassConfig :: addISelPrepare ( ) ; } </s>

Add common passes that perform LLVM IR to IR transforms in preparation for instruction selection .


<s> bool runOnMachineFunction ( MachineFunction & MF ) { if ( ! MF . getFrameInfo ( ) . hasVarSizedObjects ( ) ) { return false ; } const AVRSubtarget & STI = MF . getSubtarget < AVRSubtarget > ( ) ; const TargetInstrInfo & TII = * STI . getInstrInfo ( ) ; MachineBasicBlock & EntryMBB = MF . front ( ) ; MachineBasicBlock :: iterator MBBI = EntryMBB . begin ( ) ; DebugLoc DL = EntryMBB . findDebugLoc ( MBBI ) ; unsigned SPCopy = MF . getRegInfo ( ) . createVirtualRegister ( & AVR :: DREGSRegClass ) ; BuildMI ( EntryMBB , MBBI , DL , TII . get ( AVR :: COPY ) , SPCopy ) . addReg ( AVR :: SP ) ; for ( MachineBasicBlock & MBB : MF ) { if ( ! MBB . empty ( ) && MBB . back ( ) . isReturn ( ) ) { MBBI = MBB . getLastNonDebugInstr ( ) ; DL = MBBI -> getDebugLoc ( ) ; BuildMI ( MBB , MBBI , DL , TII . get ( AVR :: COPY ) , AVR :: SP ) . addReg ( SPCopy , RegState :: Kill ) ; } } return true ; } </s>

AVR AVR AVR AVR::DREGSRegClass AVR::COPY AVR::SP AVR::COPY AVR::SP


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

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


<s>
unsigned
MipsMCCodeEmitter
::
getMachineOpValue
(
const
MCInst
&
MI
,
const
MCOperand
&
MO
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
)
const
{
if
(
MO
.
isReg
(
)
)
{
unsigned
Reg
=
MO
.
getReg
(
)
;
unsigned
RegNo
=
getMipsRegisterNumbering
(
Reg
)
;
return
RegNo
;
}
else
if
(
MO
.
isImm
(
)
)
{
return
static_cast
<
unsigned
>
(
MO
.
getImm
(
)
)
;
}
else
if
(
MO
.
isFPImm
(
)
)
{
return
static_cast
<
unsigned
>
(
APFloat
(
MO
.
getFPImm
(
)
)
.
bitcastToAPInt
(
)
.
getHiBits
(
32
)
.
getLimitedValue
(
)
)
;
}
else
if
(
MO
.
isExpr
(
)
)
{
const
MCExpr
*
Expr
=
MO
.
getExpr
(
)
;
MCExpr
::
ExprKind
Kind
=
Expr
->
getKind
(
)
;
unsigned
Ret
=
0
;
if
(
Kind
==
MCExpr
::
Binary
)
{
const
MCBinaryExpr
*
BE
=
static_cast
<
const
MCBinaryExpr
*
>
(
Expr
)
;
Expr
=
BE
->
getLHS
(
)
;
Kind
=
Expr
->
getKind
(
)
;
const
MCConstantExpr
*
CE
=
dyn_cast
<
MCConstantExpr
>
(
BE
->
getRHS
(
)
)
;
assert
(
(
Kind
==
MCExpr
::
SymbolRef
)
&&
CE
&&
"Binary expression must be sym+const."
)
;
Ret
=
CE
->
getValue
(
)
;
}
if
(
Kind
==
MCExpr
::
SymbolRef
)
{
Mips
::
Fixups
FixupKind
;
switch
(
cast
<
MCSymbolRefExpr
>
(
Expr
)
->
getKind
(
)
)
{
case
MCSymbolRefExpr
::
VK_Mips_GPREL
:
FixupKind
=
Mips
::
fixup_Mips_GPREL16
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_GOT_CALL
:
FixupKind
=
Mips
::
fixup_Mips_CALL16
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_GOT16
:
FixupKind
=
Mips
::
fixup_Mips_GOT_Global
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_GOT
:
FixupKind
=
Mips
::
fixup_Mips_GOT_Local
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_ABS_HI
:
FixupKind
=
Mips
::
fixup_Mips_HI16
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_ABS_LO
:
FixupKind
=
Mips
::
fixup_Mips_LO16
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_TLSGD
:
FixupKind
=
Mips
::
fixup_Mips_TLSGD
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_TLSLDM
:
FixupKind
=
Mips
::
fixup_Mips_TLSLDM
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_DTPREL_HI
:
FixupKind
=
Mips
::
fixup_Mips_DTPREL_HI
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_DTPREL_LO
:
FixupKind
=
Mips
::
fixup_Mips_DTPREL_LO
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_GOTTPREL
:
FixupKind
=
Mips
::
fixup_Mips_GOTTPREL
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_TPREL_HI
:
FixupKind
=
Mips
::
fixup_Mips_TPREL_HI
;
break
;
case
MCSymbolRefExpr
::
VK_Mips_TPREL_LO
:
FixupKind
=
Mips
::
fixup_Mips_TPREL_LO
;
break
;
default
:
return
Ret
;
}
Fixups
.
push_back
(
MCFixup
::
Create
(
0
,
Expr
,
MCFixupKind
(
FixupKind
)
)
)
;
}
return
Ret
;
}
llvm_unreachable
(
"Unable to encode MCOperand!"
)
;
}
</s>

getMachineOpValue - Return binary encoding of operand .


"256-bit vector operations only available in AVX2"

"256-bit insert/extract only available in AVX2"

Change the opcode of MI to execute in Domain .


<s> bool SPUAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode , raw_ostream & O ) { if ( ExtraCode && ExtraCode [ 0 ] ) { if ( ExtraCode [ 1 ] != 0 ) return true ; switch ( ExtraCode [ 0 ] ) { default : return true ; case 'L' : if ( ! MI -> getOperand ( OpNo ) . isReg ( ) || OpNo + 1 == MI -> getNumOperands ( ) || ! MI -> getOperand ( OpNo + 1 ) . isReg ( ) ) return true ; ++ OpNo ; break ; } } printOperand ( MI , OpNo , O ) ; return false ; } </s>

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


<s> unsigned getFlatAddressSpace ( ) const { if ( IsGraphics ) return - 1 ; return AMDGPUAS :: FLAT_ADDRESS ; } </s>

Returns the address space ID for a target 's 'flat ' address space .


<s> virtual bool SelectInlineAsmMemoryOperand ( const SDValue & Op , char ConstraintCode , std :: vector < SDValue > & OutOps ) { SDValue Op0 ; switch ( ConstraintCode ) { default : return true ; case 'm' : Op0 = Op ; break ; } OutOps . push_back ( Op0 ) ; return false ; } </s>

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


<s> unsigned Z80oldInstrInfo :: getInstSizeInBytes ( const MachineInstr & MI ) const { auto TSFlags = MI . getDesc ( ) . TSFlags ; unsigned Size = 1 ; switch ( TSFlags >> Z80oldII :: ImmSizeShift & Z80oldII :: ImmSizeMask ) { case 2 : Size += false ; break ; case 3 : Size += true ; break ; } unsigned Prefix = TSFlags >> Z80oldII :: PrefixShift & Z80oldII :: PrefixMask ; bool HasPrefix ; if ( TSFlags & Z80oldII :: IndexedIndexPrefix ) { Size += HasPrefix = isIndex ( MI . getOperand ( Prefix ) , getRegisterInfo ( ) ) ; } else switch ( Prefix ) { case Z80oldII :: NoPrefix : HasPrefix = false ; break ; case Z80oldII :: CBPrefix : case Z80oldII :: DDPrefix : case Z80oldII :: EDPrefix : case Z80oldII :: FDPrefix : Size += 1 ; HasPrefix = true ; break ; case Z80oldII :: DDCBPrefix : case Z80oldII :: FDCBPrefix : Size += 2 ; HasPrefix = true ; break ; case Z80oldII :: AnyIndexPrefix : Size += HasPrefix = hasIndex ( MI , getRegisterInfo ( ) ) ; break ; } if ( TSFlags & Z80oldII :: HasImm ) { unsigned ImmSize = TSFlags >> Z80oldII :: ImmSizeShift & Z80oldII :: ImmSizeMask ; if ( ! ImmSize ) { ImmSize = 2 ; } Size += ImmSize ; } if ( TSFlags & Z80oldII :: HasOff ) { Size += HasPrefix ; } return Size ; } </s>

Returns the size in bytes of the specified MachineInstr , or ~0U when this function is not implemented by a target .


<s> static bool rs6000_builtin_valid_without_lhs ( enum rs6000_gen_builtins fn_code , tree fndecl ) { if ( TREE_TYPE ( TREE_TYPE ( fndecl ) ) == void_type_node ) return true ; switch ( fn_code ) { case RS6000_BIF_STVX_V16QI : case RS6000_BIF_STVX_V8HI : case RS6000_BIF_STVX_V4SI : case RS6000_BIF_STVX_V4SF : case RS6000_BIF_STVX_V2DI : case RS6000_BIF_STVX_V2DF : case RS6000_BIF_STXVW4X_V16QI : case RS6000_BIF_STXVW4X_V8HI : case RS6000_BIF_STXVW4X_V4SF : case RS6000_BIF_STXVW4X_V4SI : case RS6000_BIF_STXVD2X_V2DF : case RS6000_BIF_STXVD2X_V2DI : return true ; default : return false ; } } </s>

Helper function to sort out which built-ins may be valid without having a LHS .


"********** AArch64 Conditional Compares **********\n"

runOnMachineFunction - Emit the function body .


<s> const M68kInstrInfo * getInstrInfo ( ) const { return Subtarget -> getInstrInfo ( ) ; } </s>


<s> int frv_expand_block_clear ( rtx operands [ ] ) { rtx orig_dest = operands [ 0 ] ; rtx bytes_rtx = operands [ 1 ] ; rtx align_rtx = operands [ 3 ] ; int constp = ( GET_CODE ( bytes_rtx ) == CONST_INT ) ; int align ; int bytes ; int offset ; rtx dest_reg ; rtx dest_addr ; rtx dest_mem ; int clear_bytes ; machine_mode mode ; if ( ! constp ) return FALSE ; gcc_assert ( GET_CODE ( align_rtx ) == CONST_INT ) ; align = INTVAL ( align_rtx ) ; bytes = INTVAL ( bytes_rtx ) ; if ( bytes <= 0 ) return TRUE ; if ( bytes > TOTAL_MOVE_REG * align ) return FALSE ; dest_reg = copy_addr_to_reg ( XEXP ( orig_dest , 0 ) ) ; offset = 0 ; for ( ; bytes > 0 ; ( bytes -= clear_bytes ) , ( offset += clear_bytes ) ) { dest_addr = ( ( offset == 0 ) ? dest_reg : plus_constant ( Pmode , dest_reg , offset ) ) ; if ( bytes >= 4 && align >= 4 ) mode = SImode ; else if ( bytes >= 2 && align >= 2 ) mode = HImode ; else mode = QImode ; clear_bytes = GET_MODE_SIZE ( mode ) ; dest_mem = change_address ( orig_dest , mode , dest_addr ) ; emit_insn ( gen_rtx_SET ( dest_mem , const0_rtx ) ) ; } return TRUE ; } </s>

Expand a block clear operation , and return 1 if successful . Return 0 if we should let the compiler generate normal code . operands [ 0 ] is the destination operands [ 1 ] is the length operands [ 3 ] is the alignment


<s> const MCPhysReg * SHUXIRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { return CC_Save_SaveList ; } </s>


<s> bool isImm ( int64_t MinValue , int64_t MaxValue ) const { return Kind == KindImm && inRange ( Imm , MinValue , MaxValue ) ; } </s>


<s> PPCTargetLowering :: ConstraintType PPCTargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'b' : case 'r' : case 'f' : case 'd' : case 'v' : case 'y' : return C_RegisterClass ; case 'Z' : return C_Memory ; } } else if ( Constraint == "wc" ) { return C_RegisterClass ; } else if ( Constraint == "wa" || Constraint == "wd" || Constraint == "wf" || Constraint == "ws" || Constraint == "wi" || Constraint == "ww" ) { return C_RegisterClass ; } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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

PowerPC PPC PPC 1 0 "wc" "wa" "wd" "wf" "ws" "wi" "ww"


<s> int R600FrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , unsigned & FrameReg ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const R600RegisterInfo * RI = MF . getSubtarget < R600Subtarget > ( ) . getRegisterInfo ( ) ; FrameReg = RI -> getFrameRegister ( MF ) ; unsigned OffsetBytes = 2 * ( getStackWidth ( MF ) * 4 ) ; int UpperBound = FI == - 1 ? MFI . getNumObjects ( ) : FI ; for ( int i = MFI . getObjectIndexBegin ( ) ; i < UpperBound ; ++ i ) { OffsetBytes = alignTo ( OffsetBytes , MFI . getObjectAlignment ( i ) ) ; OffsetBytes += MFI . getObjectSize ( i ) ; OffsetBytes = alignTo ( OffsetBytes , 4 ) ; } if ( FI != - 1 ) OffsetBytes = alignTo ( OffsetBytes , MFI . getObjectAlignment ( FI ) ) ; return OffsetBytes / ( getStackWidth ( MF ) * 4 ) ; } </s>

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


<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 ; 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>
bool
M68kAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
{
SMLoc
Start
=
getLexer
(
)
.
getLoc
(
)
;
Operands
.
push_back
(
M68kOperand
::
createToken
(
Name
,
Start
,
Start
)
)
;
bool
First
=
true
;
while
(
Parser
.
getTok
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
if
(
!
First
)
{
eatComma
(
)
;
}
else
{
First
=
false
;
}
auto
MatchResult
=
MatchOperandParserImpl
(
Operands
,
Name
)
;
if
(
MatchResult
==
MatchOperand_Success
)
{
continue
;
}
SMLoc
Loc
=
getLexer
(
)
.
getLoc
(
)
;
Parser
.
eatToEndOfStatement
(
)
;
return
Error
(
Loc
,
"unexpected token parsing operands"
)
;
}
Parser
.
Lex
(
)
;
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .


<s> virtual const VideocoreInstrInfo * getInstrInfo ( ) const { return & InstrInfo ; } </s>


<s>
SDValue
RISCVTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
report_fatal_error
(
"unimplemented operand"
)
;
case
ISD
::
GlobalAddress
:
return
lowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
lowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
ConstantPool
:
return
lowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
return
lowerGlobalTLSAddress
(
Op
,
DAG
)
;
case
ISD
::
SELECT
:
return
lowerSELECT
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
lowerVASTART
(
Op
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
lowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
RETURNADDR
:
return
lowerRETURNADDR
(
Op
,
DAG
)
;
case
ISD
::
SHL_PARTS
:
return
lowerShiftLeftParts
(
Op
,
DAG
)
;
case
ISD
::
SRA_PARTS
:
return
lowerShiftRightParts
(
Op
,
DAG
,
true
)
;
case
ISD
::
SRL_PARTS
:
return
lowerShiftRightParts
(
Op
,
DAG
,
false
)
;
case
ISD
::
BITCAST
:
{
assert
(
Subtarget
.
is64Bit
(
)
&&
Subtarget
.
hasStdExtF
(
)
&&
"Unexpected custom legalisation"
)
;
SDLoc
DL
(
Op
)
;
SDValue
Op0
=
Op
.
getOperand
(
0
)
;
if
(
Op
.
getValueType
(
)
!=
MVT
::
f32
||
Op0
.
getValueType
(
)
!=
MVT
::
i32
)
return
SDValue
(
)
;
SDValue
NewOp0
=
DAG
.
getNode
(
ISD
::
ANY_EXTEND
,
DL
,
MVT
::
i64
,
Op0
)
;
SDValue
FPConv
=
DAG
.
getNode
(
RISCVISD
::
FMV_W_X_RV64
,
DL
,
MVT
::
f32
,
NewOp0
)
;
return
FPConv
;
}
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> const MCPhysReg * RV16KRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { return CSR_SaveList ; } </s>


<s> static machine_mode rs6000_preferred_simd_mode ( scalar_mode mode ) { if ( TARGET_VSX ) switch ( mode ) { case E_DFmode : return V2DFmode ; default : ; } if ( TARGET_ALTIVEC || TARGET_VSX ) switch ( mode ) { case E_SFmode : return V4SFmode ; case E_TImode : return V1TImode ; case E_DImode : return V2DImode ; case E_SImode : return V4SImode ; case E_HImode : return V8HImode ; case E_QImode : return V16QImode ; default : ; } return word_mode ; } </s>


<s>
void
LoongArchRegisterInfo
::
eliminateFrameIndex
(
MachineBasicBlock
::
iterator
II
,
int
SPAdj
,
unsigned
FIOperandNum
,
RegScavenger
*
RS
)
const
{
assert
(
SPAdj
==
0
&&
"Unexpected non-zero SPAdj value"
)
;
}
</s>

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

LoongArch
LoongArch
0
"Unexpected non-zero SPAdj value"


<s> bool MINA32AsmBackend :: shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) { switch ( ( unsigned ) Fixup . getKind ( ) ) { default : return false ; } } </s>

Hook to check if a relocation is needed for some target specific reason .


<s> bool AMDGPUDAGToDAGISel :: runOnMachineFunction ( MachineFunction & MF ) { DominatorTree & DT = getAnalysis < DominatorTreeWrapperPass > ( ) . getDomTree ( ) ; LoopInfo * LI = & getAnalysis < LoopInfoWrapperPass > ( ) . getLoopInfo ( ) ; for ( auto & L : LI -> getLoopsInPreorder ( ) ) { assert ( L -> isLCSSAForm ( DT ) ) ; } Subtarget = & MF . getSubtarget < GCNSubtarget > ( ) ; Mode = AMDGPU :: SIModeRegisterDefaults ( MF . getFunction ( ) , * Subtarget ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ; } </s>


"force: group count = %d, can_issue_more = %d\n"

"done force: group count = %d, can_issue_more = %d\n"

Utility of the function redefine_groups . Check if it is too costly to schedule NEXT_INSN together with GROUP_INSNS in the same dispatch group . If so , insert nops before NEXT_INSN , in order to keep it `` far '' ( in a separate group ) from GROUP_INSNS , following one of the following schemes , depending on the value of the flag -minsert_sched_nops = X : ( 1 ) X == sched_finish_regroup_exact : insert exactly as many nops as needed in order to force NEXT_INSN into a separate group . ( 2 ) X < sched_finish_regroup_exact : insert exactly X nops . GROUP_END , CAN_ISSUE_MORE and GROUP_COUNT record the state after nop insertion ( has a group just ended , how many vacant issue slots remain in the last group , and how many dispatch groups were encountered so far ) .


"FMA or FMUL at insn %d but destination "

"register (%s) has different parity from expected to "

"Destination register of insn %d could not be "

"renamed. Dependent FMA insns will use this parity from "

Rename the destination register of a single FMUL or FMADD/FMSUB instruction represented by FMA_NODE to a register that respect the target parity for FOREST or with same parity of the instruction represented by its parent node if it has one .


"Do not know how to custom type legalize this operation!"

"Unexpected result type for CTR decrement intrinsic"

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


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

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


<s>
bool
SIAnnotateControlFlow
::
runOnFunction
(
Function
&
F
)
{
DT
=
&
getAnalysis
<
DominatorTreeWrapperPass
>
(
)
.
getDomTree
(
)
;
LI
=
&
getAnalysis
<
LoopInfoWrapperPass
>
(
)
.
getLoopInfo
(
)
;
DA
=
&
getAnalysis
<
DivergenceAnalysis
>
(
)
;
for
(
df_iterator
<
BasicBlock
*
>
I
=
df_begin
(
&
F
.
getEntryBlock
(
)
)
,
E
=
df_end
(
&
F
.
getEntryBlock
(
)
)
;
I
!=
E
;
++
I
)
{
BasicBlock
*
BB
=
*
I
;
BranchInst
*
Term
=
dyn_cast
<
BranchInst
>
(
BB
->
getTerminator
(
)
)
;
if
(
!
Term
||
Term
->
isUnconditional
(
)
)
{
if
(
isTopOfStack
(
BB
)
)
closeControlFlow
(
BB
)
;
continue
;
}
if
(
I
.
nodeVisited
(
Term
->
getSuccessor
(
1
)
)
)
{
if
(
isTopOfStack
(
BB
)
)
closeControlFlow
(
BB
)
;
handleLoop
(
Term
)
;
continue
;
}
if
(
isTopOfStack
(
BB
)
)
{
PHINode
*
Phi
=
dyn_cast
<
PHINode
>
(
Term
->
getCondition
(
)
)
;
if
(
Phi
&&
Phi
->
getParent
(
)
==
BB
&&
isElse
(
Phi
)
)
{
insertElse
(
Term
)
;
eraseIfUnused
(
Phi
)
;
continue
;
}
closeControlFlow
(
BB
)
;
}
openIf
(
Term
)
;
}
if
(
!
Stack
.
empty
(
)
)
{
report_fatal_error
(
"failed to annotate CFG"
)
;
}
return
true
;
}
</s>

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


<s>
Register
ARMTargetLowering
::
getRegisterByName
(
const
char
*
RegName
,
LLT
VT
,
const
MachineFunction
&
MF
)
const
{
Register
Reg
=
StringSwitch
<
unsigned
>
(
RegName
)
.
Case
(
"sp"
,
ARM
::
SP
)
.
Default
(
0
)
;
if
(
Reg
)
return
Reg
;
report_fatal_error
(
Twine
(
"Invalid register name \""
+
StringRef
(
RegName
)
+
"\"."
)
)
;
}
</s>

Return the register ID of the name passed in .

ARM
ARM
"sp"
ARM::SP
0
"Invalid register name \""
"\"."


<s>
void
AArch64InstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MBBI
,
unsigned
SrcReg
,
bool
isKill
,
int
FrameIdx
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
DebugLoc
DL
=
MBB
.
findDebugLoc
(
MBBI
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
MachineFrameInfo
&
MFI
=
*
MF
.
getFrameInfo
(
)
;
unsigned
Align
=
MFI
.
getObjectAlignment
(
FrameIdx
)
;
MachineMemOperand
*
MMO
=
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getFixedStack
(
FrameIdx
)
,
MachineMemOperand
::
MOStore
,
MFI
.
getObjectSize
(
FrameIdx
)
,
Align
)
;
unsigned
StoreOp
=
0
;
if
(
RC
->
hasType
(
MVT
::
i64
)
||
RC
->
hasType
(
MVT
::
i32
)
)
{
switch
(
RC
->
getSize
(
)
)
{
case
4
:
StoreOp
=
AArch64
::
LS32_STR
;
break
;
case
8
:
StoreOp
=
AArch64
::
LS64_STR
;
break
;
default
:
llvm_unreachable
(
"Unknown size for regclass"
)
;
}
}
else
if
(
AArch64
::
FPR8RegClass
.
hasSubClassEq
(
RC
)
)
{
StoreOp
=
AArch64
::
LSFP8_STR
;
}
else
if
(
AArch64
::
FPR16RegClass
.
hasSubClassEq
(
RC
)
)
{
StoreOp
=
AArch64
::
LSFP16_STR
;
}
else
if
(
RC
->
hasType
(
MVT
::
f32
)
||
RC
->
hasType
(
MVT
::
f64
)
||
RC
->
hasType
(
MVT
::
f128
)
)
{
switch
(
RC
->
getSize
(
)
)
{
case
4
:
StoreOp
=
AArch64
::
LSFP32_STR
;
break
;
case
8
:
StoreOp
=
AArch64
::
LSFP64_STR
;
break
;
case
16
:
StoreOp
=
AArch64
::
LSFP128_STR
;
break
;
default
:
llvm_unreachable
(
"Unknown size for regclass"
)
;
}
}
else
{
if
(
AArch64
::
DPairRegClass
.
hasSubClassEq
(
RC
)
)
StoreOp
=
AArch64
::
ST1x2_8B
;
else
if
(
AArch64
::
DTripleRegClass
.
hasSubClassEq
(
RC
)
)
StoreOp
=
AArch64
::
ST1x3_8B
;
else
if
(
AArch64
::
DQuadRegClass
.
hasSubClassEq
(
RC
)
)
StoreOp
=
AArch64
::
ST1x4_8B
;
else
if
(
AArch64
::
QPairRegClass
.
hasSubClassEq
(
RC
)
)
StoreOp
=
AArch64
::
ST1x2_16B
;
else
if
(
AArch64
::
QTripleRegClass
.
hasSubClassEq
(
RC
)
)
StoreOp
=
AArch64
::
ST1x3_16B
;
else
if
(
AArch64
::
QQuadRegClass
.
hasSubClassEq
(
RC
)
)
StoreOp
=
AArch64
::
ST1x4_16B
;
else
llvm_unreachable
(
"Unknown reg class"
)
;
MachineInstrBuilder
NewMI
=
BuildMI
(
MBB
,
MBBI
,
DL
,
get
(
StoreOp
)
)
;
NewMI
.
addFrameIndex
(
FrameIdx
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addMemOperand
(
MMO
)
;
return
;
}
MachineInstrBuilder
NewMI
=
BuildMI
(
MBB
,
MBBI
,
DL
,
get
(
StoreOp
)
)
;
NewMI
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FrameIdx
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
;
}
</s>

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


<s> bool HexagonMCExpr :: classof ( MCExpr const * E ) { return E -> getKind ( ) == MCExpr :: Target ; } </s>

Methods for support type inquiry through isa , cast , and dyn_cast :


runOnMachineFunction - Emit the function body .


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


<s> bool Thumb2SizeReduce :: runOnMachineFunction ( MachineFunction & MF ) { const TargetMachine & TM = MF . getTarget ( ) ; TII = static_cast < const Thumb2InstrInfo * > ( TM . getInstrInfo ( ) ) ; STI = & TM . getSubtarget < ARMSubtarget > ( ) ; bool Modified = false ; for ( MachineFunction :: iterator I = MF . begin ( ) , E = MF . end ( ) ; I != E ; ++ I ) Modified |= ReduceMBB ( * I ) ; return Modified ; } </s>


<s> TargetTransformInfo RISCVTargetMachine :: getTargetTransformInfo ( const Function & F ) { return TargetTransformInfo ( RISCVTTIImpl ( this , F ) ) ; } </s>

Get a TargetTransformInfo implementation for the target .


<s> static void enable_mask_for_builtins ( struct builtin_description * desc , int size , enum rs6000_builtins start , enum rs6000_builtins end ) { int i ; for ( i = 0 ; i < size ; ++ i ) if ( desc [ i ] . code == start ) break ; if ( i == size ) return ; for ( ; i < size ; ++ i ) { desc [ i ] . mask = target_flags ; if ( desc [ i ] . code == end ) break ; } } </s>

Search through a set of builtins and enable the mask bits . DESC is an array of builtins . SIZE is the total number of builtins . START is the builtin enum at which to start . END is the builtin enum at which to end .


<s> unsigned char AArch64Subtarget :: classifyGlobalFunctionReference ( const GlobalValue * GV , const TargetMachine & TM ) const { if ( TM . getCodeModel ( ) == CodeModel :: Large && isTargetMachO ( ) && ! GV -> hasInternalLinkage ( ) ) return AArch64II :: MO_GOT ; auto * F = dyn_cast < Function > ( GV ) ; if ( UseNonLazyBind && F && F -> hasFnAttribute ( Attribute :: NonLazyBind ) && ! TM . shouldAssumeDSOLocal ( * GV -> getParent ( ) , GV ) ) return AArch64II :: MO_GOT ; return AArch64II :: MO_NO_FLAG ; } </s>

Classify a global function reference for the current subtarget .


<s>
unsigned
SIInstrInfo
::
getInstSizeInBytes
(
const
MachineInstr
&
MI
)
const
{
unsigned
Opc
=
MI
.
getOpcode
(
)
;
const
MCInstrDesc
&
Desc
=
getMCOpcodeFromPseudo
(
Opc
)
;
unsigned
DescSize
=
Desc
.
getSize
(
)
;
if
(
DescSize
!=
0
&&
DescSize
!=
4
)
return
DescSize
;
if
(
Opc
==
AMDGPU
::
WAVE_BARRIER
)
return
0
;
if
(
isVALU
(
MI
)
||
isSALU
(
MI
)
)
{
if
(
isFixedSize
(
MI
)
)
{
assert
(
DescSize
==
4
)
;
return
DescSize
;
}
int
Src0Idx
=
AMDGPU
::
getNamedOperandIdx
(
Opc
,
AMDGPU
::
OpName
::
src0
)
;
if
(
Src0Idx
==
1
)
return
4
;
if
(
isLiteralConstantLike
(
MI
.
getOperand
(
Src0Idx
)
,
Desc
.
OpInfo
[
Src0Idx
]
)
)
return
8
;
int
Src1Idx
=
AMDGPU
::
getNamedOperandIdx
(
Opc
,
AMDGPU
::
OpName
::
src1
)
;
if
(
Src1Idx
==
1
)
return
4
;
if
(
isLiteralConstantLike
(
MI
.
getOperand
(
Src1Idx
)
,
Desc
.
OpInfo
[
Src1Idx
]
)
)
return
8
;
return
4
;
}
if
(
DescSize
==
4
)
return
4
;
switch
(
Opc
)
{
case
AMDGPU
::
SI_MASK_BRANCH
:
case
TargetOpcode
::
IMPLICIT_DEF
:
case
TargetOpcode
::
KILL
:
case
TargetOpcode
::
DBG_VALUE
:
case
TargetOpcode
::
BUNDLE
:
case
TargetOpcode
::
EH_LABEL
:
return
0
;
case
TargetOpcode
::
INLINEASM
:
{
const
MachineFunction
*
MF
=
MI
.
getParent
(
)
->
getParent
(
)
;
const
char
*
AsmStr
=
MI
.
getOperand
(
0
)
.
getSymbolName
(
)
;
return
getInlineAsmLength
(
AsmStr
,
*
MF
->
getTarget
(
)
.
getMCAsmInfo
(
)
)
;
}
default
:
llvm_unreachable
(
"unable to find instruction size"
)
;
}
}
</s>

Returns the size in bytes of the specified MachineInstr , or ~0U when this function is not implemented by a target .


<s> bool fixupNeedsRelaxation ( const MCFixup & Fixup , uint64_t Value , const MCRelaxableFragment * DF , const MCAsmLayout & Layout ) const override { return false ; } </s>

Simple predicate for targets where ! Resolved implies requiring relaxation .


"Not a machine_mode mode, legitimate address\n"

Return a nonzero value if XINSN is a legitimate address for a memory operand of the indicated MODE . STRICT is nonzero if this function is called during reload .


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


<s> void buildLoad ( Register Val , Register Addr , uint64_t Size , unsigned Alignment , MachinePointerInfo & MPO ) { auto MMO = MIRBuilder . getMF ( ) . getMachineMemOperand ( MPO , MachineMemOperand :: MOLoad , Size , Alignment ) ; MIRBuilder . buildLoad ( Val , Addr , * MMO ) ; } </s>

Build and insert a G_LOAD instruction , while constructing the MachineMemOperand .


<s> static rtx nvptx_gen_unpack ( rtx dst0 , rtx dst1 , rtx src ) { rtx res ; switch ( GET_MODE ( src ) ) { case E_DImode : res = gen_unpackdisi2 ( dst0 , dst1 , src ) ; break ; case E_DFmode : res = gen_unpackdfsi2 ( dst0 , dst1 , src ) ; break ; default : gcc_unreachable ( ) ; } return res ; } </s>

Generate instruction ( s ) to unpack a 64 bit object into 2 32 bit objects .


<s> int pdp11_cmp_length ( rtx * operands , int words ) { rtx inops [ 2 ] ; rtx exops [ 4 ] [ 2 ] ; int i , len = 0 ; if ( ! reload_completed ) return 2 ; inops [ 0 ] = operands [ 0 ] ; inops [ 1 ] = operands [ 1 ] ; pdp11_expand_operands ( inops , exops , 2 , words , NULL , big ) ; for ( i = 0 ; i < words ; i ++ ) { len += 4 ; if ( ! REG_P ( exops [ i ] [ 0 ] ) && ! simple_memory_operand ( exops [ i ] [ 0 ] , HImode ) ) len += 2 ; if ( ! REG_P ( exops [ i ] [ 1 ] ) && ! simple_memory_operand ( exops [ i ] [ 1 ] , HImode ) && ! ( CONST_INT_P ( exops [ i ] [ 1 ] ) && INTVAL ( exops [ i ] [ 1 ] ) == 0 ) ) len += 2 ; } return len - 2 ; } </s>

Return the length of 2 or 4 word integer compares .


<s> bool sh_attr_renesas_p ( const_tree td ) { if ( TARGET_HITACHI ) return true ; if ( td == NULL_TREE ) return false ; if ( DECL_P ( td ) ) td = TREE_TYPE ( td ) ; if ( td == error_mark_node ) return false ; return lookup_attribute ( "renesas" , TYPE_ATTRIBUTES ( td ) ) != NULL_TREE ; } </s>

True if __attribute__ ( ( renesas ) ) or -mrenesas .


<s> Value * X86TargetLowering :: getIRStackGuard ( IRBuilder < > & IRB ) const { if ( hasStackGuardSlotTLS ( Subtarget . getTargetTriple ( ) ) ) { if ( Subtarget . isTargetFuchsia ( ) ) { return SegmentOffset ( IRB , 0x10 , 257 ) ; } else { unsigned Offset = ( Subtarget . is64Bit ( ) ) ? 0x28 : 0x14 ; return SegmentOffset ( IRB , Offset , getAddressSpace ( ) ) ; } } return TargetLowering :: getIRStackGuard ( IRB ) ; } </s>

If the target has a standard location for the stack protector cookie , returns the address of that location .


<s> bool SIInstrInfo :: isOperandLegal ( const MachineInstr * MI , unsigned OpIdx , const MachineOperand * MO ) const { const MachineRegisterInfo & MRI = MI -> getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; const MCInstrDesc & InstDesc = get ( MI -> getOpcode ( ) ) ; const MCOperandInfo & OpInfo = InstDesc . OpInfo [ OpIdx ] ; const TargetRegisterClass * DefinedRC = OpInfo . RegClass != - 1 ? RI . getRegClass ( OpInfo . RegClass ) : nullptr ; if ( ! MO ) MO = & MI -> getOperand ( OpIdx ) ; if ( isVALU ( InstDesc . Opcode ) && usesConstantBus ( MRI , * MO , DefinedRC -> getSize ( ) ) ) { unsigned SGPRUsed = MO -> isReg ( ) ? MO -> getReg ( ) : ( unsigned ) AMDGPU :: NoRegister ; for ( unsigned i = 0 , e = MI -> getNumOperands ( ) ; i != e ; ++ i ) { if ( i == OpIdx ) continue ; const MachineOperand & Op = MI -> getOperand ( i ) ; if ( Op . isReg ( ) && Op . getReg ( ) != SGPRUsed && usesConstantBus ( MRI , Op , getOpSize ( * MI , i ) ) ) { return false ; } } } if ( MO -> isReg ( ) ) { assert ( DefinedRC ) ; const TargetRegisterClass * RC = TargetRegisterInfo :: isVirtualRegister ( MO -> getReg ( ) ) ? MRI . getRegClass ( MO -> getReg ( ) ) : RI . getPhysRegClass ( MO -> getReg ( ) ) ; return RI . getCommonSubClass ( RC , RI . getRegClass ( OpInfo . RegClass ) ) == RC ; } assert ( MO -> isImm ( ) || MO -> isTargetIndex ( ) || MO -> isFI ( ) ) ; if ( ! DefinedRC ) { return true ; } return isImmOperandLegal ( MI , OpIdx , * MO ) ; } </s>

Check if MO is a legal operand if it was the OpIdx Operand for MI .


<s>
void
Thumb1InstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
SrcReg
,
bool
isKill
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
assert
(
(
RC
==
&
ARM
::
tGPRRegClass
||
(
Register
::
isPhysicalRegister
(
SrcReg
)
&&
isARMLowRegister
(
SrcReg
)
)
)
&&
"Unknown regclass!"
)
;
if
(
RC
==
&
ARM
::
tGPRRegClass
||
(
Register
::
isPhysicalRegister
(
SrcReg
)
&&
isARMLowRegister
(
SrcReg
)
)
)
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
MachineMemOperand
*
MMO
=
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getFixedStack
(
MF
,
FI
)
,
MachineMemOperand
::
MOStore
,
MFI
.
getObjectSize
(
FI
)
,
MFI
.
getObjectAlignment
(
FI
)
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tSTRspi
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
}
}
</s>

ARM
ARM::tGPRRegClass
ARM
"Unknown regclass!"
ARM::tGPRRegClass
ARM
ARM::tSTRspi
0
ARMCC::AL


<s> static rtx single_set_and_flags ( rtx_insn * insn ) { if ( multiple_sets ( insn ) ) { rtx pat = PATTERN ( insn ) ; if ( XVECLEN ( pat , 0 ) == 2 && GET_CODE ( XVECEXP ( pat , 0 , 1 ) ) == SET && REG_P ( SET_DEST ( XVECEXP ( pat , 0 , 1 ) ) ) && REGNO ( SET_DEST ( XVECEXP ( pat , 0 , 1 ) ) ) == FLAGS_REGNUM ) return XVECEXP ( pat , 0 , 0 ) ; } return single_set ( insn ) ; } </s>

Wrapper around single_set which returns the first SET of a pair if the second SET is to the flags register .


<s> static void visium_function_arg_advance ( cumulative_args_t pcum_v , machine_mode mode , const_tree type ATTRIBUTE_UNUSED , bool named ) { int size = ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; int stack_size = 0 ; CUMULATIVE_ARGS * ca = get_cumulative_args ( pcum_v ) ; if ( TARGET_FPU && ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT && GET_MODE_SIZE ( mode ) <= UNITS_PER_HWFPVALUE ) || ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT && GET_MODE_SIZE ( mode ) <= UNITS_PER_HWFPVALUE * 2 ) ) ) { if ( ca -> frcount + size <= MAX_ARGS_IN_FP_REGISTERS ) ca -> frcount += size ; else { stack_size = size ; ca -> frcount = MAX_ARGS_IN_FP_REGISTERS ; } } else { if ( ca -> grcount + size <= MAX_ARGS_IN_GP_REGISTERS ) ca -> grcount += size ; else { stack_size = size ; ca -> grcount = MAX_ARGS_IN_GP_REGISTERS ; } } if ( named ) ca -> stack_words += stack_size ; } </s>

Update the summarizer variable pointed to by PCUM_V to advance past an argument in the argument list . The values MODE , TYPE and NAMED describe that argument . Once this is done , the variable CUM is suitable for analyzing the _following_ argument with visium_function_arg .


<s> rtx tilepro_emit_conditional_move ( rtx cmp ) { return tilepro_emit_cc_test ( GET_CODE ( cmp ) , XEXP ( cmp , 0 ) , XEXP ( cmp , 1 ) , GET_MODE ( XEXP ( cmp , 0 ) ) , true ) ; } </s>


<s> void X86PassConfig :: addPreEmitPass2 ( ) { const Triple & TT = TM -> getTargetTriple ( ) ; const MCAsmInfo * MAI = TM -> getMCAsmInfo ( ) ; addPass ( createX86RetpolineThunksPass ( ) ) ; if ( TT . isOSWindows ( ) && TT . getArch ( ) == Triple :: x86_64 ) addPass ( createX86AvoidTrailingCallPass ( ) ) ; if ( ! TT . isOSDarwin ( ) && ( ! TT . isOSWindows ( ) || MAI -> getExceptionHandlingType ( ) == ExceptionHandling :: DwarfCFI ) ) addPass ( createCFIInstrInserter ( ) ) ; } </s>

Targets may add passes immediately before machine code is emitted in this callback .


<s> void rs6000_emit_swsqrt ( rtx dst , rtx src , bool recip ) { machine_mode mode = GET_MODE ( src ) ; rtx e = gen_reg_rtx ( mode ) ; rtx g = gen_reg_rtx ( mode ) ; rtx h = gen_reg_rtx ( mode ) ; int passes = ( TARGET_RECIP_PRECISION ) ? 1 : 3 ; if ( mode == DFmode || mode == V2DFmode ) passes ++ ; int i ; rtx mhalf ; enum insn_code code = optab_handler ( smul_optab , mode ) ; insn_gen_fn gen_mul = GEN_FCN ( code ) ; gcc_assert ( code != CODE_FOR_nothing ) ; mhalf = rs6000_load_constant_and_splat ( mode , dconsthalf ) ; emit_insn ( gen_rtx_SET ( e , gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , src ) , UNSPEC_RSQRT ) ) ) ; if ( ! recip ) { rtx zero = force_reg ( mode , CONST0_RTX ( mode ) ) ; if ( mode == SFmode ) { rtx target = emit_conditional_move ( e , { GT , src , zero , mode } , e , zero , mode , 0 ) ; if ( target != e ) emit_move_insn ( e , target ) ; } else { rtx cond = gen_rtx_GT ( VOIDmode , e , zero ) ; rs6000_emit_vector_cond_expr ( e , e , zero , cond , src , zero ) ; } } emit_insn ( gen_mul ( g , e , src ) ) ; emit_insn ( gen_mul ( h , e , mhalf ) ) ; if ( recip ) { if ( passes == 1 ) { rtx t = gen_reg_rtx ( mode ) ; rs6000_emit_nmsub ( t , g , h , mhalf ) ; rs6000_emit_madd ( dst , e , t , e ) ; } else { for ( i = 0 ; i < passes ; i ++ ) { rtx t1 = gen_reg_rtx ( mode ) ; rtx g1 = gen_reg_rtx ( mode ) ; rtx h1 = gen_reg_rtx ( mode ) ; rs6000_emit_nmsub ( t1 , g , h , mhalf ) ; rs6000_emit_madd ( g1 , g , t1 , g ) ; rs6000_emit_madd ( h1 , h , t1 , h ) ; g = g1 ; h = h1 ; } emit_insn ( gen_add3_insn ( dst , h , h ) ) ; } } else { rtx t = gen_reg_rtx ( mode ) ; rs6000_emit_nmsub ( t , g , h , mhalf ) ; rs6000_emit_madd ( dst , g , t , g ) ; } return ; } </s>

Goldschmidt 's Algorithm for single/double-precision floating point sqrt and rsqrt . Assumes no trapping math and finite arguments .


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> bool arc_raw_symbolic_reference_mentioned_p ( rtx op , bool skip_local ) { const char * fmt ; int i ; if ( GET_CODE ( op ) == UNSPEC ) return false ; if ( GET_CODE ( op ) == SYMBOL_REF ) { if ( SYMBOL_REF_TLS_MODEL ( op ) ) return true ; if ( ! flag_pic ) return false ; tree decl = SYMBOL_REF_DECL ( op ) ; return ! skip_local || ! decl || ! default_binds_local_p ( decl ) ; } fmt = GET_RTX_FORMAT ( GET_CODE ( op ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( op ) ) - 1 ; i >= 0 ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( op , i ) - 1 ; j >= 0 ; j -- ) if ( arc_raw_symbolic_reference_mentioned_p ( XVECEXP ( op , i , j ) , skip_local ) ) return true ; } else if ( fmt [ i ] == 'e' && arc_raw_symbolic_reference_mentioned_p ( XEXP ( op , i ) , skip_local ) ) return true ; } return false ; } </s>

Return true if OP contains a SYMBOL_REF that is not wrapped in an unspec . If SKIP_LOCAL is true , skip symbols that bind locally . This is used further down in this file , and , without SKIP_LOCAL , in the addsi3 / subsi3 expanders when generating PIC code .


<s> const TargetRegisterClass * SIRegisterInfo :: getCrossCopyRegClass ( const TargetRegisterClass * RC ) const { if ( isAGPRClass ( RC ) && ! ST . hasGFX90AInsts ( ) ) return getEquivalentVGPRClass ( RC ) ; return RC ; } </s>

getCrossCopyRegClass - Returns a legal register class to copy a register in the specified class to or from .


<s> static short find_set_regmode_weight ( rtx x , enum machine_mode mode ) { if ( GET_CODE ( x ) == CLOBBER && register_operand ( SET_DEST ( x ) , mode ) ) return 1 ; if ( GET_CODE ( x ) == SET && register_operand ( SET_DEST ( x ) , mode ) ) { if ( GET_CODE ( SET_DEST ( x ) ) == REG ) { if ( ! reg_mentioned_p ( SET_DEST ( x ) , SET_SRC ( x ) ) ) return 1 ; else return 0 ; } return 1 ; } return 0 ; } </s>


<s>
void
Thumb1InstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
const
ARMSubtarget
&
st
=
MF
.
getSubtarget
<
ARMSubtarget
>
(
)
;
assert
(
ARM
::
GPRRegClass
.
contains
(
DestReg
,
SrcReg
)
&&
"Thumb1 can only copy GPR registers"
)
;
if
(
st
.
hasV6Ops
(
)
||
ARM
::
hGPRRegClass
.
contains
(
SrcReg
)
||
!
ARM
::
tGPRRegClass
.
contains
(
DestReg
)
)
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tMOVr
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
)
;
else
{
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tPUSH
)
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tPOP
)
)
)
.
addReg
(
DestReg
,
getDefRegState
(
true
)
)
;
}
}
</s>

ARM
ARM
ARM
ARM::GPRRegClass
"Thumb1 can only copy GPR registers"
ARM::hGPRRegClass
ARM::tGPRRegClass
ARM::tMOVr
ARM::tPUSH
ARM::tPOP


<s>
SDValue
KudeyarTargetLowering
::
LowerFormalArguments
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
InputArg
>
&
Ins
,
DebugLoc
dl
,
SelectionDAG
&
DAG
,
SmallVectorImpl
<
SDValue
>
&
InVals
)
const
{
switch
(
CallConv
)
{
default
:
llvm_unreachable
(
"Unsupported calling convention"
)
;
case
CallingConv
::
C
:
case
CallingConv
::
Fast
:
return
LowerCCCArguments
(
Chain
,
CallConv
,
isVarArg
,
Ins
,
dl
,
DAG
,
InVals
)
;
case
CallingConv
::
Kudeyar_INTR
:
if
(
Ins
.
empty
(
)
)
return
Chain
;
report_fatal_error
(
"ISRs cannot have arguments"
)
;
}
}
</s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by the Ins array , into the specified DAG .

Kudeyar
Kudeyar
ISD::InputArg
"Unsupported calling convention"
Kudeyar
"ISRs cannot have arguments"


<s> unsigned aarch64_dbx_register_number ( unsigned regno ) { if ( GP_REGNUM_P ( regno ) ) return AARCH64_DWARF_R0 + regno - R0_REGNUM ; else if ( regno == SP_REGNUM ) return AARCH64_DWARF_SP ; else if ( FP_REGNUM_P ( regno ) ) return AARCH64_DWARF_V0 + regno - V0_REGNUM ; else if ( PR_REGNUM_P ( regno ) ) return AARCH64_DWARF_P0 + regno - P0_REGNUM ; else if ( regno == VG_REGNUM ) return AARCH64_DWARF_VG ; return DWARF_FRAME_REGISTERS ; } </s>

Provide a mapping from gcc register numbers to dwarf register numbers .


Control the placement of special register scavenging spill slots when allocating a stack frame .


<s> BitVector PPCRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; const PPCFrameLowering * PPCFI = static_cast < const PPCFrameLowering * > ( MF . getTarget ( ) . getFrameLowering ( ) ) ; Reserved . set ( PPC :: R0 ) ; Reserved . set ( PPC :: R1 ) ; Reserved . set ( PPC :: LR ) ; Reserved . set ( PPC :: LR8 ) ; Reserved . set ( PPC :: RM ) ; if ( Subtarget . isSVR4ABI ( ) ) { Reserved . set ( PPC :: R2 ) ; Reserved . set ( PPC :: R13 ) ; } if ( Subtarget . isDarwinABI ( ) ) { Reserved . set ( PPC :: R2 ) ; } if ( Subtarget . isPPC64 ( ) ) { Reserved . set ( PPC :: R13 ) ; Reserved . set ( PPC :: R31 ) ; Reserved . set ( PPC :: X0 ) ; Reserved . set ( PPC :: X1 ) ; Reserved . set ( PPC :: X13 ) ; Reserved . set ( PPC :: X31 ) ; if ( Subtarget . isSVR4ABI ( ) ) { Reserved . set ( PPC :: X2 ) ; } if ( Subtarget . isDarwinABI ( ) ) { Reserved . set ( PPC :: X2 ) ; } } if ( PPCFI -> needsFP ( MF ) ) Reserved . set ( PPC :: R31 ) ; return Reserved ; } </s>

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


"Unhandled instruction encoding format!"

Targets should implement this to emit instructions .


<s> static bool m68k_save_reg ( unsigned int regno , bool interrupt_handler ) { if ( flag_pic && regno == PIC_OFFSET_TABLE_REGNUM ) { if ( current_function_uses_pic_offset_table ) return true ; if ( ! current_function_is_leaf && TARGET_ID_SHARED_LIBRARY ) return true ; } if ( current_function_calls_eh_return ) { unsigned int i ; for ( i = 0 ; ; i ++ ) { unsigned int test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( fixed_regs [ regno ] ) return false ; if ( regno == FRAME_POINTER_REGNUM && frame_pointer_needed ) return false ; if ( interrupt_handler ) { if ( regs_ever_live [ regno ] ) return true ; if ( ! current_function_is_leaf && call_used_regs [ regno ] ) return true ; } if ( ! regs_ever_live [ regno ] ) return false ; return ! call_used_regs [ regno ] ; } </s>

Refer to the array ` regs_ever_live ' to determine which registers to save ; ` regs_ever_live [ I ] ' is nonzero if register number I is ever used in the function . This function is responsible for knowing which registers should not be saved even if used . Return true if we need to save REGNO .


<s> bool ARMAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getIdentifier ( ) ; if ( IDVal == ".word" ) return ParseDirectiveWord ( 4 , DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".thumb" ) return ParseDirectiveThumb ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".thumb_func" ) return ParseDirectiveThumbFunc ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".code" ) return ParseDirectiveCode ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".syntax" ) return ParseDirectiveSyntax ( DirectiveID . getLoc ( ) ) ; return true ; } </s>

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


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const override { uint64_t NumNops = Count / 4 ; for ( uint64_t i = 0 ; i != NumNops ; ++ i ) OW -> write32 ( 0x60000000 ) ; OW -> WriteZeros ( Count % 4 ) ; return true ; } </s>

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


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

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


<s> bool OR1KPassConfig :: addInstSelector ( ) { addPass ( createOR1KISelDag ( getOR1KTargetMachine ( ) ) ) ; addPass ( createOR1KGlobalBaseRegPass ( ) ) ; return false ; } </s>

addInstSelector - This method should install an instruction selector pass , which converts from LLVM code to machine instructions .


<s> static bool rs6000_scalar_mode_supported_p ( machine_mode mode ) { if ( TARGET_32BIT && mode == TImode ) return false ; if ( DECIMAL_FLOAT_MODE_P ( mode ) ) return default_decimal_float_supported_p ( ) ; else if ( TARGET_FLOAT128_TYPE && ( mode == KFmode || mode == IFmode ) ) return true ; else return default_scalar_mode_supported_p ( mode ) ; } </s>

Target hook for scalar_mode_supported_p .


<s> unsigned getGlobalBaseReg ( ) const { return GlobalBaseReg ; } </s>

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


<s> unsigned int nds32_debugger_regno ( unsigned int regno ) { if ( NDS32_IS_FPR_REGNUM ( regno ) ) return regno + 4 ; return regno ; } </s>

Map internal gcc register numbers to DWARF2 register numbers .


<s> bool M88kAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getIdentifier ( ) ; if ( IDVal == ".requires_88110" ) { MCSubtargetInfo & STI = copySTI ( ) ; STI . setDefaultFeatures ( "m88110" , "m88110" , "" ) ; setAvailableFeatures ( ComputeAvailableFeatures ( STI . getFeatureBits ( ) ) ) ; getTargetStreamer ( ) . emitDirectiveRequires881100 ( ) ; return false ; } return true ; } </s>


<s> StringRef getPassName ( ) const override { return "M88kPostLegalizerLowering" ; } </s>

getPassName - Return a nice clean name for a pass .


<s> void visium_expand_copysign ( rtx * operands , machine_mode mode ) { rtx op0 = operands [ 0 ] ; rtx op1 = operands [ 1 ] ; rtx op2 = operands [ 2 ] ; rtx mask = force_reg ( SImode , GEN_INT ( 0x7fffffff ) ) ; rtx x ; gcc_assert ( mode == SFmode ) ; if ( GET_CODE ( op1 ) == CONST_DOUBLE ) { if ( real_isneg ( CONST_DOUBLE_REAL_VALUE ( op1 ) ) ) op1 = simplify_unary_operation ( ABS , mode , op1 , mode ) ; if ( op1 != CONST0_RTX ( mode ) ) { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( op1 ) , l ) ; op1 = force_reg ( SImode , gen_int_mode ( l , SImode ) ) ; } } else { op1 = copy_to_mode_reg ( SImode , gen_lowpart ( SImode , op1 ) ) ; op1 = force_reg ( SImode , gen_rtx_AND ( SImode , op1 , mask ) ) ; } mask = force_reg ( SImode , gen_rtx_NOT ( SImode , mask ) ) ; op2 = copy_to_mode_reg ( SImode , gen_lowpart ( SImode , op2 ) ) ; op2 = force_reg ( SImode , gen_rtx_AND ( SImode , op2 , mask ) ) ; if ( op1 == CONST0_RTX ( SFmode ) ) x = op2 ; else x = force_reg ( SImode , gen_rtx_IOR ( SImode , op1 , op2 ) ) ; emit_insn ( gen_rtx_SET ( op0 , gen_lowpart ( SFmode , x ) ) ) ; } </s>


<s> StringRef getPassName ( ) const override { return AARCH64_DEAD_REG_DEF_NAME ; } </s>


"%qT uses address space %qs beyond flash of %d KiB"

"%s %q+D uses address space %qs beyond flash of %d KiB"

"pointer targeting address space %qs must be const in %qT"

"pointer targeting address space %qs must be const"

Sanity check NODE so that all pointers targeting non-generic address spaces go along with CONST qualifier . Writing to these address spaces should be detected and complained about as early as possible .


<s> SDValue PPCTargetLowering :: LowerCall ( SDValue Chain , SDValue Callee , unsigned CallConv , bool isVarArg , bool isTailCall , const SmallVectorImpl < ISD :: OutputArg > & Outs , const SmallVectorImpl < ISD :: InputArg > & Ins , DebugLoc dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) { if ( PPCSubTarget . isSVR4ABI ( ) && ! PPCSubTarget . isPPC64 ( ) ) { return LowerCall_SVR4 ( Chain , Callee , CallConv , isVarArg , isTailCall , Outs , Ins , dl , DAG , InVals ) ; } else { return LowerCall_Darwin ( Chain , Callee , CallConv , isVarArg , isTailCall , Outs , Ins , dl , DAG , InVals ) ; } } </s>

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

PowerPC PPC ISD::OutputArg ISD::InputArg PPC PPC PPC


<s> void conditional_register_usage ( void ) { bfin_cc_rtx = gen_rtx_REG ( BImode , REG_CC ) ; bfin_rets_rtx = gen_rtx_REG ( Pmode , REG_RETS ) ; } </s>

Called early in the compilation to conditionally modify fixed_regs/call_used_regs .


"Tail call is handled in the normal case. See comments"

EmitInstruction - This callback is invoked when an instruction is emitted , to advance the hazard state .


<s> void X86ATTInstPrinter :: printInst ( const MCInst * MI , raw_ostream & OS , StringRef Annot , const MCSubtargetInfo & STI ) { const MCInstrDesc & Desc = MII . get ( MI -> getOpcode ( ) ) ; uint64_t TSFlags = Desc . TSFlags ; if ( CommentStream ) HasCustomInstComment = EmitAnyX86InstComments ( MI , * CommentStream , getRegisterName ) ; unsigned Flags = MI -> getFlags ( ) ; if ( TSFlags & X86II :: LOCK ) OS << "\tlock\t" ; if ( ! ( TSFlags & X86II :: LOCK ) && Flags & X86 :: IP_HAS_LOCK ) OS << "\tlock\t" ; if ( Flags & X86 :: IP_HAS_REPEAT_NE ) OS << "\trepne\t" ; else if ( Flags & X86 :: IP_HAS_REPEAT ) OS << "\trep\t" ; if ( MI -> getOpcode ( ) == X86 :: CALLpcrel32 && ( STI . getFeatureBits ( ) [ X86 :: Mode64Bit ] ) ) { OS << "\tcallq\t" ; printPCRelImm ( MI , 0 , OS ) ; } else if ( MI -> getOpcode ( ) == X86 :: DATA16_PREFIX && ( STI . getFeatureBits ( ) [ X86 :: Mode16Bit ] ) ) { MCInst Data32MI ( * MI ) ; Data32MI . setOpcode ( X86 :: DATA32_PREFIX ) ; printInstruction ( & Data32MI , OS ) ; } else if ( ! printAliasInstr ( MI , OS ) ) printInstruction ( MI , OS ) ; printAnnotation ( OS , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


<s> void addExpr ( MCInst & Inst , const MCExpr * Expr ) const { if ( Expr == 0 ) Inst . addOperand ( MCOperand :: createImm ( 0 ) ) ; else if ( const MCConstantExpr * CE = dyn_cast < MCConstantExpr > ( Expr ) ) Inst . addOperand ( MCOperand :: createImm ( CE -> getValue ( ) ) ) ; else Inst . addOperand ( MCOperand :: createExpr ( Expr ) ) ; } </s>


<s> static rtx gen_gpr_to_xmm_move_src ( enum machine_mode vmode , rtx gpr ) { switch ( GET_MODE_NUNITS ( vmode ) ) { case 1 : gcc_unreachable ( ) ; case 2 : return gen_rtx_VEC_CONCAT ( vmode , gpr , CONST0_RTX ( GET_MODE_INNER ( vmode ) ) ) ; default : return gen_rtx_VEC_MERGE ( vmode , gen_rtx_VEC_DUPLICATE ( vmode , gpr ) , CONST0_RTX ( vmode ) , GEN_INT ( HOST_WIDE_INT_1U ) ) ; } } </s>

Generate the canonical SET_SRC to move GPR to a VMODE vector register , zeroing the upper parts .


<s>
void
nvptx_output_aligned_decl
(
FILE
*
file
,
const
char
*
name
,
const_tree
decl
,
HOST_WIDE_INT
size
,
unsigned
align
)
{
write_var_marker
(
file
,
true
,
TREE_PUBLIC
(
decl
)
,
name
)
;
fprintf
(
file
,
"\t%s"
,
TREE_PUBLIC
(
decl
)
".weak "
:
""
)
;
nvptx_assemble_decl_begin
(
file
,
name
,
section_for_decl
(
decl
)
,
TREE_TYPE
(
decl
)
,
size
,
align
)
;
nvptx_assemble_decl_end
(
)
;
}
</s>

Output an uninitialized common or file-scope variable .


<s> rtx function_expander :: use_contiguous_store_insn ( insn_code icode ) { gcc_assert ( call_expr_nargs ( exp ) > 0 ) ; machine_mode mode = TYPE_MODE ( builtin_types [ type . index ] . vector ) ; int arg_offset = 0 ; add_mem_operand ( mode , use_real_mask_p ( pred ) ? 1 : 0 ) ; if ( use_real_mask_p ( pred ) ) add_input_operand ( arg_offset ++ ) ; else add_all_one_mask_operand ( mask_mode ( ) ) ; arg_offset ++ ; for ( int argno = arg_offset ; argno < call_expr_nargs ( exp ) ; argno ++ ) add_input_operand ( argno ) ; return generate_insn ( icode ) ; } </s>


<s> static std :: unique_ptr < Cpu0Operand > CreateMem ( unsigned Base , const MCExpr * Off , SMLoc S , SMLoc E ) { auto Op = make_unique < Cpu0Operand > ( k_Memory ) ; Op -> Mem . Base = Base ; Op -> Mem . Off = Off ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addRequired < ScalarEvolutionWrapperPass > ( ) ; AU . addRequired < LoopInfoWrapperPass > ( ) ; AU . addRequired < TargetPassConfig > ( ) ; AU . addRequired < TargetTransformInfoWrapperPass > ( ) ; AU . addPreserved < LoopInfoWrapperPass > ( ) ; AU . setPreservesCFG ( ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> static int frame_save_reg ( rtx reg , HOST_WIDE_INT offset ) { rtx addr ; if ( offset ) { rtx tmp = plus_constant ( Pmode , stack_pointer_rtx , offset - GET_MODE_SIZE ( GET_MODE ( reg ) ) ) ; addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ) ; } else addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) ; frame_move_inc ( addr , reg , stack_pointer_rtx , 0 ) ; return GET_MODE_SIZE ( GET_MODE ( reg ) ) - offset ; } </s>

Helper for prologue : emit frame store with pre_modify or pre_dec to save register REG on stack . An initial offset OFFSET can be passed to the function .


<s> void ARMBaseInstrInfo :: reMaterialize ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , Register 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 ) ; BuildMI ( MBB , I , Orig . getDebugLoc ( ) , get ( Opcode ) , DestReg ) . addConstantPoolIndex ( CPI ) . addImm ( PCLabelId ) . cloneMemRefs ( Orig ) ; break ; } } } </s>

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


<s> static void mips_restore_reg ( rtx reg , rtx mem ) { if ( TARGET_MIPS16 && REGNO ( reg ) == GP_REG_FIRST + 31 ) reg = gen_rtx_REG ( GET_MODE ( reg ) , 7 ) ; if ( TARGET_MIPS16 && ! M16_REG_P ( REGNO ( reg ) ) ) { emit_move_insn ( MIPS_EPILOGUE_TEMP ( GET_MODE ( reg ) ) , mem ) ; emit_move_insn ( reg , MIPS_EPILOGUE_TEMP ( GET_MODE ( reg ) ) ) ; } else emit_move_insn ( reg , mem ) ; } </s>

Emit instructions to restore register REG from slot MEM .


<s> bool PPCPassConfig :: addPreRegAlloc ( ) { if ( ! DisableCTRLoops && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCCTRLoops ( ) ) ; return false ; } </s>

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


<s> int xstormy16_mode_dependent_address_p ( rtx x ) { if ( LEGITIMATE_ADDRESS_CONST_INT_P ( x , 0 ) && ! LEGITIMATE_ADDRESS_CONST_INT_P ( x , 6 ) ) return 1 ; if ( GET_CODE ( x ) == PLUS && LEGITIMATE_ADDRESS_INTEGER_P ( XEXP ( x , 1 ) , 0 ) && ! LEGITIMATE_ADDRESS_INTEGER_P ( XEXP ( x , 1 ) , 6 ) ) return 1 ; if ( GET_CODE ( x ) == PLUS ) x = XEXP ( x , 0 ) ; if ( GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == PRE_DEC ) return 1 ; return 0 ; } </s>

Return nonzero if memory address X ( an RTX ) can have different meanings depending on the machine mode of the memory reference it is used for or if the address is valid for some modes but not others . Autoincrement and autodecrement addresses typically have mode-dependent effects because the amount of the increment or decrement is the size of the operand being addressed . Some machines have other mode-dependent addresses . Many RISC machines have no mode-dependent addresses . You may assume that ADDR is a valid address for the machine . On this chip , this is true if the address is valid with an offset of 0 but not of 6 , because in that case it can not be used as an address for DImode or DFmode , or if the address is a post-increment or pre-decrement address .


"Flag output operand is of invalid type"


<s> bool WebAssemblyExceptionInfo :: runOnMachineFunction ( MachineFunction & F ) { releaseMemory ( ) ; auto & MDT = getAnalysis < MachineDominatorTree > ( ) ; auto & MDF = getAnalysis < MachineDominanceFrontier > ( ) ; recalculate ( MDT , MDF ) ; return false ; } </s>

runOnMachineFunction - Emit the function body .


<s>
bool
X86CallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
ArrayRef
<
Register
>
VRegs
,
FunctionLoweringInfo
&
FLI
)
const
{
assert
(
(
(
Val
&&
!
VRegs
.
empty
(
)
)
||
(
!
Val
&&
VRegs
.
empty
(
)
)
)
&&
"Return value without a vreg"
)
;
auto
MIB
=
MIRBuilder
.
buildInstrNoInsert
(
X86
::
RET
)
.
addImm
(
0
)
;
if
(
!
VRegs
.
empty
(
)
)
{
MachineFunction
&
MF
=
MIRBuilder
.
getMF
(
)
;
const
Function
&
F
=
MF
.
getFunction
(
)
;
MachineRegisterInfo
&
MRI
=
MF
.
getRegInfo
(
)
;
const
DataLayout
&
DL
=
MF
.
getDataLayout
(
)
;
ArgInfo
OrigRetInfo
(
VRegs
,
Val
->
getType
(
)
)
;
setArgFlags
(
OrigRetInfo
,
AttributeList
::
ReturnIndex
,
DL
,
F
)
;
SmallVector
<
ArgInfo
,
4
>
SplitRetInfos
;
splitToValueTypes
(
OrigRetInfo
,
SplitRetInfos
,
DL
,
F
.
getCallingConv
(
)
)
;
X86OutgoingValueAssigner
Assigner
(
RetCC_X86
)
;
X86OutgoingValueHandler
Handler
(
MIRBuilder
,
MRI
,
MIB
)
;
if
(
!
determineAndHandleAssignments
(
Handler
,
Assigner
,
SplitRetInfos
,
MIRBuilder
,
F
.
getCallingConv
(
)
,
F
.
isVarArg
(
)
)
)
return
false
;
}
MIRBuilder
.
insertInstr
(
MIB
)
;
return
true
;
}
</s>

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


<s>
StringRef
getPassName
(
)
const
override
{
return
"PowerPC QPX Load Splat Simplification"
;
}
</s>

PowerPC
"PowerPC QPX Load Splat Simplification"


<s> bool aarch64_sve_cmp_immediate_p ( rtx x , bool signed_p ) { x = unwrap_const_vec_duplicate ( x ) ; return ( CONST_INT_P ( x ) && ( signed_p ? IN_RANGE ( INTVAL ( x ) , - 16 , 15 ) : IN_RANGE ( INTVAL ( x ) , 0 , 127 ) ) ) ; } </s>

Return true if X is a valid immediate operand for an SVE CMP instruction . SIGNED_P says whether the operand is signed rather than unsigned .


<s>
void
GCNIterativeScheduler
::
schedule
(
)
{
LLVM_DEBUG
(
printLivenessInfo
(
dbgs
(
)
,
RegionBegin
,
RegionEnd
,
LIS
)
;
if
(
!
Regions
.
empty
(
)
&&
Regions
.
back
(
)
->
Begin
==
RegionBegin
)
{
dbgs
(
)
<<
"Max RP: "
;
Regions
.
back
(
)
->
MaxPressure
.
print
(
dbgs
(
)
,
&
MF
.
getSubtarget
<
GCNSubtarget
>
(
)
)
;
}
dbgs
(
)
<<
'\n'
;
)
;
}
</s>

Schedule - This is called back from ScheduleDAGInstrs : :Run ( ) when it 's time to do some work .


<s> bool AMDGPUAsmPrinter :: doFinalization ( Module & M ) { CallGraphResourceInfo . clear ( ) ; const MCSubtargetInfo & STI = * getGlobalSTI ( ) ; if ( ( AMDGPU :: isGFX10Plus ( STI ) || AMDGPU :: isGFX90A ( STI ) ) && ( STI . getTargetTriple ( ) . getOS ( ) == Triple :: AMDHSA || STI . getTargetTriple ( ) . getOS ( ) == Triple :: AMDPAL ) ) { OutStreamer -> SwitchSection ( getObjFileLowering ( ) . getTextSection ( ) ) ; getTargetStreamer ( ) -> EmitCodeEnd ( STI ) ; } return AsmPrinter :: doFinalization ( M ) ; } </s>

doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes have run .


"RegScavenger required for long branching"

"new block should be inserted for expanding unconditional branch"

Insert an unconditional indirect branch at the end of MBB to NewDestBB .


<s> const char * loongarch_output_probe_stack_range ( rtx reg1 , rtx reg2 , rtx reg3 ) { static int labelno = 0 ; char loop_lab [ 32 ] , tmp [ 64 ] ; rtx xops [ 3 ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , "LPSRL" , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ 0 ] = reg1 ; xops [ 2 ] = reg3 ; if ( TARGET_64BIT ) output_asm_insn ( "sub.d\t%0,%0,%2" , xops ) ; else output_asm_insn ( "sub.w\t%0,%0,%2" , xops ) ; xops [ 1 ] = reg2 ; strcpy ( tmp , "bne\t%0,%1," ) ; if ( TARGET_64BIT ) output_asm_insn ( "st.d\t$r0,%0,0" , xops ) ; else output_asm_insn ( "st.w\t$r0,%0,0" , xops ) ; output_asm_insn ( strcat ( tmp , & loop_lab [ 1 ] ) , xops ) ; return "" ; } </s>

Probe a range of stack addresses from REG1 to REG2 inclusive . These are absolute addresses .


<s> const char * TLCS900TargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return NULL ; case TLCS900ISD :: RET_FLAG : return "TLCS900ISD::RET_FLAG" ; case TLCS900ISD :: RETI_FLAG : return "TLCS900ISD::RETI_FLAG" ; case TLCS900ISD :: RRA : return "TLCS900ISD::RRA" ; case TLCS900ISD :: RLA : return "TLCS900ISD::RLA" ; case TLCS900ISD :: RRC : return "TLCS900ISD::RRC" ; case TLCS900ISD :: CALL : return "TLCS900ISD::CALL" ; case TLCS900ISD :: Wrapper : return "TLCS900ISD::Wrapper" ; case TLCS900ISD :: BR_CC : return "TLCS900ISD::BR_CC" ; case TLCS900ISD :: CMP : return "TLCS900ISD::CMP" ; case TLCS900ISD :: SELECT_CC : return "TLCS900ISD::SELECT_CC" ; case TLCS900ISD :: SHL : return "TLCS900ISD::SHL" ; case TLCS900ISD :: SRA : return "TLCS900ISD::SRA" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


<s>
unsigned
MipsSEInstrInfo
::
getOppositeBranchOpc
(
unsigned
Opc
)
const
{
switch
(
Opc
)
{
default
:
llvm_unreachable
(
"Illegal opcode!"
)
;
case
Mips
::
BEQ
:
return
Mips
::
BNE
;
case
Mips
::
BNE
:
return
Mips
::
BEQ
;
case
Mips
::
BGTZ
:
return
Mips
::
BLEZ
;
case
Mips
::
BGEZ
:
return
Mips
::
BLTZ
;
case
Mips
::
BLTZ
:
return
Mips
::
BGEZ
;
case
Mips
::
BLEZ
:
return
Mips
::
BGTZ
;
case
Mips
::
BEQ64
:
return
Mips
::
BNE64
;
case
Mips
::
BNE64
:
return
Mips
::
BEQ64
;
case
Mips
::
BGTZ64
:
return
Mips
::
BLEZ64
;
case
Mips
::
BGEZ64
:
return
Mips
::
BLTZ64
;
case
Mips
::
BLTZ64
:
return
Mips
::
BGEZ64
;
case
Mips
::
BLEZ64
:
return
Mips
::
BGTZ64
;
case
Mips
::
BC1T
:
return
Mips
::
BC1F
;
case
Mips
::
BC1F
:
return
Mips
::
BC1T
;
}
}
</s>

getOppositeBranchOpc - Return the inverse of the specified opcode , e.g .


<s> bool post_update_insn_p ( rtx_insn * insn ) { if ( find_post_update_rtx ( insn ) == - 1 ) return false ; else return true ; } </s>

Determine if INSN is a post update insn .


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


<s> void BPFAsmBackend :: applyFixup ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target , MutableArrayRef < char > Data , uint64_t Value , bool IsPCRel ) const { if ( Fixup . getKind ( ) == FK_SecRel_4 || Fixup . getKind ( ) == FK_SecRel_8 ) { assert ( Value == 0 ) ; } else if ( Fixup . getKind ( ) == FK_Data_4 || Fixup . getKind ( ) == FK_Data_8 ) { unsigned Size = Fixup . getKind ( ) == FK_Data_4 ? 4 : 8 ; for ( unsigned i = 0 ; i != Size ; ++ i ) { unsigned Idx = IsLittleEndian ? i : Size - i - 1 ; Data [ Fixup . getOffset ( ) + Idx ] = uint8_t ( Value >> ( i * 8 ) ) ; } } else { assert ( Fixup . getKind ( ) == FK_PCRel_2 ) ; Value = ( uint16_t ) ( ( Value - 8 ) / 8 ) ; if ( IsLittleEndian ) { Data [ Fixup . getOffset ( ) + 2 ] = Value & 0xFF ; Data [ Fixup . getOffset ( ) + 3 ] = Value >> 8 ; } else { Data [ Fixup . getOffset ( ) + 2 ] = Value >> 8 ; Data [ Fixup . getOffset ( ) + 3 ] = Value & 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> static bool epiphany_rtx_costs ( rtx x , machine_mode mode , int outer_code , int opno ATTRIBUTE_UNUSED , int * total , bool speed ATTRIBUTE_UNUSED ) { int code = GET_CODE ( x ) ; switch ( code ) { case CONST_INT : if ( ( outer_code == PLUS || outer_code == MINUS ) && SIMM11 ( INTVAL ( x ) ) ) { * total = 0 ; return true ; } if ( IMM16 ( INTVAL ( x ) ) ) { * total = outer_code == SET ? 0 : COSTS_N_INSNS ( 1 ) ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : * total = COSTS_N_INSNS ( ( epiphany_small16 ( x ) ? 0 : 1 ) + ( outer_code == SET ? 0 : 1 ) ) ; return true ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ! IMM16 ( INTVAL ( high ) ) + ! IMM16 ( INTVAL ( low ) ) ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( 1 ) ; return true ; case COMPARE : switch ( mode ) { case E_CC_N_NEmode : case E_CC_C_LTUmode : case E_CC_C_GTUmode : return true ; default : return false ; } case SET : { rtx src = SET_SRC ( x ) ; if ( BINARY_P ( src ) ) * total = 0 ; return false ; } default : return false ; } } </s>

Compute a ( partial ) cost for rtx X . Return true if the complete cost has been computed , and false if subexpressions should be scanned . In either case , * TOTAL contains the cost result .