<s> virtual bool isShuffleMaskLegal ( const SmallVectorImpl < int > & , EVT ) const { return false ; } </s>

Targets can use this to indicate that they only support some VECTOR_SHUFFLE operations , those with specific masks .


"There are no defined alternate asm variants"

Print the specified operand of MI , an INLINEASM instruction , using the specified assembler variant as an address .


<s> TargetStackID :: Value AArch64FrameLowering :: getStackIDForScalableVectors ( ) const { return TargetStackID :: SVEVector ; } </s>

Returns the StackID that scalable vectors should be associated with .


<s> static void spu_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == VAR_DECL && DECL_USER_ALIGN ( decl ) && DECL_ALIGN ( decl ) < 128 ) SYMBOL_REF_FLAGS ( XEXP ( rtl , 0 ) ) |= SYMBOL_FLAG_ALIGN1 ; } </s>

Encode symbol attributes ( local vs. global , tls model ) of a SYMBOL_REF into its SYMBOL_REF_FLAGS .


"Can only insert epilogue into returning blocks"

"Expected to see callee-save register restore code"


<s> bool X86TargetLowering :: useLoadStackGuardNode ( ) const { return Subtarget -> getTargetTriple ( ) . getObjectFormat ( ) == Triple :: MachO && Subtarget -> is64Bit ( ) ; } </s>

If this function returns true , SelectionDAGBuilder emits a LOAD_STACK_GUARD node when it is lowering Intrinsic : :stackprotector .


<s>
SDValue
mprocTargetLowering
::
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
::
mproc_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 .

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


"Can't break virtual register dependencies."

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


<s> bool isLegalMaskedScatter ( Type * Ty , MaybeAlign Alignment ) { return false ; } </s>

Return true if the target supports masked scatter .


<s> CSKYSubtarget & CSKYSubtarget :: initializeSubtargetDependencies ( const Triple & TT , StringRef CPUName , StringRef TuneCPUName , StringRef FS ) { if ( CPUName . empty ( ) ) CPUName = "generic" ; if ( TuneCPUName . empty ( ) ) TuneCPUName = CPUName ; UseHardFloat = false ; UseHardFloatABI = false ; HasFPUv2SingleFloat = false ; HasFPUv2DoubleFloat = false ; HasFPUv3HalfWord = false ; HasFPUv3HalfFloat = false ; HasFPUv3SingleFloat = false ; HasFPUv3DoubleFloat = false ; HasFdivdu = false ; HasFLOATE1 = false ; HasFLOAT1E2 = false ; HasFLOAT1E3 = false ; HasFLOAT3E4 = false ; HasFLOAT7E60 = false ; HasExtendLrw = false ; HasBTST16 = false ; HasTrust = false ; HasJAVA = false ; HasCache = false ; HasNVIC = false ; HasDSP = false ; HasDSP1E2 = false ; HasDSPE60 = false ; HasDSPV2 = false ; HasDSP_Silan = false ; HasDoloop = false ; HasHardwareDivide = false ; HasHighRegisters = false ; HasVDSPV2 = false ; HasVDSP2E3 = false ; HasVDSP2E60F = false ; ReadTPHard = false ; HasVDSPV1_128 = false ; UseCCRT = false ; DumpConstPool = false ; EnableInterruptAttribute = false ; HasPushPop = false ; HasSTM = false ; SmartMode = false ; EnableStackSize = false ; HasE1 = false ; HasE2 = false ; Has2E3 = false ; HasMP = false ; Has3E3r1 = false ; Has3r1E3r2 = false ; Has3r2E3r3 = false ; Has3E7 = false ; HasMP1E2 = false ; Has7E10 = false ; Has10E60 = false ; ParseSubtargetFeatures ( CPUName , TuneCPUName , FS ) ; return * this ; } </s>

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


<s>
ScheduleHazardRecognizer
*
PPCInstrInfo
::
CreateTargetPostRAHazardRecognizer
(
const
InstrItineraryData
*
II
,
const
ScheduleDAG
*
DAG
)
const
{
unsigned
Directive
=
TM
.
getSubtarget
<
PPCSubtarget
>
(
)
.
getDarwinDirective
(
)
;
if
(
Directive
==
PPC
::
DIR_PWR7
)
return
new
PPCDispatchGroupSBHazardRecognizer
(
II
,
DAG
)
;
if
(
Directive
!=
PPC
::
DIR_440
&&
Directive
!=
PPC
::
DIR_A2
&&
Directive
!=
PPC
::
DIR_E500mc
&&
Directive
!=
PPC
::
DIR_E5500
)
{
assert
(
TM
.
getInstrInfo
(
)
&&
"No InstrInfo?"
)
;
return
new
PPCHazardRecognizer970
(
TM
)
;
}
return
new
ScoreboardHazardRecognizer
(
II
,
DAG
)
;
}
</s>

Allocate and return a hazard recognizer to use for by non-scheduling passes .


"c4x_address_cost: Invalid addressing mode"

Provide the costs of an addressing mode that contains ADDR . If ADDR is not a valid address , its cost is irrelevant . This is used in cse and loop optimization to determine if it is worthwhile storing a common address into a register . Unfortunately , the C4x address cost depends on other operands .


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

Determine of register must be saved/restored in call .


<s> void PPCRegisterInfo :: materializeFrameBaseRegister ( MachineBasicBlock * MBB , unsigned BaseReg , int FrameIdx , int64_t Offset ) const { unsigned ADDriOpc = TM . isPPC64 ( ) ? PPC :: ADDI8 : PPC :: ADDI ; MachineBasicBlock :: iterator Ins = MBB -> begin ( ) ; DebugLoc DL ; if ( Ins != MBB -> end ( ) ) DL = Ins -> getDebugLoc ( ) ; const MachineFunction & MF = * MBB -> getParent ( ) ; const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; const TargetInstrInfo & TII = * Subtarget . getInstrInfo ( ) ; const MCInstrDesc & MCID = TII . get ( ADDriOpc ) ; MachineRegisterInfo & MRI = MBB -> getParent ( ) -> getRegInfo ( ) ; MRI . constrainRegClass ( BaseReg , TII . getRegClass ( MCID , 0 , this , MF ) ) ; BuildMI ( * MBB , Ins , DL , MCID , BaseReg ) . addFrameIndex ( FrameIdx ) . addImm ( Offset ) ; } </s>

Insert defining instruction ( s ) for a pointer to FrameIdx before insertion point I .

PowerPC PPC PPC PPC::ADDI8 PPC::ADDI PPC PPC 0


<s> bool mips_small_data_pattern_p ( rtx op ) { return mips_small_data_pattern_1 ( op , SYMBOL_CONTEXT_LEA ) ; } </s>

Return true if OP refers to small data symbols directly , not through a LO_SUM .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> bool HexagonInstrInfo :: analyzeCompare ( const MachineInstr & MI , Register & SrcReg , Register & SrcReg2 , int64_t & Mask , int64_t & Value ) const { unsigned Opc = MI . getOpcode ( ) ; switch ( Opc ) { case Hexagon :: C2_cmpeq : case Hexagon :: C2_cmpeqp : case Hexagon :: C2_cmpgt : case Hexagon :: C2_cmpgtp : case Hexagon :: C2_cmpgtu : case Hexagon :: C2_cmpgtup : case Hexagon :: C4_cmpneq : case Hexagon :: C4_cmplte : case Hexagon :: C4_cmplteu : case Hexagon :: C2_cmpeqi : case Hexagon :: C2_cmpgti : case Hexagon :: C2_cmpgtui : case Hexagon :: C4_cmpneqi : case Hexagon :: C4_cmplteui : case Hexagon :: C4_cmpltei : SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; Mask = ~ 0 ; break ; case Hexagon :: A4_cmpbeq : case Hexagon :: A4_cmpbgt : case Hexagon :: A4_cmpbgtu : case Hexagon :: A4_cmpbeqi : case Hexagon :: A4_cmpbgti : case Hexagon :: A4_cmpbgtui : SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; Mask = 0xFF ; break ; case Hexagon :: A4_cmpheq : case Hexagon :: A4_cmphgt : case Hexagon :: A4_cmphgtu : case Hexagon :: A4_cmpheqi : case Hexagon :: A4_cmphgti : case Hexagon :: A4_cmphgtui : SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; Mask = 0xFFFF ; break ; } switch ( Opc ) { case Hexagon :: C2_cmpeq : case Hexagon :: C2_cmpeqp : case Hexagon :: C2_cmpgt : case Hexagon :: C2_cmpgtp : case Hexagon :: C2_cmpgtu : case Hexagon :: C2_cmpgtup : case Hexagon :: A4_cmpbeq : case Hexagon :: A4_cmpbgt : case Hexagon :: A4_cmpbgtu : case Hexagon :: A4_cmpheq : case Hexagon :: A4_cmphgt : case Hexagon :: A4_cmphgtu : case Hexagon :: C4_cmpneq : case Hexagon :: C4_cmplte : case Hexagon :: C4_cmplteu : SrcReg2 = MI . getOperand ( 2 ) . getReg ( ) ; Value = 0 ; return true ; case Hexagon :: C2_cmpeqi : case Hexagon :: C2_cmpgtui : case Hexagon :: C2_cmpgti : case Hexagon :: C4_cmpneqi : case Hexagon :: C4_cmplteui : case Hexagon :: C4_cmpltei : case Hexagon :: A4_cmpbeqi : case Hexagon :: A4_cmpbgti : case Hexagon :: A4_cmpbgtui : case Hexagon :: A4_cmpheqi : case Hexagon :: A4_cmphgti : case Hexagon :: A4_cmphgtui : { SrcReg2 = 0 ; const MachineOperand & Op2 = MI . getOperand ( 2 ) ; if ( ! Op2 . isImm ( ) ) return false ; Value = MI . getOperand ( 2 ) . getImm ( ) ; return true ; } } return false ; } </s>

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


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

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


<s> const MachineOperand & WebAssemblyInstrInfo :: getCalleeOperand ( const MachineInstr & MI ) const { return WebAssembly :: getCalleeOp ( MI ) ; } </s>

Returns the callee operand from the given MI .


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

Returns true if the live-ins should be tracked after register allocation .


