<s> virtual uint64_t getMachineOpValue ( const MCInst & MI , const MCOperand & MO , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { return 0 ; } </s>

getMachineOpValue - Return binary encoding of operand .


<s> llvm :: PreservedAnalyses run ( llvm :: Module & M , llvm :: ModuleAnalysisManager & MAM ) { return runLowerConstExpr ( M ) ? llvm :: PreservedAnalyses :: none ( ) : llvm :: PreservedAnalyses :: all ( ) ; } </s>

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


<s> bool ARMPassConfig :: addGlobalInstructionSelect ( ) { addPass ( new InstructionSelect ( getOptLevel ( ) ) ) ; return false ; } </s>

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


<s>
void
SCEVInfo
::
dump
(
)
const
{
if
(
!
SCEVPtr
)
{
llvm
::
dbgs
(
)
<<
"Not a valid SCEV Node"
<<
"\n"
;
return
;
}
llvm
::
dbgs
(
)
<<
"Loop Name --> "
<<
L
->
getName
(
)
.
str
(
)
<<
"\n"
;
llvm
::
dbgs
(
)
<<
"Loop Depth --> "
<<
L
->
getLoopDepth
(
)
<<
"\n"
;
llvm
::
dbgs
(
)
<<
"ScevValue --> "
<<
"\n"
;
SCEVPtr
->
print
(
llvm
::
dbgs
(
)
)
;
llvm
::
dbgs
(
)
<<
"\n"
;
llvm
::
dbgs
(
)
<<
"ScevStep --> "
<<
"\n"
;
llvm
::
dbgs
(
)
<<
getSCEVStep
(
)
;
llvm
::
dbgs
(
)
<<
"\n"
;
}
</s>

Dump the plan to stderr ( for debugging ) .

TPC
"Not a valid SCEV Node"
"\n"
"Loop Name --> "
"\n"
"Loop Depth --> "
"\n"
"ScevValue --> "
"\n"
"\n"
"ScevStep --> "
"\n"
"\n"


<s> void SIMachineFunctionInfo :: removeDeadFrameIndices ( MachineFunction & MF ) { MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; const SIRegisterInfo * TRI = ST . getRegisterInfo ( ) ; for ( auto & R : make_early_inc_range ( SGPRToVGPRSpills ) ) { if ( R . first != FramePointerSaveIndex && R . first != BasePointerSaveIndex && ( ! TRI -> isCFISavedRegsSpillEnabled ( ) || ( R . first != ReturnAddressSaveIndex && R . first != EXECSaveIndex ) ) ) { MFI . RemoveStackObject ( R . first ) ; SGPRToVGPRSpills . erase ( R . first ) ; } } for ( int i = MFI . getObjectIndexBegin ( ) , e = MFI . getObjectIndexEnd ( ) ; i != e ; ++ i ) if ( i != FramePointerSaveIndex && i != BasePointerSaveIndex && ( ! TRI -> isCFISavedRegsSpillEnabled ( ) || ( i != ReturnAddressSaveIndex && i != EXECSaveIndex ) ) ) MFI . setStackID ( i , TargetStackID :: Default ) ; for ( auto & R : VGPRToAGPRSpills ) { if ( R . second . FullyAllocated ) MFI . RemoveStackObject ( R . first ) ; } } </s>

If ResetSGPRSpillStackIDs is true , reset the stack ID from sgpr-spill to the default stack .


<s> void MSP430RegisterInfo :: emitPrologue ( MachineFunction & MF ) const { MachineBasicBlock & MBB = MF . front ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; MSP430MachineFunctionInfo * MSP430FI = MF . getInfo < MSP430MachineFunctionInfo > ( ) ; MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; DebugLoc DL = ( MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc :: getUnknownLoc ( ) ) ; uint64_t StackSize = MFI -> getStackSize ( ) ; uint64_t NumBytes = 0 ; if ( hasFP ( MF ) ) { uint64_t FrameSize = StackSize - 2 ; NumBytes = FrameSize - MSP430FI -> getCalleeSavedFrameSize ( ) ; MFI -> setOffsetAdjustment ( - NumBytes ) ; BuildMI ( MBB , MBBI , DL , TII . get ( MSP430 :: PUSH16r ) ) . addReg ( MSP430 :: FPW , RegState :: Kill ) ; BuildMI ( MBB , MBBI , DL , TII . get ( MSP430 :: MOV16rr ) , MSP430 :: FPW ) . addReg ( MSP430 :: SPW ) ; for ( MachineFunction :: iterator I = llvm :: next ( MF . begin ( ) ) , E = MF . end ( ) ; I != E ; ++ I ) I -> addLiveIn ( MSP430 :: FPW ) ; } else NumBytes = StackSize - MSP430FI -> getCalleeSavedFrameSize ( ) ; while ( MBBI != MBB . end ( ) && ( MBBI -> getOpcode ( ) == MSP430 :: PUSH16r ) ) ++ MBBI ; if ( MBBI != MBB . end ( ) ) DL = MBBI -> getDebugLoc ( ) ; if ( NumBytes ) { if ( NumBytes ) { MachineInstr * MI = BuildMI ( MBB , MBBI , DL , TII . get ( MSP430 :: SUB16ri ) , MSP430 :: SPW ) . addReg ( MSP430 :: SPW ) . addImm ( NumBytes ) ; MI -> getOperand ( 3 ) . setIsDead ( ) ; } } } </s>

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


"Switch should handle all register classes"


<s> bool HexagonOptAddrMode :: isValidOffset ( MachineInstr * MI , int Offset ) { if ( HII -> isHVXVec ( * MI ) ) { switch ( MI -> getOpcode ( ) ) { case Hexagon :: V6_vgathermh_pseudo : case Hexagon :: V6_vgathermw_pseudo : case Hexagon :: V6_vgathermhw_pseudo : case Hexagon :: V6_vgathermhq_pseudo : case Hexagon :: V6_vgathermwq_pseudo : case Hexagon :: V6_vgathermhwq_pseudo : return HII -> isValidOffset ( MI -> getOpcode ( ) , Offset , HRI , false ) ; default : return false ; } } if ( HII -> getAddrMode ( * MI ) != HexagonII :: BaseImmOffset ) return false ; unsigned AlignMask = 0 ; switch ( HII -> getMemAccessSize ( * MI ) ) { case HexagonII :: MemAccessSize :: DoubleWordAccess : AlignMask = 0x7 ; break ; case HexagonII :: MemAccessSize :: WordAccess : AlignMask = 0x3 ; break ; case HexagonII :: MemAccessSize :: HalfWordAccess : AlignMask = 0x1 ; break ; case HexagonII :: MemAccessSize :: ByteAccess : AlignMask = 0x0 ; break ; default : return false ; } if ( ( AlignMask & Offset ) != 0 ) return false ; return HII -> isValidOffset ( MI -> getOpcode ( ) , Offset , HRI , false ) ; } </s>


<s> static bool rs6000_secondary_memory_needed ( enum reg_class from_class , enum reg_class to_class , machine_mode mode ) { enum rs6000_reg_type from_type , to_type ; bool altivec_p = ( ( from_class == ALTIVEC_REGS ) || ( to_class == ALTIVEC_REGS ) ) ; from_type = reg_class_to_reg_type [ ( int ) from_class ] ; to_type = reg_class_to_reg_type [ ( int ) to_class ] ; if ( rs6000_secondary_reload_move ( to_type , from_type , mode , ( secondary_reload_info * ) 0 , altivec_p ) ) return false ; if ( IS_FP_VECT_REG_TYPE ( from_type ) || IS_FP_VECT_REG_TYPE ( to_type ) ) return true ; return false ; } </s>

If we are copying between FP or AltiVec registers and anything else , we need a memory location . The exception is when we are targeting ppc64 and the move to/from fpr to gpr instructions are available . Also , under VSX , you can copy vector registers from the FP register set to the Altivec register set and vice versa .


<s> static int alpha_set_memflags_1 ( rtx * xp , void * data ) { rtx x = * xp , orig = ( rtx ) data ; if ( GET_CODE ( x ) != MEM ) return 0 ; MEM_VOLATILE_P ( x ) = MEM_VOLATILE_P ( orig ) ; MEM_IN_STRUCT_P ( x ) = MEM_IN_STRUCT_P ( orig ) ; MEM_SCALAR_P ( x ) = MEM_SCALAR_P ( orig ) ; MEM_NOTRAP_P ( x ) = MEM_NOTRAP_P ( orig ) ; MEM_READONLY_P ( x ) = MEM_READONLY_P ( orig ) ; return - 1 ; } </s>

Subfunction of the following function . Update the flags of any MEM found in part of X .


"Unused function on X86. Otherwise need a test case."

Return true if target has reserved a spill slot in the stack frame of the given function for the specified register .


<s> bool ARCompactInstrInfo :: PredicateInstruction ( MachineInstr * MI , const SmallVectorImpl < MachineOperand > & Pred ) const { int PIdx = MI -> findFirstPredOperandIdx ( ) ; if ( PIdx != - 1 ) { MachineOperand & PMO = MI -> getOperand ( PIdx ) ; PMO . setImm ( Pred [ 0 ] . getImm ( ) ) ; return true ; } return false ; } </s>

Convert the instruction into a predicated instruction .


<s> CCAssignFn * MipsTargetLowering :: CCAssignFnForCall ( ) const { return CC_Mips_FixedArg ; } </s>

Selects the correct CCAssignFn for a given CallingConvention value .


<s> virtual MVT getScalarShiftAmountTy ( EVT LHSTy ) const { return MVT :: i32 ; } </s>

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


<s> SDValue ARCompactTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { SelectionDAG & DAG = DCI . DAG ; switch ( N -> getOpcode ( ) ) { case ISD :: SELECT_CC : return PerformSELECTCCCombine ( N , DAG , DCI ) ; default : break ; } return SDValue ( ) ; } </s>

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


<s> static rtx find_last_same_clock ( rtx insn ) { rtx retval = insn ; rtx_insn * t = next_real_insn ( insn ) ; while ( t && GET_MODE ( t ) != TImode ) { if ( ! DEBUG_INSN_P ( t ) && recog_memoized ( t ) >= 0 ) retval = t ; t = next_real_insn ( t ) ; } return retval ; } </s>

Walk forward from INSN to find the last insn that issues in the same clock cycle .


<s>
SDValue
SparcTargetLowering
::
LowerReturn
(
SDValue
Chain
,
unsigned
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
DebugLoc
dl
,
SelectionDAG
&
DAG
)
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
DAG
.
getTarget
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_Sparc32
)
;
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
(
SPISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
Chain
,
Flag
)
;
return
DAG
.
getNode
(
SPISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
Chain
)
;
}
</s>

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


<s> static int sequent_regs_live ( void ) { int reg ; int live_seq = 0 ; int cur_seq = 0 ; for ( reg = 0 ; reg <= LAST_CALLEE_SAVED_REG ; ++ reg ) { if ( fixed_regs [ reg ] ) { if ( live_seq != 0 ) return 0 ; else continue ; } if ( ! call_used_regs [ reg ] ) { if ( df_regs_ever_live_p ( reg ) ) { ++ live_seq ; ++ cur_seq ; } else cur_seq = 0 ; } } if ( ! frame_pointer_needed ) { if ( df_regs_ever_live_p ( REG_Y ) ) { ++ live_seq ; ++ cur_seq ; } else cur_seq = 0 ; if ( df_regs_ever_live_p ( REG_Y + 1 ) ) { ++ live_seq ; ++ cur_seq ; } else cur_seq = 0 ; } else { cur_seq += 2 ; live_seq += 2 ; } return ( cur_seq == live_seq ) ? live_seq : 0 ; } </s>

This function checks sequence of live registers


"instruction use requires an option to be enabled"

"immediate must be an integer in the range [0, 0xff]"

"immediate must be an integer in the range [0, 0xffff]"

"operand must be an integer in the range [0, 4] "

"representing one of the Float rounding mode options"

"or an integer in the range [0, 0xffff]"

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


<s> rtx aarch64_return_addr_rtx ( void ) { rtx val = get_hard_reg_initial_val ( Pmode , LR_REGNUM ) ; rtx lr = gen_rtx_REG ( Pmode , LR_REGNUM ) ; emit_move_insn ( lr , val ) ; emit_insn ( GEN_FCN ( CODE_FOR_xpaclri ) ( ) ) ; return lr ; } </s>


<s>
bool
X86InstrInfo
::
expandPostRAPseudo
(
MachineBasicBlock
::
iterator
MI
)
const
{
bool
HasAVX
=
Subtarget
.
hasAVX
(
)
;
MachineInstrBuilder
MIB
(
*
MI
->
getParent
(
)
->
getParent
(
)
,
MI
)
;
switch
(
MI
->
getOpcode
(
)
)
{
case
X86
::
MOV32r0
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
XOR32rr
)
)
;
case
X86
::
MOV32r1
:
return
expandMOV32r1
(
MIB
,
*
this
,
false
)
;
case
X86
::
MOV32r_1
:
return
expandMOV32r1
(
MIB
,
*
this
,
true
)
;
case
X86
::
MOV32ImmSExti8
:
case
X86
::
MOV64ImmSExti8
:
return
ExpandMOVImmSExti8
(
MIB
)
;
case
X86
::
SETB_C8r
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
SBB8rr
)
)
;
case
X86
::
SETB_C16r
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
SBB16rr
)
)
;
case
X86
::
SETB_C32r
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
SBB32rr
)
)
;
case
X86
::
SETB_C64r
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
SBB64rr
)
)
;
case
X86
::
V_SET0
:
case
X86
::
FsFLD0SS
:
case
X86
::
FsFLD0SD
:
return
Expand2AddrUndef
(
MIB
,
get
(
HasAVX
X86
::
VXORPSrr
:
X86
::
XORPSrr
)
)
;
case
X86
::
AVX_SET0
:
assert
(
HasAVX
&&
"AVX not supported"
)
;
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
VXORPSYrr
)
)
;
case
X86
::
AVX512_512_SET0
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
VPXORDZrr
)
)
;
case
X86
::
V_SETALLONES
:
return
Expand2AddrUndef
(
MIB
,
get
(
HasAVX
X86
::
VPCMPEQDrr
:
X86
::
PCMPEQDrr
)
)
;
case
X86
::
AVX2_SETALLONES
:
return
Expand2AddrUndef
(
MIB
,
get
(
X86
::
VPCMPEQDYrr
)
)
;
case
X86
::
TEST8ri_NOREX
:
MI
->
setDesc
(
get
(
X86
::
TEST8ri
)
)
;
return
true
;
case
X86
::
KSET0B
:
case
X86
::
KSET0W
:
return
Expand2AddrKreg
(
MIB
,
get
(
X86
::
KXORWrr
)
,
X86
::
K0
)
;
case
X86
::
KSET0D
:
return
Expand2AddrKreg
(
MIB
,
get
(
X86
::
KXORDrr
)
,
X86
::
K0
)
;
case
X86
::
KSET0Q
:
return
Expand2AddrKreg
(
MIB
,
get
(
X86
::
KXORQrr
)
,
X86
::
K0
)
;
case
X86
::
KSET1B
:
case
X86
::
KSET1W
:
return
Expand2AddrKreg
(
MIB
,
get
(
X86
::
KXNORWrr
)
,
X86
::
K0
)
;
case
X86
::
KSET1D
:
return
Expand2AddrKreg
(
MIB
,
get
(
X86
::
KXNORDrr
)
,
X86
::
K0
)
;
case
X86
::
KSET1Q
:
return
Expand2AddrKreg
(
MIB
,
get
(
X86
::
KXNORQrr
)
,
X86
::
K0
)
;
case
TargetOpcode
::
LOAD_STACK_GUARD
:
expandLoadStackGuard
(
MIB
,
*
this
)
;
return
true
;
}
return
false
;
}
</s>

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


