<s>
static
uint16_t
name
(
struct
InternalInstruction
*
insn
,
OperandType
type
,
\
uint8_t
index
,
uint8_t
*
valid
)
{
\
*
valid
=
1
;
\
switch
(
type
)
{
\
default
:
\
debug
(
"Unhandled register type"
)
;
\
*
valid
=
0
;
\
return
0
;
\
case
TYPE_Rv
:
\
return
base
+
index
;
\
case
TYPE_R8
:
\
index
&=
mask
;
\
if
(
index
>
0xf
)
\
*
valid
=
0
;
\
if
(
insn
->
rexPrefix
&&
index
>=
4
&&
index
<=
7
)
{
\
return
prefix
##
_SPL
+
(
index
4
)
;
\
}
else
{
\
return
prefix
##
_AL
+
index
;
\
}
\
case
TYPE_R16
:
\
index
&=
mask
;
\
if
(
index
>
0xf
)
\
*
valid
=
0
;
\
return
prefix
##
_AX
+
index
;
\
case
TYPE_R32
:
\
index
&=
mask
;
\
if
(
index
>
0xf
)
\
*
valid
=
0
;
\
return
prefix
##
_EAX
+
index
;
\
case
TYPE_R64
:
\
index
&=
mask
;
\
if
(
index
>
0xf
)
\
*
valid
=
0
;
\
return
prefix
##
_RAX
+
index
;
\
case
TYPE_ZMM
:
\
return
prefix
##
_ZMM0
+
index
;
\
case
TYPE_YMM
:
\
return
prefix
##
_YMM0
+
index
;
\
case
TYPE_XMM
:
\
return
prefix
##
_XMM0
+
index
;
\
case
TYPE_TMM
:
\
if
(
index
>
7
)
\
*
valid
=
0
;
\
return
prefix
##
_TMM0
+
index
;
\
case
TYPE_VK
:
\
index
&=
0xf
;
\
if
(
index
>
7
)
\
*
valid
=
0
;
\
return
prefix
##
_K0
+
index
;
\
case
TYPE_VK_PAIR
:
\
if
(
index
>
7
)
\
*
valid
=
0
;
\
return
prefix
##
_K0_K1
+
(
index
/
2
)
;
\
case
TYPE_MM64
:
\
return
prefix
##
_MM0
+
(
index
&
0x7
)
;
\
case
TYPE_SEGMENTREG
:
\
if
(
(
index
&
7
)
>
5
)
\
*
valid
=
0
;
\
return
prefix
##
_ES
+
(
index
&
7
)
;
\
case
TYPE_DEBUGREG
:
\
return
prefix
##
_DR0
+
index
;
\
case
TYPE_CONTROLREG
:
\
return
prefix
##
_CR0
+
index
;
\
case
TYPE_BNDR
:
\
if
(
index
>
3
)
\
*
valid
=
0
;
\
return
prefix
##
_BND0
+
index
;
\
case
TYPE_MVSIBX
:
\
return
prefix
##
_XMM0
+
index
;
\
case
TYPE_MVSIBY
:
\
return
prefix
##
_YMM0
+
index
;
\
case
TYPE_MVSIBZ
:
\
return
prefix
##
_ZMM0
+
index
;
\
}
\
}
</s>

Gets the name of the pass we are mixed into .


<s> static void h8300_insert_attributes ( tree node , tree * attributes ) { if ( TREE_CODE ( node ) == FUNCTION_DECL ) { if ( pragma_interrupt ) { pragma_interrupt = 0 ; * attributes = tree_cons ( get_identifier ( "interrupt_handler" ) , NULL , * attributes ) ; } if ( pragma_saveall ) { pragma_saveall = 0 ; * attributes = tree_cons ( get_identifier ( "saveall" ) , NULL , * attributes ) ; } } } </s>

Generate an 'interrupt_handler ' attribute for decls . We convert all the pragmas to corresponding attributes .


<s> DecodeStatus SparcDisassembler :: getInstruction ( MCInst & Instr , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & CStream ) const { uint32_t Insn ; bool isLittleEndian = getContext ( ) . getAsmInfo ( ) -> isLittleEndian ( ) ; DecodeStatus Result = readInstruction32 ( Bytes , Address , Size , Insn , isLittleEndian ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; if ( STI . getFeatureBits ( ) [ Sparc :: FeatureV9 ] ) { Result = decodeInstruction ( DecoderTableSparcV932 , Instr , Insn , Address , this , STI ) ; } else { Result = decodeInstruction ( DecoderTableSparcV832 , Instr , Insn , Address , this , STI ) ; } if ( Result != MCDisassembler :: Fail ) return Result ; Result = decodeInstruction ( DecoderTableSparc32 , Instr , Insn , Address , this , STI ) ; if ( Result != MCDisassembler :: Fail ) { Size = 4 ; return Result ; } return MCDisassembler :: Fail ; } </s>

Returns the disassembly of a single instruction .

Sparc Sparc Sparc::FeatureV9 Sparc Sparc Sparc 4


"Unexpected Kind in getPointerRegClass!"

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<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> unsigned getNumFixupKinds ( ) const override { return 14 ; } </s>

Get the number of target specific fixup kinds .


<s> int loongarch_class_max_nregs ( enum reg_class rclass , machine_mode mode ) { int size ; HARD_REG_SET left ; size = 0x8000 ; left = reg_class_contents [ rclass ] ; if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FCC_REGS ] ) ) { if ( loongarch_hard_regno_mode_ok ( FCC_REG_FIRST , mode ) ) size = MIN ( size , 4 ) ; left &= ~ reg_class_contents [ FCC_REGS ] ; } if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FP_REGS ] ) ) { if ( loongarch_hard_regno_mode_ok ( FP_REG_FIRST , mode ) ) size = MIN ( size , UNITS_PER_FPREG ) ; left &= ~ reg_class_contents [ FP_REGS ] ; } if ( ! hard_reg_set_empty_p ( left ) ) size = MIN ( size , UNITS_PER_WORD ) ; return ( GET_MODE_SIZE ( mode ) + size - 1 ) / size ; } </s>

Implement CLASS_MAX_NREGS , taking the maximum of the cases in loongarch_hard_regno_nregs .


<s> SDValue ARM64SelectionDAGInfo :: EmitTargetCodeForMemset ( SelectionDAG & DAG , SDLoc dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , unsigned Align , bool isVolatile , MachinePointerInfo DstPtrInfo ) const { ConstantSDNode * V = dyn_cast < ConstantSDNode > ( Src ) ; ConstantSDNode * SizeValue = dyn_cast < ConstantSDNode > ( Size ) ; const char * bzeroEntry = ( V && V -> isNullValue ( ) ) ? Subtarget -> getBZeroEntry ( ) : nullptr ; if ( bzeroEntry && ( ! SizeValue || SizeValue -> getZExtValue ( ) > 256 ) ) { const ARM64TargetLowering & TLI = * static_cast < const ARM64TargetLowering * > ( DAG . getTarget ( ) . getTargetLowering ( ) ) ; EVT IntPtr = TLI . getPointerTy ( ) ; Type * IntPtrTy = getDataLayout ( ) -> getIntPtrType ( * DAG . getContext ( ) ) ; TargetLowering :: ArgListTy Args ; TargetLowering :: ArgListEntry Entry ; Entry . Node = Dst ; Entry . Ty = IntPtrTy ; Args . push_back ( Entry ) ; Entry . Node = Size ; Args . push_back ( Entry ) ; TargetLowering :: CallLoweringInfo CLI ( Chain , Type :: getVoidTy ( * DAG . getContext ( ) ) , false , false , false , false , 0 , CallingConv :: C , false , false , false , DAG . getExternalSymbol ( bzeroEntry , IntPtr ) , Args , DAG , dl ) ; std :: pair < SDValue , SDValue > CallResult = TLI . LowerCallTo ( CLI ) ; return CallResult . second ; } return SDValue ( ) ; } </s>

Emit target-specific code that performs a memset .


<s> bool NVPTXFavorNonGenericAddrSpaces :: runOnFunction ( Function & F ) { if ( DisableFavorNonGeneric || skipFunction ( F ) ) return false ; bool Changed = false ; for ( BasicBlock & B : F ) { for ( Instruction & I : B ) { if ( isa < LoadInst > ( I ) ) { Changed |= optimizeMemoryInstruction ( & I , 0 ) ; } else if ( isa < StoreInst > ( I ) ) { Changed |= optimizeMemoryInstruction ( & I , 1 ) ; } } } return Changed ; } </s>

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


<s>
unsigned
char
X86Subtarget
::
ClassifyGlobalReference
(
const
GlobalValue
*
GV
,
const
TargetMachine
&
TM
)
const
{
if
(
GV
->
hasDLLImportStorageClass
(
)
)
return
X86II
::
MO_DLLIMPORT
;
bool
isDecl
=
GV
->
isDeclarationForLinker
(
)
;
if
(
isPICStyleRIPRel
(
)
)
{
if
(
TM
.
getCodeModel
(
)
==
CodeModel
::
Large
)
return
X86II
::
MO_NO_FLAG
;
if
(
isTargetDarwin
(
)
)
{
if
(
GV
->
hasDefaultVisibility
(
)
&&
(
isDecl
||
GV
->
isWeakForLinker
(
)
)
)
return
X86II
::
MO_GOTPCREL
;
}
else
if
(
!
isTargetWin64
(
)
)
{
assert
(
isTargetELF
(
)
&&
"Unknown rip-relative target"
)
;
if
(
!
GV
->
hasLocalLinkage
(
)
&&
GV
->
hasDefaultVisibility
(
)
)
return
X86II
::
MO_GOTPCREL
;
}
return
X86II
::
MO_NO_FLAG
;
}
if
(
isPICStyleGOT
(
)
)
{
if
(
GV
->
hasLocalLinkage
(
)
||
GV
->
hasHiddenVisibility
(
)
)
return
X86II
::
MO_GOTOFF
;
return
X86II
::
MO_GOT
;
}
if
(
isPICStyleStubPIC
(
)
)
{
if
(
!
isDecl
&&
!
GV
->
isWeakForLinker
(
)
)
return
X86II
::
MO_PIC_BASE_OFFSET
;
if
(
!
GV
->
hasHiddenVisibility
(
)
)
return
X86II
::
MO_DARWIN_NONLAZY_PIC_BASE
;
if
(
isDecl
||
GV
->
hasCommonLinkage
(
)
)
{
return
X86II
::
MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE
;
}
return
X86II
::
MO_PIC_BASE_OFFSET
;
}
if
(
isPICStyleStubNoDynamic
(
)
)
{
if
(
!
isDecl
&&
!
GV
->
isWeakForLinker
(
)
)
return
X86II
::
MO_NO_FLAG
;
if
(
!
GV
->
hasHiddenVisibility
(
)
)
return
X86II
::
MO_DARWIN_NONLAZY
;
return
X86II
::
MO_NO_FLAG
;
}
return
X86II
::
MO_NO_FLAG
;
}
</s>

ClassifyGlobalReference - Find the target operand flags that describe how a global value should be referenced for the current subtarget .