<s> bool OptimizePICCall :: runOnMachineFunction ( MachineFunction & F ) { if ( static_cast < const MipsSubtarget & > ( F . getSubtarget ( ) ) . inMips16Mode ( ) ) return false ; MachineDominatorTree * MDT = & getAnalysis < MachineDominatorTree > ( ) ; bool Changed = false ; SmallVector < MBBInfo , 8 > WorkList ( 1 , MBBInfo ( MDT -> getRootNode ( ) ) ) ; while ( ! WorkList . empty ( ) ) { MBBInfo & MBBI = WorkList . back ( ) ; if ( MBBI . isVisited ( ) ) { MBBI . postVisit ( ) ; WorkList . pop_back ( ) ; continue ; } MBBI . preVisit ( ScopedHT ) ; Changed |= visitNode ( MBBI ) ; const MachineDomTreeNode * Node = MBBI . getNode ( ) ; WorkList . append ( Node -> begin ( ) , Node -> end ( ) ) ; } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s>
void
AArch64AppleInstPrinter
::
printInst
(
const
MCInst
*
MI
,
raw_ostream
&
O
,
StringRef
Annot
)
{
unsigned
Opcode
=
MI
->
getOpcode
(
)
;
StringRef
Layout
,
Mnemonic
;
bool
IsTbx
;
if
(
isTblTbxInstruction
(
MI
->
getOpcode
(
)
,
Layout
,
IsTbx
)
)
{
O
<<
"\t"
<<
(
IsTbx
"tbx"
:
"tbl"
)
<<
Layout
<<
'\t'
<<
getRegisterName
(
MI
->
getOperand
(
0
)
.
getReg
(
)
,
AArch64
::
vreg
)
<<
", "
;
unsigned
ListOpNum
=
IsTbx
2
:
1
;
printVectorList
(
MI
,
ListOpNum
,
O
,
""
)
;
O
<<
", "
<<
getRegisterName
(
MI
->
getOperand
(
ListOpNum
+
1
)
.
getReg
(
)
,
AArch64
::
vreg
)
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
if
(
LdStNInstrDesc
*
LdStDesc
=
getLdStNInstrDesc
(
Opcode
)
)
{
O
<<
"\t"
<<
LdStDesc
->
Mnemonic
<<
LdStDesc
->
Layout
<<
'\t'
;
int
OpNum
=
LdStDesc
->
ListOperand
;
printVectorList
(
MI
,
OpNum
++
,
O
,
""
)
;
if
(
LdStDesc
->
HasLane
)
O
<<
'['
<<
MI
->
getOperand
(
OpNum
++
)
.
getImm
(
)
<<
']'
;
unsigned
AddrReg
=
MI
->
getOperand
(
OpNum
++
)
.
getReg
(
)
;
O
<<
", ["
<<
getRegisterName
(
AddrReg
)
<<
']'
;
if
(
LdStDesc
->
NaturalOffset
!=
0
)
{
unsigned
Reg
=
MI
->
getOperand
(
OpNum
++
)
.
getReg
(
)
;
if
(
Reg
!=
AArch64
::
XZR
)
O
<<
", "
<<
getRegisterName
(
Reg
)
;
else
{
assert
(
LdStDesc
->
NaturalOffset
&&
"no offset on post-inc instruction?"
)
;
O
<<
", #"
<<
LdStDesc
->
NaturalOffset
;
}
}
printAnnotation
(
O
,
Annot
)
;
return
;
}
AArch64InstPrinter
::
printInst
(
MI
,
O
,
Annot
)
;
}
</s>

Print the specified MCInst to the specified raw_ostream .


<s> void ARMPassConfig :: addPreEmitPass ( ) { if ( getARMSubtarget ( ) . isThumb2 ( ) ) { if ( ! getARMSubtarget ( ) . prefers32BitThumb ( ) ) addPass ( createThumb2SizeReductionPass ( ) ) ; addPass ( & UnpackMachineBundlesID ) ; } addPass ( createARMOptimizeBarriersPass ( ) ) ; addPass ( createARMConstantIslandPass ( ) ) ; } </s>

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


<s> static std :: unique_ptr < AArch64Operand > CreateReg ( unsigned RegNum , bool isVector , SMLoc S , SMLoc E , MCContext & Ctx ) { auto Op = make_unique < AArch64Operand > ( k_Register , Ctx ) ; Op -> Reg . RegNum = RegNum ; Op -> Reg . isVector = isVector ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>

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


<s> bool aarch64_emit_approx_div ( rtx quo , rtx num , rtx den ) { machine_mode mode = GET_MODE ( quo ) ; if ( GET_MODE_INNER ( mode ) == HFmode ) return false ; bool use_approx_division_p = ( flag_mlow_precision_div || ( aarch64_tune_params . approx_modes -> division & AARCH64_APPROX_MODE ( mode ) ) ) ; if ( ! flag_finite_math_only || flag_trapping_math || ! flag_unsafe_math_optimizations || optimize_function_for_size_p ( cfun ) || ! use_approx_division_p ) return false ; rtx xrcp = gen_reg_rtx ( mode ) ; emit_insn ( ( * get_recpe_type ( mode ) ) ( xrcp , den ) ) ; int iterations = ( GET_MODE_INNER ( mode ) == DFmode ) ? 3 : 2 ; if ( flag_mlow_precision_div ) iterations -- ; rtx xtmp = gen_reg_rtx ( mode ) ; while ( iterations -- ) { emit_insn ( ( * get_recps_type ( mode ) ) ( xtmp , xrcp , den ) ) ; if ( iterations > 0 ) emit_set_insn ( xrcp , gen_rtx_MULT ( mode , xrcp , xtmp ) ) ; } if ( num != CONST1_RTX ( mode ) ) { rtx xnum = force_reg ( mode , num ) ; emit_set_insn ( xrcp , gen_rtx_MULT ( mode , xrcp , xnum ) ) ; } emit_set_insn ( quo , gen_rtx_MULT ( mode , xrcp , xtmp ) ) ; return true ; } </s>

Emit the instruction sequence to compute the approximation for the division of NUM by DEN in QUO and return whether the sequence was emitted or not .


<s> bool PPCFastISel :: tryToFoldLoadIntoMI ( MachineInstr * MI , unsigned OpNo , const LoadInst * LI ) { MVT VT ; if ( ! isLoadTypeLegal ( LI -> getType ( ) , VT ) ) return false ; bool IsZExt = false ; switch ( MI -> getOpcode ( ) ) { default : return false ; case PPC :: RLDICL : case PPC :: RLDICL_32_64 : { IsZExt = true ; unsigned MB = MI -> getOperand ( 3 ) . getImm ( ) ; if ( ( VT == MVT :: i8 && MB <= 56 ) || ( VT == MVT :: i16 && MB <= 48 ) || ( VT == MVT :: i32 && MB <= 32 ) ) break ; return false ; } case PPC :: RLWINM : case PPC :: RLWINM8 : { IsZExt = true ; unsigned MB = MI -> getOperand ( 3 ) . getImm ( ) ; if ( ( VT == MVT :: i8 && MB <= 24 ) || ( VT == MVT :: i16 && MB <= 16 ) ) break ; return false ; } case PPC :: EXTSB : case PPC :: EXTSB8 : case PPC :: EXTSB8_32_64 : return false ; case PPC :: EXTSH : case PPC :: EXTSH8 : case PPC :: EXTSH8_32_64 : { if ( VT != MVT :: i16 && VT != MVT :: i8 ) return false ; break ; } case PPC :: EXTSW : case PPC :: EXTSW_32 : case PPC :: EXTSW_32_64 : { if ( VT != MVT :: i32 && VT != MVT :: i16 && VT != MVT :: i8 ) return false ; break ; } } Address Addr ; if ( ! PPCComputeAddress ( LI -> getOperand ( 0 ) , Addr ) ) return false ; unsigned ResultReg = MI -> getOperand ( 0 ) . getReg ( ) ; if ( ! PPCEmitLoad ( VT , ResultReg , Addr , nullptr , IsZExt , PPCSubTarget -> hasSPE ( ) ? PPC :: EVLDD : PPC :: LFD ) ) return false ; MI -> eraseFromParent ( ) ; return true ; } </s>

The specified machine instr operand is a vreg , and that vreg is being provided by the specified load instruction .


<s> VESubtarget & VESubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = std :: string ( CPU ) ; if ( CPUName . empty ( ) ) CPUName = "ve" ; ParseSubtargetFeatures ( CPUName , CPU , FS ) ; return * this ; } </s>

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


<s> void M680x0FrameLowering :: BuildCFI ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , const DebugLoc & DL , const MCCFIInstruction & CFIInst ) const { MachineFunction & MF = * MBB . getParent ( ) ; unsigned CFIIndex = MF . addFrameInst ( CFIInst ) ; BuildMI ( MBB , MBBI , DL , TII . get ( TargetOpcode :: CFI_INSTRUCTION ) ) . addCFIIndex ( CFIIndex ) ; } </s>

Wraps up getting a CFI index and building a MachineInstr for it .


<s> void ConvergingVLIWScheduler :: schedNode ( SUnit * SU , bool IsTopNode ) { if ( IsTopNode ) { Top . bumpNode ( SU ) ; SU -> TopReadyCycle = Top . CurrCycle ; } else { Bot . bumpNode ( SU ) ; SU -> BotReadyCycle = Bot . CurrCycle ; } } </s>

ScheduleDAGMI has scheduled an instruction - tell HazardRec about it .


<s> poly_int64 riscv_initial_elimination_offset ( int from , int to ) { poly_int64 src , dest ; riscv_compute_frame_info ( ) ; if ( to == HARD_FRAME_POINTER_REGNUM ) dest = cfun -> machine -> frame . hard_frame_pointer_offset ; else if ( to == STACK_POINTER_REGNUM ) dest = 0 ; else gcc_unreachable ( ) ; if ( from == FRAME_POINTER_REGNUM ) src = cfun -> machine -> frame . frame_pointer_offset ; else if ( from == ARG_POINTER_REGNUM ) src = cfun -> machine -> frame . arg_pointer_offset ; else gcc_unreachable ( ) ; return src - dest ; } </s>

Implement INITIAL_ELIMINATION_OFFSET . FROM is either the frame pointer or argument pointer . TO is either the stack pointer or hard frame pointer .


<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> bool NVPTXDAGToDAGISel :: SelectInlineAsmMemoryOperand ( const SDValue & Op , unsigned ConstraintID , std :: vector < SDValue > & OutOps ) { SDValue Op0 , Op1 ; switch ( ConstraintID ) { default : return true ; case InlineAsm :: Constraint_m : if ( SelectDirectAddr ( Op , Op0 ) ) { OutOps . push_back ( Op0 ) ; OutOps . push_back ( CurDAG -> getTargetConstant ( 0 , MVT :: i32 ) ) ; return false ; } if ( SelectADDRri ( Op . getNode ( ) , Op , Op0 , Op1 ) ) { OutOps . push_back ( Op0 ) ; OutOps . push_back ( Op1 ) ; return false ; } break ; } return true ; } </s>

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


<s>
void
print
(
raw_ostream
&
OS
)
const
override
{
switch
(
Kind
)
{
case
Immediate
:
OS
<<
*
getImm
(
)
;
break
;
case
Register
:
OS
<<
"<register x"
;
OS
<<
getReg
(
)
<<
">"
;
break
;
case
Token
:
OS
<<
"'"
<<
getToken
(
)
<<
"'"
;
break
;
}
}
</s>

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


<s> int aarch64_branch_cost ( bool speed_p , bool predictable_p ) { const struct cpu_branch_cost * branch_costs = aarch64_tune_params . branch_costs ; if ( ! speed_p || predictable_p ) return branch_costs -> predictable ; else return branch_costs -> unpredictable ; } </s>

Return the cost of a branch . If SPEED_P is true then the compiler is optimizing for speed . If PREDICTABLE_P is true then the branch is predicted to be taken .


<s> static void ix86_pad_returns ( void ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , EXIT_BLOCK_PTR -> preds ) { basic_block bb = e -> src ; rtx ret = BB_END ( bb ) ; rtx prev ; bool replace = false ; if ( GET_CODE ( ret ) != JUMP_INSN || GET_CODE ( PATTERN ( ret ) ) != RETURN || ! maybe_hot_bb_p ( bb ) ) continue ; for ( prev = PREV_INSN ( ret ) ; prev ; prev = PREV_INSN ( prev ) ) if ( active_insn_p ( prev ) || GET_CODE ( prev ) == CODE_LABEL ) break ; if ( prev && GET_CODE ( prev ) == CODE_LABEL ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( EDGE_FREQUENCY ( e ) && e -> src -> index >= 0 && ! ( e -> flags & EDGE_FALLTHRU ) ) replace = true ; } if ( ! replace ) { prev = prev_active_insn ( ret ) ; if ( prev && ( ( GET_CODE ( prev ) == JUMP_INSN && any_condjump_p ( prev ) ) || GET_CODE ( prev ) == CALL_INSN ) ) replace = true ; if ( ! prev && cfun -> function_frequency > FUNCTION_FREQUENCY_UNLIKELY_EXECUTED ) replace = true ; } if ( replace ) { emit_insn_before ( gen_return_internal_long ( ) , ret ) ; delete_insn ( ret ) ; } } } </s>

AMD Athlon works faster when RET is not destination of conditional jump or directly preceded by other jump instruction . We avoid the penalty by inserting NOP just before the RET instructions in such cases .


<s> Triple :: ObjectFormatType getFormat ( ) const override { return Triple :: Hex ; } </s>


<s> bool R600InstrInfo :: fitsConstReadLimitations ( const std :: vector < MachineInstr * > & MIs ) const { std :: vector < unsigned > Consts ; SmallSet < int64_t , 4 > Literals ; for ( MachineInstr * MI : MIs ) { if ( ! isALUInstr ( MI -> getOpcode ( ) ) ) continue ; for ( const auto & Src : getSrcs ( * MI ) ) { if ( Src . first -> getReg ( ) == R600 :: ALU_LITERAL_X ) Literals . insert ( Src . second ) ; if ( Literals . size ( ) > 4 ) return false ; if ( Src . first -> getReg ( ) == R600 :: ALU_CONST ) Consts . push_back ( Src . second ) ; if ( R600 :: R600_KC0RegClass . contains ( Src . first -> getReg ( ) ) || R600 :: R600_KC1RegClass . contains ( Src . first -> getReg ( ) ) ) { unsigned Index = RI . getEncodingValue ( Src . first -> getReg ( ) ) & 0xff ; unsigned Chan = RI . getHWRegChan ( Src . first -> getReg ( ) ) ; Consts . push_back ( ( Index << 2 ) | Chan ) ; } } } return fitsConstReadLimitations ( Consts ) ; } </s>

Same but using const index set instead of MI set .


<s> bool SystemZFrameInfo :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getTarget ( ) . getInstrInfo ( ) ; SystemZMachineFunctionInfo * MFI = MF . getInfo < SystemZMachineFunctionInfo > ( ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( SystemZ :: FP64RegClass . contains ( Reg ) ) TII . loadRegFromStackSlot ( MBB , MI , Reg , CSI [ i ] . getFrameIdx ( ) , & SystemZ :: FP64RegClass , TRI ) ; } unsigned LowReg = MFI -> getLowReg ( ) , HighReg = MFI -> getHighReg ( ) ; unsigned StartOffset = RegSpillOffsets [ LowReg ] ; if ( StartOffset ) { MachineInstrBuilder MIB = BuildMI ( MBB , MI , DL , TII . get ( ( LowReg == HighReg ? SystemZ :: MOV64rm : SystemZ :: MOV64rmm ) ) ) ; MIB . addReg ( LowReg , RegState :: Define ) ; if ( LowReg != HighReg ) MIB . addReg ( HighReg , RegState :: Define ) ; MIB . addReg ( hasFP ( MF ) ? SystemZ :: R11D : SystemZ :: R15D ) ; MIB . addImm ( StartOffset ) ; if ( LowReg == HighReg ) MIB . addReg ( 0 ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( Reg != LowReg && Reg != HighReg ) MIB . addReg ( Reg , RegState :: ImplicitDefine ) ; } } return true ; } </s>

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


<s>
const
char
*
nds32_output_16bit_store
(
rtx
*
operands
,
int
byte
)
{
char
pattern
[
100
]
;
char
size
;
rtx
code
=
XEXP
(
operands
[
0
]
,
0
)
;
size
=
nds32_byte_to_size
(
byte
)
;
switch
(
nds32_mem_format
(
operands
[
0
]
)
)
{
case
ADDRESS_REG
:
operands
[
0
]
=
code
;
output_asm_insn
(
"swi450\t%1, [%0]"
,
operands
)
;
break
;
case
ADDRESS_LO_REG_IMM3U
:
snprintf
(
pattern
,
sizeof
(
pattern
)
,
"s%ci333\t%%1, %%0"
,
size
)
;
output_asm_insn
(
pattern
,
operands
)
;
break
;
case
ADDRESS_POST_INC_LO_REG_IMM3U
:
snprintf
(
pattern
,
sizeof
(
pattern
)
,
"swi333.bi\t%%1, %%0, 4"
)
;
output_asm_insn
(
pattern
,
operands
)
;
break
;
case
ADDRESS_POST_MODIFY_LO_REG_IMM3U
:
snprintf
(
pattern
,
sizeof
(
pattern
)
,
"swi333.bi\t%%1, %%0"
)
;
output_asm_insn
(
pattern
,
operands
)
;
break
;
case
ADDRESS_FP_IMM7U
:
output_asm_insn
(
"swi37\t%1, %0"
,
operands
)
;
break
;
case
ADDRESS_SP_IMM7U
:
operands
[
0
]
=
XEXP
(
code
,
1
)
;
output_asm_insn
(
"swi37.sp\t%1, [ + (%0)]"
,
operands
)
;
break
;
default
:
break
;
}
return
""
;
}
</s>


<s>
static
Scope
::
Scope
getScope
(
SyncScope
::
ID
Ord
)
{
switch
(
Ord
)
{
case
SyncScope
::
SingleThread
:
return
Scope
::
Invocation
;
case
SyncScope
::
System
:
return
Scope
::
Device
;
default
:
llvm_unreachable
(
"Unsupported synchronization Scope ID."
)
;
}
}
</s>

SPIRV
"Unsupported synchronization Scope ID."


<s>
unsigned
PPCInstrInfo
::
lookThruCopyLike
(
unsigned
SrcReg
,
const
MachineRegisterInfo
*
MRI
)
{
while
(
true
)
{
MachineInstr
*
MI
=
MRI
->
getVRegDef
(
SrcReg
)
;
if
(
!
MI
->
isCopyLike
(
)
)
return
SrcReg
;
unsigned
CopySrcReg
;
if
(
MI
->
isCopy
(
)
)
CopySrcReg
=
MI
->
getOperand
(
1
)
.
getReg
(
)
;
else
{
assert
(
MI
->
isSubregToReg
(
)
&&
"Bad opcode for lookThruCopyLike"
)
;
CopySrcReg
=
MI
->
getOperand
(
2
)
.
getReg
(
)
;
}
if
(
!
TargetRegisterInfo
::
isVirtualRegister
(
CopySrcReg
)
)
return
CopySrcReg
;
SrcReg
=
CopySrcReg
;
}
}
</s>

Returns the original SrcReg unless it is the target of a copy-like operation , in which case we chain backwards through all such operations to the ultimate source register .