<s> static rtx hppa_builtin_saveregs ( void ) { rtx offset , dest ; tree fntype = TREE_TYPE ( current_function_decl ) ; int argadj = ( ( ! stdarg_p ( fntype ) ) ? UNITS_PER_WORD : 0 ) ; if ( argadj ) offset = plus_constant ( Pmode , crtl -> args . arg_offset_rtx , argadj ) ; else offset = crtl -> args . arg_offset_rtx ; if ( TARGET_64BIT ) { int i , off ; if ( argadj ) offset = plus_constant ( Pmode , crtl -> args . arg_offset_rtx , - argadj ) ; else offset = crtl -> args . arg_offset_rtx ; for ( i = 26 , off = - 64 ; i >= 19 ; i -- , off += 8 ) emit_move_insn ( gen_rtx_MEM ( word_mode , plus_constant ( Pmode , arg_pointer_rtx , off ) ) , gen_rtx_REG ( word_mode , i ) ) ; emit_move_insn ( virtual_incoming_args_rtx , plus_constant ( Pmode , arg_pointer_rtx , - 64 ) ) ; return copy_to_reg ( expand_binop ( Pmode , add_optab , virtual_incoming_args_rtx , offset , 0 , 0 , OPTAB_LIB_WIDEN ) ) ; } dest = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , crtl -> args . internal_arg_pointer , - 16 ) ) ; set_mem_alias_set ( dest , get_varargs_alias_set ( ) ) ; set_mem_align ( dest , BITS_PER_WORD ) ; move_block_from_reg ( 23 , dest , 4 ) ; emit_insn ( gen_blockage ( ) ) ; return copy_to_reg ( expand_binop ( Pmode , add_optab , crtl -> args . internal_arg_pointer , offset , 0 , 0 , OPTAB_LIB_WIDEN ) ) ; } </s>