<s> void SystemZPassConfig :: addPreEmitPass ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createSystemZShortenInstPass ( getSystemZTargetMachine ( ) ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createSystemZElimComparePass ( getSystemZTargetMachine ( ) ) ) ; addPass ( createSystemZLongBranchPass ( getSystemZTargetMachine ( ) ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( & PostMachineSchedulerID ) ; } </s>

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

SystemZ SystemZ SystemZ SystemZ SystemZ SystemZ SystemZ SystemZ


<s>
MachineInstr
*
LanaiInstrInfo
::
optimizeSelect
(
MachineInstr
&
MI
,
SmallPtrSetImpl
<
MachineInstr
*
>
&
SeenMIs
,
bool
)
const
{
assert
(
MI
.
getOpcode
(
)
==
Lanai
::
SELECT
&&
"unknown select instruction"
)
;
MachineRegisterInfo
&
MRI
=
MI
.
getParent
(
)
->
getParent
(
)
->
getRegInfo
(
)
;
MachineInstr
*
DefMI
=
canFoldIntoSelect
(
MI
.
getOperand
(
1
)
.
getReg
(
)
,
MRI
)
;
bool
Invert
=
!
DefMI
;
if
(
!
DefMI
)
DefMI
=
canFoldIntoSelect
(
MI
.
getOperand
(
2
)
.
getReg
(
)
,
MRI
)
;
if
(
!
DefMI
)
return
nullptr
;
MachineOperand
FalseReg
=
MI
.
getOperand
(
Invert
1
:
2
)
;
unsigned
DestReg
=
MI
.
getOperand
(
0
)
.
getReg
(
)
;
const
TargetRegisterClass
*
PreviousClass
=
MRI
.
getRegClass
(
FalseReg
.
getReg
(
)
)
;
if
(
!
MRI
.
constrainRegClass
(
DestReg
,
PreviousClass
)
)
return
nullptr
;
MachineInstrBuilder
NewMI
=
BuildMI
(
*
MI
.
getParent
(
)
,
MI
,
MI
.
getDebugLoc
(
)
,
DefMI
->
getDesc
(
)
,
DestReg
)
;
const
MCInstrDesc
&
DefDesc
=
DefMI
->
getDesc
(
)
;
for
(
unsigned
i
=
1
,
e
=
DefDesc
.
getNumOperands
(
)
;
i
!=
e
&&
!
DefDesc
.
OpInfo
[
i
]
.
isPredicate
(
)
;
++
i
)
NewMI
.
add
(
DefMI
->
getOperand
(
i
)
)
;
unsigned
CondCode
=
MI
.
getOperand
(
3
)
.
getImm
(
)
;
if
(
Invert
)
NewMI
.
addImm
(
getOppositeCondition
(
LPCC
::
CondCode
(
CondCode
)
)
)
;
else
NewMI
.
addImm
(
CondCode
)
;
NewMI
.
copyImplicitOps
(
MI
)
;
FalseReg
.
setImplicit
(
)
;
NewMI
.
add
(
FalseReg
)
;
NewMI
->
tieOperands
(
0
,
NewMI
->
getNumOperands
(
)
1
)
;
SeenMIs
.
insert
(
NewMI
)
;
SeenMIs
.
erase
(
DefMI
)
;
if
(
DefMI
->
getParent
(
)
!=
MI
.
getParent
(
)
)
NewMI
->
clearKillInfo
(
)
;
DefMI
->
eraseFromParent
(
)
;
return
NewMI
;
}
</s>

Given a select instruction that was understood by analyzeSelect and returned Optimizable = true , attempt to optimize MI by merging it with one of its operands .


<s> static bool mips_cfg_in_reorg ( void ) { return ( mips_r10k_cache_barrier != R10K_CACHE_BARRIER_NONE || TARGET_RELAX_PIC_CALLS ) ; } </s>

Return whether CFG is used in mips_reorg .


runOnMachineFunction - Emit the function body .


"invalid feature modifier in %<-mcpu=%s%>"

Validate a command-line -mcpu option . Parse the cpu and extensions ( if any ) specified in STR and throw errors if appropriate . Put the results if they are valid in RES and ISA_FLAGS . Return whether the option is valid .


<s>
unsigned
ARMMCCodeEmitter
::
getMachineOpValue
(
const
MCInst
&
MI
,
const
MCOperand
&
MO
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
const
{
if
(
MO
.
isReg
(
)
)
{
unsigned
Reg
=
MO
.
getReg
(
)
;
unsigned
RegNo
=
CTX
.
getRegisterInfo
(
)
->
getEncodingValue
(
Reg
)
;
switch
(
Reg
)
{
default
:
return
RegNo
;
case
ARM
::
Q0
:
case
ARM
::
Q1
:
case
ARM
::
Q2
:
case
ARM
::
Q3
:
case
ARM
::
Q4
:
case
ARM
::
Q5
:
case
ARM
::
Q6
:
case
ARM
::
Q7
:
case
ARM
::
Q8
:
case
ARM
::
Q9
:
case
ARM
::
Q10
:
case
ARM
::
Q11
:
case
ARM
::
Q12
:
case
ARM
::
Q13
:
case
ARM
::
Q14
:
case
ARM
::
Q15
:
return
2
*
RegNo
;
}
}
else
if
(
MO
.
isImm
(
)
)
{
return
static_cast
<
unsigned
>
(
MO
.
getImm
(
)
)
;
}
else
if
(
MO
.
isFPImm
(
)
)
{
return
static_cast
<
unsigned
>
(
APFloat
(
MO
.
getFPImm
(
)
)
.
bitcastToAPInt
(
)
.
getHiBits
(
32
)
.
getLimitedValue
(
)
)
;
}
llvm_unreachable
(
"Unable to encode MCOperand!"
)
;
}
</s>

getMachineOpValue - Return binary encoding of operand .


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

RI5CY RISCV RISCV "riscv-call" "riscv-plt" "riscv-lo" "riscv-hi" "riscv-pcrel-lo" "riscv-pcrel-hi" "riscv-got-hi" "riscv-tprel-lo" "riscv-tprel-hi" "riscv-tprel-add" "riscv-tls-got-hi" "riscv-tls-gd-hi"


<s> int arm_regno_class ( int regno ) { if ( TARGET_THUMB ) { if ( regno == STACK_POINTER_REGNUM ) return STACK_REG ; if ( regno == CC_REGNUM ) return CC_REG ; if ( regno < 8 ) return LO_REGS ; return HI_REGS ; } if ( regno <= LAST_ARM_REGNUM || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) return GENERAL_REGS ; if ( regno == CC_REGNUM || regno == VFPCC_REGNUM ) return NO_REGS ; if ( IS_CIRRUS_REGNUM ( regno ) ) return CIRRUS_REGS ; if ( IS_VFP_REGNUM ( regno ) ) return VFP_REGS ; if ( IS_IWMMXT_REGNUM ( regno ) ) return IWMMXT_REGS ; if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return IWMMXT_GR_REGS ; return FPA_REGS ; } </s>

For efficiency and historical reasons LO_REGS , HI_REGS and CC_REGS are not used in arm mode .


<s> const ARMInstrInfo * getInstrInfo ( ) const override { return & InstrInfo ; } </s>


"Blackfin intrinsics are not overloaded"

Return a string with the name of the plan and the applicable VFs and UFs .


<s> MCSection * getExplicitSectionGlobal ( const GlobalObject * GO , SectionKind Kind , const TargetMachine & TM ) const override { return TextSection ; } </s>

Targets should implement this method to assign a section to globals with an explicit section specfied .


<s> static bool sh_function_ok_for_sibcall ( tree decl , tree exp ATTRIBUTE_UNUSED ) { return ( 1 && ( ! TARGET_SHCOMPACT || current_function_args_info . stack_regs == 0 ) && ! sh_cfun_interrupt_handler_p ( ) && ( ! flag_pic || ( decl && ! TREE_PUBLIC ( decl ) ) || ( decl && DECL_VISIBILITY ( decl ) != VISIBILITY_DEFAULT ) ) ) ; } </s>

If PIC , we can not make sibling calls to global functions because the PLT requires r12 to be live .


<s> void WebAssemblyDebugValueManager :: clone ( MachineInstr * Insert , unsigned NewReg ) { MachineBasicBlock * MBB = Insert -> getParent ( ) ; MachineFunction * MF = MBB -> getParent ( ) ; for ( MachineInstr * DBI : reverse ( DbgValues ) ) { MachineInstr * Clone = MF -> CloneMachineInstr ( DBI ) ; Clone -> getDebugOperand ( 0 ) . setReg ( NewReg ) ; MBB -> insert ( Insert , Clone ) ; } } </s>

Make a functionally equivalent copy of this MachineFunctionInfo in MF .


<s> static void c6x_print_unit_specifier_field ( FILE * file , rtx_insn * insn ) { enum attr_units units = get_attr_units ( insn ) ; enum attr_cross cross = get_attr_cross ( insn ) ; enum attr_dest_regfile rf = get_attr_dest_regfile ( insn ) ; int half ; char unitspec ; if ( units == UNITS_D_ADDR ) { enum attr_addr_regfile arf = get_attr_addr_regfile ( insn ) ; int t_half ; gcc_assert ( arf != ADDR_REGFILE_UNKNOWN ) ; half = arf == ADDR_REGFILE_A ? 1 : 2 ; t_half = rf == DEST_REGFILE_A ? 1 : 2 ; fprintf ( file , ".d%dt%d" , half , t_half ) ; return ; } if ( insn_info . exists ( ) ) { int unit = INSN_INFO_ENTRY ( INSN_UID ( insn ) ) . reservation ; fputs ( "." , file ) ; fputs ( c6x_unit_names [ unit ] , file ) ; if ( cross == CROSS_Y ) fputs ( "x" , file ) ; return ; } gcc_assert ( rf != DEST_REGFILE_UNKNOWN ) ; unitspec = c6x_get_unit_specifier ( insn ) ; half = rf == DEST_REGFILE_A ? 1 : 2 ; fprintf ( file , ".%c%d%s" , unitspec , half , cross == CROSS_Y ? "x" : "" ) ; } </s>


<s> bool csky_symbol_mentioned_p ( rtx x ) { const char * fmt ; int i ; if ( GET_CODE ( x ) == SYMBOL_REF ) return true ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - 1 ; i >= 0 ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( x , i ) - 1 ; j >= 0 ; j -- ) if ( csky_symbol_mentioned_p ( XVECEXP ( x , i , j ) ) ) return true ; } else if ( fmt [ i ] == 'e' && csky_symbol_mentioned_p ( XEXP ( x , i ) ) ) return true ; } return false ; } </s>

Return TRUE if X references a SYMBOL_REF .


"Unexpected data type for Gather/Scatter"

Calculate the cost of Gather / Scatter operation .


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

Given a physical register constraint ( e.g .


<s> void ix86_emit_swdivsf ( rtx res , rtx a , rtx b , machine_mode mode ) { rtx x0 , x1 , e0 , e1 ; x0 = gen_reg_rtx ( mode ) ; e0 = gen_reg_rtx ( mode ) ; e1 = gen_reg_rtx ( mode ) ; x1 = gen_reg_rtx ( mode ) ; b = force_reg ( mode , b ) ; if ( mode == V16SFmode || mode == V8DFmode ) { if ( TARGET_AVX512ER ) { emit_insn ( gen_rtx_SET ( x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , b ) , UNSPEC_RCP28 ) ) ) ; emit_insn ( gen_rtx_SET ( res , gen_rtx_MULT ( mode , a , x0 ) ) ) ; return ; } else emit_insn ( gen_rtx_SET ( x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , b ) , UNSPEC_RCP14 ) ) ) ; } else emit_insn ( gen_rtx_SET ( x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , b ) , UNSPEC_RCP ) ) ) ; emit_insn ( gen_rtx_SET ( e0 , gen_rtx_MULT ( mode , x0 , b ) ) ) ; emit_insn ( gen_rtx_SET ( e0 , gen_rtx_MULT ( mode , x0 , e0 ) ) ) ; emit_insn ( gen_rtx_SET ( e1 , gen_rtx_PLUS ( mode , x0 , x0 ) ) ) ; emit_insn ( gen_rtx_SET ( x1 , gen_rtx_MINUS ( mode , e1 , e0 ) ) ) ; emit_insn ( gen_rtx_SET ( res , gen_rtx_MULT ( mode , a , x1 ) ) ) ; } </s>


<s> bool isReg ( ) const override { return Kind == REGISTER ; } </s>


<s> const uint32_t * SICRegisterInfo :: getCallPreservedMask ( const MachineFunction & MF , CallingConv :: ID ) const { return CSR_O32_RegMask ; } </s>

Return a mask of call-preserved registers for the given calling convention on the current function .


<s> bool SparcAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getString ( ) ; if ( IDVal == ".byte" ) return parseDirectiveWord ( 1 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".half" ) return parseDirectiveWord ( 2 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".word" ) return parseDirectiveWord ( 4 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".nword" ) return parseDirectiveWord ( is64Bit ( ) ? 8 : 4 , DirectiveID . getLoc ( ) ) ; if ( is64Bit ( ) && IDVal == ".xword" ) return parseDirectiveWord ( 8 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".register" ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == ".proc" ) { Parser . eatToEndOfStatement ( ) ; return false ; } return true ; } </s>

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


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> bool Z80RegisterInfo :: isFrameOffsetLegal ( const MachineInstr * MI , unsigned BaseReg , int64_t Offset ) const { return isInt < 8 > ( Offset ) ; } </s>

Determine whether a given base register plus offset immediate is encodable to resolve a frame index .


<s> const TVMSubtarget * getSubtargetImpl ( const Function & F ) 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 :: getTargetNode ( GlobalAddressSDNode * N , EVT Ty , SelectionDAG & DAG , unsigned Flag ) const { return DAG . getTargetGlobalAddress ( N -> getGlobal ( ) , SDLoc ( N ) , Ty , 0 , Flag ) ; } </s>

Retrieve the target node this edge connects to .


<s> bool AArch64InstrInfo :: getMachineCombinerPatterns ( MachineInstr & Root , SmallVectorImpl < MachineCombinerPattern > & Patterns , bool DoRegPressureReduce ) const { if ( getMaddPatterns ( Root , Patterns ) ) return true ; if ( getFMAPatterns ( Root , Patterns ) ) return true ; return TargetInstrInfo :: getMachineCombinerPatterns ( Root , Patterns , DoRegPressureReduce ) ; } </s>

Return true when there is potentially a faster code sequence for an instruction chain ending in Root .


<s>
SDValue
RISCVTargetLowering
::
getAddr
(
NodeTy
*
N
,
EVT
Ty
,
SelectionDAG
&
DAG
,
bool
IsLocal
,
bool
CanDeriveFromPcc
)
const
{
SDLoc
DL
(
N
)
;
if
(
RISCVABI
::
isCheriPureCapABI
(
Subtarget
.
getTargetABI
(
)
)
)
{
SDValue
Addr
=
getTargetNode
(
N
,
DL
,
Ty
,
DAG
,
0
)
;
if
(
IsLocal
&&
CanDeriveFromPcc
)
{
return
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
PseudoCLLC
,
DL
,
Ty
,
Addr
)
,
0
)
;
}
SDValue
Load
=
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
PseudoCLGC
,
DL
,
Ty
,
Addr
)
,
0
)
;
MachineFunction
&
MF
=
DAG
.
getMachineFunction
(
)
;
MachineMemOperand
*
MemOp
=
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getGOT
(
MF
)
,
MachineMemOperand
::
MOLoad
|
MachineMemOperand
::
MODereferenceable
|
MachineMemOperand
::
MOInvariant
,
LLT
(
Ty
.
getSimpleVT
(
)
)
,
Align
(
Ty
.
getFixedSizeInBits
(
)
/
8
)
)
;
DAG
.
setNodeMemRefs
(
cast
<
MachineSDNode
>
(
Load
.
getNode
(
)
)
,
{
MemOp
}
)
;
return
Load
;
}
if
(
isPositionIndependent
(
)
)
{
SDValue
Addr
=
getTargetNode
(
N
,
DL
,
Ty
,
DAG
,
0
)
;
if
(
IsLocal
)
return
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
PseudoLLA
,
DL
,
Ty
,
Addr
)
,
0
)
;
SDValue
Load
=
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
PseudoLA
,
DL
,
Ty
,
Addr
)
,
0
)
;
MachineFunction
&
MF
=
DAG
.
getMachineFunction
(
)
;
MachineMemOperand
*
MemOp
=
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getGOT
(
MF
)
,
MachineMemOperand
::
MOLoad
|
MachineMemOperand
::
MODereferenceable
|
MachineMemOperand
::
MOInvariant
,
LLT
(
Ty
.
getSimpleVT
(
)
)
,
Align
(
Ty
.
getFixedSizeInBits
(
)
/
8
)
)
;
DAG
.
setNodeMemRefs
(
cast
<
MachineSDNode
>
(
Load
.
getNode
(
)
)
,
{
MemOp
}
)
;
return
Load
;
}
switch
(
getTargetMachine
(
)
.
getCodeModel
(
)
)
{
default
:
report_fatal_error
(
"Unsupported code model for lowering"
)
;
case
CodeModel
::
Small
:
{
SDValue
AddrHi
=
getTargetNode
(
N
,
DL
,
Ty
,
DAG
,
RISCVII
::
MO_HI
)
;
SDValue
AddrLo
=
getTargetNode
(
N
,
DL
,
Ty
,
DAG
,
RISCVII
::
MO_LO
)
;
SDValue
MNHi
=
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
LUI
,
DL
,
Ty
,
AddrHi
)
,
0
)
;
return
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
ADDI
,
DL
,
Ty
,
MNHi
,
AddrLo
)
,
0
)
;
}
case
CodeModel
::
Medium
:
{
SDValue
Addr
=
getTargetNode
(
N
,
DL
,
Ty
,
DAG
,
0
)
;
return
SDValue
(
DAG
.
getMachineNode
(
RISCV
::
PseudoLLA
,
DL
,
Ty
,
Addr
)
,
0
)
;
}
}
}
</s>