<s> unsigned BPFMCCodeEmitter :: getMachineOpValue ( const MCInst & MI , const MCOperand & MO , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { if ( MO . isReg ( ) ) return MRI . getEncodingValue ( MO . getReg ( ) ) ; if ( MO . isImm ( ) ) return static_cast < unsigned > ( MO . getImm ( ) ) ; assert ( MO . isExpr ( ) ) ; const MCExpr * Expr = MO . getExpr ( ) ; assert ( Expr -> getKind ( ) == MCExpr :: SymbolRef ) ; if ( MI . getOpcode ( ) == BPF :: JAL ) Fixups . push_back ( MCFixup :: create ( 0 , Expr , FK_PCRel_4 ) ) ; else if ( MI . getOpcode ( ) == BPF :: LD_imm64 ) Fixups . push_back ( MCFixup :: create ( 0 , Expr , FK_SecRel_8 ) ) ; else Fixups . push_back ( MCFixup :: create ( 0 , Expr , FK_PCRel_2 ) ) ; return 0 ; } </s>

getMachineOpValue - Return binary encoding of operand .


<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 [ 1 ] = GEN_INT ( - PROBE_INTERVAL ) ; 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> void MipsFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const MipsInstrInfo & TII = * static_cast < const MipsInstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; DebugLoc dl = MBBI -> getDebugLoc ( ) ; unsigned SP = STI . isABI_N64 ( ) ? Mips :: SP_64 : Mips :: SP ; unsigned FP = STI . isABI_N64 ( ) ? Mips :: FP_64 : Mips :: FP ; unsigned ZERO = STI . isABI_N64 ( ) ? Mips :: ZERO_64 : Mips :: ZERO ; unsigned ADDu = STI . isABI_N64 ( ) ? Mips :: DADDu : Mips :: ADDu ; unsigned ADDiu = STI . isABI_N64 ( ) ? Mips :: DADDiu : Mips :: ADDiu ; unsigned StackSize = MFI -> getStackSize ( ) ; unsigned NewReg = 0 ; int NewImm = 0 ; bool ATUsed = false ; if ( hasFP ( MF ) ) { MachineBasicBlock :: iterator I = MBBI ; for ( unsigned i = 0 ; i < MFI -> getCalleeSavedInfo ( ) . size ( ) ; ++ i ) -- I ; BuildMI ( MBB , I , dl , TII . get ( ADDu ) , SP ) . addReg ( FP ) . addReg ( ZERO ) ; } if ( StackSize ) { ATUsed = expandRegLargeImmPair ( SP , StackSize , NewReg , NewImm , MBB , MBBI ) ; BuildMI ( MBB , MBBI , dl , TII . get ( ADDiu ) , SP ) . addReg ( NewReg ) . addImm ( NewImm ) ; if ( ATUsed ) BuildMI ( MBB , MBBI , dl , TII . get ( Mips :: ATMACRO ) ) ; } } </s>

Mips Mips Mips Mips Mips::SP_64 Mips::SP Mips::FP_64 Mips::FP Mips::ZERO_64 Mips::ZERO Mips::DADDu Mips::ADDu Mips::DADDiu Mips::ADDiu 0 0 0 Mips::ATMACRO


"\nrs6000_address_cost, return = %d, speed = %s, x:\n"

Debug form of ADDRESS_COST that is selected if -mdebug=cost .


<s> static void nvptx_file_end ( void ) { hash_table < tree_hasher > :: iterator iter ; tree decl ; FOR_EACH_HASH_TABLE_ELEMENT ( * needed_fndecls_htab , decl , tree , iter ) nvptx_record_fndecl ( decl ) ; fputs ( func_decls . str ( ) . c_str ( ) , asm_out_file ) ; if ( worker_bcast_size ) write_worker_buffer ( asm_out_file , worker_bcast_sym , worker_bcast_align , worker_bcast_size ) ; if ( worker_red_size ) write_worker_buffer ( asm_out_file , worker_red_sym , worker_red_align , worker_red_size ) ; } </s>

Write out the function declarations we 've collected .


<s>
static
const
char
*
output_move_simode_const
(
rtx
*
operands
)
{
rtx
dest
;
HOST_WIDE_INT
src
;
dest
=
operands
[
0
]
;
src
=
INTVAL
(
operands
[
1
]
)
;
if
(
src
==
0
&&
(
DATA_REG_P
(
dest
)
||
MEM_P
(
dest
)
)
&&
(
(
TARGET_68010
||
TARGET_COLDFIRE
)
||
!
(
MEM_P
(
dest
)
&&
MEM_VOLATILE_P
(
dest
)
)
)
)
return
"clr%.l %0"
;
else
if
(
GET_MODE
(
dest
)
==
SImode
&&
valid_mov3q_const
(
src
)
)
return
"mov3q%.l %1,%0"
;
else
if
(
src
==
0
&&
ADDRESS_REG_P
(
dest
)
)
return
"sub%.l %0,%0"
;
else
if
(
DATA_REG_P
(
dest
)
)
return
output_move_const_into_data_reg
(
operands
)
;
else
if
(
ADDRESS_REG_P
(
dest
)
&&
IN_RANGE
(
src
,
0x8000
,
0x7fff
)
)
{
if
(
valid_mov3q_const
(
src
)
)
return
"mov3q%.l %1,%0"
;
return
"move%.w %1,%0"
;
}
else
if
(
MEM_P
(
dest
)
&&
GET_CODE
(
XEXP
(
dest
,
0
)
)
==
PRE_DEC
&&
REGNO
(
XEXP
(
XEXP
(
dest
,
0
)
,
0
)
)
==
STACK_POINTER_REGNUM
&&
IN_RANGE
(
src
,
0x8000
,
0x7fff
)
)
{
if
(
valid_mov3q_const
(
src
)
)
return
"mov3q%.l %1,%-"
;
return
"pea %a1"
;
}
return
"move%.l %1,%0"
;
}
</s>

Return an instruction to move CONST_INT OPERANDS [ 1 ] into OPERANDS [ 0 ] . I is the value of OPERANDS [ 1 ] .


<s>
void
mmix_asm_output_aligned_common
(
FILE
*
stream
,
const
char
*
name
,
int
size
,
int
align
)
{
fprintf
(
stream
,
"\t.comm\t"
)
;
assemble_name
(
stream
,
name
)
;
fprintf
(
stream
,
",%u,%u ! mmixal-incompatible COMMON\n"
,
size
,
align
/
BITS_PER_UNIT
)
;
}
</s>

mmix
"\t.comm\t"
",%u,%u ! mmixal-incompatible COMMON\n"


<s>
bool
ARMAsmParser
::
MatchAndEmitInstruction
(
SMLoc
IDLoc
,
unsigned
&
Opcode
,
OperandVector
&
Operands
,
MCStreamer
&
Out
,
uint64_t
&
ErrorInfo
,
bool
MatchingInlineAsm
)
{
MCInst
Inst
;
unsigned
MatchResult
;
bool
PendConditionalInstruction
=
false
;
SmallVector
<
NearMissInfo
,
4
>
NearMisses
;
MatchResult
=
MatchInstruction
(
Operands
,
Inst
,
NearMisses
,
MatchingInlineAsm
,
PendConditionalInstruction
,
Out
)
;
switch
(
MatchResult
)
{
case
Match_Success
:
LLVM_DEBUG
(
dbgs
(
)
<<
"Parsed as: "
;
Inst
.
dump_pretty
(
dbgs
(
)
,
MII
.
getName
(
Inst
.
getOpcode
(
)
)
)
;
dbgs
(
)
<<
"\n"
)
;
if
(
validateInstruction
(
Inst
,
Operands
)
)
{
forwardITPosition
(
)
;
return
true
;
}
{
bool
wasInITBlock
=
inITBlock
(
)
;
while
(
processInstruction
(
Inst
,
Operands
,
Out
)
)
LLVM_DEBUG
(
dbgs
(
)
<<
"Changed to: "
;
Inst
.
dump_pretty
(
dbgs
(
)
,
MII
.
getName
(
Inst
.
getOpcode
(
)
)
)
;
dbgs
(
)
<<
"\n"
)
;
if
(
wasInITBlock
&&
hasV8Ops
(
)
&&
isThumb
(
)
&&
!
isV8EligibleForIT
(
&
Inst
)
)
{
Warning
(
IDLoc
,
"deprecated instruction in IT block"
)
;
}
}
forwardITPosition
(
)
;
if
(
Inst
.
getOpcode
(
)
==
ARM
::
ITasm
)
return
false
;
Inst
.
setLoc
(
IDLoc
)
;
if
(
PendConditionalInstruction
)
{
PendingConditionalInsts
.
push_back
(
Inst
)
;
if
(
isITBlockFull
(
)
||
isITBlockTerminator
(
Inst
)
)
flushPendingInstructions
(
Out
)
;
}
else
{
Out
.
EmitInstruction
(
Inst
,
getSTI
(
)
)
;
}
return
false
;
case
Match_NearMisses
:
ReportNearMisses
(
NearMisses
,
IDLoc
,
Operands
)
;
return
true
;
case
Match_MnemonicFail
:
{
FeatureBitset
FBS
=
ComputeAvailableFeatures
(
getSTI
(
)
.
getFeatureBits
(
)
)
;
std
::
string
Suggestion
=
ARMMnemonicSpellCheck
(
(
(
ARMOperand
&
)
*
Operands
[
0
]
)
.
getToken
(
)
,
FBS
)
;
return
Error
(
IDLoc
,
"invalid instruction"
+
Suggestion
,
(
(
ARMOperand
&
)
*
Operands
[
0
]
)
.
getLocRange
(
)
)
;
}
}
llvm_unreachable
(
"Implement any new match types added!"
)
;
}
</s>

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

ARM
ARM
4
"Parsed as: "
"\n"
"Changed to: "
"\n"
"deprecated instruction in IT block"
ARM::ITasm
ARM
ARM
0
"invalid instruction"
ARM
0
"Implement any new match types added!"


<s> void R600TTIImpl :: getUnrollingPreferences ( Loop * L , ScalarEvolution & SE , TTI :: UnrollingPreferences & UP ) { CommonTTI . getUnrollingPreferences ( L , SE , UP ) ; } </s>

Get target-customized preferences for the generic loop unrolling transformation .


<s> bool SIPreEmitPeephole :: runOnMachineFunction ( MachineFunction & MF ) { const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; TII = ST . getInstrInfo ( ) ; TRI = & TII -> getRegisterInfo ( ) ; bool Changed = false ; MF . RenumberBlocks ( ) ; for ( MachineBasicBlock & MBB : MF ) { MachineBasicBlock :: iterator TermI = MBB . getFirstTerminator ( ) ; if ( TermI != MBB . end ( ) ) { MachineInstr & MI = * TermI ; switch ( MI . getOpcode ( ) ) { case AMDGPU :: S_CBRANCH_VCCZ : case AMDGPU :: S_CBRANCH_VCCNZ : Changed |= optimizeVccBranch ( MI ) ; break ; case AMDGPU :: S_CBRANCH_EXECZ : Changed |= removeExeczBranch ( MI , MBB ) ; break ; } } if ( ! ST . hasVGPRIndexMode ( ) ) continue ; MachineInstr * SetGPRMI = nullptr ; const unsigned Threshold = 20 ; unsigned Count = 0 ; for ( auto & MI : make_early_inc_range ( make_range ( MBB . instr_begin ( ) , MBB . instr_end ( ) ) ) ) { if ( Count == Threshold ) SetGPRMI = nullptr ; else ++ Count ; if ( MI . getOpcode ( ) != AMDGPU :: S_SET_GPR_IDX_ON ) continue ; Count = 0 ; if ( ! SetGPRMI ) { SetGPRMI = & MI ; continue ; } if ( optimizeSetGPR ( * SetGPRMI , MI ) ) Changed = true ; else SetGPRMI = & MI ; } } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> enum reg_class ix86_preferred_reload_class ( rtx x , enum reg_class class ) { if ( class == NO_REGS ) return NO_REGS ; if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) return class ; if ( GET_CODE ( x ) == CONST_DOUBLE && GET_MODE ( x ) != VOIDmode ) { if ( reg_class_subset_p ( class , GENERAL_REGS ) ) return class ; if ( TARGET_80387 && ( TARGET_MIX_SSE_I387 || ! ( TARGET_SSE_MATH && SSE_FLOAT_MODE_P ( GET_MODE ( x ) ) ) ) && standard_80387_constant_p ( x ) ) { if ( class == FLOAT_SSE_REGS ) return FLOAT_REGS ; if ( class == FP_TOP_SSE_REGS ) return FP_TOP_REG ; if ( class == FP_SECOND_SSE_REGS ) return FP_SECOND_REG ; if ( class == FLOAT_INT_REGS || class == FLOAT_REGS ) return class ; } return NO_REGS ; } if ( MAYBE_MMX_CLASS_P ( class ) && CONSTANT_P ( x ) ) return NO_REGS ; if ( MAYBE_SSE_CLASS_P ( class ) && CONSTANT_P ( x ) ) return NO_REGS ; if ( GET_CODE ( x ) == PLUS ) return reg_class_subset_p ( class , GENERAL_REGS ) ? class : NO_REGS ; if ( GET_MODE ( x ) == QImode && ! CONSTANT_P ( x ) ) { if ( reg_class_subset_p ( class , Q_REGS ) ) return class ; if ( reg_class_subset_p ( Q_REGS , class ) ) return Q_REGS ; return NO_REGS ; } return class ; } </s>

Put float CONST_DOUBLE in the constant pool instead of fp regs . QImode must go into class Q_REGS . Narrow ALL_REGS to GENERAL_REGS . This supports allowing movsf and movdf to do mem-to-mem moves through integer regs .


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

Return the output streamer for the assembler .


<s> static reg_class_t xtensa_preferred_reload_class ( rtx x , reg_class_t rclass ) { if ( CONSTANT_P ( x ) && CONST_DOUBLE_P ( x ) ) return NO_REGS ; if ( rclass == AR_REGS || rclass == GR_REGS ) return RL_REGS ; return rclass ; } </s>

Worker function for TARGET_PREFERRED_RELOAD_CLASS .


<s> bool RISCVAsmBackend :: shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) { if ( Fixup . getKind ( ) >= FirstLiteralRelocationKind ) return true ; switch ( Fixup . getTargetKind ( ) ) { default : break ; case FK_Data_1 : case FK_Data_2 : case FK_Data_4 : case FK_Data_8 : if ( Target . isAbsolute ( ) ) return false ; break ; case RISCV :: fixup_riscv_got_hi20 : case RISCV :: fixup_riscv_tls_got_hi20 : case RISCV :: fixup_riscv_tls_gd_hi20 : return true ; case RISCV :: fixup_pulpv2_loop_setup : case RISCV :: fixup_pulpv2_loop_setupi : return false ; } return STI . getFeatureBits ( ) [ RISCV :: FeatureRelax ] || ForceRelocs ; } </s>

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


<s> bool HexagonGenPredicate :: runOnMachineFunction ( MachineFunction & MF ) { if ( skipFunction ( MF . getFunction ( ) ) ) return false ; TII = MF . getSubtarget < HexagonSubtarget > ( ) . getInstrInfo ( ) ; TRI = MF . getSubtarget < HexagonSubtarget > ( ) . getRegisterInfo ( ) ; MRI = & MF . getRegInfo ( ) ; PredGPRs . clear ( ) ; PUsers . clear ( ) ; G2P . clear ( ) ; bool Changed = false ; collectPredicateGPR ( MF ) ; for ( SetOfReg :: iterator I = PredGPRs . begin ( ) , E = PredGPRs . end ( ) ; I != E ; ++ I ) processPredicateGPR ( * I ) ; bool Again ; do { Again = false ; VectOfInst Processed , Copy ; Copy = PUsers ; for ( MachineInstr * MI : Copy ) { bool Done = convertToPredForm ( MI ) ; if ( Done ) { Processed . insert ( MI ) ; Again = true ; } } Changed |= Again ; auto Done = [ Processed ] ( MachineInstr * MI ) -> bool { return Processed . count ( MI ) ; } ; PUsers . remove_if ( Done ) ; } while ( Again ) ; Changed |= eliminatePredCopies ( MF ) ; return Changed ; } </s>