Do what is necessary for ` va_start ' . We look at the current function to determine if stdargs or varargs is used and fill in an initial va_list . A pointer to this constructor is returned .


<s> rtx arm_gen_return_addr_mask ( void ) { rtx reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_return_addr_mask ( reg ) ) ; return reg ; } </s>

Generate a sequence of insns that will generate the correct return address mask depending on the physical architecture that the program is running on .


<s> bool SPIRVLegalizerInfo :: legalizeCustom ( LegalizerHelper & Helper , MachineInstr & MI ) const { auto Opc = MI . getOpcode ( ) ; MachineRegisterInfo & MRI = MI . getMF ( ) -> getRegInfo ( ) ; assert ( Opc == TargetOpcode :: G_ICMP ) ; assert ( GR -> getSPIRVTypeForVReg ( MI . getOperand ( 0 ) . getReg ( ) ) ) ; auto & Op0 = MI . getOperand ( 2 ) ; auto & Op1 = MI . getOperand ( 3 ) ; Register Reg0 = Op0 . getReg ( ) ; Register Reg1 = Op1 . getReg ( ) ; CmpInst :: Predicate Cond = static_cast < CmpInst :: Predicate > ( MI . getOperand ( 1 ) . getPredicate ( ) ) ; if ( ( ! ST -> canDirectlyComparePointers ( ) || ( Cond != CmpInst :: ICMP_EQ && Cond != CmpInst :: ICMP_NE ) ) && MRI . getType ( Reg0 ) . isPointer ( ) && MRI . getType ( Reg1 ) . isPointer ( ) ) { LLT ConvT = LLT :: scalar ( ST -> getPointerSize ( ) ) ; Type * LLVMTy = IntegerType :: get ( MI . getMF ( ) -> getFunction ( ) . getContext ( ) , ST -> getPointerSize ( ) ) ; SPIRVType * SpirvTy = GR -> getOrCreateSPIRVType ( LLVMTy , Helper . MIRBuilder ) ; Op0 . setReg ( convertPtrToInt ( Reg0 , ConvT , SpirvTy , Helper , MRI , GR ) ) ; Op1 . setReg ( convertPtrToInt ( Reg1 , ConvT , SpirvTy , Helper , MRI , GR ) ) ; } return true ; } </s>

Called for instructions with the Custom LegalizationAction .


<s> int cris_initial_elimination_offset ( int fromreg , int toreg ) { int fp_sp_offset = cris_initial_frame_pointer_offset ( ) ; bool return_address_on_stack = cris_return_address_on_stack ( ) ; int ap_fp_offset = 4 + ( return_address_on_stack ? 4 : 0 ) ; if ( fromreg == ARG_POINTER_REGNUM && toreg == HARD_FRAME_POINTER_REGNUM ) return ap_fp_offset ; if ( fromreg == FRAME_POINTER_REGNUM && toreg == STACK_POINTER_REGNUM ) return fp_sp_offset ; if ( fromreg == ARG_POINTER_REGNUM && toreg == STACK_POINTER_REGNUM ) return ap_fp_offset + fp_sp_offset - 4 ; if ( fromreg == FRAME_POINTER_REGNUM && toreg == HARD_FRAME_POINTER_REGNUM ) return 0 ; gcc_unreachable ( ) ; } </s>

The INITIAL_ELIMINATION_OFFSET worker . Calculate the difference between imaginary registers such as frame pointer and the stack pointer . Used to eliminate the frame pointer and imaginary arg pointer .


<s>
EVT
Z80TargetLowering
::
getSetCCResultType
(
const
DataLayout
&
DL
,
LLVMContext
&
Context
,
EVT
VT
)
const
{
assert
(
!
VT
.
isVector
(
)
&&
"No default SetCC type for vectors!"
)
;
return
MVT
::
i8
;
}
</s>

Return the value type to use for ISD : :SETCC .


"-misched-topdown incompatible with -misched-bottomup"

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


<s> void VideocoreFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { } </s>


<s>
static
int
rs6000_arg_partial_bytes
(
cumulative_args_t
cum_v
,
machine_mode
mode
,
tree
type
,
bool
named
)
{
CUMULATIVE_ARGS
*
cum
=
get_cumulative_args
(
cum_v
)
;
bool
passed_in_gprs
=
true
;
int
ret
=
0
;
int
align_words
;
machine_mode
elt_mode
;
int
n_elts
;
rs6000_discover_homogeneous_aggregate
(
mode
,
type
,
&
elt_mode
,
&
n_elts
)
;
if
(
DEFAULT_ABI
==
ABI_V4
)
return
0
;
if
(
USE_ALTIVEC_FOR_ARG_P
(
cum
,
elt_mode
,
named
)
)
{
if
(
TARGET_64BIT
&&
!
cum
->
prototype
&&
(
!
cum
->
libcall
||
!
FLOAT128_VECTOR_P
(
elt_mode
)
)
)
return
0
;
passed_in_gprs
=
false
;
if
(
cum
->
vregno
+
n_elts
>
ALTIVEC_ARG_MAX_REG
+
1
)
ret
=
(
ALTIVEC_ARG_MAX_REG
+
1
cum
->
vregno
)
*
16
;
}
if
(
TARGET_MACHO
&&
rs6000_darwin64_struct_check_p
(
mode
,
type
)
)
return
0
;
align_words
=
rs6000_parm_start
(
mode
,
type
,
cum
->
words
)
;
if
(
USE_FP_FOR_ARG_P
(
cum
,
elt_mode
)
&&
!
(
TARGET_AIX
&&
!
TARGET_ELF
&&
type
!=
&&
AGGREGATE_TYPE_P
(
type
)
)
)
{
unsigned
long
n_fpreg
=
(
GET_MODE_SIZE
(
elt_mode
)
+
7
)
>>
3
;
if
(
type
&&
(
cum
->
nargs_prototype
<=
0
||
(
(
DEFAULT_ABI
==
ABI_AIX
||
DEFAULT_ABI
==
ABI_ELFv2
)
&&
TARGET_XL_COMPAT
&&
align_words
>=
GP_ARG_NUM_REG
)
)
)
return
0
;
passed_in_gprs
=
false
;
if
(
cum
->
fregno
+
n_elts
*
n_fpreg
>
FP_ARG_MAX_REG
+
1
)
{
int
fpr
=
(
(
FP_ARG_MAX_REG
+
1
cum
->
fregno
)
*
MIN
(
8
,
GET_MODE_SIZE
(
elt_mode
)
)
)
;
int
fpr_words
=
fpr
/
(
TARGET_32BIT
4
:
8
)
;
if
(
align_words
+
fpr_words
<
GP_ARG_NUM_REG
)
passed_in_gprs
=
true
;
else
ret
=
fpr
;
}
}
if
(
passed_in_gprs
&&
align_words
<
GP_ARG_NUM_REG
&&
GP_ARG_NUM_REG
<
align_words
+
rs6000_arg_size
(
mode
,
type
)
)
ret
=
(
GP_ARG_NUM_REG
align_words
)
*
(
TARGET_32BIT
4
:
8
)
;
if
(
ret
!=
0
&&
TARGET_DEBUG_ARG
)
fprintf
(
stderr
,
"rs6000_arg_partial_bytes: %d\n"
,
ret
)
;
return
ret
;
}
</s>

For an arg passed partly in registers and partly in memory , this is the number of bytes passed in registers . For args passed entirely in registers or entirely in memory , zero . When an arg is described by a PARALLEL , perhaps using more than one register type , this function returns the number of bytes used by the first element of the PARALLEL .


<s> static bool bfin_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { switch ( GET_CODE ( x ) ) { case REG : if ( bfin_valid_reg_p ( REGNO ( x ) , strict , mode , MEM ) ) return true ; break ; case PLUS : if ( REG_P ( XEXP ( x , 0 ) ) && bfin_valid_reg_p ( REGNO ( XEXP ( x , 0 ) ) , strict , mode , PLUS ) && ( ( GET_CODE ( XEXP ( x , 1 ) ) == UNSPEC && mode == SImode ) || ( GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT && bfin_valid_add ( mode , INTVAL ( XEXP ( x , 1 ) ) ) ) ) ) return true ; break ; case POST_INC : case POST_DEC : if ( LEGITIMATE_MODE_FOR_AUTOINC_P ( mode ) && REG_P ( XEXP ( x , 0 ) ) && bfin_valid_reg_p ( REGNO ( XEXP ( x , 0 ) ) , strict , mode , POST_INC ) ) return true ; case PRE_DEC : if ( LEGITIMATE_MODE_FOR_AUTOINC_P ( mode ) && XEXP ( x , 0 ) == stack_pointer_rtx && REG_P ( XEXP ( x , 0 ) ) && bfin_valid_reg_p ( REGNO ( XEXP ( x , 0 ) ) , strict , mode , PRE_DEC ) ) return true ; break ; default : break ; } return false ; } </s>

Recognize an RTL expression that is a valid memory address for an instruction . The MODE argument is the machine mode for the MEM expression that wants to use this address . Blackfin addressing modes are as follows : [ preg ] [ preg + imm16 ] B [ Preg + uimm15 ] W [ Preg + uimm16m2 ] [ Preg + uimm17m4 ] [ preg++ ] [ preg -- ] [ -- sp ]


<s> inline tree function_instance :: base_vector_type ( ) const { return acle_vector_types [ 0 ] [ mode_suffix ( ) . base_vector_type ] ; } </s>

Return the type of the function 's vector base address argument , or null it does n't have a vector base address .


<s> Optional < MCFixupKind > getFixupKind ( StringRef Name ) const override { unsigned Type ; Type = llvm :: StringSwitch < unsigned > ( Name ) . Case ( "BFD_RELOC_NONE" , ELF :: R_SPARC_NONE ) . Case ( "BFD_RELOC_8" , ELF :: R_SPARC_8 ) . Case ( "BFD_RELOC_16" , ELF :: R_SPARC_16 ) . Case ( "BFD_RELOC_32" , ELF :: R_SPARC_32 ) . Case ( "BFD_RELOC_64" , ELF :: R_SPARC_64 ) . Default ( - 1u ) ; if ( Type == - 1u ) return None ; return static_cast < MCFixupKind > ( FirstLiteralRelocationKind + Type ) ; } </s>

getFixupKind - Get the fixup kind of this expression .


"getBranchTargetOpValue expects only expressions"

getBranchTargetOpValue - Return binary encoding of the branch target operand .


<s> HOST_WIDE_INT or1k_initial_elimination_offset ( int from , int to ) { HOST_WIDE_INT offset ; switch ( from ) { case ARG_POINTER_REGNUM : offset = cfun -> machine -> total_size ; break ; case FRAME_POINTER_REGNUM : offset = cfun -> machine -> args_size + cfun -> machine -> local_vars_size ; break ; default : gcc_unreachable ( ) ; } if ( to == HARD_FRAME_POINTER_REGNUM ) offset -= cfun -> machine -> total_size ; return offset ; } </s>

Helper for defining INITIAL_ELIMINATION_OFFSET . We allow the following eliminiations : FP - > HARD_FP or SP AP - > HARD_FP or SP HARD_FP and AP are the same which is handled below .


<s> bool Z80TargetLowering :: shouldConvertConstantLoadToIntImm ( const APInt & Imm , Type * Ty ) const { assert ( Ty -> isIntegerTy ( ) ) ; return true ; } </s>

Returns true if it is beneficial to convert a load of a constant to just the constant itself .


<s> static void do_rotl3 ( rtx dest , rtx src1 , rtx src2 ) { if ( GET_MODE ( dest ) == DImode ) emit_insn ( gen_rotldi3 ( dest , src1 , src2 ) ) ; else emit_insn ( gen_rotlsi3 ( dest , src1 , src2 ) ) ; } </s>

Emit a rotl of the proper mode for DEST . DEST is the destination register for the and . SRC1 is the first and input . SRC2 is the second and input . Computes DEST = SRC1 rotated left by SRC2 .


<s> int ARMBaseInstrInfo :: getOperandLatency ( const InstrItineraryData * ItinData , SDNode * DefNode , unsigned DefIdx , SDNode * UseNode , unsigned UseIdx ) const { if ( ! DefNode -> isMachineOpcode ( ) ) return 1 ; const TargetInstrDesc & DefTID = get ( DefNode -> getMachineOpcode ( ) ) ; if ( isZeroCost ( DefTID . Opcode ) ) return 0 ; if ( ! ItinData || ItinData -> isEmpty ( ) ) return DefTID . mayLoad ( ) ? 3 : 1 ; if ( ! UseNode -> isMachineOpcode ( ) ) { int Latency = ItinData -> getOperandCycle ( DefTID . getSchedClass ( ) , DefIdx ) ; if ( Subtarget . isCortexA9 ( ) ) return Latency <= 2 ? 1 : Latency - 1 ; else return Latency <= 3 ? 1 : Latency - 2 ; } const TargetInstrDesc & UseTID = get ( UseNode -> getMachineOpcode ( ) ) ; const MachineSDNode * DefMN = dyn_cast < MachineSDNode > ( DefNode ) ; unsigned DefAlign = ! DefMN -> memoperands_empty ( ) ? ( * DefMN -> memoperands_begin ( ) ) -> getAlignment ( ) : 0 ; const MachineSDNode * UseMN = dyn_cast < MachineSDNode > ( UseNode ) ; unsigned UseAlign = ! UseMN -> memoperands_empty ( ) ? ( * UseMN -> memoperands_begin ( ) ) -> getAlignment ( ) : 0 ; int Latency = getOperandLatency ( ItinData , DefTID , DefIdx , DefAlign , UseTID , UseIdx , UseAlign ) ; if ( Latency > 1 && ( Subtarget . isCortexA8 ( ) || Subtarget . isCortexA9 ( ) ) ) { switch ( DefTID . getOpcode ( ) ) { default : break ; case ARM :: LDRrs : case ARM :: LDRBrs : { unsigned ShOpVal = cast < ConstantSDNode > ( DefNode -> getOperand ( 2 ) ) -> getZExtValue ( ) ; unsigned ShImm = ARM_AM :: getAM2Offset ( ShOpVal ) ; if ( ShImm == 0 || ( ShImm == 2 && ARM_AM :: getAM2ShiftOpc ( ShOpVal ) == ARM_AM :: lsl ) ) -- Latency ; break ; } case ARM :: t2LDRs : case ARM :: t2LDRBs : case ARM :: t2LDRHs : case ARM :: t2LDRSHs : { unsigned ShAmt = cast < ConstantSDNode > ( DefNode -> getOperand ( 2 ) ) -> getZExtValue ( ) ; if ( ShAmt == 0 || ShAmt == 2 ) -- Latency ; break ; } } } return Latency ; } </s>

Compute and return the use operand latency of a given pair of def and use .


<s> int64_t getStackPointerBias ( ) const { return is64Bit ( ) ? 2047 : 0 ; } </s>

The 64-bit ABI uses biased stack and frame pointers , so the stack frame of the current function is the area from [ sp+BIAS ] to [ fp+BIAS ] .


Having failed to find a 3 insn sequence in alpha_emit_set_const , fall back to a straight forward decomposition . We do this to avoid exponential run times encountered when looking for longer sequences with alpha_emit_set_const .


<s> static int v850_arg_partial_bytes ( cumulative_args_t cum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int size , align ; if ( ! arg . named ) return 0 ; size = arg . promoted_size_in_bytes ( ) ; if ( size < 1 ) size = 1 ; if ( ! TARGET_GCC_ABI ) align = UNITS_PER_WORD ; else if ( arg . type ) align = TYPE_ALIGN ( arg . type ) / BITS_PER_UNIT ; else align = size ; cum -> nbytes = ( cum -> nbytes + align - 1 ) & ~ ( align - 1 ) ; if ( cum -> nbytes > 4 * UNITS_PER_WORD ) return 0 ; if ( cum -> nbytes + size <= 4 * UNITS_PER_WORD ) return 0 ; if ( arg . type == NULL_TREE && cum -> nbytes + size > 4 * UNITS_PER_WORD ) return 0 ; return 4 * UNITS_PER_WORD - cum -> nbytes ; } </s>

Return the number of bytes which must be put into registers for values which are part in registers and part in memory .


<s> const CallLowering * AArch64Subtarget :: getCallLowering ( ) const { return CallLoweringInfo . get ( ) ; } </s>


<s> static void def_or_undef_macro ( cpp_reader * pfile , const char * name , bool def_p ) { if ( def_p ) cpp_define ( pfile , name ) ; else cpp_undef ( pfile , name ) ; } </s>

Define or undefine macros based on the current target . If the user does # pragma GCC target , we need to adjust the macros dynamically .


<s> bool HexagonInstrInfo :: hasStoreToStackSlot ( const MachineInstr & MI , const MachineMemOperand * & MMO , int & FrameIndex ) const { if ( MI . isBundle ( ) ) { const MachineBasicBlock * MBB = MI . getParent ( ) ; MachineBasicBlock :: const_instr_iterator MII = MI . getIterator ( ) ; for ( ++ MII ; MII != MBB -> instr_end ( ) && MII -> isInsideBundle ( ) ; ++ MII ) if ( TargetInstrInfo :: hasStoreToStackSlot ( * MII , MMO , FrameIndex ) ) return true ; return false ; } return TargetInstrInfo :: hasStoreToStackSlot ( MI , MMO , FrameIndex ) ; } </s>

If the specified machine instruction has a store to a stack slot , return true along with the FrameIndices of the loaded stack slot and the machine mem operands containing the reference .


"%qE attribute only applies to functions"

"%qs and %qs attributes are not compatible"

Handle a `` ms_abi '' or `` sysv '' attribute ; arguments as in struct attribute_spec.handler .


<s> void mips_expand_vec_cond_expr ( machine_mode mode , machine_mode vimode , rtx * operands ) { rtx cond = operands [ 3 ] ; rtx cmp_op0 = operands [ 4 ] ; rtx cmp_op1 = operands [ 5 ] ; rtx cmp_res = gen_reg_rtx ( vimode ) ; mips_expand_msa_cmp ( cmp_res , GET_CODE ( cond ) , cmp_op0 , cmp_op1 ) ; if ( operands [ 1 ] == CONSTM1_RTX ( vimode ) && operands [ 2 ] == CONST0_RTX ( vimode ) ) emit_move_insn ( operands [ 0 ] , cmp_res ) ; else { rtx src1 = gen_reg_rtx ( vimode ) ; rtx src2 = gen_reg_rtx ( vimode ) ; rtx mask = gen_reg_rtx ( vimode ) ; rtx bsel ; emit_move_insn ( mask , cmp_res ) ; if ( register_operand ( operands [ 1 ] , mode ) ) { rtx xop1 = operands [ 1 ] ; if ( mode != vimode ) { xop1 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop1 , gen_lowpart ( vimode , operands [ 1 ] ) ) ; } emit_move_insn ( src1 , xop1 ) ; } else { gcc_assert ( operands [ 1 ] == CONSTM1_RTX ( vimode ) ) ; emit_move_insn ( src1 , mask ) ; } if ( register_operand ( operands [ 2 ] , mode ) ) { rtx xop2 = operands [ 2 ] ; if ( mode != vimode ) { xop2 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop2 , gen_lowpart ( vimode , operands [ 2 ] ) ) ; } emit_move_insn ( src2 , xop2 ) ; } else { gcc_assert ( operands [ 2 ] == CONST0_RTX ( mode ) ) ; emit_move_insn ( src2 , mask ) ; } bsel = gen_rtx_IOR ( vimode , gen_rtx_AND ( vimode , gen_rtx_NOT ( vimode , mask ) , src2 ) , gen_rtx_AND ( vimode , mask , src1 ) ) ; emit_insn ( gen_rtx_SET ( mask , bsel ) ) ; emit_move_insn ( operands [ 0 ] , gen_rtx_SUBREG ( mode , mask , 0 ) ) ; } } </s>

Expand VEC_COND_EXPR , where : MODE is mode of the result VIMODE equivalent integer mode OPERANDS operands of VEC_COND_EXPR .


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

Return true if the target supports swifterror attribute .


<s> static void ix86_live_on_entry ( bitmap regs ) { if ( cfun -> machine -> split_stack_varargs_pointer != NULL_RTX ) { gcc_assert ( flag_split_stack ) ; bitmap_set_bit ( regs , split_stack_prologue_scratch_regno ( ) ) ; } } </s>

We may have to tell the dataflow pass that the split stack prologue is initializing a scratch register .


Return the string to output a compare and branch instruction to DEST . DEST is the destination insn ( i.e . the label ) , INSN is the source , and OP is the conditional expression .


<s> static int tilegx_sched_adjust_cost ( rtx_insn * insn , int dep_type , rtx_insn * dep_insn , int cost , unsigned int ) { if ( CALL_P ( insn ) && dep_type == REG_DEP_TRUE ) { rtx target = get_jump_target ( insn ) ; if ( ! REG_P ( target ) || ! set_of ( target , dep_insn ) ) return 0 ; } return cost ; } </s>


<s> static PatmosOperand * CreateMem ( unsigned Base , const MCExpr * Off , SMLoc S , SMLoc E ) { PatmosOperand * Op = new PatmosOperand ( Memory ) ; Op -> Mem . Base = Base ; Op -> Mem . Off = Off ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>


<s> FunctionCallee AMDGPULibCalls :: getFunction ( Module * M , const FuncInfo & fInfo ) { return EnablePreLink ? AMDGPULibFunc :: getOrInsertFunction ( M , fInfo ) : AMDGPULibFunc :: getFunction ( M , fInfo ) ; } </s>

getFunction - Return this trace 's parent function .


<s> void BTFDebug :: endModule ( ) { processGlobals ( ) ; for ( const auto & TypeEntry : TypeEntries ) TypeEntry -> completeType ( * this ) ; emitBTFSection ( ) ; emitBTFExtSection ( ) ; } </s>

Emit all exception information that should come after the content .


<s> bool SIInstrInfo :: usesConstantBus ( const MachineRegisterInfo & MRI , const MachineOperand & MO , const MCOperandInfo & OpInfo ) const { if ( MO . isImm ( ) ) return ! isInlineConstant ( MO , OpInfo ) ; if ( ! MO . isReg ( ) ) return true ; if ( ! MO . isUse ( ) ) return false ; if ( TargetRegisterInfo :: isVirtualRegister ( MO . getReg ( ) ) ) return RI . isSGPRClass ( MRI . getRegClass ( MO . getReg ( ) ) ) ; if ( MO . getReg ( ) == AMDGPU :: SGPR_NULL ) return false ; if ( MO . isImplicit ( ) ) { return MO . getReg ( ) == AMDGPU :: M0 || MO . getReg ( ) == AMDGPU :: VCC || MO . getReg ( ) == AMDGPU :: VCC_LO ; } else { return AMDGPU :: SReg_32RegClass . contains ( MO . getReg ( ) ) || AMDGPU :: SReg_64RegClass . contains ( MO . getReg ( ) ) ; } } </s>

Returns true if this operand uses the constant bus .


<s> enum direction function_arg_padding ( machine_mode mode , const_tree type ) { if ( ! AGGREGATE_PADDING_FIXED ) { if ( BYTES_BIG_ENDIAN ) { HOST_WIDE_INT size = 0 ; if ( mode == BLKmode ) { if ( type && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST ) size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ; if ( size == 1 || size == 2 || size == 4 ) return downward ; } return upward ; } if ( AGGREGATES_PAD_UPWARD_ALWAYS ) { if ( type != 0 && AGGREGATE_TYPE_P ( type ) ) return upward ; } return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) ; } </s>

Handle the FUNCTION_ARG_PADDING macro . For the 64 bit ABI structs are always stored left shifted in their argument slot .


<s> bool M68kDAGToDAGISel :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & MF . getSubtarget < M68kSubtarget > ( ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool SILowerControlFlowPass :: runOnMachineFunction ( MachineFunction & MF ) { TII = static_cast < const SIInstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; TRI = static_cast < const SIRegisterInfo * > ( MF . getSubtarget ( ) . getRegisterInfo ( ) ) ; SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; bool HaveKill = false ; bool NeedM0 = false ; bool NeedWQM = false ; unsigned Depth = 0 ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { MachineBasicBlock & MBB = * BI ; MachineBasicBlock :: iterator I , Next ; for ( I = MBB . begin ( ) ; I != MBB . end ( ) ; I = Next ) { Next = std :: next ( I ) ; MachineInstr & MI = * I ; if ( TII -> isDS ( MI . getOpcode ( ) ) ) { NeedM0 = true ; NeedWQM = true ; } switch ( MI . getOpcode ( ) ) { default : break ; case AMDGPU :: SI_IF : ++ Depth ; If ( MI ) ; break ; case AMDGPU :: SI_ELSE : Else ( MI ) ; break ; case AMDGPU :: SI_BREAK : Break ( MI ) ; break ; case AMDGPU :: SI_IF_BREAK : IfBreak ( MI ) ; break ; case AMDGPU :: SI_ELSE_BREAK : ElseBreak ( MI ) ; break ; case AMDGPU :: SI_LOOP : ++ Depth ; Loop ( MI ) ; break ; case AMDGPU :: SI_END_CF : if ( -- Depth == 0 && HaveKill ) { SkipIfDead ( MI ) ; HaveKill = false ; } EndCf ( MI ) ; break ; case AMDGPU :: SI_KILL : if ( Depth == 0 ) SkipIfDead ( MI ) ; else HaveKill = true ; Kill ( MI ) ; break ; case AMDGPU :: S_BRANCH : Branch ( MI ) ; break ; case AMDGPU :: SI_INDIRECT_SRC : IndirectSrc ( MI ) ; break ; case AMDGPU :: SI_INDIRECT_DST_V1 : case AMDGPU :: SI_INDIRECT_DST_V2 : case AMDGPU :: SI_INDIRECT_DST_V4 : case AMDGPU :: SI_INDIRECT_DST_V8 : case AMDGPU :: SI_INDIRECT_DST_V16 : IndirectDst ( MI ) ; break ; case AMDGPU :: V_INTERP_P1_F32 : case AMDGPU :: V_INTERP_P2_F32 : case AMDGPU :: V_INTERP_MOV_F32 : NeedWQM = true ; break ; } } } if ( NeedM0 ) { MachineBasicBlock & MBB = MF . front ( ) ; InitM0ForLDS ( MBB . getFirstNonPHI ( ) ) ; } if ( NeedWQM && MFI -> getShaderType ( ) == ShaderType :: PIXEL ) { MachineBasicBlock & MBB = MF . front ( ) ; BuildMI ( MBB , MBB . getFirstNonPHI ( ) , DebugLoc ( ) , TII -> get ( AMDGPU :: S_WQM_B64 ) , AMDGPU :: EXEC ) . addReg ( AMDGPU :: EXEC ) ; } return true ; } </s>

R600 SI SI SI SI SI 0 SI SI SI SI SI SI SI 0 SI 0 SI SI SI SI SI SI


<s> void handle_arm_acle_h ( void ) { if ( TARGET_LS64 ) aarch64_init_ls64_builtins ( ) ; } </s>

Implement # pragma GCC aarch64 `` arm_acle.h '' .


"FixAllFDIVSQRT: Erratum Fix LBR34: fix FDIVS/FDIVD/FSQRTS/FSQRTD "

"instructions with NOPs and floating-point store"

getPassName - Return a nice clean name for a pass .


<s> static rtx gen_save_register_window ( rtx increment ) { if ( TARGET_ARCH64 ) return gen_save_register_windowdi ( increment ) ; else return gen_save_register_windowsi ( increment ) ; } </s>


<s> const MCRegisterInfo * getRegInfo ( ) const { return RegInfo ; } </s>

getRegInfo - Return information about the registers currently in use .


<s> void R600TargetLowering :: ReplaceNodeResults ( SDNode * N , SmallVectorImpl < SDValue > & Results , SelectionDAG & DAG ) const { switch ( N -> getOpcode ( ) ) { default : return ; case ISD :: FP_TO_UINT : Results . push_back ( LowerFPTOUINT ( N -> getOperand ( 0 ) , DAG ) ) ; } } </s>

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


<s> int arm_no_early_mul_dep ( rtx producer , rtx consumer ) { rtx value , op ; if ( ! arm_get_set_operands ( producer , consumer , & value , & op ) ) return 0 ; if ( GET_CODE ( op ) == PLUS || GET_CODE ( op ) == MINUS ) { if ( GET_CODE ( XEXP ( op , 0 ) ) == MULT ) return ! reg_overlap_mentioned_p ( value , XEXP ( op , 0 ) ) ; else return ! reg_overlap_mentioned_p ( value , XEXP ( op , 1 ) ) ; } return 0 ; } </s>

Return nonzero if the CONSUMER ( a mul or mac op ) does not have an early register mult dependency on the result of PRODUCER .


<s> static bool rs6000_secondary_reload_direct_move ( enum rs6000_reg_type to_type , enum rs6000_reg_type from_type , machine_mode mode , secondary_reload_info * sri , bool altivec_p ) { bool ret = false ; enum insn_code icode = CODE_FOR_nothing ; int cost = 0 ; int size = GET_MODE_SIZE ( mode ) ; if ( TARGET_POWERPC64 && size == 16 ) { if ( to_type == VSX_REG_TYPE && from_type == GPR_REG_TYPE ) { cost = 3 ; icode = reg_addr [ mode ] . reload_vsx_gpr ; } else if ( to_type == GPR_REG_TYPE && from_type == VSX_REG_TYPE ) { cost = 3 ; icode = reg_addr [ mode ] . reload_gpr_vsx ; } } else if ( TARGET_POWERPC64 && mode == SFmode ) { if ( to_type == GPR_REG_TYPE && from_type == VSX_REG_TYPE ) { cost = 3 ; icode = reg_addr [ mode ] . reload_gpr_vsx ; } else if ( to_type == VSX_REG_TYPE && from_type == GPR_REG_TYPE ) { cost = 2 ; icode = reg_addr [ mode ] . reload_vsx_gpr ; } } else if ( ! TARGET_POWERPC64 && size == 8 ) { if ( to_type == VSX_REG_TYPE && from_type == GPR_REG_TYPE && ! altivec_p ) { cost = 3 ; icode = reg_addr [ mode ] . reload_fpr_gpr ; } } if ( icode != CODE_FOR_nothing ) { ret = true ; if ( sri ) { sri -> icode = icode ; sri -> extra_cost = cost ; } } return ret ; } </s>

Power8 helper function for rs6000_secondary_reload , handle all of the special direct moves that involve allocating an extra register , return the insn code of the helper function if there is such a function or CODE_FOR_nothing if not .


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


<s>
bool
Z80InstrInfo
::
expandPostRAPseudo
(
MachineInstr
&
MI
)
const
{
MachineBasicBlock
&
MBB
=
*
MI
.
getParent
(
)
;
MachineFunction
*
MF
=
MBB
.
getParent
(
)
;
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
const
DebugLoc
&
DL
=
MI
.
getDebugLoc
(
)
;
auto
Opcode
=
MI
.
getOpcode
(
)
;
switch
(
Opcode
)
{
case
Z80
::
ZEXTLOAD_I8
:
case
Z80
::
SEXTLOAD_I8
:
{
auto
DestReg
=
MI
.
getOperand
(
0
)
.
getReg
(
)
;
auto
AddrImm
=
MI
.
getOperand
(
1
)
;
assert
(
Z80
::
GR16RegClass
.
contains
(
DestReg
)
&&
"Dest is a GR16"
)
;
auto
DestLow
=
getPairLow
(
DestReg
)
;
auto
DestHigh
=
getPairHigh
(
DestReg
)
;
if
(
DestReg
!=
Z80
::
HL
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
PUSHRP
)
)
.
addReg
(
Z80
::
HL
)
;
}
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
LD16ri
)
,
Z80
::
HL
)
.
add
(
AddrImm
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
LDrHL
)
,
DestLow
)
.
addReg
(
Z80
::
HL
)
;
if
(
DestReg
!=
Z80
::
HL
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
POPRP
)
,
Z80
::
HL
)
;
}
if
(
Opcode
==
Z80
::
SEXTLOAD_I8
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
LD8rr
)
,
Z80
::
ACC
)
.
addReg
(
DestLow
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
ADD_A_r
)
,
Z80
::
ACC
)
.
addReg
(
Z80
::
ACC
)
.
addReg
(
Z80
::
ACC
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
SBC_A_r
)
,
Z80
::
ACC
)
.
addReg
(
Z80
::
ACC
)
.
addReg
(
Z80
::
ACC
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
LD8rr
)
,
DestHigh
)
.
addReg
(
Z80
::
ACC
)
;
}
else
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Z80
::
LD8ri
)
,
DestHigh
)
.
addImm
(
0
)
;
}
MI
.
eraseFromParent
(
)
;
return
true
;
}
default
:
break
;
}
llvm_unreachable
(
"DIE"
)
;
return
false
;
}
</s>

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


<s> static void core2i7_first_cycle_multipass_init ( void * _data ) { ix86_first_cycle_multipass_data_t data = ( ix86_first_cycle_multipass_data_t ) _data ; data -> ifetch_block_len = 0 ; data -> ifetch_block_n_insns = 0 ; data -> ready_try_change = NULL ; data -> ready_try_change_size = 0 ; } </s>


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

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

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


Return a register priority for hard reg REGNO .


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

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


<s> static int ix86_adjust_priority ( rtx_insn * insn , int priority ) { rtx set ; if ( reload_completed ) return priority ; if ( ! NONDEBUG_INSN_P ( insn ) ) return priority ; set = single_set ( insn ) ; if ( set ) { rtx tmp = SET_SRC ( set ) ; if ( REG_P ( tmp ) && HARD_REGISTER_P ( tmp ) && ! TEST_HARD_REG_BIT ( fixed_reg_set , REGNO ( tmp ) ) && ix86_class_likely_spilled_p ( REGNO_REG_CLASS ( REGNO ( tmp ) ) ) ) return current_sched_info -> sched_max_insns_priority ; } return priority ; } </s>

Hook for pre-reload schedule - set priority of moves from likely spilled HW registers to maximum , to schedule them at soon as possible . These are moves from function argument registers at the top of the function entry and moves from function return value registers after call .


"Blocked load and store instructions: \n"


<s> BitVector Z80RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( Z80 :: PC ) ; Reserved . set ( Z80 :: SP ) ; Reserved . set ( Z80 :: FLAGS ) ; Reserved . set ( getFrameRegister ( MF ) ) ; return Reserved ; } </s>

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


<s> static bool fr30_must_pass_in_stack ( machine_mode mode , const_tree type ) { if ( mode == BLKmode ) return true ; if ( type == NULL ) return false ; return AGGREGATE_TYPE_P ( type ) ; } </s>

Return true if we should pass an argument on the stack rather than in registers .


<s> static bool riscv_save_reg_p ( unsigned int regno ) { bool call_saved = ! global_regs [ regno ] && ! call_used_or_fixed_reg_p ( regno ) ; bool might_clobber = crtl -> saves_all_registers || df_regs_ever_live_p ( regno ) ; if ( call_saved && might_clobber ) return true ; if ( regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed ) return true ; if ( regno == RETURN_ADDR_REGNUM && crtl -> calls_eh_return ) return true ; if ( cfun -> machine -> interrupt_handler_p ) { if ( regno == GP_REG_FIRST ) return false ; if ( regno == STACK_POINTER_REGNUM ) return false ; if ( regno == GP_REGNUM || regno == THREAD_POINTER_REGNUM ) return false ; if ( df_regs_ever_live_p ( regno ) || ( ! crtl -> is_leaf && call_used_or_fixed_reg_p ( regno ) ) ) return true ; } return false ; } </s>

Return true if the current function must save register REGNO .


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

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


<s>
void
WebAssemblyPassConfig
::
addFastRegAlloc
(
FunctionPass
*
RegAllocPass
)
{
assert
(
!
RegAllocPass
&&
"WebAssembly uses no regalloc!"
)
;
addRegAllocPasses
(
false
)
;
}
</s>

addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast register allocation .

WebAssembly
WebAssembly
"WebAssembly uses no regalloc!"


<s> static void ix86_emit_save_sse_regs_using_mov ( HOST_WIDE_INT cfa_offset ) { unsigned int regno ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true ) ) { ix86_emit_save_reg_using_mov ( V4SFmode , regno , cfa_offset ) ; cfa_offset -= 16 ; } } </s>

Emit code to save SSE registers using MOV insns . First register is stored at CFA - CFA_OFFSET .


<s> const BPFSubtarget * getSubtargetImpl ( const Function & ) const override { return & Subtarget ; } </s>

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


<s> SDValue AArch64TargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { default : break ; case ISD :: AND : return PerformANDCombine ( N , DCI ) ; case ISD :: OR : return PerformORCombine ( N , DCI , getSubtarget ( ) ) ; case ISD :: SRA : return PerformSRACombine ( N , DCI ) ; } return SDValue ( ) ; } </s>

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


<s> static bool riscv_use_save_libcall ( const struct riscv_frame_info * frame ) { if ( ! TARGET_SAVE_RESTORE || crtl -> calls_eh_return || frame_pointer_needed ) return false ; return frame -> save_libcall_adjustment != 0 ; } </s>

Determine whether to call GPR save/restore routines .


<s> void print_operand ( FILE * file , rtx op , int letter ) { if ( letter == '.' ) { if ( MOTOROLA ) fprintf ( file , "." ) ; } else if ( letter == '#' ) asm_fprintf ( file , "%I" ) ; else if ( letter == '-' ) asm_fprintf ( file , MOTOROLA ? "-(%Rsp)" : "%Rsp@-" ) ; else if ( letter == '+' ) asm_fprintf ( file , MOTOROLA ? "(%Rsp)+" : "%Rsp@+" ) ; else if ( letter == '@' ) asm_fprintf ( file , MOTOROLA ? "(%Rsp)" : "%Rsp@" ) ; else if ( letter == '!' ) asm_fprintf ( file , "%Rfpcr" ) ; else if ( letter == '$' ) { if ( TARGET_68040_ONLY ) fprintf ( file , "s" ) ; } else if ( letter == '&' ) { if ( TARGET_68040_ONLY ) fprintf ( file , "d" ) ; } else if ( letter == '/' ) asm_fprintf ( file , "%R" ) ; else if ( letter == 'o' ) { gcc_assert ( GET_CODE ( op ) == MEM && GET_CODE ( XEXP ( op , 0 ) ) == SYMBOL_REF && TARGET_PCREL ) ; output_addr_const ( file , XEXP ( op , 0 ) ) ; } else if ( GET_CODE ( op ) == REG ) { if ( letter == 'R' ) fputs ( M68K_REGNAME ( REGNO ( op ) + 1 ) , file ) ; else fputs ( M68K_REGNAME ( REGNO ( op ) ) , file ) ; } else if ( GET_CODE ( op ) == MEM ) { output_address ( XEXP ( op , 0 ) ) ; if ( letter == 'd' && ! TARGET_68020 && CONSTANT_ADDRESS_P ( XEXP ( op , 0 ) ) && ! ( GET_CODE ( XEXP ( op , 0 ) ) == CONST_INT && INTVAL ( XEXP ( op , 0 ) ) < 0x8000 && INTVAL ( XEXP ( op , 0 ) ) >= - 0x8000 ) ) fprintf ( file , MOTOROLA ? ".l" : ":l" ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == SFmode ) { REAL_VALUE_TYPE r ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; ASM_OUTPUT_FLOAT_OPERAND ( letter , file , r ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == XFmode ) { REAL_VALUE_TYPE r ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; ASM_OUTPUT_LONG_DOUBLE_OPERAND ( file , r ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == DFmode ) { REAL_VALUE_TYPE r ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; ASM_OUTPUT_DOUBLE_OPERAND ( file , r ) ; } else { asm_fprintf ( file , "%I" ) ; if ( TARGET_PCREL && ( GET_CODE ( op ) == SYMBOL_REF || GET_CODE ( op ) == CONST ) ) print_operand_address ( file , op ) ; else output_addr_const ( file , op ) ; } } </s>

Use S for SI regsUse B & T for parts of DI regs X - stack pointer name Registers Q - byte sized register name U - high byte of word register V - low byte of word register H - word register name I - next word register name S & B - long register name T - next long register name D - quad register name P - register name in size of pointer Integers O - log two of value P - inverted log two H - bottom 16 bits I - top 16 bits N - negative B - high 32 bits of 32bit number . default : value Memory I - adjusted upwards by two T - adjusted upwards by four default : value Address H - low 16 bits I - high 16 bits A - as long constant S - as A but with # default : error Misc C - conditional name D - reverse conditional name F - clear v flag if necessary


<s> unsigned MipsTargetLowering :: getJumpTableEncoding ( ) const { if ( ABI . IsN64 ( ) ) return MachineJumpTableInfo :: EK_GPRel64BlockAddress ; return TargetLowering :: getJumpTableEncoding ( ) ; } </s>

Return the entry encoding for a jump table in the current function .


<s> static struct machine_function * nvptx_init_machine_status ( void ) { struct machine_function * p = ggc_cleared_alloc < machine_function > ( ) ; p -> return_mode = VOIDmode ; return p ; } </s>

Allocate a new , cleared machine_function structure .


"Expected last operand to be the scratch reg."

"Reg alloc should have already happened."

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
LanaiDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
DEBUG
(
errs
(
)
<<
"Selecting: "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
if
(
Node
->
isMachineOpcode
(
)
)
{
DEBUG
(
errs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
return
;
}
EVT
VT
=
Node
->
getValueType
(
0
)
;
switch
(
Opcode
)
{
case
ISD
::
Constant
:
if
(
VT
==
MVT
::
i32
)
{
ConstantSDNode
*
ConstNode
=
cast
<
ConstantSDNode
>
(
Node
)
;
if
(
ConstNode
->
isNullValue
(
)
)
{
SDValue
New
=
CurDAG
->
getCopyFromReg
(
CurDAG
->
getEntryNode
(
)
,
SDLoc
(
Node
)
,
Lanai
::
R0
,
MVT
::
i32
)
;
return
ReplaceNode
(
Node
,
New
.
getNode
(
)
)
;
}
if
(
ConstNode
->
isAllOnesValue
(
)
)
{
SDValue
New
=
CurDAG
->
getCopyFromReg
(
CurDAG
->
getEntryNode
(
)
,
SDLoc
(
Node
)
,
Lanai
::
R1
,
MVT
::
i32
)
;
return
ReplaceNode
(
Node
,
New
.
getNode
(
)
)
;
}
}
break
;
case
ISD
::
FrameIndex
:
selectFrameIndex
(
Node
)
;
return
;
default
:
break
;
}
SelectCode
(
Node
)
;
}
</s>

Main hook for targets to transform nodes into machine nodes .


<s> static void c6x_reorg ( void ) { basic_block bb ; bool do_selsched = ( c6x_flag_schedule_insns2 && flag_selective_scheduling2 && ! maybe_skip_selective_scheduling ( ) ) ; compute_bb_for_insn ( ) ; df_clear_flags ( DF_LR_RUN_DCE ) ; df_note_add_problem ( ) ; if ( optimize == 0 ) split_all_insns ( ) ; df_analyze ( ) ; if ( c6x_flag_schedule_insns2 ) { int sz = get_max_uid ( ) * 3 / 2 + 1 ; insn_info . create ( sz ) ; } sched_no_dce = true ; c6x_hwloops ( ) ; if ( c6x_flag_schedule_insns2 ) { split_delayed_insns ( ) ; timevar_push ( TV_SCHED2 ) ; if ( do_selsched ) run_selective_scheduling ( ) ; else schedule_ebbs ( ) ; conditionalize_after_sched ( ) ; timevar_pop ( TV_SCHED2 ) ; free_delay_pairs ( ) ; } sched_no_dce = false ; rtx_insn * * call_labels = XCNEWVEC ( rtx_insn * , get_max_uid ( ) + 1 ) ; reorg_split_calls ( call_labels ) ; if ( c6x_flag_schedule_insns2 ) { FOR_EACH_BB_FN ( bb , cfun ) if ( ( bb -> flags & BB_DISABLE_SCHEDULE ) == 0 ) assign_reservations ( BB_HEAD ( bb ) , BB_END ( bb ) ) ; } if ( c6x_flag_var_tracking ) { timevar_push ( TV_VAR_TRACKING ) ; variable_tracking_main ( ) ; timevar_pop ( TV_VAR_TRACKING ) ; } reorg_emit_nops ( call_labels ) ; if ( c6x_flag_schedule_insns2 ) { free_delay_pairs ( ) ; c6x_gen_bundles ( ) ; } df_finish_pass ( false ) ; } </s>

Implement the TARGET_MACHINE_DEPENDENT_REORG pass . We split call insns here into a sequence that loads the return register and performs the call , and emit the return label . If scheduling after reload is requested , it happens here .


<s>
void
pa_asm_output_aligned_bss
(
FILE
*
stream
,
const
char
*
name
,
unsigned
HOST_WIDE_INT
size
,
unsigned
int
align
)
{
switch_to_section
(
bss_section
)
;
ASM_OUTPUT_TYPE_DIRECTIVE
(
stream
,
name
,
"object"
)
;
ASM_OUTPUT_SIZE_DIRECTIVE
(
stream
,
name
,
size
)
;
fprintf
(
stream
,
"\t.align %u\n"
,
align
/
BITS_PER_UNIT
)
;
ASM_OUTPUT_LABEL
(
stream
,
name
)
;
fprintf
(
stream
,
"\t.block "
HOST_WIDE_INT_PRINT_UNSIGNED
"\n"
,
size
)
;
}
</s>

This function places uninitialized global data in the bss section . The ASM_OUTPUT_ALIGNED_BSS macro needs to be defined to call this function on the SOM port to prevent uninitialized global data from being placed in the data section .

pa
"object"
"\t.align %u\n"
"\t.block "
"\n"


<s> bool tilepro_legitimate_pic_operand_p ( rtx x ) { if ( tilepro_pic_address_needs_scratch ( x ) ) return false ; if ( tilepro_tls_referenced_p ( x ) ) return false ; return true ; } </s>

Return true if the constant value X is a legitimate general operand when generating PIC code . It is given that flag_pic is on and that X satisfies CONSTANT_P .


<s> enum aarch64_symbol_type aarch64_classify_symbol ( rtx x , HOST_WIDE_INT offset ) { x = strip_salt ( x ) ; if ( LABEL_REF_P ( x ) ) { switch ( aarch64_cmodel ) { case AARCH64_CMODEL_LARGE : return SYMBOL_FORCE_TO_MEM ; case AARCH64_CMODEL_TINY_PIC : case AARCH64_CMODEL_TINY : return SYMBOL_TINY_ABSOLUTE ; case AARCH64_CMODEL_SMALL_SPIC : case AARCH64_CMODEL_SMALL_PIC : case AARCH64_CMODEL_SMALL : return SYMBOL_SMALL_ABSOLUTE ; default : gcc_unreachable ( ) ; } } if ( SYMBOL_REF_P ( x ) ) { if ( aarch64_tls_symbol_p ( x ) ) return aarch64_classify_tls_symbol ( x ) ; switch ( aarch64_cmodel ) { case AARCH64_CMODEL_TINY : if ( SYMBOL_REF_WEAK ( x ) && ! aarch64_symbol_binds_local_p ( x ) ) return SYMBOL_FORCE_TO_MEM ; if ( ! ( IN_RANGE ( offset , - 0x10000 , 0x10000 ) || offset_within_block_p ( x , offset ) ) ) return SYMBOL_FORCE_TO_MEM ; return SYMBOL_TINY_ABSOLUTE ; case AARCH64_CMODEL_SMALL : if ( SYMBOL_REF_WEAK ( x ) && ! aarch64_symbol_binds_local_p ( x ) ) return SYMBOL_FORCE_TO_MEM ; if ( ! ( IN_RANGE ( offset , - 0x100000 , 0x100000 ) || offset_within_block_p ( x , offset ) ) ) return SYMBOL_FORCE_TO_MEM ; return SYMBOL_SMALL_ABSOLUTE ; case AARCH64_CMODEL_TINY_PIC : if ( ! aarch64_symbol_binds_local_p ( x ) ) return SYMBOL_TINY_GOT ; return SYMBOL_TINY_ABSOLUTE ; case AARCH64_CMODEL_SMALL_SPIC : case AARCH64_CMODEL_SMALL_PIC : if ( ! aarch64_symbol_binds_local_p ( x ) ) return ( aarch64_cmodel == AARCH64_CMODEL_SMALL_SPIC ? SYMBOL_SMALL_GOT_28K : SYMBOL_SMALL_GOT_4G ) ; return SYMBOL_SMALL_ABSOLUTE ; case AARCH64_CMODEL_LARGE : if ( ! aarch64_pcrelative_literal_loads && CONSTANT_POOL_ADDRESS_P ( x ) ) return SYMBOL_SMALL_ABSOLUTE ; else return SYMBOL_FORCE_TO_MEM ; default : gcc_unreachable ( ) ; } } return SYMBOL_FORCE_TO_MEM ; } </s>

Return the method that should be used to access SYMBOL_REF or LABEL_REF X .


<s>
void
NVPTXPassConfig
::
addFastRegAlloc
(
FunctionPass
*
RegAllocPass
)
{
assert
(
!
RegAllocPass
&&
"NVPTX uses no regalloc!"
)
;
addPass
(
&
PHIEliminationID
)
;
addPass
(
&
TwoAddressInstructionPassID
)
;
}
</s>


<s> void riscv_move_integer ( rtx temp , rtx dest , HOST_WIDE_INT value , machine_mode orig_mode , bool in_splitter ) { struct riscv_integer_op codes [ RISCV_MAX_INTEGER_OPS ] ; machine_mode mode ; int i , num_ops ; rtx x ; bool can_create_pseudo = can_create_pseudo_p ( ) && ! in_splitter ; mode = GET_MODE ( dest ) ; num_ops = riscv_build_integer ( codes , value , orig_mode ) ; if ( can_create_pseudo && num_ops > 2 && num_ops >= riscv_split_integer_cost ( value ) ) x = riscv_split_integer ( value , mode ) ; else { codes [ 0 ] . value = trunc_int_for_mode ( codes [ 0 ] . value , mode ) ; x = GEN_INT ( codes [ 0 ] . value ) ; for ( i = 1 ; i < num_ops ; i ++ ) { if ( ! can_create_pseudo ) x = riscv_emit_set ( temp , x ) ; else x = force_reg ( mode , x ) ; codes [ i ] . value = trunc_int_for_mode ( codes [ i ] . value , mode ) ; x = gen_rtx_fmt_ee ( codes [ i ] . code , mode , x , GEN_INT ( codes [ i ] . value ) ) ; } } riscv_emit_set ( dest , x ) ; } </s>

Load VALUE into DEST . TEMP is as for riscv_force_temporary .


<s> bool sh_small_register_classes_for_mode_p ( machine_mode mode ATTRIBUTE_UNUSED ) { return true ; } </s>

Return true if registers in machine mode MODE will likely be allocated to registers in small register classes .


<s> static bool mips_return_in_memory ( const_tree type , const_tree fndecl ATTRIBUTE_UNUSED ) { if ( TARGET_OLDABI ) return ( VECTOR_FLOAT_TYPE_P ( type ) || TYPE_MODE ( type ) == BLKmode ) ; return ( ! IN_RANGE ( int_size_in_bytes ( type ) , 0 , 2 * UNITS_PER_WORD ) ) ; } </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 GCNTTIImpl :: isSourceOfDivergence ( const Value * V ) const { if ( const Argument * A = dyn_cast < Argument > ( V ) ) return ! isArgPassedInSGPR ( A ) ; if ( const LoadInst * Load = dyn_cast < LoadInst > ( V ) ) return Load -> getPointerAddressSpace ( ) == AMDGPUAS :: PRIVATE_ADDRESS || Load -> getPointerAddressSpace ( ) == AMDGPUAS :: FLAT_ADDRESS ; if ( isa < AtomicRMWInst > ( V ) || isa < AtomicCmpXchgInst > ( V ) ) return true ; if ( const IntrinsicInst * Intrinsic = dyn_cast < IntrinsicInst > ( V ) ) return AMDGPU :: isIntrinsicSourceOfDivergence ( Intrinsic -> getIntrinsicID ( ) ) ; if ( isa < CallInst > ( V ) || isa < InvokeInst > ( V ) ) return true ; return false ; } </s>

Returns whether V is a source of divergence .

AMDGPU AMDGPU AMDGPU AMDGPU::isIntrinsicSourceOfDivergence


<s> void PPCRegisterInfo :: lowerCRSpilling ( MachineBasicBlock :: iterator II , unsigned FrameIndex ) const { MachineInstr & MI = * II ; MachineBasicBlock & MBB = * MI . getParent ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; DebugLoc dl = MI . getDebugLoc ( ) ; bool LP64 = Subtarget . isPPC64 ( ) ; const TargetRegisterClass * G8RC = & PPC :: G8RCRegClass ; const TargetRegisterClass * GPRC = & PPC :: GPRCRegClass ; unsigned Reg = MF . getRegInfo ( ) . createVirtualRegister ( LP64 ? G8RC : GPRC ) ; unsigned SrcReg = MI . getOperand ( 0 ) . getReg ( ) ; BuildMI ( MBB , II , dl , TII . get ( LP64 ? PPC :: MFOCRF8 : PPC :: MFOCRF ) , Reg ) . addReg ( SrcReg , getKillRegState ( MI . getOperand ( 0 ) . isKill ( ) ) ) ; if ( SrcReg != PPC :: CR0 ) { unsigned Reg1 = Reg ; Reg = MF . getRegInfo ( ) . createVirtualRegister ( LP64 ? G8RC : GPRC ) ; BuildMI ( MBB , II , dl , TII . get ( LP64 ? PPC :: RLWINM8 : PPC :: RLWINM ) , Reg ) . addReg ( Reg1 , RegState :: Kill ) . addImm ( getEncodingValue ( SrcReg ) * 4 ) . addImm ( 0 ) . addImm ( 31 ) ; } addFrameReference ( BuildMI ( MBB , II , dl , TII . get ( LP64 ? PPC :: STW8 : PPC :: STW ) ) . addReg ( Reg , RegState :: Kill ) , FrameIndex ) ; MBB . erase ( II ) ; } </s>

lowerCRSpilling - Generate the code for spilling a CR register .


<s> bool SIInstrInfo :: canInsertSelect ( const MachineBasicBlock & MBB , ArrayRef < MachineOperand > Cond , unsigned DstReg , unsigned TrueReg , unsigned FalseReg , int & CondCycles , int & TrueCycles , int & FalseCycles ) const { switch ( Cond [ 0 ] . getImm ( ) ) { case VCCNZ : case VCCZ : { const MachineRegisterInfo & MRI = MBB . getParent ( ) -> getRegInfo ( ) ; const TargetRegisterClass * RC = MRI . getRegClass ( TrueReg ) ; assert ( MRI . getRegClass ( FalseReg ) == RC ) ; int NumInsts = AMDGPU :: getRegBitWidth ( RC -> getID ( ) ) / 32 ; CondCycles = TrueCycles = FalseCycles = NumInsts ; return RI . hasVGPRs ( RC ) && NumInsts <= 6 ; } case SCC_TRUE : case SCC_FALSE : { const MachineRegisterInfo & MRI = MBB . getParent ( ) -> getRegInfo ( ) ; const TargetRegisterClass * RC = MRI . getRegClass ( TrueReg ) ; assert ( MRI . getRegClass ( FalseReg ) == RC ) ; int NumInsts = AMDGPU :: getRegBitWidth ( RC -> getID ( ) ) / 32 ; if ( NumInsts % 2 == 0 ) NumInsts /= 2 ; CondCycles = TrueCycles = FalseCycles = NumInsts ; return RI . isSGPRClass ( RC ) ; } default : return false ; } } </s>

Return true if it is possible to insert a select instruction that chooses between TrueReg and FalseReg based on the condition code in Cond .


<s> bool MipsSEFrameLowering :: hasReservedCallFrame ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return isInt < 16 > ( MFI -> getMaxCallFrameSize ( ) + getStackAlignment ( ) ) && ! 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> unsigned HexagonMCInst :: getType ( ) const { const uint64_t F = getDesc ( ) . TSFlags ; return ( ( F >> HexagonII :: TypePos ) & HexagonII :: TypeMask ) ; } </s>

Overload to return most specific vector type .

Hexagon Hexagon HexagonII::TypePos HexagonII::TypeMask


<s> int pa_fmpyaddoperands ( rtx * operands ) { machine_mode mode = GET_MODE ( operands [ 0 ] ) ; if ( mode != SFmode && mode != DFmode ) return 0 ; if ( ! ( mode == GET_MODE ( operands [ 1 ] ) && mode == GET_MODE ( operands [ 2 ] ) && mode == GET_MODE ( operands [ 3 ] ) && mode == GET_MODE ( operands [ 4 ] ) && mode == GET_MODE ( operands [ 5 ] ) ) ) return 0 ; if ( ! ( GET_CODE ( operands [ 1 ] ) == REG && GET_CODE ( operands [ 2 ] ) == REG && GET_CODE ( operands [ 3 ] ) == REG && GET_CODE ( operands [ 4 ] ) == REG && GET_CODE ( operands [ 5 ] ) == REG ) ) return 0 ; if ( ! rtx_equal_p ( operands [ 3 ] , operands [ 4 ] ) && ! rtx_equal_p ( operands [ 3 ] , operands [ 5 ] ) ) return 0 ; if ( rtx_equal_p ( operands [ 3 ] , operands [ 0 ] ) || rtx_equal_p ( operands [ 3 ] , operands [ 1 ] ) || rtx_equal_p ( operands [ 3 ] , operands [ 2 ] ) ) return 0 ; if ( rtx_equal_p ( operands [ 4 ] , operands [ 0 ] ) || rtx_equal_p ( operands [ 5 ] , operands [ 0 ] ) ) return 0 ; if ( mode == SFmode && ( REGNO_REG_CLASS ( REGNO ( operands [ 0 ] ) ) != FPUPPER_REGS || REGNO_REG_CLASS ( REGNO ( operands [ 1 ] ) ) != FPUPPER_REGS || REGNO_REG_CLASS ( REGNO ( operands [ 2 ] ) ) != FPUPPER_REGS || REGNO_REG_CLASS ( REGNO ( operands [ 3 ] ) ) != FPUPPER_REGS || REGNO_REG_CLASS ( REGNO ( operands [ 4 ] ) ) != FPUPPER_REGS || REGNO_REG_CLASS ( REGNO ( operands [ 5 ] ) ) != FPUPPER_REGS ) ) return 0 ; return 1 ; } </s>

Returns 1 if the 6 operands specified in OPERANDS are suitable for use in fmpyadd instructions .


<s> static void aarch64_emit_store_exclusive ( machine_mode mode , rtx bval , rtx rval , rtx mem , rtx model_rtx ) { emit_insn ( gen_aarch64_store_exclusive ( mode , bval , rval , mem , model_rtx ) ) ; } </s>


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


<s> void sparc_profile_hook ( int labelno ) { char buf [ 32 ] ; rtx lab , fun ; ASM_GENERATE_INTERNAL_LABEL ( buf , "LP" , labelno ) ; lab = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( buf ) ) ; fun = gen_rtx_SYMBOL_REF ( Pmode , MCOUNT_FUNCTION ) ; emit_library_call ( fun , LCT_NORMAL , VOIDmode , 1 , lab , Pmode ) ; } </s>

Output rtl to increment the profiler label LABELNO for profiling a function entry .


<s>
static
void
s390_adjust_loops
(
)
{
df_analyze
(
)
;
compute_bb_for_insn
(
)
;
loop_optimizer_init
(
AVOID_CFG_MODIFICATIONS
)
;
for
(
auto
loop
:
loops_list
(
cfun
,
LI_ONLY_INNERMOST
)
)
{
if
(
dump_file
)
{
flow_loop_dump
(
loop
,
dump_file
,
,
0
)
;
fprintf
(
dump_file
,
";;  OSC loop scan Loop: "
)
;
}
if
(
loop
->
latch
==
||
pc_set
(
BB_END
(
loop
->
latch
)
)
==
NULL_RTX
||
!
s390_adjust_loop_scan_osc
(
loop
)
)
{
if
(
dump_file
)
{
if
(
loop
->
latch
==
)
fprintf
(
dump_file
,
" muliple backward jumps\n"
)
;
else
{
fprintf
(
dump_file
,
" header insn: %d latch insn: %d "
,
INSN_UID
(
BB_HEAD
(
loop
->
header
)
)
,
INSN_UID
(
BB_END
(
loop
->
latch
)
)
)
;
if
(
pc_set
(
BB_END
(
loop
->
latch
)
)
==
NULL_RTX
)
fprintf
(
dump_file
,
" loop does not end with jump\n"
)
;
else
fprintf
(
dump_file
,
" not instrumented\n"
)
;
}
}
}
else
{
rtx_insn
*
new_insn
;
if
(
dump_file
)
fprintf
(
dump_file
,
" adding OSC break insn: "
)
;
new_insn
=
emit_insn_before
(
gen_osc_break
(
)
,
BB_END
(
loop
->
latch
)
)
;
INSN_ADDRESSES_NEW
(
new_insn
,
1
)
;
}
}
loop_optimizer_finalize
(
)
;
df_finish_pass
(
false
)
;
}
</s>

Look for adjustments which can be done on simple innermost loops .

s390
0
";;  OSC loop scan Loop: "
" muliple backward jumps\n"
" header insn: %d latch insn: %d "
" loop does not end with jump\n"
" not instrumented\n"
" adding OSC break insn: "
1


<s> XCoreTargetMachine :: XCoreTargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) : LLVMTargetMachine ( T , TT , CPU , FS , Options , RM , CM , OL ) , TLOF ( make_unique < XCoreTargetObjectFile > ( ) ) , Subtarget ( TT , CPU , FS , * this ) { initAsmInfo ( ) ; } </s>


<s> void LanaiTargetLowering :: LowerAsmOperandForConstraint ( SDValue Op , std :: string & Constraint , std :: vector < SDValue > & Ops , SelectionDAG & DAG ) const { SDValue Result ( 0 , 0 ) ; if ( Constraint . length ( ) > 1 ) return ; char ConstraintLetter = Constraint [ 0 ] ; switch ( ConstraintLetter ) { case 'I' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( isInt < 16 > ( C -> getSExtValue ( ) ) ) { Result = DAG . getTargetConstant ( C -> getSExtValue ( ) , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'J' : case 'O' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( C -> getZExtValue ( ) == 0 ) { Result = DAG . getTargetConstant ( 0 , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'K' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( isUInt < 16 > ( C -> getZExtValue ( ) ) ) { Result = DAG . getTargetConstant ( C -> getSExtValue ( ) , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'L' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( C -> getZExtValue ( ) <= 31 ) { Result = DAG . getTargetConstant ( C -> getZExtValue ( ) , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'M' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { int64_t Val = C -> getSExtValue ( ) ; if ( ( isInt < 32 > ( Val ) ) && ( ( Val & 0xffff ) == 0 ) ) { Result = DAG . getTargetConstant ( Val , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'N' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { int64_t Val = C -> getSExtValue ( ) ; if ( ( Val >= - 33554432 ) && ( Val <= 33554431 ) ) { Result = DAG . getTargetConstant ( Val , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; default : break ; } if ( Result . getNode ( ) ) { Ops . push_back ( Result ) ; return ; } TargetLowering :: LowerAsmOperandForConstraint ( Op , Constraint , Ops , DAG ) ; } </s>

Lower the specified operand into the Ops vector .


<s> virtual bool isImm ( ) const LLVM_OVERRIDE { return Kind == KindImm ; } </s>


<s> const std :: string & THMToARMStub :: name ( ) const { return m_Name ; } </s>

Gets the name of the pass we are mixed into .


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


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

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

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


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


"position-independent code requires the Linux ABI"


"End of block construct with no start: "

"Block construct type mismatch, expected: "


<s> SDValue SystemZTargetLowering :: LowerCallResult ( SDValue Chain , SDValue InFlag , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , DebugLoc dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , getTargetMachine ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallResult ( Ins , RetCC_SystemZ ) ; for ( unsigned i = 0 ; i != RVLocs . size ( ) ; ++ i ) { CCValAssign & VA = RVLocs [ i ] ; Chain = DAG . getCopyFromReg ( Chain , dl , VA . getLocReg ( ) , VA . getLocVT ( ) , InFlag ) . getValue ( 1 ) ; SDValue RetValue = Chain . getValue ( 0 ) ; InFlag = Chain . getValue ( 2 ) ; if ( VA . getLocInfo ( ) == CCValAssign :: SExt ) RetValue = DAG . getNode ( ISD :: AssertSext , dl , VA . getLocVT ( ) , RetValue , DAG . getValueType ( VA . getValVT ( ) ) ) ; else if ( VA . getLocInfo ( ) == CCValAssign :: ZExt ) RetValue = DAG . getNode ( ISD :: AssertZext , dl , VA . getLocVT ( ) , RetValue , DAG . getValueType ( VA . getValVT ( ) ) ) ; if ( VA . getLocInfo ( ) != CCValAssign :: Full ) RetValue = DAG . getNode ( ISD :: TRUNCATE , dl , VA . getValVT ( ) , RetValue ) ; InVals . push_back ( RetValue ) ; } return Chain ; } </s>

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


<s> SDNode * SITargetLowering :: PostISelFolding ( MachineSDNode * Node , SelectionDAG & DAG ) const { const SIInstrInfo * TII = static_cast < const SIInstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; Node = AdjustRegClass ( Node , DAG ) ; if ( TII -> isMIMG ( Node -> getMachineOpcode ( ) ) ) adjustWritemask ( Node , DAG ) ; if ( Node -> getMachineOpcode ( ) == AMDGPU :: INSERT_SUBREG || Node -> getMachineOpcode ( ) == AMDGPU :: REG_SEQUENCE ) { legalizeTargetIndependentNode ( Node , DAG ) ; return Node ; } return Node ; } </s>

Fold the instructions after selecting them .


<s> void AGCPassConfig :: addPreEmitPass2 ( ) { addPass ( createAGCExpandPseudoPass ( ) ) ; } </s>

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


<s> static rtx nds32_expand_noarg_builtin ( enum insn_code icode , rtx target ) { rtx pat ; target = nds32_legitimize_target ( icode , target ) ; pat = GEN_FCN ( icode ) ( target ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; return target ; } </s>


<s>
void
Cpu0InstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
SrcReg
,
bool
isKill
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
MachineMemOperand
*
MMO
=
GetMemOperand
(
MBB
,
FI
,
MachineMemOperand
::
MOStore
)
;
unsigned
Opc
=
0
;
if
(
Cpu0
::
CPURegsRegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
Cpu0
::
ST
;
assert
(
Opc
&&
"Register class not handled!"
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
;
}
</s>

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


<s> rtx alpha_return_addr ( int count , rtx frame ATTRIBUTE_UNUSED ) { if ( count != 0 ) return const0_rtx ; return get_hard_reg_initial_val ( Pmode , REG_RA ) ; } </s>

Start the ball rolling with RETURN_ADDR_RTX .


<s> void X86PassConfig :: addIRPasses ( ) { addPass ( createAtomicExpandPass ( & getX86TargetMachine ( ) ) ) ; if ( Triple ( TM -> getTargetTriple ( ) ) . isOSNaCl ( ) && Triple ( TM -> getTargetTriple ( ) ) . isArch64Bit ( ) && NaClDontBreakABI ) { addPass ( createClearPtrToIntTop32Pass ( ) ) ; } TargetPassConfig :: addIRPasses ( ) ; } </s>

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


"local variable memory requirements exceed capacity"

Called after register allocation to add any instructions needed for the prologue . Using a prologue insn is favored compared to putting all of the instructions in the TARGET_ASM_FUNCTION_PROLOGUE macro , since it allows the scheduler to intermix instructions with the saves of the caller saved registers . In some cases , it might be necessary to emit a barrier instruction as the last insn to prevent such scheduling . Also any insns generated here should have RTX_FRAME_RELATED_P ( insn ) = 1 so that the debug info generation code can handle them properly .


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


<s>
void
M88kFrameLowering
::
processFunctionBeforeFrameFinalized
(
MachineFunction
&
MF
,
RegScavenger
*
RS
)
const
{
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
assert
(
MFI
.
isMaxCallFrameSizeComputed
(
)
&&
"MaxCallFrame not computed"
)
;
unsigned
MaxCallFrameSize
=
MFI
.
getMaxCallFrameSize
(
)
;
MaxCallFrameSize
=
alignTo
(
MaxCallFrameSize
,
getStackAlign
(
)
)
;
MFI
.
setMaxCallFrameSize
(
MaxCallFrameSize
)
;
}
</s>

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


<s> void relaxInstruction ( const MCInst & , const MCSubtargetInfo & , MCInst & ) const override { } </s>

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


<s> bool doInitialization ( Module & M ) override { LLVMContext & Ctx = M . getContext ( ) ; Mod = & M ; FloatType = Type :: getFloatTy ( Ctx ) ; Int32Type = Type :: getInt32Ty ( Ctx ) ; V4f32Type = VectorType :: get ( FloatType , 4 ) ; V4i32Type = VectorType :: get ( Int32Type , 4 ) ; Type * ArgsType [ ] = { V4f32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , } ; TexSign = FunctionType :: get ( V4f32Type , ArgsType , false ) ; Type * ArgsQType [ ] = { V4i32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , Int32Type , } ; TexQSign = FunctionType :: get ( V4f32Type , ArgsQType , false ) ; return false ; } </s>

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


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

getPassName - Return a nice clean name for a pass .


<s> static int cris_reg_saved_in_regsave_area ( unsigned int regno , bool got_really_used ) { return ( ( ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || ( regno == PIC_OFFSET_TABLE_REGNUM && ( got_really_used || ( flag_pic && regs_ever_live [ regno + 1 ] && ! call_used_regs [ regno + 1 ] ) ) ) ) && ( regno != FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regno != CRIS_SRP_REGNUM ) || ( current_function_calls_eh_return && ( regno == EH_RETURN_DATA_REGNO ( 0 ) || regno == EH_RETURN_DATA_REGNO ( 1 ) || regno == EH_RETURN_DATA_REGNO ( 2 ) || regno == EH_RETURN_DATA_REGNO ( 3 ) ) ) ; } </s>

Return nonzero if REGNO is an ordinary register that * needs * to be saved together with other registers , possibly by a MOVEM instruction , or is saved for target-independent reasons . There may be target-dependent reasons to save the register anyway ; this is just a wrapper for a complicated conditional .


<s> static bool aarch64_is_reduction ( stmt_vec_info stmt_info ) { return ( STMT_VINFO_REDUC_DEF ( stmt_info ) || VECTORIZABLE_CYCLE_DEF ( STMT_VINFO_DEF_TYPE ( stmt_info ) ) ) ; } </s>

Return true if STMT_INFO represents part of a reduction .


<s> static unsigned int aarch64_offset_temporaries ( bool add_p , poly_int64 offset ) { if ( add_p && aarch64_sve_addvl_addpl_immediate_p ( offset ) ) return 0 ; unsigned int count = 0 ; HOST_WIDE_INT factor = offset . coeffs [ 1 ] ; HOST_WIDE_INT constant = offset . coeffs [ 0 ] - factor ; poly_int64 poly_offset ( factor , factor ) ; if ( add_p && aarch64_sve_addvl_addpl_immediate_p ( poly_offset ) ) count += 1 ; else if ( factor != 0 ) { factor = abs ( factor ) ; if ( factor > 16 * ( factor & - factor ) ) return 2 ; count += 1 ; } return count + aarch64_add_offset_1_temporaries ( constant ) ; } </s>

Return the number of temporary registers that aarch64_add_offset would need to move OFFSET into a register or add OFFSET to a register ; ADD_P is true if we want the latter rather than the former .


"%qE attribute only applies to functions"

Handle an attribute requiring a FUNCTION_DECL ; arguments as in struct attribute_spec.handler .


"For each split Type there should be exactly one VReg."

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


<s>
void
TeeRISCInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
if
(
TeeRISC
::
IntRegsRegClass
.
contains
(
DestReg
,
SrcReg
)
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
TeeRISC
::
OR
)
,
DestReg
)
.
addReg
(
TeeRISC
::
ZERO
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
else
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
</s>

TeeRISC
TeeRISC
TeeRISC::IntRegsRegClass
TeeRISC::OR
TeeRISC::ZERO
"Impossible reg-to-reg copy"


<s> bool BTFDebug :: InstLower ( const MachineInstr * MI , MCInst & OutMI ) { if ( MI -> getOpcode ( ) == BPF :: LD_imm64 ) { const MachineOperand & MO = MI -> getOperand ( 1 ) ; if ( MO . isGlobal ( ) ) { const GlobalValue * GVal = MO . getGlobal ( ) ; auto * GVar = dyn_cast < GlobalVariable > ( GVal ) ; if ( GVar ) { uint32_t Imm ; if ( GVar -> hasAttribute ( BPFCoreSharedInfo :: AmaAttr ) || GVar -> hasAttribute ( BPFCoreSharedInfo :: TypeIdAttr ) ) Imm = PatchImms [ GVar ] ; else return false ; OutMI . setOpcode ( BPF :: MOV_ri ) ; OutMI . addOperand ( MCOperand :: createReg ( MI -> getOperand ( 0 ) . getReg ( ) ) ) ; OutMI . addOperand ( MCOperand :: createImm ( Imm ) ) ; return true ; } } } else if ( MI -> getOpcode ( ) == BPF :: CORE_MEM || MI -> getOpcode ( ) == BPF :: CORE_ALU32_MEM || MI -> getOpcode ( ) == BPF :: CORE_SHIFT ) { const MachineOperand & MO = MI -> getOperand ( 3 ) ; if ( MO . isGlobal ( ) ) { const GlobalValue * GVal = MO . getGlobal ( ) ; auto * GVar = dyn_cast < GlobalVariable > ( GVal ) ; if ( GVar && GVar -> hasAttribute ( BPFCoreSharedInfo :: AmaAttr ) ) { uint32_t Imm = PatchImms [ GVar ] ; OutMI . setOpcode ( MI -> getOperand ( 1 ) . getImm ( ) ) ; if ( MI -> getOperand ( 0 ) . isImm ( ) ) OutMI . addOperand ( MCOperand :: createImm ( MI -> getOperand ( 0 ) . getImm ( ) ) ) ; else OutMI . addOperand ( MCOperand :: createReg ( MI -> getOperand ( 0 ) . getReg ( ) ) ) ; OutMI . addOperand ( MCOperand :: createReg ( MI -> getOperand ( 2 ) . getReg ( ) ) ) ; OutMI . addOperand ( MCOperand :: createImm ( Imm ) ) ; return true ; } } } return false ; } </s>


<s> bool HexagonFrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF -> getTarget ( ) . getInstrInfo ( ) ; if ( CSI . empty ( ) ) { return false ; } bool ContiguousRegs = true ; for ( unsigned i = 0 ; i < CSI . size ( ) ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; unsigned SuperReg = uniqueSuperReg ( Reg , TRI ) ; const TargetRegisterClass * SuperRegClass = 0 ; bool CanUseDblLoad = false ; if ( ContiguousRegs && ( i < CSI . size ( ) - 1 ) ) { unsigned SuperRegNext = uniqueSuperReg ( CSI [ i + 1 ] . getReg ( ) , TRI ) ; SuperRegClass = TRI -> getMinimalPhysRegClass ( SuperReg ) ; CanUseDblLoad = ( SuperRegNext == SuperReg ) ; } if ( CanUseDblLoad ) { TII . loadRegFromStackSlot ( MBB , MI , SuperReg , CSI [ i + 1 ] . getFrameIdx ( ) , SuperRegClass , TRI ) ; MBB . addLiveIn ( SuperReg ) ; ++ i ; } else { ContiguousRegs = false ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . loadRegFromStackSlot ( MBB , MI , Reg , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; MBB . addLiveIn ( Reg ) ; } } 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> bool AArch64PassConfig :: addPostRegAlloc ( ) { if ( TM -> getOptLevel ( ) != CodeGenOpt :: None && EnableDeadRegisterElimination ) addPass ( createAArch64DeadRegisterDefinitions ( ) ) ; if ( TM -> getOptLevel ( ) != CodeGenOpt :: None && TM -> getSubtarget < AArch64Subtarget > ( ) . isCortexA57 ( ) && ! static_cast < const AArch64TargetMachine * > ( TM ) -> isPBQPUsed ( ) ) addPass ( createAArch64A57FPLoadBalancing ( ) ) ; return true ; } </s>

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


<s> static bool rs6000_const_not_ok_for_debug_p ( rtx x ) { if ( GET_CODE ( x ) == UNSPEC ) return true ; if ( SYMBOL_REF_P ( x ) && CONSTANT_POOL_ADDRESS_P ( x ) ) { rtx c = get_pool_constant ( x ) ; machine_mode cmode = get_pool_mode ( x ) ; if ( ASM_OUTPUT_SPECIAL_POOL_ENTRY_P ( c , cmode ) ) return true ; } return false ; } </s>

Return true if X should n't be emitted into the debug info . The linker does n't like .toc section references from .debug_ * sections , so reject .toc section symbols .


<s> bool canMergeStoresTo ( unsigned AddressSpace , EVT MemVT , const SelectionDAG & DAG ) const override { return ( MemVT . getSizeInBits ( ) <= 32 ) ; } </s>

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


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


"AltiVec argument passed to unprototyped function"

Target hook for invalid_arg_for_unprototyped_fn .


<s> int mips_address_insns ( rtx x , machine_mode mode , bool might_split_p ) { struct mips_address_info addr ; int factor ; if ( mode != BLKmode && might_split_p ) factor = ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; else factor = 1 ; if ( mips_classify_address ( & addr , x , mode , false ) ) switch ( addr . type ) { case ADDRESS_REG : if ( TARGET_MIPS16 && ! mips16_unextended_reference_p ( mode , addr . reg , UINTVAL ( addr . offset ) ) ) return factor * 2 ; return factor ; case ADDRESS_LO_SUM : return TARGET_MIPS16 ? factor * 2 : factor ; case ADDRESS_CONST_INT : return factor ; case ADDRESS_SYMBOLIC : return factor * mips_symbol_insns ( addr . symbol_type , mode ) ; } return 0 ; } </s>

Return the number of instructions needed to load or store a value of mode MODE at X . Return 0 if X is n't valid for MODE . For mips16 code , count extended instructions as two instructions .


<s>
SDValue
LC2200TargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
report_fatal_error
(
"unimplemented operand"
)
;
case
ISD
::
SHL
:
return
lowerShiftLeft
(
Op
,
DAG
)
;
case
ISD
::
BR_CC
:
return
lowerBrCc
(
Op
,
DAG
)
;
case
ISD
::
BR
:
return
lowerBr
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
lowerSelectCc
(
Op
,
DAG
)
;
case
ISD
::
AND
:
return
lowerAnd
(
Op
,
DAG
)
;
case
ISD
::
OR
:
return
lowerOr
(
Op
,
DAG
)
;
case
ISD
::
XOR
:
return
lowerXor
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
lowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
SRL
:
return
ExpandLibCall
(
"__srlu"
,
Op
,
false
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s>
bool
MipsConstantIslands
::
isBBInRange
(
MachineInstr
*
MI
,
MachineBasicBlock
*
DestBB
,
unsigned
MaxDisp
)
{
unsigned
PCAdj
=
4
;
unsigned
BrOffset
=
getOffsetOf
(
MI
)
+
PCAdj
;
unsigned
DestOffset
=
BBInfo
[
DestBB
->
getNumber
(
)
]
.
Offset
;
DEBUG
(
dbgs
(
)
<<
"Branch of destination BB#"
<<
DestBB
->
getNumber
(
)
<<
" from BB#"
<<
MI
->
getParent
(
)
->
getNumber
(
)
<<
" max delta="
<<
MaxDisp
<<
" from "
<<
getOffsetOf
(
MI
)
<<
" to "
<<
DestOffset
<<
" offset "
<<
int
(
DestOffset
BrOffset
)
<<
"\t"
<<
*
MI
)
;
if
(
BrOffset
<=
DestOffset
)
{
if
(
DestOffset
BrOffset
<=
MaxDisp
)
return
true
;
}
else
{
if
(
BrOffset
DestOffset
<=
MaxDisp
)
return
true
;
}
return
false
;
}
</s>

isBBInRange - Returns true if the distance between specific MI and specific BB can fit in MI 's displacement field .

Mips
Mips
4
"Branch of destination BB#"
" from BB#"
" max delta="
" from "
" to "
" offset "
"\t"


<s> static const FunctionType * getType ( LLVMContext & Context , unsigned id ) { const Type * ResultTy = NULL ; std :: vector < const Type * > ArgTys ; bool IsVarArg = false ; return FunctionType :: get ( ResultTy , ArgTys , IsVarArg ) ; } </s>

Overload to return most specific vector type .


<s> static bool s390_is_fpr128 ( machine_mode m ) { return m == FPRX2mode || ( ! TARGET_VXE && m == TFmode ) ; } </s>

Return nonzero if mode M describes a 128-bit float in a floating point register pair .


<s> static void riscv_save_restore_reg ( machine_mode mode , int regno , HOST_WIDE_INT offset , riscv_save_restore_fn fn ) { rtx mem ; mem = gen_frame_mem ( mode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; fn ( gen_rtx_REG ( mode , regno ) , mem ) ; } </s>

Use FN to save or restore register REGNO . MODE is the register 's mode and OFFSET is the offset of its save slot from the current stack pointer .


<s> TargetLowering :: ConstraintWeight MipsTargetLowering :: getSingleConstraintMatchWeight ( AsmOperandInfo & info , const char * constraint ) const { ConstraintWeight weight = CW_Invalid ; Value * CallOperandVal = info . CallOperandVal ; if ( ! CallOperandVal ) return CW_Default ; Type * type = CallOperandVal -> getType ( ) ; switch ( * constraint ) { default : weight = TargetLowering :: getSingleConstraintMatchWeight ( info , constraint ) ; break ; case 'd' : case 'y' : if ( type -> isIntegerTy ( ) ) weight = CW_Register ; break ; case 'f' : if ( Subtarget . hasMSA ( ) && type -> isVectorTy ( ) && cast < VectorType > ( type ) -> getBitWidth ( ) == 128 ) weight = CW_Register ; else if ( type -> isFloatTy ( ) ) weight = CW_Register ; break ; case 'c' : case 'l' : case 'x' : if ( type -> isIntegerTy ( ) ) weight = CW_SpecificReg ; break ; case 'I' : case 'J' : case 'K' : case 'L' : case 'N' : case 'O' : case 'P' : if ( isa < ConstantInt > ( CallOperandVal ) ) weight = CW_Constant ; break ; case 'R' : weight = CW_Memory ; break ; } return weight ; } </s>

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


<s> bool rs6000_decl_ok_for_sibcall ( tree decl ) { if ( DEFAULT_ABI == ABI_DARWIN ) return true ; if ( DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_ELFv2 ) { if ( rs6000_pcrel_p ( ) ) return true ; if ( ! decl || DECL_EXTERNAL ( decl ) || DECL_WEAK ( decl ) || ! ( * targetm . binds_local_p ) ( decl ) ) return false ; if ( rs6000_fndecl_pcrel_p ( decl ) ) return false ; return true ; } if ( DEFAULT_ABI != ABI_V4 || ( TARGET_SECURE_PLT && flag_pic && ( ! decl || ! ( ( * targetm . binds_local_p ) ( decl ) ) ) ) ) return false ; return true ; } </s>

Helper function for rs6000_function_ok_for_sibcall .


<s> unsigned X86AsmParser :: checkTargetMatchPredicate ( MCInst & Inst ) { unsigned Opc = Inst . getOpcode ( ) ; const MCInstrDesc & MCID = MII . get ( Opc ) ; if ( ForcedVEXEncoding == VEXEncoding_EVEX && ( MCID . TSFlags & X86II :: EncodingMask ) != X86II :: EVEX ) return Match_Unsupported ; if ( ( ForcedVEXEncoding == VEXEncoding_VEX || ForcedVEXEncoding == VEXEncoding_VEX3 ) && ( MCID . TSFlags & X86II :: EncodingMask ) != X86II :: VEX ) return Match_Unsupported ; switch ( Opc ) { case X86 :: VCVTSD2SIZrm_Int : case X86 :: VCVTSD2SI64Zrm_Int : case X86 :: VCVTSS2SIZrm_Int : case X86 :: VCVTSS2SI64Zrm_Int : case X86 :: VCVTTSD2SIZrm : case X86 :: VCVTTSD2SIZrm_Int : case X86 :: VCVTTSD2SI64Zrm : case X86 :: VCVTTSD2SI64Zrm_Int : case X86 :: VCVTTSS2SIZrm : case X86 :: VCVTTSS2SIZrm_Int : case X86 :: VCVTTSS2SI64Zrm : case X86 :: VCVTTSS2SI64Zrm_Int : if ( ForcedVEXEncoding != VEXEncoding_EVEX ) return Match_Unsupported ; break ; } return Match_Success ; } </s>

checkTargetMatchPredicate - Validate the instruction match against any complex target predicates not expressible via match classes .


<s> bool CAHPAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , const char * ExtraCode , raw_ostream & OS ) { if ( ! AsmPrinter :: PrintAsmOperand ( MI , OpNo , ExtraCode , OS ) ) return false ; if ( ! ExtraCode ) { const MachineOperand & MO = MI -> getOperand ( OpNo ) ; switch ( MO . getType ( ) ) { case MachineOperand :: MO_Immediate : OS << MO . getImm ( ) ; return false ; case MachineOperand :: MO_Register : OS << CAHPInstPrinter :: getRegisterName ( MO . getReg ( ) ) ; return false ; default : break ; } } return true ; } </s>

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


<s> virtual const VideocoreSubtarget * getSubtargetImpl ( ) const { return & Subtarget ; } </s>

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


<s> static bool ix86_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { if ( CC_REGNO_P ( regno ) ) return GET_MODE_CLASS ( mode ) == MODE_CC ; if ( GET_MODE_CLASS ( mode ) == MODE_CC || GET_MODE_CLASS ( mode ) == MODE_RANDOM ) return false ; if ( STACK_REGNO_P ( regno ) ) return VALID_FP_MODE_P ( mode ) ; if ( MASK_REGNO_P ( regno ) ) { if ( ( mode == P2QImode || mode == P2HImode ) ) return MASK_PAIR_REGNO_P ( regno ) ; return ( ( TARGET_AVX512F && VALID_MASK_REG_MODE ( mode ) ) || ( TARGET_AVX512BW && VALID_MASK_AVX512BW_MODE ( mode ) ) ) ; } if ( GET_MODE_CLASS ( mode ) == MODE_PARTIAL_INT ) return false ; if ( SSE_REGNO_P ( regno ) ) { if ( TARGET_AVX512F && ( VALID_AVX512F_REG_OR_XI_MODE ( mode ) || VALID_AVX512F_SCALAR_MODE ( mode ) ) ) return true ; if ( TARGET_AVX512FP16 && VALID_AVX512FP16_SCALAR_MODE ( mode ) ) return true ; if ( ( TARGET_AVX5124FMAPS || TARGET_AVX5124VNNIW ) && ( mode == V64SFmode || mode == V64SImode ) && MOD4_SSE_REGNO_P ( regno ) ) return true ; if ( TARGET_AVX512VL && ( VALID_AVX256_REG_OR_OI_MODE ( mode ) || VALID_AVX512VL_128_REG_MODE ( mode ) ) ) return true ; if ( EXT_REX_SSE_REGNO_P ( regno ) ) return false ; return ( ( TARGET_AVX && VALID_AVX256_REG_OR_OI_MODE ( mode ) ) || VALID_SSE_REG_MODE ( mode ) || VALID_SSE2_REG_MODE ( mode ) || VALID_MMX_REG_MODE ( mode ) || VALID_MMX_REG_MODE_3DNOW ( mode ) ) ; } if ( MMX_REGNO_P ( regno ) ) { return ( VALID_MMX_REG_MODE ( mode ) || VALID_MMX_REG_MODE_3DNOW ( mode ) ) ; } if ( mode == QImode ) { if ( ANY_QI_REGNO_P ( regno ) ) return true ; if ( ! TARGET_PARTIAL_REG_STALL ) return true ; if ( lra_in_progress ) return true ; return ! can_create_pseudo_p ( ) ; } else if ( VALID_INT_MODE_P ( mode ) || VALID_FP_MODE_P ( mode ) ) return true ; else if ( VALID_MMX_REG_MODE_3DNOW ( mode ) || VALID_MMX_REG_MODE ( mode ) ) return true ; return false ; } </s>

Return TRUE if hard register REGNO can hold a value of machine-mode MODE .


<s>
SDValue
SystemZTargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
IsVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
const
SmallVectorImpl
<
SDValue
>
&
OutVals
,
const
SDLoc
&
DL
,
SelectionDAG
&
DAG
)
const
{
MachineFunction
&
MF
=
DAG
.
getMachineFunction
(
)
;
if
(
Subtarget
.
hasVector
(
)
)
VerifyVectorTypes
(
Outs
)
;
SmallVector
<
CCValAssign
,
16
>
RetLocs
;
CCState
RetCCInfo
(
CallConv
,
IsVarArg
,
MF
,
RetLocs
,
*
DAG
.
getContext
(
)
)
;
RetCCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_SystemZ
)
;
if
(
RetLocs
.
empty
(
)
)
return
DAG
.
getNode
(
SystemZISD
::
RET_FLAG
,
DL
,
MVT
::
Other
,
Chain
)
;
SDValue
Glue
;
SmallVector
<
SDValue
,
4
>
RetOps
;
RetOps
.
push_back
(
Chain
)
;
for
(
unsigned
I
=
0
,
E
=
RetLocs
.
size
(
)
;
I
!=
E
;
++
I
)
{
CCValAssign
&
VA
=
RetLocs
[
I
]
;
SDValue
RetValue
=
OutVals
[
I
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
RetValue
=
convertValVTToLocVT
(
DAG
,
DL
,
VA
,
RetValue
)
;
Register
Reg
=
VA
.
getLocReg
(
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
DL
,
Reg
,
RetValue
,
Glue
)
;
Glue
=
Chain
.
getValue
(
1
)
;
RetOps
.
push_back
(
DAG
.
getRegister
(
Reg
,
VA
.
getLocVT
(
)
)
)
;
}
RetOps
[
0
]
=
Chain
;
if
(
Glue
.
getNode
(
)
)
RetOps
.
push_back
(
Glue
)
;
return
DAG
.
getNode
(
SystemZISD
::
RET_FLAG
,
DL
,
MVT
::
Other
,
RetOps
)
;
}
</s>

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


<s> EVT SITargetLowering :: getSetCCResultType ( LLVMContext & Ctx , EVT VT ) const { if ( ! VT . isVector ( ) ) { return MVT :: i1 ; } return EVT :: getVectorVT ( Ctx , MVT :: i1 , VT . getVectorNumElements ( ) ) ; } </s>

Return the value type to use for ISD : :SETCC .


<s>
bool
AArch64FrameLowering
::
restoreCalleeSavedRegisters
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
std
::
vector
<
CalleeSavedInfo
>
&
CSI
,
const
TargetRegisterInfo
*
TRI
)
const
{
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
const
TargetInstrInfo
&
TII
=
*
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
DebugLoc
DL
;
SmallVector
<
RegPairInfo
,
8
>
RegPairs
;
if
(
MI
!=
MBB
.
end
(
)
)
DL
=
MI
->
getDebugLoc
(
)
;
computeCalleeSaveRegisterPairs
(
MF
,
CSI
,
TRI
,
RegPairs
)
;
for
(
auto
RPII
=
RegPairs
.
begin
(
)
,
RPIE
=
RegPairs
.
end
(
)
;
RPII
!=
RPIE
;
++
RPII
)
{
RegPairInfo
RPI
=
*
RPII
;
unsigned
Reg1
=
RPI
.
Reg1
;
unsigned
Reg2
=
RPI
.
Reg2
;
unsigned
LdrOpc
;
if
(
RPI
.
IsGPR
)
LdrOpc
=
RPI
.
isPaired
(
)
AArch64
::
LDPXi
:
AArch64
::
LDRXui
;
else
LdrOpc
=
RPI
.
isPaired
(
)
AArch64
::
LDPDi
:
AArch64
::
LDRDui
;
DEBUG
(
dbgs
(
)
<<
"CSR restore: ("
<<
TRI
->
getName
(
Reg1
)
;
if
(
RPI
.
isPaired
(
)
)
dbgs
(
)
<<
", "
<<
TRI
->
getName
(
Reg2
)
;
dbgs
(
)
<<
") -> fi#("
<<
RPI
.
FrameIdx
;
if
(
RPI
.
isPaired
(
)
)
dbgs
(
)
<<
", "
<<
RPI
.
FrameIdx
+
1
;
dbgs
(
)
<<
")\n"
)
;
MachineInstrBuilder
MIB
=
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
LdrOpc
)
)
;
if
(
RPI
.
isPaired
(
)
)
{
MIB
.
addReg
(
Reg2
,
getDefRegState
(
true
)
)
;
MIB
.
addMemOperand
(
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getFixedStack
(
MF
,
RPI
.
FrameIdx
+
1
)
,
MachineMemOperand
::
MOLoad
,
8
,
8
)
)
;
}
MIB
.
addReg
(
Reg1
,
getDefRegState
(
true
)
)
.
addReg
(
AArch64
::
SP
)
.
addImm
(
RPI
.
Offset
)
.
setMIFlag
(
MachineInstr
::
FrameDestroy
)
;
MIB
.
addMemOperand
(
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getFixedStack
(
MF
,
RPI
.
FrameIdx
)
,
MachineMemOperand
::
MOLoad
,
8
,
8
)
)
;
}
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 ( ) .


Generate a sequence of instructions to sign-extend an HI value into an SI value . Handles the tricky case where we are overwriting the destination . Return the number of bytes used by the emitted instructions . If RETURN_LENGTH is true then do not emit the assembly instruction sequence .


<s> static const char * svprfop_token ( enum aarch64_svprfop prfop ) { switch ( prfop ) { AARCH64_FOR_SVPRFOP ( CASE ) case AARCH64_NUM_SVPRFOPS : break ; } gcc_unreachable ( ) ; } </s>

Return the assembly token for svprfop value PRFOP .


<s> void MBlazeInstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , DebugLoc DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { llvm :: BuildMI ( MBB , I , DL , get ( MBlaze :: ADD ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) . addReg ( MBlaze :: R0 ) ; } </s>