Return the address accessed by this recipe .


<s> static void s390_reorg ( void ) { bool pool_overflow = false ; int hw_before , hw_after ; split_all_insns_noflow ( ) ; for ( ; ; ) { struct constant_pool * pool = NULL ; if ( ! pool_overflow ) { pool = s390_mainpool_start ( ) ; if ( ! pool ) pool_overflow = true ; } if ( pool_overflow ) pool = s390_chunkify_start ( ) ; if ( ! TARGET_CPU_ZARCH && s390_split_branches ( ) ) { if ( pool_overflow ) s390_chunkify_cancel ( pool ) ; else s390_mainpool_cancel ( pool ) ; continue ; } if ( pool_overflow ) s390_chunkify_finish ( pool ) ; else s390_mainpool_finish ( pool ) ; cfun -> machine -> split_branches_pending_p = false ; break ; } if ( TARGET_CPU_ZARCH ) { rtx_insn * insn , * target ; rtx label ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { label = s390_execute_label ( insn ) ; if ( ! label ) continue ; gcc_assert ( label != const0_rtx ) ; target = emit_label ( XEXP ( label , 0 ) ) ; INSN_ADDRESSES_NEW ( target , - 1 ) ; target = emit_insn ( s390_execute_target ( insn ) ) ; INSN_ADDRESSES_NEW ( target , - 1 ) ; } } s390_optimize_prologue ( ) ; if ( s390_tune == PROCESSOR_2097_Z10 || s390_tune == PROCESSOR_2817_Z196 || s390_tune == PROCESSOR_2827_ZEC12 ) { rtx_insn * insn ; bool insn_added_p = false ; shorten_branches ( get_insns ( ) ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( ! INSN_P ( insn ) || INSN_CODE ( insn ) <= 0 ) continue ; if ( JUMP_P ( insn ) ) insn_added_p |= s390_fix_long_loop_prediction ( insn ) ; if ( ( GET_CODE ( PATTERN ( insn ) ) == PARALLEL || GET_CODE ( PATTERN ( insn ) ) == SET ) && s390_tune == PROCESSOR_2097_Z10 ) insn_added_p |= s390_z10_optimize_cmp ( insn ) ; } if ( insn_added_p ) shorten_branches ( get_insns ( ) ) ; } s390_function_num_hotpatch_hw ( current_function_decl , & hw_before , & hw_after ) ; if ( hw_after > 0 ) { rtx_insn * insn ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_FUNCTION_BEG ) break ; } gcc_assert ( insn ) ; while ( hw_after > 0 ) { if ( hw_after >= 3 && TARGET_CPU_ZARCH ) { insn = emit_insn_after ( gen_nop_6_byte ( ) , insn ) ; hw_after -= 3 ; } else if ( hw_after >= 2 ) { insn = emit_insn_after ( gen_nop_4_byte ( ) , insn ) ; hw_after -= 2 ; } else { insn = emit_insn_after ( gen_nop_2_byte ( ) , insn ) ; hw_after -= 1 ; } } gcc_assert ( hw_after == 0 ) ; } } </s>


<s> bool AArch64FrameLowering :: canUseRedZone ( const MachineFunction & MF ) const { if ( ! EnableRedZone ) return false ; if ( MF . getFunction ( ) . hasFnAttribute ( Attribute :: NoRedZone ) ) return false ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const AArch64FunctionInfo * AFI = MF . getInfo < AArch64FunctionInfo > ( ) ; uint64_t NumBytes = AFI -> getLocalStackSize ( ) ; return ! ( MFI . hasCalls ( ) || hasFP ( MF ) || NumBytes > 128 || getSVEStackSize ( MF ) ) ; } </s>

Can this function use the red zone for local allocations .


<s> bool isImm ( ) const { return ! OpToFold ; } </s>


<s> unsigned WDC65816InstrInfo :: getGlobalBaseReg ( MachineFunction * MF ) const { WDC65816MachineFunctionInfo * WDC65816FI = MF -> getInfo < WDC65816MachineFunctionInfo > ( ) ; return WDC65816FI -> getGlobalBaseReg ( ) ; unsigned GlobalBaseReg = WDC65816FI -> getGlobalBaseReg ( ) ; if ( GlobalBaseReg != 0 ) return GlobalBaseReg ; MachineBasicBlock & FirstMBB = MF -> front ( ) ; MachineBasicBlock :: iterator MBBI = FirstMBB . begin ( ) ; MachineRegisterInfo & RegInfo = MF -> getRegInfo ( ) ; GlobalBaseReg = RegInfo . createVirtualRegister ( & SP :: IntRegsRegClass ) ; DebugLoc dl ; BuildMI ( FirstMBB , MBBI , dl , get ( SP :: GETPCX ) , GlobalBaseReg ) ; SparcFI -> setGlobalBaseReg ( GlobalBaseReg ) ; return GlobalBaseReg ; } </s>

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

WDC65816 WDC WDC WDC WDC WDC WDC 0 SP::IntRegsRegClass SP::GETPCX


<s> static int pad_groups ( FILE * dump , int sched_verbose , rtx_insn * prev_head_insn , rtx_insn * tail ) { rtx_insn * insn , * next_insn ; rtx nop ; int issue_rate ; int can_issue_more ; int group_end ; int group_count = 0 ; issue_rate = rs6000_issue_rate ( ) ; can_issue_more = issue_rate ; insn = get_next_active_insn ( prev_head_insn , tail ) ; next_insn = get_next_active_insn ( insn , tail ) ; while ( insn != NULL_RTX ) { can_issue_more = rs6000_variable_issue ( dump , sched_verbose , insn , can_issue_more ) ; group_end = ( next_insn == NULL_RTX || GET_MODE ( next_insn ) == TImode ) ; if ( next_insn == NULL_RTX ) break ; if ( group_end ) { if ( can_issue_more && ( rs6000_sched_insert_nops == sched_finish_pad_groups ) && ! insn_terminates_group_p ( insn , current_group ) && ! insn_terminates_group_p ( next_insn , previous_group ) ) { if ( ! is_branch_slot_insn ( next_insn ) ) can_issue_more -- ; while ( can_issue_more ) { nop = gen_nop ( ) ; emit_insn_before ( nop , next_insn ) ; can_issue_more -- ; } } can_issue_more = issue_rate ; group_count ++ ; } insn = next_insn ; next_insn = get_next_active_insn ( insn , tail ) ; } return group_count ; } </s>

Scan the insn sequence between PREV_HEAD_INSN and TAIL and examine the dispatch group boundaries that the scheduler had marked . Pad with nops any dispatch groups which have vacant issue slots , in order to force the scheduler 's grouping on the processor dispatcher . The function returns the number of dispatch groups found .


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

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


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

"%qE attribute only applies to base type of a "

Called upon detection of the use of the cmse_nonsecure_call attribute , this function will check whether the attribute is allowed here and will add the attribute to the function type tree or otherwise issue a diagnostic . The reason we check this at declaration time is to only allow the use of the attribute with declarations of function pointers and not function declarations . This function checks NODE is of the expected type and issues diagnostics otherwise using NAME . If it is not of the expected type * NO_ADD_ATTRS will be set to true .


<s> static rtx moxie_function_arg ( cumulative_args_t cum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( * cum < 8 ) return gen_rtx_REG ( arg . mode , * cum ) ; else return NULL_RTX ; } </s>

Return the next register to be used to hold a function argument or NULL_RTX if there 's no more space .


<s> const uint32_t * ARMBaseRegisterInfo :: getCallPreservedMask ( const MachineFunction & MF , CallingConv :: ID CC ) const { const ARMSubtarget & STI = MF . getSubtarget < ARMSubtarget > ( ) ; if ( CC == CallingConv :: GHC ) return CSR_NoRegs_RegMask ; return STI . isTargetDarwin ( ) ? CSR_iOS_RegMask : CSR_AAPCS_RegMask ; } </s>


<s> unsigned SIInstrInfo :: removeBranch ( MachineBasicBlock & MBB , int * BytesRemoved ) const { MachineBasicBlock :: iterator I = MBB . getFirstTerminator ( ) ; unsigned Count = 0 ; unsigned RemovedSize = 0 ; while ( I != MBB . end ( ) ) { MachineBasicBlock :: iterator Next = std :: next ( I ) ; RemovedSize += getInstSizeInBytes ( * I ) ; I -> eraseFromParent ( ) ; ++ Count ; I = Next ; } if ( BytesRemoved ) * BytesRemoved = RemovedSize ; return Count ; } </s>

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


<s> static const char * gen_prefix ( tree decl ) { if ( DECL_ONE_ONLY ( decl ) ) return NULL ; if ( has_attr ( "section" , decl ) ) return NULL ; if ( has_attr ( ATTR_LOWER , decl ) ) return lower_prefix ; if ( ! msp430x ) return NULL ; if ( has_attr ( ATTR_UPPER , decl ) ) return upper_prefix ; if ( has_attr ( ATTR_EITHER , decl ) ) return either_prefix ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { if ( msp430_code_region == LOWER ) return lower_prefix ; if ( msp430_code_region == UPPER ) return upper_prefix ; if ( msp430_code_region == EITHER ) return either_prefix ; } else { if ( msp430_data_region == LOWER ) return lower_prefix ; if ( msp430_data_region == UPPER ) return upper_prefix ; if ( msp430_data_region == EITHER ) return either_prefix ; } return NULL ; } </s>

Generate a prefix for a section name , based upon the region into which the object should be placed .


"Requesting 64-bit offset in 32-bit immediate!"

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


<s>
void
applyFixup
(
const
MCFixup
&
Fixup
,
char
*
Data
,
unsigned
DataSize
,
uint64_t
Value
,
bool
IsPCRel
,
MCContext
&
Ctx
)
const
override
{
unsigned
Size
=
1
<<
getFixupKindLog2Size
(
Fixup
.
getKind
(
)
)
;
assert
(
Fixup
.
getOffset
(
)
+
Size
<=
DataSize
&&
"Invalid fixup offset!"
)
;
assert
(
isIntN
(
Size
*
8
+
1
,
Value
)
&&
"Value does not fit in the Fixup field"
)
;
for
(
unsigned
i
=
0
;
i
!=
Size
;
++
i
)
Data
[
Fixup
.
getOffset
(
)
+
i
]
=
uint8_t
(
Value
>>
(
i
*
8
)
)
;
}
</s>

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


<s> int mve_vector_mem_operand ( machine_mode mode , rtx op , bool strict ) { enum rtx_code code ; int val , reg_no ; if ( REG_P ( op ) ) { int reg_no = REGNO ( op ) ; return ( ( ( mode == E_V8QImode || mode == E_V4QImode || mode == E_V4HImode ) ? reg_no <= LAST_LO_REGNUM : ( reg_no < LAST_ARM_REGNUM && reg_no != SP_REGNUM ) ) || ( ! strict && reg_no >= FIRST_PSEUDO_REGISTER ) ) ; } code = GET_CODE ( op ) ; if ( code == POST_INC || code == PRE_DEC || code == PRE_INC || code == POST_DEC ) { reg_no = REGNO ( XEXP ( op , 0 ) ) ; return ( ( mode == E_V8QImode || mode == E_V4QImode || mode == E_V4HImode ) ? reg_no <= LAST_LO_REGNUM : ( reg_no < LAST_ARM_REGNUM && reg_no != SP_REGNUM ) ) || reg_no >= FIRST_PSEUDO_REGISTER ; } else if ( ( ( code == POST_MODIFY || code == PRE_MODIFY ) && GET_CODE ( XEXP ( op , 1 ) ) == PLUS && XEXP ( op , 0 ) == XEXP ( XEXP ( op , 1 ) , 0 ) && REG_P ( XEXP ( op , 0 ) ) && GET_CODE ( XEXP ( XEXP ( op , 1 ) , 1 ) ) == CONST_INT ) || ( reload_completed && code == PLUS && REG_P ( XEXP ( op , 0 ) ) && GET_CODE ( XEXP ( op , 1 ) ) == CONST_INT ) ) { reg_no = REGNO ( XEXP ( op , 0 ) ) ; if ( code == PLUS ) val = INTVAL ( XEXP ( op , 1 ) ) ; else val = INTVAL ( XEXP ( XEXP ( op , 1 ) , 1 ) ) ; switch ( mode ) { case E_V16QImode : case E_V8QImode : case E_V4QImode : if ( abs ( val ) > 127 ) return FALSE ; break ; case E_V8HImode : case E_V8HFmode : case E_V4HImode : case E_V4HFmode : if ( val % 2 != 0 || abs ( val ) > 254 ) return FALSE ; break ; case E_V4SImode : case E_V4SFmode : if ( val % 4 != 0 || abs ( val ) > 508 ) return FALSE ; break ; default : return FALSE ; } return reg_no >= FIRST_PSEUDO_REGISTER || ( MVE_STN_LDW_MODE ( mode ) ? reg_no <= LAST_LO_REGNUM : ( reg_no < LAST_ARM_REGNUM && reg_no != SP_REGNUM ) ) ; } return FALSE ; } </s>

This function returns TRUE on matching mode and op.1 . For given modes , check for [ Rn ] , return TRUE for Rn < = LO_REGS.2 . For other modes , check for [ Rn ] , return TRUE for Rn < R15 ( expect R13 ) .