<s> static bool mips_return_in_memory ( tree type , tree fndecl ATTRIBUTE_UNUSED ) { if ( TARGET_OLDABI ) return ( TYPE_MODE ( type ) == BLKmode ) ; else return ( ( int_size_in_bytes ( type ) > ( 2 * UNITS_PER_WORD ) ) || ( int_size_in_bytes ( type ) == - 1 ) ) ; } </s>

Implement TARGET_RETURN_IN_MEMORY . Under the old ( i.e. , 32 and O64 ABIs ) all BLKmode objects are returned in memory . Under the new ( N32 and 64-bit MIPS ABIs ) small structures are returned in a register . Objects with varying size must still be returned in memory , of course .


<s>
bool
MCS51InstrInfo
::
isBranchOffsetInRange
(
unsigned
BranchOp
,
int64_t
BrOffset
)
const
{
switch
(
BranchOp
)
{
default
:
llvm_unreachable
(
"unexpected opcode!"
)
;
case
MCS51
::
JMPk
:
case
MCS51
::
CALLk
:
return
true
;
case
MCS51
::
RCALLk
:
case
MCS51
::
RJMPk
:
return
isIntN
(
13
,
BrOffset
)
;
case
MCS51
::
BRBSsk
:
case
MCS51
::
BRBCsk
:
case
MCS51
::
BREQk
:
case
MCS51
::
BRNEk
:
case
MCS51
::
BRSHk
:
case
MCS51
::
BRLOk
:
case
MCS51
::
BRMIk
:
case
MCS51
::
BRPLk
:
case
MCS51
::
BRGEk
:
case
MCS51
::
BRLTk
:
return
isIntN
(
7
,
BrOffset
)
;
}
}
</s>

Determine if the branch target is in range .


<s> const char * NVPTXTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return 0 ; case NVPTXISD :: CALL : return "NVPTXISD::CALL" ; case NVPTXISD :: RET_FLAG : return "NVPTXISD::RET_FLAG" ; case NVPTXISD :: Wrapper : return "NVPTXISD::Wrapper" ; case NVPTXISD :: NVBuiltin : return "NVPTXISD::NVBuiltin" ; case NVPTXISD :: DeclareParam : return "NVPTXISD::DeclareParam" ; case NVPTXISD :: DeclareScalarParam : return "NVPTXISD::DeclareScalarParam" ; case NVPTXISD :: DeclareRet : return "NVPTXISD::DeclareRet" ; case NVPTXISD :: DeclareRetParam : return "NVPTXISD::DeclareRetParam" ; case NVPTXISD :: PrintCall : return "NVPTXISD::PrintCall" ; case NVPTXISD :: LoadParam : return "NVPTXISD::LoadParam" ; case NVPTXISD :: StoreParam : return "NVPTXISD::StoreParam" ; case NVPTXISD :: StoreParamS32 : return "NVPTXISD::StoreParamS32" ; case NVPTXISD :: StoreParamU32 : return "NVPTXISD::StoreParamU32" ; case NVPTXISD :: MoveToParam : return "NVPTXISD::MoveToParam" ; case NVPTXISD :: CallArgBegin : return "NVPTXISD::CallArgBegin" ; case NVPTXISD :: CallArg : return "NVPTXISD::CallArg" ; case NVPTXISD :: LastCallArg : return "NVPTXISD::LastCallArg" ; case NVPTXISD :: CallArgEnd : return "NVPTXISD::CallArgEnd" ; case NVPTXISD :: CallVoid : return "NVPTXISD::CallVoid" ; case NVPTXISD :: CallVal : return "NVPTXISD::CallVal" ; case NVPTXISD :: CallSymbol : return "NVPTXISD::CallSymbol" ; case NVPTXISD :: Prototype : return "NVPTXISD::Prototype" ; case NVPTXISD :: MoveParam : return "NVPTXISD::MoveParam" ; case NVPTXISD :: MoveRetval : return "NVPTXISD::MoveRetval" ; case NVPTXISD :: MoveToRetval : return "NVPTXISD::MoveToRetval" ; case NVPTXISD :: StoreRetval : return "NVPTXISD::StoreRetval" ; case NVPTXISD :: PseudoUseParam : return "NVPTXISD::PseudoUseParam" ; case NVPTXISD :: RETURN : return "NVPTXISD::RETURN" ; case NVPTXISD :: CallSeqBegin : return "NVPTXISD::CallSeqBegin" ; case NVPTXISD :: CallSeqEnd : return "NVPTXISD::CallSeqEnd" ; } } </s>

getTargetNodeName - This method returns the name of a target specific

NVPTX NVPTX 0 NVPTXISD::CALL "NVPTXISD::CALL" NVPTXISD::RET_FLAG "NVPTXISD::RET_FLAG" NVPTXISD::Wrapper "NVPTXISD::Wrapper" NVPTXISD::NVBuiltin "NVPTXISD::NVBuiltin" NVPTXISD::DeclareParam "NVPTXISD::DeclareParam" NVPTXISD::DeclareScalarParam "NVPTXISD::DeclareScalarParam" NVPTXISD::DeclareRet "NVPTXISD::DeclareRet" NVPTXISD::DeclareRetParam "NVPTXISD::DeclareRetParam" NVPTXISD::PrintCall "NVPTXISD::PrintCall" NVPTXISD::LoadParam "NVPTXISD::LoadParam" NVPTXISD::StoreParam "NVPTXISD::StoreParam" NVPTXISD::StoreParamS32 "NVPTXISD::StoreParamS32" NVPTXISD::StoreParamU32 "NVPTXISD::StoreParamU32" NVPTXISD::MoveToParam "NVPTXISD::MoveToParam" NVPTXISD::CallArgBegin "NVPTXISD::CallArgBegin" NVPTXISD::CallArg "NVPTXISD::CallArg" NVPTXISD::LastCallArg "NVPTXISD::LastCallArg" NVPTXISD::CallArgEnd "NVPTXISD::CallArgEnd" NVPTXISD::CallVoid "NVPTXISD::CallVoid" NVPTXISD::CallVal "NVPTXISD::CallVal" NVPTXISD::CallSymbol "NVPTXISD::CallSymbol" NVPTXISD::Prototype "NVPTXISD::Prototype" NVPTXISD::MoveParam "NVPTXISD::MoveParam" NVPTXISD::MoveRetval "NVPTXISD::MoveRetval" NVPTXISD::MoveToRetval "NVPTXISD::MoveToRetval" NVPTXISD::StoreRetval "NVPTXISD::StoreRetval" NVPTXISD::PseudoUseParam "NVPTXISD::PseudoUseParam" NVPTXISD::RETURN "NVPTXISD::RETURN" NVPTXISD::CallSeqBegin "NVPTXISD::CallSeqBegin" NVPTXISD::CallSeqEnd "NVPTXISD::CallSeqEnd"


<s> MVT getVectorIdxTy ( const DataLayout & DL ) const override { return MVT :: i32 ; } </s>

Returns the type to be used for the index operand of : ISD : :INSERT_VECTOR_ELT , ISD : :EXTRACT_VECTOR_ELT , ISD : :INSERT_SUBVECTOR , and ISD : :EXTRACT_SUBVECTOR .


<s> rtx arm_gen_load_multiple ( int * regs , int count , rtx basereg , int write_back , rtx basemem , HOST_WIDE_INT * offsetp ) { return arm_gen_multiple_op ( TRUE , regs , count , basereg , write_back , basemem , offsetp ) ; } </s>


<s> std :: pair < const Value * , unsigned > NVPTXTargetMachine :: getPredicatedAddrSpace ( const Value * V ) const { if ( auto * II = dyn_cast < IntrinsicInst > ( V ) ) { switch ( II -> getIntrinsicID ( ) ) { case Intrinsic :: nvvm_isspacep_const : return std :: make_pair ( II -> getArgOperand ( 0 ) , llvm :: ADDRESS_SPACE_CONST ) ; case Intrinsic :: nvvm_isspacep_global : return std :: make_pair ( II -> getArgOperand ( 0 ) , llvm :: ADDRESS_SPACE_GLOBAL ) ; case Intrinsic :: nvvm_isspacep_local : return std :: make_pair ( II -> getArgOperand ( 0 ) , llvm :: ADDRESS_SPACE_LOCAL ) ; case Intrinsic :: nvvm_isspacep_shared : return std :: make_pair ( II -> getArgOperand ( 0 ) , llvm :: ADDRESS_SPACE_SHARED ) ; default : break ; } } return std :: make_pair ( nullptr , - 1 ) ; } </s>

If the specified predicate checks whether a generic pointer falls within a specified address space , return that generic pointer and the address space being queried .


<s> static int rs6000_hard_regno_nregs_internal ( int regno , machine_mode mode ) { unsigned HOST_WIDE_INT reg_size ; if ( FP_REGNO_P ( regno ) ) reg_size = ( VECTOR_MEM_VSX_P ( mode ) ? UNITS_PER_VSX_WORD : UNITS_PER_FP_WORD ) ; else if ( SPE_SIMD_REGNO_P ( regno ) && TARGET_SPE && SPE_VECTOR_MODE ( mode ) ) reg_size = UNITS_PER_SPE_WORD ; else if ( ALTIVEC_REGNO_P ( regno ) ) reg_size = UNITS_PER_ALTIVEC_WORD ; else if ( TARGET_E500_DOUBLE && FLOAT_MODE_P ( mode ) && mode != SCmode && ! DECIMAL_FLOAT_MODE_P ( mode ) && SPE_SIMD_REGNO_P ( regno ) ) reg_size = UNITS_PER_FP_WORD ; else reg_size = UNITS_PER_WORD ; return ( GET_MODE_SIZE ( mode ) + reg_size - 1 ) / reg_size ; } </s>

Return number of consecutive hard regs needed starting at reg REGNO to hold something of mode MODE . This is ordinarily the length in words of a value of mode MODE but can be less for certain modes in special long registers . POWER and PowerPC GPRs hold 32 bits worth ; PowerPC64 GPRs and FPRs point register holds 64 bits worth .


"SIInstrInfo::loadRegFromStackSlot - Do not know how to"

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


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

Check whether the given instruction may need relaxation .


<s> int arm_early_store_addr_dep ( rtx producer , rtx consumer ) { return ! arm_no_early_store_addr_dep ( producer , consumer ) ; } </s>

Return nonzero if the CONSUMER instruction ( a store ) does need PRODUCER 's value to calculate the address .


<s> SMLoc getEndLoc ( ) const override { return EndLoc ; } </s>

getEndLoc - Get the location of the last token of this operand .


<s> TargetLowering :: AtomicExpansionKind ARMTargetLowering :: shouldExpandAtomicLoadInIR ( LoadInst * LI ) const { unsigned Size = LI -> getType ( ) -> getPrimitiveSizeInBits ( ) ; return ( ( Size == 64 ) && ! Subtarget -> isMClass ( ) ) ? AtomicExpansionKind :: LLSC : AtomicExpansionKind :: None ; } </s>

Returns how the given ( atomic ) load should be expanded by the IR-level AtomicExpand pass .


<s> void GCNPassConfig :: addPostRegAlloc ( ) { addPass ( & SIFixVGPRCopiesID ) ; addPass ( & SIOptimizeExecMaskingID ) ; TargetPassConfig :: addPostRegAlloc ( ) ; } </s>

This method may be implemented by targets that want to run passes after register allocation pass pipeline but before prolog-epilog insertion .


<s>
bool
X86ATTAsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
const
Function
*
F
=
MF
.
getFunction
(
)
;
this
->
MF
=
&
MF
;
unsigned
CC
=
F
->
getCallingConv
(
)
;
SetupMachineFunction
(
MF
)
;
O
<<
"\n\n"
;
if
(
CC
==
CallingConv
::
X86_StdCall
||
CC
==
CallingConv
::
X86_FastCall
)
FunctionInfoMap
[
F
]
=
*
MF
.
getInfo
<
X86MachineFunctionInfo
>
(
)
;
EmitConstantPool
(
MF
.
getConstantPool
(
)
)
;
if
(
F
->
hasDLLExportLinkage
(
)
)
DLLExportedFns
.
insert
(
Mang
->
getMangledName
(
F
)
)
;
emitFunctionHeader
(
MF
)
;
if
(
TAI
->
doesSupportDebugInformation
(
)
||
TAI
->
doesSupportExceptionHandling
(
)
)
DW
->
BeginFunction
(
&
MF
)
;
bool
hasAnyRealCode
=
false
;
for
(
MachineFunction
::
const_iterator
I
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
I
!=
E
;
++
I
)
{
if
(
!
VerboseAsm
&&
(
I
->
pred_empty
(
)
||
I
->
isOnlyReachableByFallthrough
(
)
)
)
{
}
else
{
printBasicBlockLabel
(
I
,
true
,
true
,
VerboseAsm
)
;
O
<<
'\n'
;
}
for
(
MachineBasicBlock
::
const_iterator
II
=
I
->
begin
(
)
,
IE
=
I
->
end
(
)
;
II
!=
IE
;
++
II
)
{
if
(
!
II
->
isLabel
(
)
)
hasAnyRealCode
=
true
;
printMachineInstruction
(
II
)
;
}
}
if
(
Subtarget
->
isTargetDarwin
(
)
&&
!
hasAnyRealCode
)
{
O
<<
"\tnop\n"
;
}
if
(
TAI
->
hasDotTypeDotSizeDirective
(
)
)
O
<<
"\t.size\t"
<<
CurrentFnName
<<
", .-"
<<
CurrentFnName
<<
'\n'
;
if
(
TAI
->
doesSupportDebugInformation
(
)
||
TAI
->
doesSupportExceptionHandling
(
)
)
DW
->
EndFunction
(
&
MF
)
;
EmitJumpTableInfo
(
MF
.
getJumpTableInfo
(
)
,
MF
)
;
return
false
;
}
</s>

runOnMachineFunction - Emit the function body .


<s> static void s390_register_info ( ) { int i ; char clobbered_regs [ 32 ] ; gcc_assert ( ! epilogue_completed ) ; if ( reload_completed ) s390_regs_ever_clobbered ( clobbered_regs ) ; else for ( i = 0 ; i < 32 ; i ++ ) clobbered_regs [ i ] = df_regs_ever_live_p ( i ) ; for ( i = 0 ; i < 32 ; i ++ ) clobbered_regs [ i ] = clobbered_regs [ i ] && ! global_regs [ i ] ; cfun_frame_layout . fpr_bitmap = 0 ; cfun_frame_layout . high_fprs = 0 ; for ( i = FPR0_REGNUM ; i <= FPR15_REGNUM ; i ++ ) if ( clobbered_regs [ i ] && ! call_used_regs [ i ] ) { cfun_set_fpr_save ( i ) ; if ( i >= FPR8_REGNUM ) cfun_frame_layout . high_fprs ++ ; } clobbered_regs [ 12 ] |= ( ( flag_pic && df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) ) || ( flag_split_stack && cfun -> stdarg && ( crtl -> is_leaf || TARGET_TPF_PROFILING || has_hard_reg_initial_val ( Pmode , RETURN_REGNUM ) ) ) ) ; clobbered_regs [ BASE_REGNUM ] |= ( cfun -> machine -> base_reg && REGNO ( cfun -> machine -> base_reg ) == BASE_REGNUM ) ; clobbered_regs [ HARD_FRAME_POINTER_REGNUM ] |= ! ! frame_pointer_needed ; clobbered_regs [ RETURN_REGNUM ] |= ( ! crtl -> is_leaf || TARGET_TPF_PROFILING || cfun_frame_layout . save_return_addr_p || crtl -> calls_eh_return ) ; clobbered_regs [ STACK_POINTER_REGNUM ] |= ( ! crtl -> is_leaf || TARGET_TPF_PROFILING || cfun_save_high_fprs_p || get_frame_size ( ) > 0 || ( reload_completed && cfun_frame_layout . frame_size > 0 ) || cfun -> calls_alloca ) ; memset ( cfun_frame_layout . gpr_save_slots , SAVE_SLOT_NONE , 16 ) ; for ( i = 0 ; i < 16 ; i ++ ) if ( clobbered_regs [ i ] && ! call_used_regs [ i ] ) cfun_gpr_save_slot ( i ) = SAVE_SLOT_STACK ; s390_register_info_arg_fpr ( ) ; s390_register_info_gprtofpr ( ) ; s390_register_info_set_ranges ( ) ; s390_register_info_arg_gpr ( ) ; } </s>

Fill cfun- > machine with info about register usage of current function . Return in CLOBBERED_REGS which GPRs are currently considered set .


<s> static int ix86_i387_mode_needed ( int entity , rtx_insn * insn ) { enum attr_i387_cw mode ; if ( CALL_P ( insn ) || ( NONJUMP_INSN_P ( insn ) && ( asm_noperands ( PATTERN ( insn ) ) >= 0 || GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT ) ) ) return I387_CW_UNINITIALIZED ; if ( recog_memoized ( insn ) < 0 ) return I387_CW_ANY ; mode = get_attr_i387_cw ( insn ) ; switch ( entity ) { case I387_ROUNDEVEN : if ( mode == I387_CW_ROUNDEVEN ) return mode ; break ; case I387_TRUNC : if ( mode == I387_CW_TRUNC ) return mode ; break ; case I387_FLOOR : if ( mode == I387_CW_FLOOR ) return mode ; break ; case I387_CEIL : if ( mode == I387_CW_CEIL ) return mode ; break ; default : gcc_unreachable ( ) ; } return I387_CW_ANY ; } </s>

Return mode that i387 must be switched into prior to the execution of insn .


<s> bool RISCVAsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & MF . getSubtarget < RISCVSubtarget > ( ) ; return AsmPrinter :: runOnMachineFunction ( MF ) ; } </s>


<s> void gen_ashift ( int type , int n , rtx reg ) { if ( n < 0 ) { if ( type == ASHIFT ) type = LSHIFTRT ; else type = ASHIFT ; n = - n ; } switch ( type ) { case ASHIFTRT : emit_insn ( gen_ashrsi3_k ( reg , reg , GEN_INT ( n ) ) ) ; break ; case LSHIFTRT : if ( n == 1 ) emit_insn ( gen_lshrsi3_m ( reg , reg , GEN_INT ( n ) ) ) ; else emit_insn ( gen_lshrsi3_k ( reg , reg , GEN_INT ( n ) ) ) ; break ; case ASHIFT : emit_insn ( gen_ashlsi3_std ( reg , reg , GEN_INT ( n ) ) ) ; break ; } } </s>


<s>
const
MCSection
*
XCoreTargetObjectFile
::
getSectionForConstant
(
SectionKind
Kind
,
const
Constant
*
C
)
const
{
if
(
Kind
.
isMergeableConst4
(
)
)
return
MergeableConst4Section
;
if
(
Kind
.
isMergeableConst8
(
)
)
return
MergeableConst8Section
;
if
(
Kind
.
isMergeableConst16
(
)
)
return
MergeableConst16Section
;
assert
(
(
Kind
.
isReadOnly
(
)
||
Kind
.
isReadOnlyWithRel
(
)
)
&&
"Unknown section kind"
)
;
return
ReadOnlySection
;
}
</s>

Given a constant with the SectionKind , return a section that it should be placed in .


<s> static bool mips16_stub_function_p ( const_rtx x ) { return ( GET_CODE ( x ) == SYMBOL_REF && startswith ( XSTR ( x , 0 ) , "__mips16_" ) ) ; } </s>

Return true if function X is a libgcc MIPS16 stub function .


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


<s> MVT getScalarShiftAmountTy ( const DataLayout & , EVT ) const override { return MVT :: i257 ; } </s>

Return the type to use for a scalar shift opcode , given the shifted amount type .


<s> bool vax_acceptable_pic_operand_p ( rtx x ATTRIBUTE_UNUSED , bool local_p ATTRIBUTE_UNUSED , bool symbol_p ATTRIBUTE_UNUSED ) { if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , 0 ) ) == PLUS ) { x = XEXP ( XEXP ( x , 0 ) , 0 ) ; local_p = true ; } switch ( GET_CODE ( x ) ) { case SYMBOL_REF : return symbol_p && ! ( local_p && ! SYMBOL_REF_LOCAL_P ( x ) ) ; case LABEL_REF : return symbol_p && ! ( local_p && LABEL_REF_NONLOCAL_P ( x ) ) ; default : break ; } return true ; } </s>