<s> static void s390_optimize_register_info ( ) { char clobbered_regs [ 32 ] ; int i , j ; gcc_assert ( epilogue_completed ) ; gcc_assert ( ! cfun -> machine -> split_branches_pending_p ) ; s390_regs_ever_clobbered ( clobbered_regs ) ; for ( i = 0 ; i < 32 ; i ++ ) clobbered_regs [ i ] = clobbered_regs [ i ] && ! global_regs [ i ] ; clobbered_regs [ RETURN_REGNUM ] |= ( TARGET_TPF_PROFILING || cfun_frame_layout . save_return_addr_p || crtl -> calls_eh_return ) ; memset ( cfun_frame_layout . gpr_save_slots , 0 , 6 ) ; for ( i = 6 ; i < 16 ; i ++ ) if ( ! clobbered_regs [ i ] ) cfun_gpr_save_slot ( i ) = 0 ; for ( i = 0 ; i < 16 && cfun_gpr_save_slot ( i ) != - 1 ; i ++ ) ; for ( j = 15 ; j > i && cfun_gpr_save_slot ( j ) != - 1 ; j -- ) ; cfun_frame_layout . first_restore_gpr = ( i == 16 ) ? - 1 : i ; cfun_frame_layout . last_restore_gpr = ( i == 16 ) ? - 1 : j ; s390_register_info_stdarg_gpr ( ) ; for ( i = 0 ; i < 16 && cfun_gpr_save_slot ( i ) != - 1 ; i ++ ) ; for ( j = 15 ; j > i && cfun_gpr_save_slot ( j ) != - 1 ; j -- ) ; cfun_frame_layout . first_save_gpr = ( i == 16 ) ? - 1 : i ; cfun_frame_layout . last_save_gpr = ( i == 16 ) ? - 1 : j ; } </s>

This function is called by s390_optimize_prologue in order to get rid of unnecessary GPR save/restore instructions . The register info for the GPRs is re-computed and the ranges are re-calculated .


<s> static bool isF128SoftLibCall ( const char * CallSym ) { const char * const LibCalls [ ] = { "__addtf3" , "__divtf3" , "__eqtf2" , "__extenddftf2" , "__extendsftf2" , "__fixtfdi" , "__fixtfsi" , "__fixtfti" , "__fixunstfdi" , "__fixunstfsi" , "__fixunstfti" , "__floatditf" , "__floatsitf" , "__floattitf" , "__floatunditf" , "__floatunsitf" , "__floatuntitf" , "__getf2" , "__gttf2" , "__letf2" , "__lttf2" , "__multf3" , "__netf2" , "__powitf2" , "__subtf3" , "__trunctfdf2" , "__trunctfsf2" , "__unordtf2" , "ceill" , "copysignl" , "cosl" , "exp2l" , "expl" , "floorl" , "fmal" , "fmodl" , "log10l" , "log2l" , "logl" , "nearbyintl" , "powl" , "rintl" , "roundl" , "sinl" , "sqrtl" , "truncl" } ; auto Comp = [ ] ( const char * S1 , const char * S2 ) { return strcmp ( S1 , S2 ) < 0 ; } ; assert ( std :: is_sorted ( std :: begin ( LibCalls ) , std :: end ( LibCalls ) , Comp ) ) ; return std :: binary_search ( std :: begin ( LibCalls ) , std :: end ( LibCalls ) , CallSym , Comp ) ; } </s>

This function returns true if CallSym is a long double emulation routine .


<s> bool s390_hard_regno_rename_ok ( unsigned int old_reg , unsigned int new_reg ) { if ( cfun -> machine -> base_reg ) if ( REGNO ( cfun -> machine -> base_reg ) == old_reg || REGNO ( cfun -> machine -> base_reg ) == new_reg ) return false ; return true ; } </s>

Return nonzero if register OLD_REG can be renamed to register NEW_REG .


runOnMachineFunction - Emit the function body .


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

Given a physical register constraint ( e.g .


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

getPassName - Return a nice clean name for a pass .


"eliminateFrameIndex currently requires hasFP"

"Frame offsets outside of the signed 12-bit range not supported"


<s>
bool
X86InstrInfo
::
hasReassociableOperands
(
const
MachineInstr
&
Inst
,
const
MachineBasicBlock
*
MBB
)
const
{
assert
(
Inst
.
getNumExplicitOperands
(
)
==
3
&&
Inst
.
getNumExplicitDefs
(
)
==
1
&&
Inst
.
getNumDefs
(
)
<=
2
&&
"Reassociation needs binary operators"
)
;
const
MachineOperand
*
FlagDef
=
Inst
.
findRegisterDefOperand
(
X86
::
EFLAGS
)
;
assert
(
(
Inst
.
getNumDefs
(
)
==
1
||
FlagDef
)
&&
"Implicit def isn't flags?"
)
;
if
(
FlagDef
&&
!
FlagDef
->
isDead
(
)
)
return
false
;
return
TargetInstrInfo
::
hasReassociableOperands
(
Inst
,
MBB
)
;
}
</s>

Return true when \P Inst has reassociable operands in the same \P MBB .


<s> bool AArch64TargetLowering :: isLegalAddImmediate ( int64_t Immed ) const { if ( Immed == std :: numeric_limits < int64_t > :: min ( ) ) return false ; Immed = std :: abs ( Immed ) ; return ( ( Immed >> 12 ) == 0 || ( ( Immed & 0xfff ) == 0 && Immed >> 24 == 0 ) ) ; } </s>

Return true if the specified immediate is legal add immediate , that is the target has add instructions which can add a register and the immediate without having to materialize the immediate into a register .


<s> bool PPCPassConfig :: addPreRegAlloc ( ) { initializePPCVSXFMAMutatePass ( * PassRegistry :: getPassRegistry ( ) ) ; insertPass ( VSXFMAMutateEarly ? & RegisterCoalescerID : & MachineSchedulerID , & PPCVSXFMAMutateID ) ; return false ; } </s>

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


<s> bool SITargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace , unsigned Align , bool * IsFast ) const { if ( IsFast ) * IsFast = false ; if ( VT == MVT :: Other || ( VT != MVT :: Other && VT . getSizeInBits ( ) > 1024 && VT . getStoreSize ( ) > 16 ) ) { return false ; } if ( AddrSpace == AMDGPUASI . LOCAL_ADDRESS || AddrSpace == AMDGPUASI . REGION_ADDRESS ) { bool AlignedBy4 = ( Align % 4 == 0 ) ; if ( IsFast ) * IsFast = AlignedBy4 ; return AlignedBy4 ; } if ( ! Subtarget -> hasUnalignedScratchAccess ( ) && ( AddrSpace == AMDGPUASI . PRIVATE_ADDRESS || AddrSpace == AMDGPUASI . FLAT_ADDRESS ) ) { return false ; } if ( Subtarget -> hasUnalignedBufferAccess ( ) ) { if ( IsFast ) { * IsFast = ( AddrSpace == AMDGPUASI . CONSTANT_ADDRESS ) ? ( Align % 4 == 0 ) : true ; } return true ; } if ( VT . bitsLT ( MVT :: i32 ) ) return false ; if ( IsFast ) * IsFast = true ; return VT . bitsGT ( MVT :: i32 ) && Align % 4 == 0 ; } </s>

Returns true if the target allows unaligned memory accesses of the specified type .


<s> void PPCRegisterInfo :: lowerCRSpilling ( MachineBasicBlock :: iterator II , unsigned FrameIndex ) const { MachineInstr & MI = * II ; MachineBasicBlock & MBB = * MI . getParent ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; const TargetInstrInfo & TII = * Subtarget . getInstrInfo ( ) ; DebugLoc dl = MI . getDebugLoc ( ) ; bool LP64 = TM . 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>
void
MipsCodeEmitter
::
emitInstruction
(
MachineBasicBlock
::
instr_iterator
MI
,
MachineBasicBlock
&
MBB
)
{
DEBUG
(
errs
(
)
<<
"JIT: "
<<
(
void
*
)
MCE
.
getCurrentPCValue
(
)
<<
":\t"
<<
*
MI
)
;
if
(
(
(
MI
->
getDesc
(
)
.
TSFlags
&
MipsII
::
FormMask
)
==
MipsII
::
Pseudo
)
&&
!
expandPseudos
(
MI
,
MBB
)
)
return
;
MCE
.
processDebugLoc
(
MI
->
getDebugLoc
(
)
,
true
)
;
emitWord
(
getBinaryCodeForInstr
(
*
MI
)
)
;
++
NumEmitted
;
MCE
.
processDebugLoc
(
MI
->
getDebugLoc
(
)
,
false
)
;
}
</s>

Targets should implement this to emit instructions .

Mips
Mips
"JIT: "
":\t"
MipsII::FormMask
MipsII::Pseudo


<s> void s390_conditional_register_usage ( void ) { int i ; if ( flag_pic ) { fixed_regs [ PIC_OFFSET_TABLE_REGNUM ] = 1 ; call_used_regs [ PIC_OFFSET_TABLE_REGNUM ] = 1 ; } if ( TARGET_CPU_ZARCH ) { fixed_regs [ BASE_REGNUM ] = 0 ; call_used_regs [ BASE_REGNUM ] = 0 ; fixed_regs [ RETURN_REGNUM ] = 0 ; call_used_regs [ RETURN_REGNUM ] = 0 ; } if ( TARGET_64BIT ) { for ( i = 24 ; i < 32 ; i ++ ) call_used_regs [ i ] = call_really_used_regs [ i ] = 0 ; } else { for ( i = 18 ; i < 20 ; i ++ ) call_used_regs [ i ] = call_really_used_regs [ i ] = 0 ; } if ( TARGET_SOFT_FLOAT ) { for ( i = 16 ; i < 32 ; i ++ ) call_used_regs [ i ] = fixed_regs [ i ] = 1 ; } } </s>


<s> MachineBasicBlock :: iterator Cpu0FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { } </s>

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


<s> unsigned GCNSubtarget :: getOccupancyWithNumSGPRs ( unsigned SGPRs ) const { if ( getGeneration ( ) >= AMDGPUSubtarget :: VOLCANIC_ISLANDS ) { if ( SGPRs <= 80 ) return 10 ; if ( SGPRs <= 88 ) return 9 ; if ( SGPRs <= 100 ) return 8 ; return 7 ; } if ( SGPRs <= 48 ) return 10 ; if ( SGPRs <= 56 ) return 9 ; if ( SGPRs <= 64 ) return 8 ; if ( SGPRs <= 72 ) return 7 ; if ( SGPRs <= 80 ) return 6 ; return 5 ; } </s>

Return the maximum number of waves per SIMD for kernels using SGPRs SGPRs .


<s>
SDValue
AMDGPUTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
Op
.
getNode
(
)
->
dump
(
)
;
assert
(
0
&&
"Custom lowering code for this"
"instruction is not implemented yet!"
)
;
break
;
case
ISD
::
SDIV
:
return
LowerSDIV
(
Op
,
DAG
)
;
case
ISD
::
SREM
:
return
LowerSREM
(
Op
,
DAG
)
;
case
ISD
::
SIGN_EXTEND_INREG
:
return
LowerSIGN_EXTEND_INREG
(
Op
,
DAG
)
;
case
ISD
::
BRCOND
:
return
LowerBRCOND
(
Op
,
DAG
)
;
case
ISD
::
CONCAT_VECTORS
:
return
LowerCONCAT_VECTORS
(
Op
,
DAG
)
;
case
ISD
::
EXTRACT_SUBVECTOR
:
return
LowerEXTRACT_SUBVECTOR
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
STORE
:
return
LowerSTORE
(
Op
,
DAG
)
;
case
ISD
::
UDIVREM
:
return
LowerUDIVREM
(
Op
,
DAG
)
;
}
return
Op
;
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> const char * output_387_reg_move ( rtx insn , rtx * operands ) { if ( REG_P ( operands [ 0 ] ) ) { if ( REG_P ( operands [ 1 ] ) && find_regno_note ( insn , REG_DEAD , REGNO ( operands [ 1 ] ) ) ) { if ( REGNO ( operands [ 0 ] ) == FIRST_STACK_REG ) return output_387_ffreep ( operands , 0 ) ; return "fstp\t%y0" ; } if ( STACK_TOP_P ( operands [ 0 ] ) ) return "fld%Z1\t%y1" ; return "fst\t%y0" ; } else if ( MEM_P ( operands [ 0 ] ) ) { gcc_assert ( REG_P ( operands [ 1 ] ) ) ; if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ 1 ] ) ) ) return "fstp%Z0\t%y0" ; else { if ( GET_MODE ( operands [ 0 ] ) == XFmode ) return "fstp%Z0\t%y0\n\tfld%Z0\t%y0" ; else return "fst%Z0\t%y0" ; } } else gcc_unreachable ( ) ; } </s>

Output code to perform an x87 FP register move , from OPERANDS [ 1 ] to OPERANDS [ 0 ] .


<s> MCObjectWriter * AVRAsmBackend :: createObjectWriter ( raw_pwrite_stream & OS ) const { return createAVRELFObjectWriter ( OS , MCELFObjectTargetWriter :: getOSABI ( OSType ) ) ; } </s>

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


<s> void RISCVAsmBackend :: applyFixup ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target , MutableArrayRef < char > Data , uint64_t Value , bool IsPCRel ) const { return ; } </s>

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


<s> bool SITargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace , unsigned Align , bool * IsFast ) const { if ( IsFast ) * IsFast = false ; if ( ! VT . isSimple ( ) || VT == MVT :: Other ) return false ; if ( AddrSpace == AMDGPUAS :: LOCAL_ADDRESS ) { return Align % 4 == 0 ; } if ( IsFast ) * IsFast = true ; return VT . bitsGT ( MVT :: i32 ) && Align % 4 == 0 ; } </s>


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

Return true if the target can handle a standalone remainder operation .


<s>
char
*
m32c_output_compare
(
rtx_insn
*
insn
,
rtx
*
operands
)
{
static
char
templ
[
]
=
";cmp.b\t%1,%0"
;
templ
[
5
]
=
" bwll"
[
GET_MODE_SIZE
(
GET_MODE
(
operands
[
0
]
)
)
]
;
if
(
m32c_compare_redundant
(
insn
,
operands
)
)
{
fprintf
(
stderr
,
"cbranch: cmp not needed\n"
)
;
return
templ
;
}
fprintf
(
stderr
,
"cbranch: cmp needed: `%s'\n"
,
templ
+
1
)
;
return
templ
+
1
;
}
</s>

Return the pattern for a compare . This will be commented out if the compare is redundant , else a normal pattern is returned . Thus , the assembler output says where the compare would have been .


<s> const char * AVRMCExpr :: getName ( ) const { const auto & Modifier = std :: find_if ( std :: begin ( ModifierNames ) , std :: end ( ModifierNames ) , [ this ] ( ModifierEntry const & Mod ) { return Mod . VariantKind == Kind ; } ) ; if ( Modifier != std :: end ( ModifierNames ) ) { return Modifier -> Spelling ; } return nullptr ; } </s>

Return a string with the name of the plan and the applicable VFs and UFs .


<s>
void
WebAssemblyRegisterInfo
::
eliminateFrameIndex
(
MachineBasicBlock
::
iterator
II
,
int
SPAdj
,
unsigned
FIOperandNum
,
RegScavenger
*
)
const
{
assert
(
SPAdj
==
0
)
;
MachineInstr
&
MI
=
*
II
;
MachineBasicBlock
&
MBB
=
*
MI
.
getParent
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
int
FrameIndex
=
MI
.
getOperand
(
FIOperandNum
)
.
getIndex
(
)
;
const
MachineFrameInfo
&
MFI
=
*
MF
.
getFrameInfo
(
)
;
int64_t
FrameOffset
=
MFI
.
getStackSize
(
)
+
MFI
.
getObjectOffset
(
FrameIndex
)
;
if
(
MI
.
mayLoadOrStore
(
)
)
{
assert
(
FrameOffset
>=
0
&&
MI
.
getOperand
(
1
)
.
getImm
(
)
>=
0
)
;
int64_t
Offset
=
MI
.
getOperand
(
1
)
.
getImm
(
)
+
FrameOffset
;
if
(
static_cast
<
uint64_t
>
(
Offset
)
>
std
::
numeric_limits
<
uint32_t
>
::
max
(
)
)
{
report_fatal_error
(
"Memory offset field overflow"
)
;
}
MI
.
getOperand
(
1
)
.
setImm
(
Offset
)
;
MI
.
getOperand
(
2
)
.
ChangeToRegister
(
WebAssembly
::
SP32
,
false
)
;
}
else
{
auto
&
MRI
=
MF
.
getRegInfo
(
)
;
const
auto
*
TII
=
MF
.
getSubtarget
<
WebAssemblySubtarget
>
(
)
.
getInstrInfo
(
)
;
unsigned
FIRegOperand
=
WebAssembly
::
SP32
;
if
(
FrameOffset
)
{
FIRegOperand
=
MRI
.
createVirtualRegister
(
&
WebAssembly
::
I32RegClass
)
;
BuildMI
(
MBB
,
MI
,
MI
.
getDebugLoc
(
)
,
TII
->
get
(
WebAssembly
::
CONST_I32
)
,
FIRegOperand
)
.
addImm
(
FrameOffset
)
;
BuildMI
(
MBB
,
MI
,
MI
.
getDebugLoc
(
)
,
TII
->
get
(
WebAssembly
::
ADD_I32
)
,
FIRegOperand
)
.
addReg
(
WebAssembly
::
SP32
)
.
addReg
(
FIRegOperand
)
;
}
MI
.
getOperand
(
FIOperandNum
)
.
ChangeToRegister
(
FIRegOperand
,
false
)
;
}
}
</s>

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


<s> const TargetRegisterClass * SIRegisterInfo :: getCompatibleSubRegClass ( const TargetRegisterClass * SuperRC , const TargetRegisterClass * SubRC , unsigned SubIdx ) const { const TargetRegisterClass * MatchRC = getMatchingSuperRegClass ( SuperRC , SubRC , SubIdx ) ; return MatchRC && MatchRC -> hasSubClassEq ( SuperRC ) ? MatchRC : nullptr ; } </s>

Returns a register class which is compatible with SuperRC , such that a subregister exists with class SubRC with subregister index SubIdx .


<s> void printPCRelImm ( const MCInst * MI , uint64_t Address , unsigned opNum , raw_ostream & O ) { printAbsMem ( MI , opNum , O ) ; } </s>


getTargetNodeName - This method returns the name of a target specific


<s> bool X86TargetLowering :: reduceSelectOfFPConstantLoads ( bool IsFPSetCC ) const { return ! IsFPSetCC || ! Subtarget . isTarget64BitLP64 ( ) || ! Subtarget . hasAVX ( ) ; } </s>

Return true if it is profitable to convert a select of FP constants into a constant pool load whose address depends on the select condition .


<s>
const
uint32_t
*
RISCVRegisterInfo
::
getCallPreservedMask
(
const
MachineFunction
&
MF
,
CallingConv
::
ID
CC
)
const
{
auto
&
Subtarget
=
MF
.
getSubtarget
<
RISCVSubtarget
>
(
)
;
if
(
CC
==
CallingConv
::
GHC
)
return
CSR_NoRegs_RegMask
;
switch
(
Subtarget
.
getTargetABI
(
)
)
{
default
:
llvm_unreachable
(
"Unrecognized ABI"
)
;
case
RISCVABI
::
ABI_ILP32
:
case
RISCVABI
::
ABI_LP64
:
return
CSR_ILP32_LP64_RegMask
;
case
RISCVABI
::
ABI_ILP32F
:
case
RISCVABI
::
ABI_LP64F
:
return
CSR_ILP32F_LP64F_RegMask
;
case
RISCVABI
::
ABI_ILP32D
:
case
RISCVABI
::
ABI_LP64D
:
return
CSR_ILP32D_LP64D_RegMask
;
}
}
</s>

Return a mask of call-preserved registers for the given calling convention on the current function .


<s> void SparcPassConfig :: addPreEmitPass ( ) { addPass ( createSparcDelaySlotFillerPass ( getSparcTargetMachine ( ) ) ) ; if ( this -> getSparcTargetMachine ( ) . getSubtargetImpl ( ) -> insertNOPLoad ( ) ) { addPass ( new InsertNOPLoad ( getSparcTargetMachine ( ) ) ) ; } if ( this -> getSparcTargetMachine ( ) . getSubtargetImpl ( ) -> fixFSMULD ( ) ) { addPass ( new FixFSMULD ( getSparcTargetMachine ( ) ) ) ; } if ( this -> getSparcTargetMachine ( ) . getSubtargetImpl ( ) -> replaceFMULS ( ) ) { addPass ( new ReplaceFMULS ( getSparcTargetMachine ( ) ) ) ; } if ( this -> getSparcTargetMachine ( ) . getSubtargetImpl ( ) -> detectRoundChange ( ) ) { addPass ( new DetectRoundChange ( getSparcTargetMachine ( ) ) ) ; } if ( this -> getSparcTargetMachine ( ) . getSubtargetImpl ( ) -> fixAllFDIVSQRT ( ) ) { addPass ( new FixAllFDIVSQRT ( getSparcTargetMachine ( ) ) ) ; } } </s>

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

Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc Sparc


<s> bool X86CallLowering :: splitToValueTypes ( const ArgInfo & OrigArg , SmallVectorImpl < ArgInfo > & SplitArgs , const DataLayout & DL , MachineRegisterInfo & MRI , SplitArgTy PerformArgSplit ) const { const X86TargetLowering & TLI = * getTLI < X86TargetLowering > ( ) ; LLVMContext & Context = OrigArg . Ty -> getContext ( ) ; SmallVector < EVT , 4 > SplitVTs ; SmallVector < uint64_t , 4 > Offsets ; ComputeValueVTs ( TLI , DL , OrigArg . Ty , SplitVTs , & Offsets , 0 ) ; if ( SplitVTs . size ( ) != 1 ) { return false ; } EVT VT = SplitVTs [ 0 ] ; unsigned NumParts = TLI . getNumRegisters ( Context , VT ) ; if ( NumParts == 1 ) { SplitArgs . emplace_back ( OrigArg . Reg , VT . getTypeForEVT ( Context ) , OrigArg . Flags , OrigArg . IsFixed ) ; return true ; } SmallVector < unsigned , 8 > SplitRegs ; EVT PartVT = TLI . getRegisterType ( Context , VT ) ; Type * PartTy = PartVT . getTypeForEVT ( Context ) ; for ( unsigned i = 0 ; i < NumParts ; ++ i ) { ArgInfo Info = ArgInfo { MRI . createGenericVirtualRegister ( getLLTForType ( * PartTy , DL ) ) , PartTy , OrigArg . Flags } ; SplitArgs . push_back ( Info ) ; SplitRegs . push_back ( Info . Reg ) ; } PerformArgSplit ( SplitRegs ) ; return true ; } </s>

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


<s> void VEFrameLowering :: determineCalleeSaves ( MachineFunction & MF , BitVector & SavedRegs , RegScavenger * RS ) const { TargetFrameLowering :: determineCalleeSaves ( MF , SavedRegs , RS ) ; if ( isLeafProc ( MF ) && ! hasBP ( MF ) ) { VEMachineFunctionInfo * FuncInfo = MF . getInfo < VEMachineFunctionInfo > ( ) ; FuncInfo -> setLeafProc ( true ) ; } } </s>

This method determines which of the registers reported by TargetRegisterInfo : :getCalleeSavedRegs ( ) should actually get saved .


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

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


<s> void function_expander :: add_mem_operand ( machine_mode mode , unsigned argno ) { gcc_assert ( VECTOR_MODE_P ( mode ) ) ; rtx addr = expand_normal ( CALL_EXPR_ARG ( exp , argno ) ) ; rtx mem = gen_rtx_MEM ( mode , memory_address ( mode , addr ) ) ; set_mem_align ( mem , GET_MODE_ALIGNMENT ( GET_MODE_INNER ( mode ) ) ) ; add_fixed_operand ( mem ) ; } </s>

Add a memory operand with mode MODE and address ADDR .


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

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


<s> EVT AArch64TargetLowering :: getOptimalMemOpType ( uint64_t Size , unsigned DstAlign , unsigned SrcAlign , bool IsMemset , bool ZeroMemset , bool MemcpyStrSrc , MachineFunction & MF ) const { const Function & F = MF . getFunction ( ) ; bool CanImplicitFloat = ! F . hasFnAttribute ( Attribute :: NoImplicitFloat ) ; bool CanUseNEON = Subtarget -> hasNEON ( ) && CanImplicitFloat ; bool CanUseFP = Subtarget -> hasFPARMv8 ( ) && CanImplicitFloat ; bool IsSmallMemset = IsMemset && Size < 32 ; auto AlignmentIsAcceptable = [ & ] ( EVT VT , unsigned AlignCheck ) { if ( memOpAlign ( SrcAlign , DstAlign , AlignCheck ) ) return true ; bool Fast ; return allowsMisalignedMemoryAccesses ( VT , 0 , 1 , & Fast ) && Fast ; } ; if ( CanUseNEON && IsMemset && ! IsSmallMemset && AlignmentIsAcceptable ( MVT :: v2i64 , 16 ) ) return MVT :: v2i64 ; if ( CanUseFP && ! IsSmallMemset && AlignmentIsAcceptable ( MVT :: f128 , 16 ) ) return MVT :: f128 ; if ( Size >= 8 && AlignmentIsAcceptable ( MVT :: i64 , 8 ) ) return MVT :: i64 ; if ( Size >= 4 && AlignmentIsAcceptable ( MVT :: i32 , 4 ) ) return MVT :: i32 ; return MVT :: Other ; } </s>

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


<s> static bool m68k_save_reg ( unsigned int regno , bool interrupt_handler ) { if ( flag_pic && regno == PIC_REG ) { if ( crtl -> saves_all_registers ) return true ; if ( crtl -> uses_pic_offset_table ) return true ; if ( crtl -> uses_const_pool ) return true ; } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = 0 ; ; i ++ ) { unsigned int test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( fixed_regs [ regno ] ) return false ; if ( regno == FRAME_POINTER_REGNUM && frame_pointer_needed ) return false ; if ( interrupt_handler ) { if ( df_regs_ever_live_p ( regno ) ) return true ; if ( ! crtl -> is_leaf && call_used_or_fixed_reg_p ( regno ) ) return true ; } if ( ! df_regs_ever_live_p ( regno ) ) return false ; return ! call_used_or_fixed_reg_p ( regno ) ; } </s>

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


<s> unsigned GCNTTIImpl :: getNumberOfRegisters ( unsigned RCID ) const { return 4 ; } </s>


<s> void SIScheduleBlock :: releaseSuccessors ( SUnit * SU , bool InOrOutBlock ) { for ( SDep & Succ : SU -> Succs ) { SUnit * SuccSU = Succ . getSUnit ( ) ; if ( BC -> isSUInBlock ( SuccSU , ID ) != InOrOutBlock ) continue ; releaseSucc ( SU , & Succ ) ; if ( SuccSU -> NumPredsLeft == 0 && InOrOutBlock ) TopReadySUs . push_back ( SuccSU ) ; } } </s>

releaseSuccessors - Call releaseSucc on each of SU 's successors .


<s> MachineInstr * SystemZInstrInfo :: commuteInstructionImpl ( MachineInstr & MI , bool NewMI , unsigned OpIdx1 , unsigned OpIdx2 ) const { auto cloneIfNew = [ NewMI ] ( MachineInstr & MI ) -> MachineInstr & { if ( NewMI ) return * MI . getParent ( ) -> getParent ( ) -> CloneMachineInstr ( & MI ) ; return MI ; } ; switch ( MI . getOpcode ( ) ) { case SystemZ :: SELRMux : case SystemZ :: SELFHR : case SystemZ :: SELR : case SystemZ :: SELGR : case SystemZ :: LOCRMux : case SystemZ :: LOCFHR : case SystemZ :: LOCR : case SystemZ :: LOCGR : { auto & WorkingMI = cloneIfNew ( MI ) ; unsigned CCValid = WorkingMI . getOperand ( 3 ) . getImm ( ) ; unsigned CCMask = WorkingMI . getOperand ( 4 ) . getImm ( ) ; WorkingMI . getOperand ( 4 ) . setImm ( CCMask ^ CCValid ) ; return TargetInstrInfo :: commuteInstructionImpl ( WorkingMI , false , OpIdx1 , OpIdx2 ) ; } default : return TargetInstrInfo :: commuteInstructionImpl ( MI , NewMI , OpIdx1 , OpIdx2 ) ; } } </s>

Commutes the operands in the given instruction by changing the operands order and/or changing the instruction 's opcode and/or the immediate value operand .