With ELF we do not support GOT entries for external ` symbol+offset ' references , so do not accept external symbol references if an offset is to be added . Do not accept external symbol references at all if LOCAL_P is set . This is for cases where making a reference indirect would make it invalid . Do not accept any kind of symbols if SYMBOL_P is clear . This is for situations where the a reference is used as an immediate value for operations other than address loads ( MOVA/PUSHA ) , as those operations do not support PC-relative immediates .


<s> std :: pair < const TargetRegisterClass * , uint8_t > X86TargetLowering :: findRepresentativeClass ( EVT VT ) const { const TargetRegisterClass * RRC = 0 ; uint8_t Cost = 1 ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { default : return TargetLowering :: findRepresentativeClass ( VT ) ; case MVT :: i8 : case MVT :: i16 : case MVT :: i32 : case MVT :: i64 : RRC = Subtarget -> is64Bit ( ) ? ( const TargetRegisterClass * ) & X86 :: GR64RegClass : ( const TargetRegisterClass * ) & X86 :: GR32RegClass ; break ; case MVT :: x86mmx : RRC = & X86 :: VR64RegClass ; break ; case MVT :: f32 : case MVT :: f64 : case MVT :: v16i8 : case MVT :: v8i16 : case MVT :: v4i32 : case MVT :: v2i64 : case MVT :: v4f32 : case MVT :: v2f64 : case MVT :: v32i8 : case MVT :: v8i32 : case MVT :: v4i64 : case MVT :: v8f32 : case MVT :: v4f64 : RRC = & X86 :: VR128RegClass ; break ; } return std :: make_pair ( RRC , Cost ) ; } </s>

Return the largest legal super-reg register class of the register class for the specified type and its associated `` cost '' .


<s> HOST_WIDE_INT compute_frame_size ( HOST_WIDE_INT size ) { int regno ; HOST_WIDE_INT total_size ; HOST_WIDE_INT var_size ; HOST_WIDE_INT args_size ; HOST_WIDE_INT extra_size ; HOST_WIDE_INT gp_reg_rounded ; HOST_WIDE_INT gp_reg_size ; HOST_WIDE_INT fp_reg_size ; long mask ; int fp_inc ; long fp_bits ; gp_reg_size = 0 ; fp_reg_size = 0 ; mask = 0 ; extra_size = IQ2000_STACK_ALIGN ( ( 0 ) ) ; var_size = IQ2000_STACK_ALIGN ( size ) ; args_size = IQ2000_STACK_ALIGN ( current_function_outgoing_args_size ) ; if ( args_size == 0 && current_function_calls_alloca ) args_size = 4 * UNITS_PER_WORD ; total_size = var_size + args_size + extra_size ; for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) { if ( MUST_SAVE_REGISTER ( regno ) ) { gp_reg_size += GET_MODE_SIZE ( gpr_mode ) ; mask |= 1L << ( regno - GP_REG_FIRST ) ; } } if ( current_function_calls_eh_return ) { unsigned int i ; for ( i = 0 ; ; ++ i ) { regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == ( int ) INVALID_REGNUM ) break ; gp_reg_size += GET_MODE_SIZE ( gpr_mode ) ; mask |= 1L << ( regno - GP_REG_FIRST ) ; } } fp_inc = 2 ; fp_bits = 3 ; gp_reg_rounded = IQ2000_STACK_ALIGN ( gp_reg_size ) ; total_size += gp_reg_rounded + IQ2000_STACK_ALIGN ( fp_reg_size ) ; if ( total_size == extra_size && ! profile_flag ) total_size = extra_size = 0 ; total_size += IQ2000_STACK_ALIGN ( current_function_pretend_args_size ) ; cfun -> machine -> total_size = total_size ; cfun -> machine -> var_size = var_size ; cfun -> machine -> args_size = args_size ; cfun -> machine -> extra_size = extra_size ; cfun -> machine -> gp_reg_size = gp_reg_size ; cfun -> machine -> fp_reg_size = fp_reg_size ; cfun -> machine -> mask = mask ; cfun -> machine -> initialized = reload_completed ; cfun -> machine -> num_gp = gp_reg_size / UNITS_PER_WORD ; if ( mask ) { unsigned long offset ; offset = ( args_size + extra_size + var_size + gp_reg_size - GET_MODE_SIZE ( gpr_mode ) ) ; cfun -> machine -> gp_sp_offset = offset ; cfun -> machine -> gp_save_offset = offset - total_size ; } else { cfun -> machine -> gp_sp_offset = 0 ; cfun -> machine -> gp_save_offset = 0 ; } cfun -> machine -> fp_sp_offset = 0 ; cfun -> machine -> fp_save_offset = 0 ; return total_size ; } </s>

Typical stack layout should looks like this after the function 's prologue : | | -- ^ | | \ | | | arguments saved | Increasing | | on the stack | addresses PARENT arg pointer - > | | / -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - | | - space for argument split between regs & stack -- CHILD | | \ < -- ( return address here ) | | other call | | saved registers | | / -- frame pointer - > | | \ ___ | | local | | | variables |f | | / |r -- |a | | \ |m | | outgoing |e | | arguments | | Decreasing ( hard ) frame pointer | | / | | addresses and stack pointer - > | | / _|_ | -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- V


<s> void PPCAIXAsmPrinter :: emitEndOfAsmFile ( Module & M ) { if ( M . empty ( ) ) return ; OutStreamer -> SwitchSection ( getObjFileLowering ( ) . getTOCBaseSection ( ) ) ; PPCTargetStreamer * TS = static_cast < PPCTargetStreamer * > ( OutStreamer -> getTargetStreamer ( ) ) ; for ( auto & I : TOC ) { MCSectionXCOFF * TCEntry = cast < MCSectionXCOFF > ( getObjFileLowering ( ) . getSectionForTOCEntry ( I . first , TM ) ) ; OutStreamer -> SwitchSection ( TCEntry ) ; OutStreamer -> emitLabel ( I . second ) ; if ( TS != nullptr ) TS -> emitTCEntry ( * I . first ) ; } } </s>

This virtual method can be overridden by targets that want to emit something at the end of their file .


"getBranchTargetOpValue expects only expressions or immediates"

getBranchTargetOpValue - Return binary encoding of the branch target operand .


<s> static void predict_jump ( int prob ) { rtx_insn * insn = get_last_insn ( ) ; gcc_assert ( JUMP_P ( insn ) ) ; add_int_reg_note ( insn , REG_BR_PROB , prob ) ; } </s>

Predict just emitted jump instruction to be taken with probability PROB .


<s>
static
void
ia64_asm_unwind_emit
(
FILE
*
out_file
,
rtx_insn
*
insn
)
{
bool
unwind
=
ia64_except_unwind_info
(
&
global_options
)
==
UI_TARGET
;
bool
frame
=
dwarf2out_do_frame
(
)
;
rtx
note
,
pat
;
bool
handled_one
;
if
(
!
unwind
&&
!
frame
)
return
;
if
(
NOTE_INSN_BASIC_BLOCK_P
(
insn
)
)
{
last_block
=
NOTE_BASIC_BLOCK
(
insn
)
->
next_bb
==
EXIT_BLOCK_PTR_FOR_FN
(
cfun
)
;
if
(
need_copy_state
)
{
if
(
unwind
)
{
fprintf
(
out_file
,
"\t.body\n"
)
;
fprintf
(
out_file
,
"\t.copy_state %d\n"
,
cfun
->
machine
->
state_num
)
;
}
need_copy_state
=
false
;
}
}
if
(
NOTE_P
(
insn
)
||
!
RTX_FRAME_RELATED_P
(
insn
)
)
return
;
if
(
INSN_CODE
(
insn
)
==
CODE_FOR_alloc
)
{
rtx
dest
=
SET_DEST
(
XVECEXP
(
PATTERN
(
insn
)
,
0
,
0
)
)
;
int
dest_regno
=
REGNO
(
dest
)
;
if
(
dest_regno
==
current_frame_info
.
r
[
reg_save_ar_pfs
]
)
{
if
(
unwind
)
fprintf
(
out_file
,
"\t.save ar.pfs, r%d\n"
,
ia64_dbx_register_number
(
dest_regno
)
)
;
}
else
{
if
(
current_frame_info
.
total_size
==
0
&&
!
frame_pointer_needed
)
process_epilogue
(
out_file
,
insn
,
unwind
,
frame
)
;
if
(
unwind
)
fprintf
(
out_file
,
"\t.prologue\n"
)
;
}
return
;
}
handled_one
=
false
;
for
(
note
=
REG_NOTES
(
insn
)
;
note
;
note
=
XEXP
(
note
,
1
)
)
switch
(
REG_NOTE_KIND
(
note
)
)
{
case
REG_CFA_ADJUST_CFA
:
pat
=
XEXP
(
note
,
0
)
;
if
(
pat
==
)
pat
=
PATTERN
(
insn
)
;
process_cfa_adjust_cfa
(
out_file
,
pat
,
insn
,
unwind
,
frame
)
;
handled_one
=
true
;
break
;
case
REG_CFA_OFFSET
:
pat
=
XEXP
(
note
,
0
)
;
if
(
pat
==
)
pat
=
PATTERN
(
insn
)
;
process_cfa_offset
(
out_file
,
pat
,
unwind
)
;
handled_one
=
true
;
break
;
case
REG_CFA_REGISTER
:
pat
=
XEXP
(
note
,
0
)
;
if
(
pat
==
)
pat
=
PATTERN
(
insn
)
;
process_cfa_register
(
out_file
,
pat
,
unwind
)
;
handled_one
=
true
;
break
;
case
REG_FRAME_RELATED_EXPR
:
case
REG_CFA_DEF_CFA
:
case
REG_CFA_EXPRESSION
:
case
REG_CFA_RESTORE
:
case
REG_CFA_SET_VDRAP
:
gcc_unreachable
(
)
;
default
:
break
;
}
gcc_assert
(
handled_one
)
;
}
</s>

This function looks at a single insn and emits any directives required to unwind this insn .


<s> bool MipsSEFrameLowering :: hasReservedCallFrame ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return isInt < 16 > ( MFI -> getMaxCallFrameSize ( ) ) && ! MFI -> hasVarSizedObjects ( ) ; } </s>

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


<s> DecodeStatus AArch64Disassembler :: getInstruction ( MCInst & MI , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & OS , raw_ostream & CS ) const { CommentStream = & CS ; Size = 0 ; if ( Bytes . size ( ) < 4 ) return Fail ; Size = 4 ; uint32_t Insn = ( Bytes [ 3 ] << 24 ) | ( Bytes [ 2 ] << 16 ) | ( Bytes [ 1 ] << 8 ) | ( Bytes [ 0 ] << 0 ) ; return decodeInstruction ( DecoderTable32 , MI , Insn , Address , this , STI ) ; } </s>

Returns the disassembly of a single instruction .


<s> bool RV16KFrameLowering :: hasFP ( const MachineFunction & MF ) const { const TargetRegisterInfo * RegInfo = MF . getSubtarget ( ) . getRegisterInfo ( ) ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; return MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || RegInfo -> needsStackRealignment ( MF ) || MFI . hasVarSizedObjects ( ) || MFI . isFrameAddressTaken ( ) ; } </s>

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


<s> void WebAssemblyPassConfig :: addIRPasses ( ) { if ( TM -> Options . ThreadModel == ThreadModel :: Single ) addPass ( createLowerAtomicPass ( ) ) ; else addPass ( createAtomicExpandPass ( TM ) ) ; addPass ( createWebAssemblyOptimizeReturned ( ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>

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


<s> static rtx rs6000_legitimize_tls_address_aix ( rtx addr , enum tls_model model ) { rtx sym , mem , tocref , tlsreg , tmpreg , dest , tlsaddr ; const char * name ; char * tlsname ; name = XSTR ( addr , 0 ) ; if ( name [ strlen ( name ) - 1 ] != ']' && ( TREE_PUBLIC ( SYMBOL_REF_DECL ( addr ) ) || bss_initializer_p ( SYMBOL_REF_DECL ( addr ) ) ) ) { tlsname = XALLOCAVEC ( char , strlen ( name ) + 4 ) ; strcpy ( tlsname , name ) ; strcat ( tlsname , bss_initializer_p ( SYMBOL_REF_DECL ( addr ) ) ? "[UL]" : "[TL]" ) ; tlsaddr = copy_rtx ( addr ) ; XSTR ( tlsaddr , 0 ) = ggc_strdup ( tlsname ) ; } else tlsaddr = addr ; sym = force_const_mem ( GET_MODE ( tlsaddr ) , tlsaddr ) ; if ( constant_pool_expr_p ( XEXP ( sym , 0 ) ) && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P ( get_pool_constant ( XEXP ( sym , 0 ) ) , Pmode ) ) { tocref = create_TOC_reference ( XEXP ( sym , 0 ) , NULL_RTX ) ; mem = gen_const_mem ( Pmode , tocref ) ; set_mem_alias_set ( mem , get_TOC_alias_set ( ) ) ; } else return sym ; if ( model == TLS_MODEL_GLOBAL_DYNAMIC || model == TLS_MODEL_LOCAL_DYNAMIC ) { name = XSTR ( XVECEXP ( XEXP ( mem , 0 ) , 0 , 0 ) , 0 ) ; tlsname = XALLOCAVEC ( char , strlen ( name ) + 1 ) ; strcpy ( tlsname , "*LCM" ) ; strcat ( tlsname , name + 3 ) ; rtx modaddr = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( tlsname ) ) ; SYMBOL_REF_FLAGS ( modaddr ) |= SYMBOL_FLAG_LOCAL ; tocref = create_TOC_reference ( modaddr , NULL_RTX ) ; rtx modmem = gen_const_mem ( Pmode , tocref ) ; set_mem_alias_set ( modmem , get_TOC_alias_set ( ) ) ; rtx modreg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , modreg , modmem ) ) ; tmpreg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmpreg , mem ) ) ; dest = gen_reg_rtx ( Pmode ) ; if ( TARGET_32BIT ) emit_insn ( gen_tls_get_addrsi ( dest , modreg , tmpreg ) ) ; else emit_insn ( gen_tls_get_addrdi ( dest , modreg , tmpreg ) ) ; return dest ; } else if ( TARGET_32BIT ) { tlsreg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_tls_get_tpointer ( tlsreg ) ) ; } else tlsreg = gen_rtx_REG ( DImode , 13 ) ; tmpreg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmpreg , mem ) ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , gen_rtx_MINUS ( Pmode , addr , tlsreg ) ) ; dest = force_reg ( Pmode , gen_rtx_PLUS ( Pmode , tmpreg , tlsreg ) ) ; return dest ; } </s>


<s> bool WebAssemblyTargetLowering :: isVectorLoadExtDesirable ( SDValue ExtVal ) const { EVT ExtT = ExtVal . getValueType ( ) ; EVT MemT = cast < LoadSDNode > ( ExtVal -> getOperand ( 0 ) ) -> getValueType ( 0 ) ; return ( ExtT == MVT :: v8i16 && MemT == MVT :: v8i8 ) || ( ExtT == MVT :: v4i32 && MemT == MVT :: v4i16 ) || ( ExtT == MVT :: v2i64 && MemT == MVT :: v2i32 ) ; } </s>

Return true if folding a vector load into ExtVal ( a sign , zero , or any extend node ) is profitable .


<s> std :: pair < unsigned , const TargetRegisterClass * > DLXTargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> unsigned HexagonInstrInfo :: getUnits ( const MachineInstr & MI ) const { const InstrItineraryData & II = * Subtarget . getInstrItineraryData ( ) ; const InstrStage & IS = * II . beginStage ( MI . getDesc ( ) . getSchedClass ( ) ) ; return IS . getUnits ( ) ; } </s>


<s> static void emit_pop_byte ( unsigned regno ) { rtx mem , reg ; mem = gen_rtx_PRE_INC ( HImode , stack_pointer_rtx ) ; mem = gen_frame_mem ( QImode , mem ) ; reg = gen_rtx_REG ( QImode , regno ) ; emit_insn ( gen_rtx_SET ( reg , mem ) ) ; } </s>

Helper for avr_expand_epilogue . Emit a pop of a byte register .


<s> static void ix86_simd_clone_adjust ( struct cgraph_node * node ) { const char * str = NULL ; if ( ! node -> definition ) return ; gcc_assert ( node -> decl == cfun -> decl ) ; switch ( node -> simdclone -> vecsize_mangle ) { case 'b' : if ( ! TARGET_SSE2 ) str = "sse2" ; break ; case 'c' : if ( ! TARGET_AVX ) str = "avx" ; break ; case 'd' : if ( ! TARGET_AVX2 ) str = "avx2" ; break ; case 'e' : if ( ! TARGET_AVX512F ) str = "avx512f" ; break ; default : gcc_unreachable ( ) ; } if ( str == NULL ) return ; push_cfun ( NULL ) ; tree args = build_tree_list ( NULL_TREE , build_string ( strlen ( str ) , str ) ) ; bool ok = ix86_valid_target_attribute_p ( node -> decl , NULL , args , 0 ) ; gcc_assert ( ok ) ; pop_cfun ( ) ; ix86_reset_previous_fndecl ( ) ; ix86_set_current_function ( node -> decl ) ; } </s>

Add target attribute to SIMD clone NODE if needed .


<s> void PPCRegisterInfo :: materializeFrameBaseRegister ( MachineBasicBlock * MBB , unsigned BaseReg , int FrameIdx , int64_t Offset ) const { unsigned ADDriOpc = Subtarget . isPPC64 ( ) ? PPC :: ADDI8 : PPC :: ADDI ; MachineBasicBlock :: iterator Ins = MBB -> begin ( ) ; DebugLoc DL ; if ( Ins != MBB -> end ( ) ) DL = Ins -> getDebugLoc ( ) ; const MachineFunction & MF = * MBB -> getParent ( ) ; const TargetInstrInfo & TII = * Subtarget . getInstrInfo ( ) ; const MCInstrDesc & MCID = TII . get ( ADDriOpc ) ; MachineRegisterInfo & MRI = MBB -> getParent ( ) -> getRegInfo ( ) ; MRI . constrainRegClass ( BaseReg , TII . getRegClass ( MCID , 0 , this , MF ) ) ; BuildMI ( * MBB , Ins , DL , MCID , BaseReg ) . addFrameIndex ( FrameIdx ) . addImm ( Offset ) ; } </s>

Insert defining instruction ( s ) for a pointer to FrameIdx before insertion point I .


<s>
unsigned
X86TTI
::
getArithmeticInstrCost
(
unsigned
Opcode
,
Type
*
Ty
)
const
{
std
::
pair
<
unsigned
,
MVT
>
LT
=
TLI
->
getTypeLegalizationCost
(
Ty
)
;
int
ISD
=
TLI
->
InstructionOpcodeToISD
(
Opcode
)
;
assert
(
ISD
&&
"Invalid opcode"
)
;
static
const
CostTblEntry
<
MVT
>
AVX1CostTable
[
]
=
{
{
ISD
::
MUL
,
MVT
::
v8i32
,
4
}
,
{
ISD
::
SUB
,
MVT
::
v8i32
,
4
}
,
{
ISD
::
ADD
,
MVT
::
v8i32
,
4
}
,
{
ISD
::
SUB
,
MVT
::
v4i64
,
4
}
,
{
ISD
::
ADD
,
MVT
::
v4i64
,
4
}
,
{
ISD
::
MUL
,
MVT
::
v4i64
,
18
}
,
}
;
if
(
ST
->
hasAVX
(
)
&&
!
ST
->
hasAVX2
(
)
)
{
int
Idx
=
CostTableLookup
<
MVT
>
(
AVX1CostTable
,
array_lengthof
(
AVX1CostTable
)
,
ISD
,
LT
.
second
)
;
if
(
Idx
!=
1
)
return
LT
.
first
*
AVX1CostTable
[
Idx
]
.
Cost
;
}
static
const
CostTblEntry
<
MVT
>
CustomLowered
[
]
=
{
{
ISD
::
MUL
,
MVT
::
v2i64
,
9
}
,
{
ISD
::
MUL
,
MVT
::
v4i64
,
9
}
,
}
;
int
Idx
=
CostTableLookup
<
MVT
>
(
CustomLowered
,
array_lengthof
(
CustomLowered
)
,
ISD
,
LT
.
second
)
;
if
(
Idx
!=
1
)
return
LT
.
first
*
CustomLowered
[
Idx
]
.
Cost
;
if
(
ISD
==
ISD
::
MUL
&&
LT
.
second
==
MVT
::
v4i32
&&
ST
->
hasSSE2
(
)
&&
!
ST
->
hasSSE41
(
)
)
return
6
;
return
TargetTransformInfo
::
getArithmeticInstrCost
(
Opcode
,
Ty
)
;
}
</s>

This is an approximation of reciprocal throughput of a math/logic op .


<s> PreservedAnalyses HexagonLoopIdiomRecognitionPass :: run ( Loop & L , LoopAnalysisManager & AM , LoopStandardAnalysisResults & AR , LPMUpdater & U ) { return HexagonLoopIdiomRecognize ( & AR . AA , & AR . DT , & AR . LI , & AR . TLI , & AR . SE ) . run ( & L ) ? getLoopPassPreservedAnalyses ( ) : PreservedAnalyses :: all ( ) ; } </s>

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


<s> void PPCDAGToDAGISel :: PostprocessISelDAG ( ) { if ( TM . getOptLevel ( ) == CodeGenOpt :: None ) return ; PeepholePPC64 ( ) ; PeepholeCROps ( ) ; } </s>

PostprocessISelDAG ( ) - This hook allows the target to hack on the graph right after selection .


<s> DEBUG_FUNCTION void debug_dispatch_window ( int window_num ) { debug_dispatch_window_file ( stdout , window_num ) ; } </s>


<s> static tree arm_stack_protect_guard ( void ) { if ( arm_stack_protector_guard == SSP_GLOBAL ) return default_stack_protect_guard ( ) ; return NULL_TREE ; } </s>

Implement TARGET_STACK_PROTECT_GUARD . In case of a global variable based guard use the default else return a null tree .


<s> bool isBlockAddress ( ) { return Kind == ARMCP :: CPBlockAddress ; } </s>

isBlockAddress - Tests if this is a MO_BlockAddress operand .


<s> int avr_simplify_comparison_p ( machine_mode mode , RTX_CODE op , rtx x ) { unsigned int max = ( mode == QImode ? 0xff : mode == HImode ? 0xffff : mode == PSImode ? 0xffffff : mode == SImode ? 0xffffffff : 0 ) ; if ( max && op && CONST_INT_P ( x ) ) { if ( unsigned_condition ( op ) != op ) max >>= 1 ; if ( max != ( INTVAL ( x ) & max ) && INTVAL ( x ) != 0xff ) return 1 ; } return 0 ; } </s>

Return 0 if undefined , 1 if always true or always false .


<s> bool reg_unused_after ( rtx reg , rtx_insn * insn ) { enum rtx_code code ; rtx set ; set = single_set ( insn ) ; if ( set && ! MEM_P ( SET_DEST ( set ) ) && reg_overlap_mentioned_p ( reg , SET_DEST ( set ) ) ) return true ; while ( ( insn = NEXT_INSN ( insn ) ) ) { rtx set ; if ( ! INSN_P ( insn ) ) continue ; code = GET_CODE ( insn ) ; if ( code == CODE_LABEL ) return 1 ; if ( code == JUMP_INSN ) return false ; else if ( code == INSN && GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) { rtx_sequence * seq = as_a < rtx_sequence * > ( PATTERN ( insn ) ) ; int i ; int retval = 0 ; for ( i = 0 ; i < seq -> len ( ) ; i ++ ) { rtx_insn * this_insn = seq -> insn ( i ) ; rtx set = single_set ( this_insn ) ; if ( CALL_P ( this_insn ) ) code = CALL_INSN ; else if ( JUMP_P ( this_insn ) ) { if ( INSN_ANNULLED_BRANCH_P ( this_insn ) ) return false ; code = JUMP_INSN ; } if ( set && reg_overlap_mentioned_p ( reg , SET_SRC ( set ) ) ) return false ; if ( set && reg_overlap_mentioned_p ( reg , SET_DEST ( set ) ) ) { if ( ! MEM_P ( SET_DEST ( set ) ) ) retval = true ; else return false ; } if ( set == NULL_RTX && reg_overlap_mentioned_p ( reg , PATTERN ( this_insn ) ) ) return false ; } if ( retval == 1 ) return true ; else if ( code == JUMP_INSN ) return false ; } set = single_set ( insn ) ; if ( set && reg_overlap_mentioned_p ( reg , SET_SRC ( set ) ) ) return false ; if ( set && reg_overlap_mentioned_p ( reg , SET_DEST ( set ) ) ) return ! MEM_P ( SET_DEST ( set ) ) ; if ( set == 0 && reg_overlap_mentioned_p ( reg , PATTERN ( insn ) ) ) return false ; if ( code == CALL_INSN && call_really_used_regs [ REGNO ( reg ) ] ) return true ; } return true ; } </s>

Return nonzero if REG is not used after INSN . We assume REG is a reload reg , and therefore does not live past labels or calls or jumps .


<s> static void build_one ( function_builder & b , const char * signature , const function_group_info & group , mode_suffix_index mode_suffix_id , unsigned int ti , unsigned int pi , bool force_direct_overloads ) { auto_vec < tree , 16 > argument_types ; function_instance instance ( group . base_name , * group . base , * group . shape , mode_suffix_id , group . types [ ti ] , group . preds [ pi ] ) ; tree return_type = parse_signature ( instance , signature , argument_types ) ; apply_predication ( instance , return_type , argument_types ) ; b . add_unique_function ( instance , return_type , argument_types , group . required_extensions , force_direct_overloads ) ; } </s>

Add one function instance for GROUP , using operand suffix at index OI , mode suffix at index PAIR & & bi and predication suffix at index pred_idx .


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

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


<s> void bpf_expand_epilogue ( void ) { if ( TARGET_XBPF ) { int regno ; int fp_offset = - cfun -> machine -> local_vars_size ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) || ( cfun -> calls_alloca && regno == STACK_POINTER_REGNUM ) ) { rtx mem ; if ( ! IN_RANGE ( fp_offset , - 1 - 0x7fff , 0x7fff ) ) break ; else { mem = gen_frame_mem ( DImode , plus_constant ( DImode , hard_frame_pointer_rtx , fp_offset - 8 ) ) ; emit_move_insn ( gen_rtx_REG ( DImode , regno ) , mem ) ; fp_offset -= 8 ; } } } } emit_jump_insn ( gen_exit ( ) ) ; } </s>

Expand to the instructions in a function epilogue . This function is called when expanding the 'epilogue ' pattern in bpf.md .


<s> ARMBaseTargetMachine :: ARMBaseTargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL , bool isLittle ) : LLVMTargetMachine ( T , computeDataLayout ( TT , CPU , Options , isLittle ) , TT , CPU , FS , Options , RM , CM , OL ) , TargetABI ( computeTargetABI ( TT , CPU , Options ) ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) , Subtarget ( TT , CPU , FS , * this , isLittle ) , isLittle ( isLittle ) { if ( Options . FloatABIType == FloatABI :: Default ) this -> Options . FloatABIType = Subtarget . isTargetHardFloat ( ) ? FloatABI :: Hard : FloatABI :: Soft ; if ( Options . EABIVersion == EABI :: Default || Options . EABIVersion == EABI :: Unknown ) { if ( Subtarget . isTargetGNUAEABI ( ) ) this -> Options . EABIVersion = EABI :: GNU ; else this -> Options . EABIVersion = EABI :: EABI5 ; } } </s>


<s> static unsigned HOST_WIDE_INT sparc_asan_shadow_offset ( void ) { return TARGET_ARCH64 ? ( HOST_WIDE_INT_1 << 43 ) : ( HOST_WIDE_INT_1 << 29 ) ; } </s>

Implement the TARGET_ASAN_SHADOW_OFFSET hook .


<s>
void
ARMConstantIslands
::
verify
(
MachineFunction
&
MF
)
{
assert
(
BBOffsets
.
size
(
)
==
BBSizes
.
size
(
)
)
;
for
(
unsigned
i
=
1
,
e
=
BBOffsets
.
size
(
)
;
i
!=
e
;
++
i
)
assert
(
BBOffsets
[
i
1
]
+
BBSizes
[
i
1
]
==
BBOffsets
[
i
]
)
;
if
(
!
isThumb
)
return
;
for
(
MachineFunction
::
iterator
MBBI
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
MBBI
!=
E
;
++
MBBI
)
{
MachineBasicBlock
*
MBB
=
MBBI
;
if
(
!
MBB
->
empty
(
)
&&
MBB
->
begin
(
)
->
getOpcode
(
)
==
ARM
::
CONSTPOOL_ENTRY
)
{
unsigned
MBBId
=
MBB
->
getNumber
(
)
;
assert
(
HasInlineAsm
||
(
BBOffsets
[
MBBId
]
%
4
==
0
&&
BBSizes
[
MBBId
]
%
4
==
0
)
||
(
BBOffsets
[
MBBId
]
%
4
!=
0
&&
BBSizes
[
MBBId
]
%
4
!=
0
)
)
;
}
}
for
(
unsigned
i
=
0
,
e
=
CPUsers
.
size
(
)
;
i
!=
e
;
++
i
)
{
CPUser
&
U
=
CPUsers
[
i
]
;
unsigned
UserOffset
=
GetOffsetOf
(
U
.
MI
)
+
(
isThumb
4
:
8
)
;
unsigned
CPEOffset
=
GetOffsetOf
(
U
.
CPEMI
)
;
unsigned
Disp
=
UserOffset
<
CPEOffset
CPEOffset
UserOffset
:
UserOffset
CPEOffset
;
assert
(
Disp
<=
U
.
MaxDisp
||
"Constant pool entry out of range!"
)
;
}
}
</s>


<s> unsigned MSP430AsmParser :: validateTargetOperandClass ( MCParsedAsmOperand & AsmOp , unsigned Kind ) { MSP430Operand & Op = static_cast < MSP430Operand & > ( AsmOp ) ; if ( ! Op . isReg ( ) ) return Match_InvalidOperand ; unsigned Reg = Op . getReg ( ) ; bool isGR16 = MSP430MCRegisterClasses [ MSP430 :: GR16RegClassID ] . contains ( Reg ) ; if ( isGR16 && ( Kind == MCK_GR8 ) ) { Op . setReg ( convertGR16ToGR8 ( Reg ) ) ; 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 SITargetLowering :: isOffsetFoldingLegal ( const GlobalAddressSDNode * GA ) const { return ( GA -> getAddressSpace ( ) == AMDGPUAS :: GLOBAL_ADDRESS || GA -> getAddressSpace ( ) == AMDGPUAS :: CONSTANT_ADDRESS || GA -> getAddressSpace ( ) == AMDGPUAS :: CONSTANT_ADDRESS_32BIT ) && ! shouldEmitGOTReloc ( GA -> getGlobal ( ) ) ; } </s>

Return true if folding a constant offset with the given GlobalAddress is legal .


<s>
const
char
*
emit_fusion_p9_store
(
rtx
mem
,
rtx
reg
,
rtx
tmp_reg
)
{
enum
machine_mode
mode
=
GET_MODE
(
reg
)
;
rtx
hi
;
rtx
lo
;
rtx
addr
;
const
char
*
store_string
;
int
r
;
if
(
GET_CODE
(
reg
)
==
SUBREG
)
{
gcc_assert
(
SUBREG_BYTE
(
reg
)
==
0
)
;
reg
=
SUBREG_REG
(
reg
)
;
}
if
(
!
REG_P
(
reg
)
)
fatal_insn
(
"emit_fusion_p9_store, bad reg #1"
,
reg
)
;
r
=
REGNO
(
reg
)
;
if
(
FP_REGNO_P
(
r
)
)
{
if
(
mode
==
SFmode
)
store_string
=
"stfs"
;
else
if
(
mode
==
DFmode
)
store_string
=
"stfd"
;
else
gcc_unreachable
(
)
;
}
else
if
(
INT_REGNO_P
(
r
)
)
{
switch
(
mode
)
{
case
QImode
:
store_string
=
"stb"
;
break
;
case
HImode
:
store_string
=
"sth"
;
break
;
case
SImode
:
case
SFmode
:
store_string
=
"stw"
;
break
;
case
DImode
:
case
DFmode
:
if
(
!
TARGET_POWERPC64
)
gcc_unreachable
(
)
;
store_string
=
"std"
;
break
;
default
:
gcc_unreachable
(
)
;
}
}
else
fatal_insn
(
"emit_fusion_p9_store, bad reg #2"
,
reg
)
;
if
(
!
MEM_P
(
mem
)
)
fatal_insn
(
"emit_fusion_p9_store not MEM"
,
mem
)
;
addr
=
XEXP
(
mem
,
0
)
;
fusion_split_address
(
addr
,
&
hi
,
&
lo
)
;
emit_fusion_addis
(
tmp_reg
,
hi
,
"power9 store fusion"
,
GET_MODE_NAME
(
mode
)
)
;
emit_fusion_load_store
(
reg
,
tmp_reg
,
lo
,
store_string
)
;
return
""
;
}
</s>

Return a string to fuse an addis instruction with a store using extended fusion . The address that is used is the logical address that was formed during peephole2 : ( lo_sum ( high ) ( low-part ) ) The code is complicated , so we call output_asm_insn directly , and just return `` '' .

rs6000
0
"emit_fusion_p9_store, bad reg #1"
"stfs"
"stfd"
"stb"
"sth"
"stw"
"std"
"emit_fusion_p9_store, bad reg #2"
"emit_fusion_p9_store not MEM"
0
"power9 store fusion"
""


<s> rtx function_expander :: expand ( ) { unsigned int nargs = call_expr_nargs ( call_expr ) ; args . reserve ( nargs ) ; for ( unsigned int i = 0 ; i < nargs ; ++ i ) args . quick_push ( expand_normal ( CALL_EXPR_ARG ( call_expr , i ) ) ) ; return base -> expand ( * this ) ; } </s>


"getGlobalBaseReg not implemented yet!\n"

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


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

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


<s>
SDValue
MBlazeTargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
DebugLoc
dl
,
SelectionDAG
&
DAG
)
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
getTargetMachine
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_MBlaze
)
;
if
(
DAG
.
getMachineFunction
(
)
.
getRegInfo
(
)
.
liveout_empty
(
)
)
{
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
if
(
RVLocs
[
i
]
.
isRegLoc
(
)
)
DAG
.
getMachineFunction
(
)
.
getRegInfo
(
)
.
addLiveOut
(
RVLocs
[
i
]
.
getLocReg
(
)
)
;
}
SDValue
Flag
;
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
Outs
[
i
]
.
Val
,
Flag
)
;
Flag
=
Chain
.
getValue
(
1
)
;
}
if
(
Flag
.
getNode
(
)
)
return
DAG
.
getNode
(
MBlazeISD
::
Ret
,
dl
,
MVT
::
Other
,
Chain
,
DAG
.
getRegister
(
MBlaze
::
R15
,
MVT
::
i32
)
,
Flag
)
;
else
return
DAG
.
getNode
(
MBlazeISD
::
Ret
,
dl
,
MVT
::
Other
,
Chain
,
DAG
.
getRegister
(
MBlaze
::
R15
,
MVT
::
i32
)
)
;
}
</s>

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


<s> const DirectXSubtarget * DirectXTargetMachine :: getSubtargetImpl ( const Function & ) const { return Subtarget . get ( ) ; } </s>

Virtual method implemented by subclasses that returns a reference to that target 's TargetSubtargetInfo-derived member variable .


<s> bool FPGATTIImpl :: isLegalMaskedStore ( Type * DataType ) { return true ; } </s>

Return true if the target supports masked store .


<s> rtx msp430_eh_return_stackadj_rtx ( void ) { if ( ! cfun -> machine -> eh_stack_adjust ) { rtx sa ; sa = gen_rtx_REG ( Pmode , 15 ) ; cfun -> machine -> eh_stack_adjust = sa ; } return cfun -> machine -> eh_stack_adjust ; } </s>

Implements EH_RETURN_STACKADJ_RTX . Saved and used later in m32c_emit_eh_epilogue .


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

getPassName - Return a nice clean name for a pass .


<s>
bool
HexagonExpandCondsets
::
split
(
MachineInstr
&
MI
,
std
::
set
<
Register
>
&
UpdRegs
)
{
if
(
TfrLimitActive
)
{
if
(
TfrCounter
>=
TfrLimit
)
return
false
;
TfrCounter
++
;
}
LLVM_DEBUG
(
dbgs
(
)
<<
"\nsplitting "
<<
printMBBReference
(
*
MI
.
getParent
(
)
)
<<
": "
<<
MI
)
;
MachineOperand
&
MD
=
MI
.
getOperand
(
0
)
;
MachineOperand
&
MP
=
MI
.
getOperand
(
1
)
;
assert
(
MD
.
isDef
(
)
)
;
Register
DR
=
MD
.
getReg
(
)
,
DSR
=
MD
.
getSubReg
(
)
;
bool
ReadUndef
=
MD
.
isUndef
(
)
;
MachineBasicBlock
::
iterator
At
=
MI
;
auto
updateRegs
=
[
&
UpdRegs
]
(
const
MachineInstr
&
MI
)
->
void
{
for
(
auto
&
Op
:
MI
.
operands
(
)
)
if
(
Op
.
isReg
(
)
)
UpdRegs
.
insert
(
Op
.
getReg
(
)
)
;
}
;
MachineOperand
&
ST
=
MI
.
getOperand
(
2
)
;
MachineOperand
&
SF
=
MI
.
getOperand
(
3
)
;
if
(
ST
.
isReg
(
)
&&
SF
.
isReg
(
)
)
{
RegisterRef
RT
(
ST
)
;
if
(
RT
==
RegisterRef
(
SF
)
)
{
updateRegs
(
MI
)
;
MI
.
setDesc
(
HII
->
get
(
TargetOpcode
::
COPY
)
)
;
unsigned
S
=
getRegState
(
ST
)
;
while
(
MI
.
getNumOperands
(
)
>
1
)
MI
.
RemoveOperand
(
MI
.
getNumOperands
(
)
1
)
;
MachineFunction
&
MF
=
*
MI
.
getParent
(
)
->
getParent
(
)
;
MachineInstrBuilder
(
MF
,
MI
)
.
addReg
(
RT
.
Reg
,
S
,
RT
.
Sub
)
;
return
true
;
}
}
MachineInstr
*
TfrT
=
genCondTfrFor
(
ST
,
At
,
DR
,
DSR
,
MP
,
true
,
ReadUndef
,
false
)
;
MachineInstr
*
TfrF
=
genCondTfrFor
(
SF
,
At
,
DR
,
DSR
,
MP
,
false
,
ReadUndef
,
true
)
;
LIS
->
InsertMachineInstrInMaps
(
*
TfrT
)
;
LIS
->
InsertMachineInstrInMaps
(
*
TfrF
)
;
updateRegs
(
MI
)
;
removeInstr
(
MI
)
;
return
true
;
}
</s>

Split into substrings around the occurrences of a separator character .


<s> const P2Subtarget * P2TargetMachine :: getSubtargetImpl ( const Function & ) const { return & subtarget ; } </s>


<s> static tree ix86_vector_shift_count ( tree arg1 ) { if ( tree_fits_uhwi_p ( arg1 ) ) return arg1 ; else if ( TREE_CODE ( arg1 ) == VECTOR_CST && CHAR_BIT == 8 ) { unsigned char buf [ 16 ] ; int len = native_encode_expr ( arg1 , buf , 16 ) ; if ( len == 0 ) return NULL_TREE ; tree t = native_interpret_expr ( uint64_type_node , buf , len ) ; if ( t && tree_fits_uhwi_p ( t ) ) return t ; } return NULL_TREE ; } </s>

Return the shift count of a vector by scalar shift builtin second argument ARG1 .


<s> void AMDGPUTargetLowering :: computeKnownBitsForTargetNode ( const SDValue Op , APInt & KnownZero , APInt & KnownOne , const SelectionDAG & DAG , unsigned Depth ) const { KnownZero = KnownOne = APInt ( KnownOne . getBitWidth ( ) , 0 ) ; APInt KnownZero2 ; APInt KnownOne2 ; unsigned Opc = Op . getOpcode ( ) ; switch ( Opc ) { default : break ; case ISD :: INTRINSIC_WO_CHAIN : { switch ( cast < ConstantSDNode > ( Op . getOperand ( 0 ) ) -> getZExtValue ( ) ) { case AMDGPUIntrinsic :: AMDGPU_imax : case AMDGPUIntrinsic :: AMDGPU_umax : case AMDGPUIntrinsic :: AMDGPU_imin : case AMDGPUIntrinsic :: AMDGPU_umin : computeKnownBitsForMinMax ( Op . getOperand ( 1 ) , Op . getOperand ( 2 ) , KnownZero , KnownOne , DAG , Depth ) ; break ; default : break ; } break ; } case AMDGPUISD :: SMAX : case AMDGPUISD :: UMAX : case AMDGPUISD :: SMIN : case AMDGPUISD :: UMIN : computeKnownBitsForMinMax ( Op . getOperand ( 0 ) , Op . getOperand ( 1 ) , KnownZero , KnownOne , DAG , Depth ) ; break ; case AMDGPUISD :: CARRY : case AMDGPUISD :: BORROW : { KnownZero = APInt :: getHighBitsSet ( 32 , 31 ) ; break ; } case AMDGPUISD :: BFE_I32 : case AMDGPUISD :: BFE_U32 : { ConstantSDNode * CWidth = dyn_cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; if ( ! CWidth ) return ; unsigned BitWidth = 32 ; uint32_t Width = CWidth -> getZExtValue ( ) & 0x1f ; if ( Opc == AMDGPUISD :: BFE_U32 ) KnownZero = APInt :: getHighBitsSet ( BitWidth , BitWidth - Width ) ; break ; } } } </s>

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


<s> void arm_d_target_versions ( void ) { d_add_builtin_version ( "ARM" ) ; if ( TARGET_THUMB || TARGET_THUMB2 ) { d_add_builtin_version ( "Thumb" ) ; d_add_builtin_version ( "ARM_Thumb" ) ; } if ( TARGET_HARD_FLOAT_ABI ) d_add_builtin_version ( "ARM_HardFloat" ) ; else { if ( TARGET_SOFT_FLOAT ) d_add_builtin_version ( "ARM_SoftFloat" ) ; else if ( TARGET_HARD_FLOAT ) d_add_builtin_version ( "ARM_SoftFP" ) ; } if ( TARGET_SOFT_FLOAT ) d_add_builtin_version ( "D_SoftFloat" ) ; else if ( TARGET_HARD_FLOAT ) d_add_builtin_version ( "D_HardFloat" ) ; } </s>

Implement TARGET_D_CPU_VERSIONS for ARM targets .


<s> bool HexagonInstrInfo :: getIncrementValue ( const MachineInstr & MI , int & Value ) const { if ( isPostIncrement ( MI ) ) { unsigned BasePos = 0 , OffsetPos = 0 ; if ( ! getBaseAndOffsetPosition ( MI , BasePos , OffsetPos ) ) return false ; const MachineOperand & OffsetOp = MI . getOperand ( OffsetPos ) ; if ( OffsetOp . isImm ( ) ) { Value = OffsetOp . getImm ( ) ; return true ; } } else if ( MI . getOpcode ( ) == Hexagon :: A2_addi ) { const MachineOperand & AddOp = MI . getOperand ( 2 ) ; if ( AddOp . isImm ( ) ) { Value = AddOp . getImm ( ) ; return true ; } } return false ; } </s>

If the instruction is an increment of a constant value , return the amount .


<s> bool ARMBaseRegisterInfo :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return ( ( NoFramePointerElim && MFI -> hasCalls ( ) ) || needsStackRealignment ( MF ) || MFI -> hasVarSizedObjects ( ) || MFI -> isFrameAddressTaken ( ) ) ; } </s>

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


<s> static rtx mips_frame_set ( rtx mem , rtx reg ) { rtx set ; set = gen_rtx_SET ( mem , reg ) ; RTX_FRAME_RELATED_P ( set ) = 1 ; return set ; } </s>

Return a frame-related rtx that stores register REGNO at ( SP + OFFSET ) . The expression should only be used to store single registers .


<s> static void arm_option_save ( struct cl_target_option * ptr , struct gcc_options * opts ) { ptr -> x_arm_arch_string = opts -> x_arm_arch_string ; ptr -> x_arm_cpu_string = opts -> x_arm_cpu_string ; ptr -> x_arm_tune_string = opts -> x_arm_tune_string ; } </s>


<s> static unsigned int insn_is_load_p ( rtx insn ) { rtx body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == SET ) { if ( GET_CODE ( SET_SRC ( body ) ) == MEM ) return 1 ; if ( GET_CODE ( SET_SRC ( body ) ) == VEC_SELECT && GET_CODE ( XEXP ( SET_SRC ( body ) , 0 ) ) == MEM ) return 1 ; return 0 ; } if ( GET_CODE ( body ) != PARALLEL ) return 0 ; rtx set = XVECEXP ( body , 0 , 0 ) ; if ( GET_CODE ( set ) == SET && GET_CODE ( SET_SRC ( set ) ) == MEM ) return 1 ; return 0 ; } </s>

Return 1 iff INSN is a load insn , including permuting loads that represent an lvxd2x instruction ; else return 0 .


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


<s> static bool spu_truly_noop_truncation ( poly_uint64 outprec , poly_uint64 inprec ) { return inprec <= 32 && outprec <= inprec ; } </s>


<s> static bool aarch64_multiply_add_p ( vec_info * vinfo , stmt_vec_info stmt_info ) { gassign * assign = dyn_cast < gassign * > ( stmt_info -> stmt ) ; if ( ! assign ) return false ; tree_code code = gimple_assign_rhs_code ( assign ) ; if ( code != PLUS_EXPR && code != MINUS_EXPR ) return false ; if ( CONSTANT_CLASS_P ( gimple_assign_rhs1 ( assign ) ) || CONSTANT_CLASS_P ( gimple_assign_rhs2 ( assign ) ) ) return false ; for ( int i = 1 ; i < 3 ; ++ i ) { tree rhs = gimple_op ( assign , i ) ; if ( TREE_CODE ( rhs ) != SSA_NAME ) continue ; stmt_vec_info def_stmt_info = vinfo -> lookup_def ( rhs ) ; if ( ! def_stmt_info || STMT_VINFO_DEF_TYPE ( def_stmt_info ) != vect_internal_def ) continue ; gassign * rhs_assign = dyn_cast < gassign * > ( def_stmt_info -> stmt ) ; if ( ! rhs_assign || gimple_assign_rhs_code ( rhs_assign ) != MULT_EXPR ) continue ; return true ; } return false ; } </s>

Return true if STMT_INFO is the second part of a two-statement multiply-add or multiply-subtract sequence that might be suitable for fusing into a single instruction .


"call frame with stack not yet implemented!"

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> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addRequired < DataLayoutPass > ( ) ; AU . addPreserved ( "stack-protector" ) ; AU . addPreserved < MachineFunctionAnalysis > ( ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> static void aarch64_emit_store_exclusive ( machine_mode mode , rtx bval , rtx rval , rtx mem , rtx model_rtx ) { rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; switch ( mode ) { case E_QImode : gen = gen_aarch64_store_exclusiveqi ; break ; case E_HImode : gen = gen_aarch64_store_exclusivehi ; break ; case E_SImode : gen = gen_aarch64_store_exclusivesi ; break ; case E_DImode : gen = gen_aarch64_store_exclusivedi ; break ; default : gcc_unreachable ( ) ; } emit_insn ( gen ( bval , rval , mem , model_rtx ) ) ; } </s>


<s> void TPCPassConfig :: addPreSched2 ( ) { addPass ( createTPCSetSpillBase ( ) , 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> void M68kAsmPrinter :: emitEndOfAsmFile ( Module & M ) { } </s>

This virtual method can be overridden by targets that want to emit something at the end of their file .


<s>
bool
RISCVInstrInfo
::
verifyInstruction
(
const
MachineInstr
&
MI
,
StringRef
&
ErrInfo
)
const
{
const
MCInstrInfo
*
MCII
=
STI
.
getInstrInfo
(
)
;
MCInstrDesc
const
&
Desc
=
MCII
->
get
(
MI
.
getOpcode
(
)
)
;
for
(
auto
&
OI
:
enumerate
(
Desc
.
operands
(
)
)
)
{
unsigned
OpType
=
OI
.
value
(
)
.
OperandType
;
if
(
OpType
>=
RISCVOp
::
OPERAND_FIRST_RISCV_IMM
&&
OpType
<=
RISCVOp
::
OPERAND_LAST_RISCV_IMM
)
{
const
MachineOperand
&
MO
=
MI
.
getOperand
(
OI
.
index
(
)
)
;
if
(
MO
.
isImm
(
)
)
{
int64_t
Imm
=
MO
.
getImm
(
)
;
bool
Ok
;
switch
(
OpType
)
{
default
:
llvm_unreachable
(
"Unexpected operand type"
)
;
case
RISCVOp
::
OPERAND_UIMM4
:
Ok
=
isUInt
<
4
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM5
:
Ok
=
isUInt
<
5
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM12
:
Ok
=
isUInt
<
12
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM12M1
:
Ok
=
isUInt
<
12
>
(
Imm
)
&&
(
Imm
!=
0
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM3
:
Ok
=
isUInt
<
3
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_SIMM12
:
Ok
=
isInt
<
12
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM20
:
Ok
=
isUInt
<
20
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMMLOG2XLEN
:
if
(
STI
.
getTargetTriple
(
)
.
isArch64Bit
(
)
)
Ok
=
isUInt
<
6
>
(
Imm
)
;
else
Ok
=
isUInt
<
5
>
(
Imm
)
;
break
;
}
if
(
!
Ok
)
{
ErrInfo
=
"Invalid immediate"
;
return
false
;
}
}
}
}
return
true
;
}
</s>

Perform target-specific instruction verification .


<s> static bool isNodeHidden ( const T , const agraph & G ) { return false ; } </s>

Do not print nodes that are part of a pi-block separately .


<s>
bool
SHUXIInstrInfo
::
reverseBranchCondition
(
SmallVectorImpl
<
MachineOperand
>
&
Cond
)
const
{
assert
(
Cond
.
size
(
)
==
1
&&
"Invalid Xbranch condition!"
)
;
SHUXICC
::
CondCodes
CC
=
static_cast
<
SHUXICC
::
CondCodes
>
(
Cond
[
0
]
.
getImm
(
)
)
;
switch
(
CC
)
{
default
:
llvm_unreachable
(
"Invalid branch condition!"
)
;
case
SHUXICC
::
COND_C
:
CC
=
SHUXICC
::
COND_NC
;
break
;
case
SHUXICC
::
COND_N
:
CC
=
SHUXICC
::
COND_NN
;
break
;
case
SHUXICC
::
COND_V
:
CC
=
SHUXICC
::
COND_NV
;
break
;
case
SHUXICC
::
COND_Z
:
CC
=
SHUXICC
::
COND_NZ
;
break
;
case
SHUXICC
::
COND_GE
:
CC
=
SHUXICC
::
COND_L
;
break
;
case
SHUXICC
::
COND_NC
:
CC
=
SHUXICC
::
COND_C
;
break
;
case
SHUXICC
::
COND_NN
:
CC
=
SHUXICC
::
COND_N
;
break
;
case
SHUXICC
::
COND_NV
:
CC
=
SHUXICC
::
COND_V
;
break
;
case
SHUXICC
::
COND_NZ
:
CC
=
SHUXICC
::
COND_Z
;
break
;
case
SHUXICC
::
COND_L
:
CC
=
SHUXICC
::
COND_GE
;
break
;
}
Cond
[
0
]
.
setImm
(
CC
)
;
return
false
;
}
</s>

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


<s> bool check ( function_checker & c ) const override { return c . require_immediate_range ( 2 , 0 , 7 ) ; } </s>

Perform semantic checks on the call . Return true if the call is valid , otherwise report a suitable error .


<s> static bool riscv_memmodel_needs_release_fence ( enum memmodel model ) { switch ( model ) { case MEMMODEL_ACQ_REL : case MEMMODEL_SEQ_CST : case MEMMODEL_SYNC_SEQ_CST : case MEMMODEL_RELEASE : case MEMMODEL_SYNC_RELEASE : return true ; case MEMMODEL_ACQUIRE : case MEMMODEL_CONSUME : case MEMMODEL_SYNC_ACQUIRE : case MEMMODEL_RELAXED : return false ; default : gcc_unreachable ( ) ; } } </s>

Return true if a FENCE should be emitted to before a memory access to implement the release portion of memory model MODEL .


"Instruction use requires option to be enabled"

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


<s> static void s390_dump_pool ( struct constant_pool * pool , bool remote_label ) { struct constant * c ; rtx_insn * insn = pool -> pool_insn ; size_t i ; insn = emit_insn_after ( gen_pool_section_start ( ) , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; insn = emit_insn_after ( gen_pool_align ( GEN_INT ( 8 ) ) , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; if ( ! remote_label ) { insn = emit_label_after ( pool -> label , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; } for ( i = 0 ; i < NR_C_MODES ; i ++ ) for ( c = pool -> constants [ i ] ; c ; c = c -> next ) { rtx value = copy_rtx ( c -> value ) ; if ( GET_CODE ( value ) == CONST && GET_CODE ( XEXP ( value , 0 ) ) == UNSPEC && XINT ( XEXP ( value , 0 ) , 1 ) == UNSPEC_LTREL_OFFSET && XVECLEN ( XEXP ( value , 0 ) , 0 ) == 1 ) value = s390_pool_offset ( pool , XVECEXP ( XEXP ( value , 0 ) , 0 , 0 ) ) ; insn = emit_label_after ( c -> label , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; value = gen_rtx_UNSPEC_VOLATILE ( constant_modes [ i ] , gen_rtvec ( 1 , value ) , UNSPECV_POOL_ENTRY ) ; insn = emit_insn_after ( value , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; } insn = emit_insn_after ( gen_pool_align ( GEN_INT ( 2 ) ) , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; for ( c = pool -> execute ; c ; c = c -> next ) { insn = emit_label_after ( c -> label , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; insn = emit_insn_after ( s390_execute_target ( c -> value ) , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; } insn = emit_insn_after ( gen_pool_section_end ( ) , insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; insn = emit_barrier_after ( insn ) ; INSN_ADDRESSES_NEW ( insn , - 1 ) ; remove_insn ( pool -> pool_insn ) ; } </s>

Dump out the constants in POOL . If REMOTE_LABEL is true , do not emit the pool base label .


"Instr doesn't have FrameIndex operand!"

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