SystemZ SystemZ SystemZ::SELRMux SystemZ::SELFHR SystemZ::SELR SystemZ::SELGR SystemZ::LOCRMux SystemZ::LOCFHR SystemZ::LOCR SystemZ::LOCGR 3 4 4


<s>
bool
GBZ80InstrInfo
::
reverseBranchCondition
(
SmallVectorImpl
<
MachineOperand
>
&
Cond
)
const
{
assert
(
(
Cond
.
size
(
)
%
2
==
0
)
&&
"Invalid GBZ80 branch condition!"
)
;
return
!
invertCondition
(
Cond
)
;
}
</s>

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


<s> static bool aarch64_use_new_vector_costs_p ( ) { return ( aarch64_tune_params . extra_tuning_flags & AARCH64_EXTRA_TUNE_USE_NEW_VECTOR_COSTS ) ; } </s>

Return true if the current CPU should use the new costs defined in GCC 11 . This should be removed for GCC 12 and above , with the costs applying to all CPUs instead .


<s> virtual bool runOnMachineFunction ( MachineFunction & MF ) { return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool SIFixSGPRLiveRanges :: runOnMachineFunction ( MachineFunction & MF ) { MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; const SIRegisterInfo * TRI = static_cast < const SIRegisterInfo * > ( MF . getTarget ( ) . getRegisterInfo ( ) ) ; LiveIntervals * LIS = & getAnalysis < LiveIntervals > ( ) ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { MachineBasicBlock & MBB = * BI ; for ( MachineBasicBlock :: iterator I = MBB . begin ( ) , E = MBB . end ( ) ; I != E ; ++ I ) { MachineInstr & MI = * I ; MachineOperand * ExecUse = MI . findRegisterUseOperand ( AMDGPU :: EXEC ) ; if ( ExecUse ) continue ; for ( const MachineOperand & Def : MI . operands ( ) ) { if ( ! Def . isReg ( ) || ! Def . isDef ( ) || ! TargetRegisterInfo :: isVirtualRegister ( Def . getReg ( ) ) ) continue ; const TargetRegisterClass * RC = MRI . getRegClass ( Def . getReg ( ) ) ; if ( ! TRI -> isSGPRClass ( RC ) ) continue ; LiveInterval & LI = LIS -> getInterval ( Def . getReg ( ) ) ; for ( unsigned i = 0 , e = LI . size ( ) - 1 ; i != e ; ++ i ) { LiveRange :: Segment & Seg = LI . segments [ i ] ; LiveRange :: Segment & Next = LI . segments [ i + 1 ] ; Seg . end = Next . start ; } } } } return false ; } </s>


<s> rtx ix86_zero_extend_to_Pmode ( rtx exp ) { rtx r ; if ( GET_MODE ( exp ) == VOIDmode ) return force_reg ( Pmode , exp ) ; if ( GET_MODE ( exp ) == Pmode ) return copy_to_mode_reg ( Pmode , exp ) ; r = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_zero_extendsidi2 ( r , exp ) ) ; return r ; } </s>

Zero extend possibly SImode EXP to Pmode register .


<s> int immediate_load_p ( rtx op , machine_mode mode ) { if ( CONSTANT_P ( op ) ) { enum immediate_class c = classify_immediate ( op , mode ) ; return c == IC_IL1 || c == IC_IL1s || ( ! epilogue_completed && ( c == IC_IL2 || c == IC_IL2s ) ) ; } return 0 ; } </s>

Return true when OP can be loaded by one of the il instructions , or when flow2 is not completed and OP can be loaded using ilhu and iohl .


<s> rtx arc_rewrite_small_data ( rtx op ) { op = arc_rewrite_small_data_1 ( op ) ; if ( MEM_P ( op ) && ! LEGITIMATE_SMALL_DATA_ADDRESS_P ( XEXP ( op , 0 ) ) ) { rtx addr = XEXP ( op , 0 ) ; rtx tmp = gen_reg_rtx ( Pmode ) ; emit_move_insn ( tmp , addr ) ; op = replace_equiv_address_nv ( op , tmp ) ; } return op ; } </s>

If possible , rewrite OP so that it refers to small data using explicit relocations .


<s>
SDNode
*
MBlazeDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
SDLoc
dl
(
Node
)
;
if
(
Node
->
isMachineOpcode
(
)
)
return
;
switch
(
Opcode
)
{
default
:
break
;
case
ISD
::
GLOBAL_OFFSET_TABLE
:
return
getGlobalBaseReg
(
)
;
case
ISD
::
FrameIndex
:
{
SDValue
imm
=
CurDAG
->
getTargetConstant
(
0
,
MVT
::
i32
)
;
int
FI
=
dyn_cast
<
FrameIndexSDNode
>
(
Node
)
->
getIndex
(
)
;
EVT
VT
=
Node
->
getValueType
(
0
)
;
SDValue
TFI
=
CurDAG
->
getTargetFrameIndex
(
FI
,
VT
)
;
unsigned
Opc
=
MBlaze
::
ADDIK
;
if
(
Node
->
hasOneUse
(
)
)
return
CurDAG
->
SelectNodeTo
(
Node
,
Opc
,
VT
,
TFI
,
imm
)
;
return
CurDAG
->
getMachineNode
(
Opc
,
dl
,
VT
,
TFI
,
imm
)
;
}
case
MBlazeISD
::
JmpLink
:
{
if
(
TM
.
getRelocationModel
(
)
==
Reloc
::
PIC_
)
{
SDValue
Chain
=
Node
->
getOperand
(
0
)
;
SDValue
Callee
=
Node
->
getOperand
(
1
)
;
SDValue
R20Reg
=
CurDAG
->
getRegister
(
MBlaze
::
R20
,
MVT
::
i32
)
;
SDValue
InFlag
(
0
,
0
)
;
if
(
(
isa
<
GlobalAddressSDNode
>
(
Callee
)
)
||
(
isa
<
ExternalSymbolSDNode
>
(
Callee
)
)
)
{
SDValue
GPReg
=
CurDAG
->
getRegister
(
MBlaze
::
R15
,
MVT
::
i32
)
;
SDValue
Ops
[
]
=
{
Callee
,
GPReg
,
Chain
}
;
SDValue
Load
=
SDValue
(
CurDAG
->
getMachineNode
(
MBlaze
::
LW
,
dl
,
MVT
::
i32
,
MVT
::
Other
,
Ops
)
,
0
)
;
Chain
=
Load
.
getValue
(
1
)
;
Chain
=
CurDAG
->
getCopyToReg
(
Chain
,
dl
,
R20Reg
,
Load
,
InFlag
)
;
}
else
Chain
=
CurDAG
->
getCopyToReg
(
Chain
,
dl
,
R20Reg
,
Callee
,
InFlag
)
;
SDNode
*
ResNode
=
CurDAG
->
getMachineNode
(
MBlaze
::
BRLID
,
dl
,
MVT
::
Other
,
MVT
::
Glue
,
R20Reg
,
Chain
)
;
Chain
=
SDValue
(
ResNode
,
0
)
;
InFlag
=
SDValue
(
ResNode
,
1
)
;
ReplaceUses
(
SDValue
(
Node
,
0
)
,
Chain
)
;
ReplaceUses
(
SDValue
(
Node
,
1
)
,
InFlag
)
;
return
ResNode
;
}
}
}
SDNode
*
ResNode
=
SelectCode
(
Node
)
;
DEBUG
(
errs
(
)
<<
"=> "
)
;
if
(
ResNode
==
||
ResNode
==
Node
)
DEBUG
(
Node
->
dump
(
CurDAG
)
)
;
else
DEBUG
(
ResNode
->
dump
(
CurDAG
)
)
;
DEBUG
(
errs
(
)
<<
"\n"
)
;
return
ResNode
;
}
</s>

Main hook for targets to transform nodes into machine nodes .


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


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

Returns true if the target requires post PEI scavenging of registers for materializing frame index constants .


<s>
const
char
*
avr_out_lshrpsi3
(
rtx_insn
*
insn
,
rtx
*
op
,
int
*
plen
)
{
int
dest
=
REGNO
(
op
[
0
]
)
;
int
src
=
REGNO
(
op
[
1
]
)
;
if
(
CONST_INT_P
(
op
[
2
]
)
)
{
if
(
plen
)
*
plen
=
0
;
switch
(
INTVAL
(
op
[
2
]
)
)
{
case
8
:
if
(
dest
<=
src
)
return
avr_asm_len
(
"mov %A0,%B1"
CR_TAB
"mov %B0,%C1"
CR_TAB
"clr %C0"
,
op
,
plen
,
3
)
;
else
return
avr_asm_len
(
"clr %C0"
CR_TAB
"mov %B0,%C1"
CR_TAB
"mov %A0,%B1"
,
op
,
plen
,
3
)
;
case
16
:
if
(
dest
!=
src
+
2
)
avr_asm_len
(
"mov %A0,%C1"
,
op
,
plen
,
1
)
;
return
avr_asm_len
(
"clr %B0"
CR_TAB
"clr %C0"
,
op
,
plen
,
2
)
;
default
:
if
(
INTVAL
(
op
[
2
]
)
<
24
)
break
;
case
23
:
return
avr_asm_len
(
"clr %A0"
CR_TAB
"sbrc %C0,7"
CR_TAB
"inc %A0"
CR_TAB
"clr %B0"
CR_TAB
"clr %C0"
,
op
,
plen
,
5
)
;
}
}
out_shift_with_cnt
(
"lsr %C0"
CR_TAB
"ror %B0"
CR_TAB
"ror %A0"
,
insn
,
op
,
plen
,
3
)
;
return
""
;
}
</s>


<s> BitVector WDC65816RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( WDC :: P ) ; Reserved . set ( WDC :: S ) ; Reserved . set ( WDC :: D ) ; Reserved . set ( WDC :: K ) ; Reserved . set ( WDC :: B ) ; Reserved . set ( WDC :: PC ) ; Reserved . set ( WDC :: dpI32_0 ) ; 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 .

WDC65816 WDC WDC::P WDC::S WDC::D WDC::K WDC::B WDC::PC WDC::dpI32_0


<s>
void
setReg
(
unsigned
Reg
)
{
assert
(
isRegBase
(
)
&&
"Invalid base register access!"
)
;
assert
(
!
IsBaseSet
&&
"Base cannot be reset"
)
;
Base
.
Reg
=
Reg
;
IsBaseSet
=
true
;
}
</s>

Assigns the associated register for this edge .

WebAssembly
"Invalid base register access!"
"Base cannot be reset"


<s> bool SparcAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode , raw_ostream & O ) { if ( ExtraCode && ExtraCode [ 0 ] ) { if ( ExtraCode [ 1 ] != 0 ) return true ; switch ( ExtraCode [ 0 ] ) { default : return AsmPrinter :: PrintAsmOperand ( MI , OpNo , AsmVariant , ExtraCode , O ) ; case 'f' : case 'r' : break ; } } printOperand ( MI , OpNo , O ) ; return false ; } </s>

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


<s> bool isNoopAddrSpaceCast ( unsigned SrcAS , unsigned DestAS ) const override { return true ; } </s>

Returns true if a cast between SrcAS and DestAS is a noop .


<s> bool MipsCallEntry :: mayAlias ( const MachineFrameInfo * ) const { return false ; } </s>

Returns true if this instruction 's memory access aliases the memory access of Other .


<s> bool HexagonInstrInfo :: isSchedulingBoundary ( const MachineInstr & MI , const MachineBasicBlock * MBB , const MachineFunction & MF ) const { if ( MI . isDebugValue ( ) ) return false ; if ( MI . isCall ( ) ) { if ( doesNotReturn ( MI ) ) return true ; for ( auto I : MBB -> successors ( ) ) if ( I -> isEHPad ( ) ) return true ; } if ( MI . getDesc ( ) . isTerminator ( ) || MI . isPosition ( ) ) return true ; if ( MI . isInlineAsm ( ) && ! ScheduleInlineAsm ) return true ; return false ; } </s>

isSchedulingBoundary - Overrides the isSchedulingBoundary from Codegen/TargetInstrInfo.cpp to make it capable of identifying ENDBR intructions and prevent it from being re-scheduled .


<s>
BitVector
ARMBaseRegisterInfo
::
getReservedRegs
(
const
MachineFunction
&
MF
)
const
{
const
ARMSubtarget
&
STI
=
MF
.
getSubtarget
<
ARMSubtarget
>
(
)
;
const
ARMFrameLowering
*
TFI
=
getFrameLowering
(
MF
)
;
BitVector
Reserved
(
getNumRegs
(
)
)
;
markSuperRegs
(
Reserved
,
ARM
::
SP
)
;
markSuperRegs
(
Reserved
,
ARM
::
PC
)
;
markSuperRegs
(
Reserved
,
ARM
::
FPSCR
)
;
markSuperRegs
(
Reserved
,
ARM
::
APSR_NZCV
)
;
if
(
TFI
->
hasFP
(
MF
)
||
STI
.
isTargetDarwin
(
)
)
markSuperRegs
(
Reserved
,
getFramePointerReg
(
STI
)
)
;
if
(
hasBasePointer
(
MF
)
)
markSuperRegs
(
Reserved
,
BasePtr
)
;
if
(
STI
.
isR9Reserved
(
)
)
markSuperRegs
(
Reserved
,
ARM
::
R9
)
;
if
(
!
STI
.
hasD32
(
)
)
{
static_assert
(
ARM
::
D31
==
ARM
::
D16
+
15
,
"Register list not consecutive!"
)
;
for
(
unsigned
R
=
0
;
R
<
16
;
++
R
)
markSuperRegs
(
Reserved
,
ARM
::
D16
+
R
)
;
}
const
TargetRegisterClass
&
RC
=
ARM
::
GPRPairRegClass
;
for
(
unsigned
Reg
:
RC
)
for
(
MCSubRegIterator
SI
(
Reg
,
this
)
;
SI
.
isValid
(
)
;
++
SI
)
if
(
Reserved
.
test
(
*
SI
)
)
markSuperRegs
(
Reserved
,
Reg
)
;
markSuperRegs
(
Reserved
,
ARM
::
ZR
)
;
assert
(
checkAllSuperRegsMarked
(
Reserved
)
)
;
return
Reserved
;
}
</s>


<s> bool MipsTargetLowering :: CanLowerReturn ( CallingConv :: ID CallConv , MachineFunction & MF , bool IsVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , LLVMContext & Context ) const { SmallVector < CCValAssign , 16 > RVLocs ; MipsCCState CCInfo ( CallConv , IsVarArg , MF , RVLocs , Context ) ; return CCInfo . CheckReturn ( Outs , RetCC_Mips ) ; } </s>

This hook should be implemented to check whether the return values described by the Outs array can fit into the return registers .


<s> static bool visium_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) { tree type = arg . type ; return type && ( AGGREGATE_TYPE_P ( type ) || TREE_CODE ( type ) == VECTOR_TYPE ) ; } </s>

Return true if an argument must be passed by indirect reference .


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

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


<s> int tilepro_initial_elimination_offset ( int from , int to ) { int total_size = compute_total_frame_size ( ) ; if ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { return ( total_size - crtl -> args . pretend_args_size - tilepro_saved_regs_size ( ) ) ; } else if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) { return - ( crtl -> args . pretend_args_size + tilepro_saved_regs_size ( ) ) ; } else if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { return STACK_POINTER_OFFSET + total_size ; } else if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) { return STACK_POINTER_OFFSET ; } else gcc_unreachable ( ) ; } </s>


<s> bool PPCSubtarget :: enableMachineScheduler ( ) const { return true ; } </s>

Enable the MachineScheduler pass for all X86 subtargets .


<s>
bool
X86AsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
SetupMachineFunction
(
MF
)
;
if
(
Subtarget
->
isTargetCOFF
(
)
)
{
const
Function
*
F
=
MF
.
getFunction
(
)
;
OutStreamer
.
EmitRawText
(
"\t.def\t "
+
Twine
(
CurrentFnSym
->
getName
(
)
)
+
";\t.scl\t"
+
Twine
(
F
->
hasInternalLinkage
(
)
COFF
::
C_STAT
:
COFF
::
C_EXT
)
+
";\t.type\t"
+
Twine
(
COFF
::
DT_FCN
<<
COFF
::
N_BTSHFT
)
+
";\t.endef"
)
;
}
EmitFunctionHeader
(
)
;
EmitFunctionBody
(
)
;
return
false
;
}
</s>


<s> bool nios2_validate_fpu_compare ( machine_mode mode , rtx * cmp , rtx * op1 , rtx * op2 , bool modify_p ) { bool rev_p = false ; enum rtx_code code = GET_CODE ( * cmp ) ; if ( ! nios2_fpu_compare_enabled ( code , mode ) ) { code = swap_condition ( code ) ; if ( nios2_fpu_compare_enabled ( code , mode ) ) rev_p = true ; else return false ; } if ( modify_p ) { if ( rev_p ) { rtx tmp = * op1 ; * op1 = * op2 ; * op2 = tmp ; } * op1 = force_reg ( mode , * op1 ) ; * op2 = force_reg ( mode , * op2 ) ; * cmp = gen_rtx_fmt_ee ( code , mode , * op1 , * op2 ) ; } return true ; } </s>

Checks if the FPU comparison in * CMP , * OP1 , and * OP2 can be supported in the current configuration . Perform modifications if MODIFY_P is true . Returns true if FPU compare can be done .


"inconsistent dll linkage for %q+D, dllexport assumed"

Mark a DECL as being dllexport 'd . Note that we override the previous setting ( e.g . : dllimport ) .


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

runOnMachineFunction - Emit the function body .

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


<s> bool GCNPassConfig :: addIRTranslator ( ) { addPass ( new IRTranslator ( getOptLevel ( ) ) ) ; return false ; } </s>

This method should install an IR translator pass , which converts from LLVM code to machine instructions with possibly generic opcodes .


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

getPassName - Return a nice clean name for a pass .


<s> bool PPCInstrInfo :: canInsertSelect ( const MachineBasicBlock & MBB , const SmallVectorImpl < MachineOperand > & Cond , unsigned TrueReg , unsigned FalseReg , int & CondCycles , int & TrueCycles , int & FalseCycles ) const { if ( ! TM . getSubtargetImpl ( ) -> hasISEL ( ) ) return false ; if ( Cond . size ( ) != 2 ) return false ; if ( Cond [ 1 ] . getReg ( ) == PPC :: CTR || Cond [ 1 ] . getReg ( ) == PPC :: CTR8 ) return false ; const MachineRegisterInfo & MRI = MBB . getParent ( ) -> getRegInfo ( ) ; const TargetRegisterClass * RC = RI . getCommonSubClass ( MRI . getRegClass ( TrueReg ) , MRI . getRegClass ( FalseReg ) ) ; if ( ! RC ) return false ; if ( ! PPC :: GPRCRegClass . hasSubClassEq ( RC ) && ! PPC :: G8RCRegClass . hasSubClassEq ( RC ) ) return false ; CondCycles = 1 ; TrueCycles = 1 ; FalseCycles = 1 ; return true ; } </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 .


"Instr doesn't have FrameIndex operand!"

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


<s> unsigned getIssueWidth ( ) const { return IssueWidth ; } </s>

Maximum number of micro-ops that may be scheduled per cycle .


<s> bool PPCDarwinAsmPrinter :: doFinalization ( Module & M ) { bool isPPC64 = TM . getSubtargetImpl ( ) -> getDataLayout ( ) -> getPointerSizeInBits ( ) == 64 ; const TargetLoweringObjectFileMachO & TLOFMacho = static_cast < const TargetLoweringObjectFileMachO & > ( getObjFileLowering ( ) ) ; MachineModuleInfoMachO & MMIMacho = MMI -> getObjFileInfo < MachineModuleInfoMachO > ( ) ; MachineModuleInfoMachO :: SymbolListTy Stubs = MMIMacho . GetFnStubList ( ) ; if ( ! Stubs . empty ( ) ) EmitFunctionStubs ( Stubs ) ; if ( MAI -> doesSupportExceptionHandling ( ) && MMI ) { const std :: vector < const Function * > & Personalities = MMI -> getPersonalities ( ) ; for ( std :: vector < const Function * > :: const_iterator I = Personalities . begin ( ) , E = Personalities . end ( ) ; I != E ; ++ I ) { if ( * I ) { MCSymbol * NLPSym = getSymbolWithGlobalValueBase ( * I , "$non_lazy_ptr" ) ; MachineModuleInfoImpl :: StubValueTy & StubSym = MMIMacho . getGVStubEntry ( NLPSym ) ; StubSym = MachineModuleInfoImpl :: StubValueTy ( getSymbol ( * I ) , true ) ; } } } Stubs = MMIMacho . GetGVStubList ( ) ; if ( ! Stubs . empty ( ) ) { OutStreamer . SwitchSection ( TLOFMacho . getNonLazySymbolPointerSection ( ) ) ; EmitAlignment ( isPPC64 ? 3 : 2 ) ; for ( unsigned i = 0 , e = Stubs . size ( ) ; i != e ; ++ i ) { OutStreamer . EmitLabel ( Stubs [ i ] . first ) ; MachineModuleInfoImpl :: StubValueTy & MCSym = Stubs [ i ] . second ; OutStreamer . EmitSymbolAttribute ( MCSym . getPointer ( ) , MCSA_IndirectSymbol ) ; if ( MCSym . getInt ( ) ) OutStreamer . EmitIntValue ( 0 , isPPC64 ? 8 : 4 ) ; else OutStreamer . EmitValue ( MCSymbolRefExpr :: Create ( MCSym . getPointer ( ) , OutContext ) , isPPC64 ? 8 : 4 ) ; } Stubs . clear ( ) ; OutStreamer . AddBlankLine ( ) ; } Stubs = MMIMacho . GetHiddenGVStubList ( ) ; if ( ! Stubs . empty ( ) ) { OutStreamer . SwitchSection ( getObjFileLowering ( ) . getDataSection ( ) ) ; EmitAlignment ( isPPC64 ? 3 : 2 ) ; for ( unsigned i = 0 , e = Stubs . size ( ) ; i != e ; ++ i ) { OutStreamer . EmitLabel ( Stubs [ i ] . first ) ; OutStreamer . EmitValue ( MCSymbolRefExpr :: Create ( Stubs [ i ] . second . getPointer ( ) , OutContext ) , isPPC64 ? 8 : 4 ) ; } Stubs . clear ( ) ; OutStreamer . AddBlankLine ( ) ; } OutStreamer . EmitAssemblerFlag ( MCAF_SubsectionsViaSymbols ) ; return AsmPrinter :: doFinalization ( M ) ; } </s>

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


<s> static tree nvptx_global_lock_addr ( ) { tree v = global_lock_var ; if ( ! v ) { tree name = get_identifier ( "__reduction_lock" ) ; tree type = build_qualified_type ( unsigned_type_node , TYPE_QUAL_VOLATILE ) ; v = build_decl ( BUILTINS_LOCATION , VAR_DECL , name , type ) ; global_lock_var = v ; DECL_ARTIFICIAL ( v ) = 1 ; DECL_EXTERNAL ( v ) = 1 ; TREE_STATIC ( v ) = 1 ; TREE_PUBLIC ( v ) = 1 ; TREE_USED ( v ) = 1 ; mark_addressable ( v ) ; mark_decl_referenced ( v ) ; } return build_fold_addr_expr ( v ) ; } </s>

Lazily generate the global lock var decl and return its address .


<s>
unsigned
RISCVMCCodeEmitter
::
getMachineOpValue
(
const
MCInst
&
MI
,
const
MCOperand
&
MO
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
const
{
if
(
MO
.
isReg
(
)
)
return
Ctx
.
getRegisterInfo
(
)
->
getEncodingValue
(
MO
.
getReg
(
)
)
;
if
(
MO
.
isImm
(
)
)
return
static_cast
<
unsigned
>
(
MO
.
getImm
(
)
)
;
if
(
MO
.
isExpr
(
)
&&
(
MI
.
getOpcode
(
)
==
RISCV
::
LOOP0setup
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP1setup
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP0setupi
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP1setupi
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP0starti
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP1starti
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP0endi
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP1endi
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP0counti
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP1counti
)
)
{
if
(
MI
.
getOpcode
(
)
==
RISCV
::
LOOP0setupi
||
MI
.
getOpcode
(
)
==
RISCV
::
LOOP1setupi
)
{
RISCV
::
Fixups
FixupKind
=
RISCV
::
fixup_pulpv2_loop_setupi
;
Fixups
.
push_back
(
MCFixup
::
create
(
0
,
MO
.
getExpr
(
)
,
MCFixupKind
(
FixupKind
)
,
MI
.
getLoc
(
)
)
)
;
}
else
{
RISCV
::
Fixups
FixupKind
=
RISCV
::
fixup_pulpv2_loop_setup
;
Fixups
.
push_back
(
MCFixup
::
create
(
0
,
MO
.
getExpr
(
)
,
MCFixupKind
(
FixupKind
)
,
MI
.
getLoc
(
)
)
)
;
}
++
MCNumFixups
;
return
0
;
}
llvm_unreachable
(
"Unhandled expression!"
)
;
return
0
;
}
</s>

getMachineOpValue - Return binary encoding of operand .


<s> unsigned PPCTargetLowering :: getByValTypeAlignment ( Type * Ty ) const { const TargetMachine & TM = getTargetMachine ( ) ; if ( TM . getSubtarget < PPCSubtarget > ( ) . isDarwin ( ) ) return 4 ; return 4 ; } </s>

Return the desired alignment for ByVal aggregate function arguments in the caller parameter area .


<s> bool Thumb2SizeReduce :: runOnMachineFunction ( MachineFunction & MF ) { STI = & static_cast < const ARMSubtarget & > ( MF . getSubtarget ( ) ) ; TII = static_cast < const Thumb2InstrInfo * > ( STI -> getInstrInfo ( ) ) ; AttributeSet FnAttrs = MF . getFunction ( ) -> getAttributes ( ) ; OptimizeSize = FnAttrs . hasAttribute ( AttributeSet :: FunctionIndex , Attribute :: OptimizeForSize ) ; MinimizeSize = FnAttrs . hasAttribute ( AttributeSet :: FunctionIndex , Attribute :: MinSize ) ; BlockInfo . clear ( ) ; BlockInfo . resize ( MF . getNumBlockIDs ( ) ) ; ReversePostOrderTraversal < MachineFunction * > RPOT ( & MF ) ; bool Modified = false ; for ( ReversePostOrderTraversal < MachineFunction * > :: rpo_iterator I = RPOT . begin ( ) , E = RPOT . end ( ) ; I != E ; ++ I ) Modified |= ReduceMBB ( * * I ) ; return Modified ; } </s>


<s>
bool
arm_check_builtin_call
(
location_t
,
vec
<
location_t
>
,
tree
fndecl
,
tree
,
unsigned
int
,
tree
*
)
{
int
fcode
=
DECL_MD_FUNCTION_CODE
(
fndecl
)
;
if
(
fcode
==
ARM_BUILTIN_saturation_occurred
||
fcode
==
ARM_BUILTIN_set_saturation
)
{
if
(
cfun
&&
cfun
->
decl
)
DECL_ATTRIBUTES
(
cfun
->
decl
)
=
tree_cons
(
get_identifier
(
"acle qbit"
)
,
NULL_TREE
,
DECL_ATTRIBUTES
(
cfun
->
decl
)
)
;
}
if
(
fcode
==
ARM_BUILTIN_sel
)
{
if
(
cfun
&&
cfun
->
decl
)
DECL_ATTRIBUTES
(
cfun
->
decl
)
=
tree_cons
(
get_identifier
(
"acle gebits"
)
,
NULL_TREE
,
DECL_ATTRIBUTES
(
cfun
->
decl
)
)
;
}
return
true
;
}
</s>

Implement TARGET_CHECK_BUILTIN_CALL . Record a read of the Q bit through intrinsics in the machine function .


"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> int HexagonInstrInfo :: getMinValue ( const MachineInstr & MI ) const { const uint64_t F = MI . getDesc ( ) . TSFlags ; unsigned isSigned = ( F >> HexagonII :: ExtentSignedPos ) & HexagonII :: ExtentSignedMask ; unsigned bits = ( F >> HexagonII :: ExtentBitsPos ) & HexagonII :: ExtentBitsMask ; if ( isSigned ) return - 1U << ( bits - 1 ) ; else return 0 ; } </s>

Return the minimal unsigned value possible given these KnownBits .

Hexagon Hexagon HexagonII::ExtentSignedPos HexagonII::ExtentSignedMask HexagonII::ExtentBitsPos HexagonII::ExtentBitsMask 1U 1 0


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

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


<s> bool SIInstrInfo :: isReallyTriviallyReMaterializable ( const MachineInstr & MI , AliasAnalysis * AA ) const { switch ( MI . getOpcode ( ) ) { case AMDGPU :: V_MOV_B32_e32 : case AMDGPU :: V_MOV_B32_e64 : case AMDGPU :: V_MOV_B64_PSEUDO : case AMDGPU :: V_ACCVGPR_READ_B32 : case AMDGPU :: V_ACCVGPR_WRITE_B32 : return MI . getNumOperands ( ) == MI . getDesc ( ) . getNumOperands ( ) ; default : return false ; } } </s>

For instructions with opcodes for which the M_REMATERIALIZABLE flag is set , this hook lets the target specify whether the instruction is actually trivially rematerializable , taking into consideration its operands .


<s> static bool ix86_cannot_force_const_mem ( machine_mode mode , rtx x ) { switch ( GET_CODE ( x ) ) { case CONST_INT : case CONST_DOUBLE : case CONST_VECTOR : return false ; default : break ; } return ! ix86_legitimate_constant_p ( mode , x ) ; } </s>

Determine if it 's legal to put X into the constant pool . This is not possible for the address of thread-local symbols , which is checked above .


<s> bool Mips16FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , ArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; for ( const CalleeSavedInfo & I : CSI ) { unsigned Reg = I . getReg ( ) ; bool IsRAAndRetAddrIsTaken = ( Reg == Mips :: RA ) && MF -> getFrameInfo ( ) . isReturnAddressTaken ( ) ; if ( ! IsRAAndRetAddrIsTaken ) MBB . addLiveIn ( Reg ) ; } return true ; } </s>

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


<s> void X86PassConfig :: addPreEmitPass ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( new X86ExecutionDomainFix ( ) ) ; addPass ( createBreakFalseDeps ( ) ) ; } addPass ( createX86IndirectBranchTrackingPass ( ) ) ; addPass ( createX86IssueVZeroUpperPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86FixupBWInsts ( ) ) ; addPass ( createX86PadShortFunctions ( ) ) ; addPass ( createX86FixupLEAs ( ) ) ; } addPass ( createX86EvexToVexInsts ( ) ) ; addPass ( createX86DiscriminateMemOpsPass ( ) ) ; addPass ( createX86InsertPrefetchPass ( ) ) ; addPass ( createX86InsertX87waitPass ( ) ) ; addPass ( createX86EncodeLiterals ( ) ) ; } </s>

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


<s>
bool
AMDGPUAsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
MF
.
setAlignment
(
8
)
;
SetupMachineFunction
(
MF
)
;
EmitFunctionHeader
(
)
;
MCContext
&
Context
=
getObjFileLowering
(
)
.
getContext
(
)
;
const
MCSectionELF
*
ConfigSection
=
Context
.
getELFSection
(
".AMDGPU.config"
,
ELF
::
SHT_PROGBITS
,
0
,
SectionKind
::
getReadOnly
(
)
)
;
OutStreamer
.
SwitchSection
(
ConfigSection
)
;
const
AMDGPUSubtarget
&
STM
=
TM
.
getSubtarget
<
AMDGPUSubtarget
>
(
)
;
SIProgramInfo
KernelInfo
;
if
(
STM
.
getGeneration
(
)
>
AMDGPUSubtarget
::
NORTHERN_ISLANDS
)
{
getSIProgramInfo
(
KernelInfo
,
MF
)
;
EmitProgramInfoSI
(
MF
,
KernelInfo
)
;
}
else
{
EmitProgramInfoR600
(
MF
)
;
}
DisasmLines
.
clear
(
)
;
HexLines
.
clear
(
)
;
DisasmLineMaxLen
=
0
;
OutStreamer
.
SwitchSection
(
getObjFileLowering
(
)
.
getTextSection
(
)
)
;
EmitFunctionBody
(
)
;
if
(
isVerbose
(
)
)
{
const
MCSectionELF
*
CommentSection
=
Context
.
getELFSection
(
".AMDGPU.csdata"
,
ELF
::
SHT_PROGBITS
,
0
,
SectionKind
::
getReadOnly
(
)
)
;
OutStreamer
.
SwitchSection
(
CommentSection
)
;
if
(
STM
.
getGeneration
(
)
>=
AMDGPUSubtarget
::
SOUTHERN_ISLANDS
)
{
OutStreamer
.
emitRawComment
(
" Kernel info:"
,
false
)
;
OutStreamer
.
emitRawComment
(
" codeLenInByte = "
+
Twine
(
KernelInfo
.
CodeLen
)
,
false
)
;
OutStreamer
.
emitRawComment
(
" NumSgprs: "
+
Twine
(
KernelInfo
.
NumSGPR
)
,
false
)
;
OutStreamer
.
emitRawComment
(
" NumVgprs: "
+
Twine
(
KernelInfo
.
NumVGPR
)
,
false
)
;
OutStreamer
.
emitRawComment
(
" FloatMode: "
+
Twine
(
KernelInfo
.
FloatMode
)
,
false
)
;
OutStreamer
.
emitRawComment
(
" IeeeMode: "
+
Twine
(
KernelInfo
.
IEEEMode
)
,
false
)
;
OutStreamer
.
emitRawComment
(
" ScratchSize: "
+
Twine
(
KernelInfo
.
ScratchSize
)
,
false
)
;
}
else
{
R600MachineFunctionInfo
*
MFI
=
MF
.
getInfo
<
R600MachineFunctionInfo
>
(
)
;
OutStreamer
.
emitRawComment
(
Twine
(
"SQ_PGM_RESOURCES:STACK_SIZE = "
+
Twine
(
MFI
->
StackSize
)
)
)
;
}
}
if
(
STM
.
dumpCode
(
)
)
{
MF
.
dump
(
)
;
if
(
DisasmEnabled
)
{
OutStreamer
.
SwitchSection
(
Context
.
getELFSection
(
".AMDGPU.disasm"
,
ELF
::
SHT_NOTE
,
0
,
SectionKind
::
getReadOnly
(
)
)
)
;
for
(
size_t
i
=
0
;
i
<
DisasmLines
.
size
(
)
;
++
i
)
{
std
::
string
Comment
(
DisasmLineMaxLen
DisasmLines
[
i
]
.
size
(
)
,
' '
)
;
Comment
+=
" ; "
+
HexLines
[
i
]
+
"\n"
;
OutStreamer
.
EmitBytes
(
StringRef
(
DisasmLines
[
i
]
)
)
;
OutStreamer
.
EmitBytes
(
StringRef
(
Comment
)
)
;
}
}
}
return
false
;
}
</s>

runOnMachineFunction - Emit the function body .


<s> Value * X86TargetLowering :: getSDagStackGuard ( const Module & M ) const { if ( Subtarget . getTargetTriple ( ) . isWindowsMSVCEnvironment ( ) || Subtarget . getTargetTriple ( ) . isWindowsItaniumEnvironment ( ) ) { return M . getGlobalVariable ( "__security_cookie" ) ; } return TargetLowering :: getSDagStackGuard ( M ) ; } </s>

Return the variable that 's previously inserted by insertSSPDeclarations , if any , otherwise return nullptr .


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

Get a TargetTransformInfo implementation for the target .


<s> bool MipsAsmBackend :: shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) { const unsigned FixupKind = Fixup . getKind ( ) ; switch ( FixupKind ) { default : return false ; case Mips :: fixup_Mips_CALL_HI16 : case Mips :: fixup_Mips_CALL_LO16 : case Mips :: fixup_Mips_CALL16 : case Mips :: fixup_Mips_GOT : case Mips :: fixup_Mips_GOT_PAGE : case Mips :: fixup_Mips_GOT_OFST : case Mips :: fixup_Mips_GOT_DISP : case Mips :: fixup_Mips_GOT_HI16 : case Mips :: fixup_Mips_GOT_LO16 : case Mips :: fixup_Mips_GOTTPREL : case Mips :: fixup_Mips_DTPREL_HI : case Mips :: fixup_Mips_DTPREL_LO : case Mips :: fixup_Mips_TLSGD : case Mips :: fixup_Mips_TLSLDM : case Mips :: fixup_Mips_TPREL_HI : case Mips :: fixup_Mips_TPREL_LO : case Mips :: fixup_Mips_JALR : case Mips :: fixup_MICROMIPS_CALL16 : case Mips :: fixup_MICROMIPS_GOT_DISP : case Mips :: fixup_MICROMIPS_GOT_PAGE : case Mips :: fixup_MICROMIPS_GOT_OFST : case Mips :: fixup_MICROMIPS_GOT16 : case Mips :: fixup_MICROMIPS_GOTTPREL : case Mips :: fixup_MICROMIPS_TLS_DTPREL_HI16 : case Mips :: fixup_MICROMIPS_TLS_DTPREL_LO16 : case Mips :: fixup_MICROMIPS_TLS_GD : case Mips :: fixup_MICROMIPS_TLS_LDM : case Mips :: fixup_MICROMIPS_TLS_TPREL_HI16 : case Mips :: fixup_MICROMIPS_TLS_TPREL_LO16 : case Mips :: fixup_MICROMIPS_JALR : case Mips :: fixup_CHERI_CAPTAB_TLSGD_HI16 : case Mips :: fixup_CHERI_CAPTAB_TLSGD_LO16 : case Mips :: fixup_CHERI_CAPTAB_TLSLDM_HI16 : case Mips :: fixup_CHERI_CAPTAB_TLSLDM_LO16 : case Mips :: fixup_CHERI_CAPTAB_TPREL_HI16 : case Mips :: fixup_CHERI_CAPTAB_TPREL_LO16 : return true ; } } </s>

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


<s> static bool legitimate_reload_vector_constant_p ( rtx op ) { if ( TARGET_VX && GET_MODE_SIZE ( GET_MODE ( op ) ) == 16 && ( satisfies_constraint_j00 ( op ) || satisfies_constraint_jm1 ( op ) || satisfies_constraint_jKK ( op ) || satisfies_constraint_jxx ( op ) || satisfies_constraint_jyy ( op ) ) ) return true ; return false ; } </s>

Returns true if the constant value OP is a legitimate vector operand during and after reload . This function accepts all constants which can be loaded directly into an VR .


<s> void SITargetLowering :: finalizeLowering ( MachineFunction & MF ) const { MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; SIMachineFunctionInfo * Info = MF . getInfo < SIMachineFunctionInfo > ( ) ; const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; const SIRegisterInfo * TRI = Subtarget -> getRegisterInfo ( ) ; const SIInstrInfo * TII = ST . getInstrInfo ( ) ; if ( Info -> isEntryFunction ( ) ) { reservePrivateMemoryRegs ( getTargetMachine ( ) , MF , * TRI , * Info ) ; } assert ( ! TRI -> isSubRegister ( Info -> getScratchRSrcReg ( ) , Info -> getStackPtrOffsetReg ( ) ) ) ; if ( Info -> getStackPtrOffsetReg ( ) != AMDGPU :: SP_REG ) MRI . replaceRegWith ( AMDGPU :: SP_REG , Info -> getStackPtrOffsetReg ( ) ) ; if ( Info -> getScratchRSrcReg ( ) != AMDGPU :: PRIVATE_RSRC_REG ) MRI . replaceRegWith ( AMDGPU :: PRIVATE_RSRC_REG , Info -> getScratchRSrcReg ( ) ) ; if ( Info -> getFrameOffsetReg ( ) != AMDGPU :: FP_REG ) MRI . replaceRegWith ( AMDGPU :: FP_REG , Info -> getFrameOffsetReg ( ) ) ; Info -> limitOccupancy ( MF ) ; if ( ST . isWave32 ( ) && ! MF . empty ( ) ) { for ( auto & MBB : MF ) { for ( auto & MI : MBB ) { TII -> fixImplicitOperands ( MI ) ; } } } if ( ST . needsAlignedVGPRs ( ) ) { for ( unsigned I = 0 , E = MRI . getNumVirtRegs ( ) ; I != E ; ++ I ) { const Register Reg = Register :: index2VirtReg ( I ) ; const TargetRegisterClass * RC = MRI . getRegClassOrNull ( Reg ) ; if ( ! RC ) continue ; int NewClassID = getAlignedAGPRClassID ( RC -> getID ( ) ) ; if ( NewClassID != - 1 ) MRI . setRegClass ( Reg , TRI -> getRegClass ( NewClassID ) ) ; } } TargetLoweringBase :: finalizeLowering ( MF ) ; if ( VGPRReserveforSGPRSpill && TRI -> spillSGPRToVGPR ( ) && ! Info -> VGPRReservedForSGPRSpill && ! Info -> isEntryFunction ( ) ) Info -> reserveVGPRforSGPRSpills ( MF ) ; } </s>

Execute target specific actions to finalize target lowering .


<s> bool Thumb1FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineInstrBuilder MIB = BuildMI ( MBB , MI , DL , TII . get ( ARM :: tPUSH ) ) ; AddDefaultPred ( MIB ) ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; bool isKill = true ; if ( Reg == ARM :: LR ) { MachineFunction & MF = * MBB . getParent ( ) ; if ( MF . getFrameInfo ( ) -> isReturnAddressTaken ( ) && MF . getRegInfo ( ) . isLiveIn ( Reg ) ) isKill = false ; } if ( isKill ) MBB . addLiveIn ( Reg ) ; MIB . addReg ( Reg , getKillRegState ( isKill ) ) ; } MIB . setMIFlags ( MachineInstr :: FrameSetup ) ; return true ; } </s>


"%qE attribute doesn't apply to functions"


<s> static enum aarch64_parse_opt_result aarch64_parse_tune ( const char * to_parse , const struct processor * * res ) { const struct processor * cpu ; for ( cpu = all_cores ; cpu -> name != NULL ; cpu ++ ) { if ( strcmp ( cpu -> name , to_parse ) == 0 ) { * res = cpu ; return AARCH64_PARSE_OK ; } } return AARCH64_PARSE_INVALID_ARG ; } </s>


<s> const TargetRegisterClass * SIRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return & AMDGPU :: VGPR_32RegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .