<s> unsigned PPCRegisterInfo :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { const PPCFrameLowering * TFI = getFrameLowering ( MF ) ; const unsigned DefaultSafety = 1 ; switch ( RC -> getID ( ) ) { default : return 0 ; case PPC :: G8RC_NOX0RegClassID : case PPC :: GPRC_NOR0RegClassID : case PPC :: SPERCRegClassID : case PPC :: G8RCRegClassID : case PPC :: GPRCRegClassID : { unsigned FP = TFI -> hasFP ( MF ) ? 1 : 0 ; return 32 - FP - DefaultSafety ; } case PPC :: F4RCRegClassID : case PPC :: F8RCRegClassID : case PPC :: VSLRCRegClassID : return 32 - DefaultSafety ; case PPC :: VFRCRegClassID : case PPC :: VRRCRegClassID : { const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; if ( ! TM . getAIXExtendedAltivecABI ( ) && Subtarget . isAIXABI ( ) ) return 20 - DefaultSafety ; } return 32 - DefaultSafety ; case PPC :: VSFRCRegClassID : case PPC :: VSSRCRegClassID : case PPC :: VSRCRegClassID : { const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; if ( ! TM . getAIXExtendedAltivecABI ( ) && Subtarget . isAIXABI ( ) ) return 52 - DefaultSafety ; } return 64 - DefaultSafety ; case PPC :: CRRCRegClassID : return 8 - DefaultSafety ; } } </s>

Return the register pressure `` high water mark '' for the specific register class .


<s> void setKind ( BaseKind K ) { Kind = K ; } </s>


<s>
void
ARMBaseInstrInfo
::
buildOutlinedFrame
(
MachineBasicBlock
&
MBB
,
MachineFunction
&
MF
,
const
outliner
::
OutlinedFunction
&
OF
)
const
{
if
(
OF
.
FrameConstructionID
==
MachineOutlinerThunk
)
{
MachineInstr
*
Call
=
&
*
MBB
.
instr_end
(
)
;
bool
isThumb
=
Subtarget
.
isThumb
(
)
;
unsigned
FuncOp
=
isThumb
2
:
0
;
unsigned
Opc
=
Call
->
getOperand
(
FuncOp
)
.
isReg
(
)
isThumb
ARM
::
tTAILJMPr
:
ARM
::
TAILJMPr
:
isThumb
Subtarget
.
isTargetMachO
(
)
ARM
::
tTAILJMPd
:
ARM
::
tTAILJMPdND
:
ARM
::
TAILJMPd
;
MachineInstrBuilder
MIB
=
BuildMI
(
MBB
,
MBB
.
end
(
)
,
DebugLoc
(
)
,
get
(
Opc
)
)
.
add
(
Call
->
getOperand
(
FuncOp
)
)
;
if
(
isThumb
&&
!
Call
->
getOperand
(
FuncOp
)
.
isReg
(
)
)
MIB
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
Call
->
eraseFromParent
(
)
;
}
auto
IsNonTailCall
=
[
]
(
MachineInstr
&
MI
)
{
return
MI
.
isCall
(
)
&&
!
MI
.
isReturn
(
)
;
}
;
if
(
llvm
::
any_of
(
MBB
.
instrs
(
)
,
IsNonTailCall
)
)
{
MachineBasicBlock
::
iterator
It
=
MBB
.
begin
(
)
;
MachineBasicBlock
::
iterator
Et
=
MBB
.
end
(
)
;
if
(
OF
.
FrameConstructionID
==
MachineOutlinerTailCall
||
OF
.
FrameConstructionID
==
MachineOutlinerThunk
)
Et
=
std
::
prev
(
MBB
.
end
(
)
)
;
if
(
!
MBB
.
isLiveIn
(
ARM
::
LR
)
)
MBB
.
addLiveIn
(
ARM
::
LR
)
;
bool
Auth
=
OF
.
Candidates
.
front
(
)
.
getMF
(
)
->
getInfo
<
ARMFunctionInfo
>
(
)
->
shouldSignReturnAddress
(
true
)
;
saveLROnStack
(
MBB
,
It
,
true
,
Auth
)
;
assert
(
OF
.
FrameConstructionID
!=
MachineOutlinerDefault
&&
"Can only fix up stack references once"
)
;
fixupPostOutline
(
MBB
)
;
restoreLRFromStack
(
MBB
,
Et
,
true
,
Auth
)
;
}
if
(
OF
.
FrameConstructionID
==
MachineOutlinerTailCall
||
OF
.
FrameConstructionID
==
MachineOutlinerThunk
)
return
;
BuildMI
(
MBB
,
MBB
.
end
(
)
,
DebugLoc
(
)
,
get
(
Subtarget
.
getReturnOpcode
(
)
)
)
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
if
(
OF
.
FrameConstructionID
!=
MachineOutlinerDefault
&&
OF
.
Candidates
[
0
]
.
CallConstructionID
!=
MachineOutlinerDefault
)
return
;
fixupPostOutline
(
MBB
)
;
}
</s>

Insert a custom frame for outlined functions .

ARM
ARM
2
0
ARM::tTAILJMPr
ARM::TAILJMPr
ARM::tTAILJMPd
ARM::tTAILJMPdND
ARM::TAILJMPd
ARMCC::AL
ARM::LR
ARM::LR
ARM
"Can only fix up stack references once"
ARMCC::AL
0


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

Return true if the extension represented by I is free .


<s>
void
GBZ80InstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
DebugLoc
&
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
const
GBZ80Subtarget
&
STI
=
MBB
.
getParent
(
)
->
getSubtarget
<
GBZ80Subtarget
>
(
)
;
const
GBZ80RegisterInfo
&
TRI
=
*
STI
.
getRegisterInfo
(
)
;
unsigned
Opc
;
if
(
GB
::
R16RegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
unsigned
DestLo
,
DestHi
,
SrcLo
,
SrcHi
;
TRI
.
splitReg
(
DestReg
,
DestLo
,
DestHi
)
;
TRI
.
splitReg
(
SrcReg
,
SrcLo
,
SrcHi
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
GB
::
LD_r_r
)
,
DestLo
)
.
addReg
(
SrcLo
,
getKillRegState
(
KillSrc
)
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
GB
::
LD_r_r
)
,
DestHi
)
.
addReg
(
SrcHi
,
getKillRegState
(
KillSrc
)
)
;
}
else
if
(
GB
::
R8RegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
GB
::
LD_r_r
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
if
(
DestReg
==
GB
::
SP
&&
SrcReg
==
GB
::
RHL
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
GB
::
LD_SP_HL
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
{
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
}
</s>


<s> bool HexagonStoreWidening :: runOnMachineFunction ( MachineFunction & MFn ) { if ( skipFunction ( MFn . getFunction ( ) ) ) return false ; MF = & MFn ; auto & ST = MFn . getSubtarget < HexagonSubtarget > ( ) ; TII = ST . getInstrInfo ( ) ; TRI = ST . getRegisterInfo ( ) ; MRI = & MFn . getRegInfo ( ) ; AA = & getAnalysis < AAResultsWrapperPass > ( ) . getAAResults ( ) ; bool Changed = false ; for ( auto & B : MFn ) Changed |= processBasicBlock ( B ) ; return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> static void mips_reorg ( void ) { if ( mips_cfg_in_reorg ( ) ) compute_bb_for_insn ( ) ; mips16_lay_out_constants ( true ) ; if ( mips_cfg_in_reorg ( ) ) { mips_df_reorg ( ) ; free_bb_for_insn ( ) ; } } </s>


<s>
static
void
rs6000_output_function_prologue
(
FILE
*
file
)
{
if
(
!
cfun
->
is_thunk
)
rs6000_output_savres_externs
(
file
)
;
if
(
rs6000_global_entry_point_needed_p
(
)
)
{
const
char
*
name
=
XSTR
(
XEXP
(
DECL_RTL
(
current_function_decl
)
,
0
)
,
0
)
;
(
*
targetm
.
asm_out
.
internal_label
)
(
file
,
"LCF"
,
rs6000_pic_labelno
)
;
if
(
TARGET_CMODEL
!=
CMODEL_LARGE
)
{
char
buf
[
256
]
;
ASM_GENERATE_INTERNAL_LABEL
(
buf
,
"LCF"
,
rs6000_pic_labelno
)
;
fprintf
(
file
,
"0:\taddis 2,12,.TOC.-"
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"@ha\n"
)
;
fprintf
(
file
,
"\taddi 2,2,.TOC.-"
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"@l\n"
)
;
}
else
{
char
buf
[
256
]
;
fprintf
(
file
,
"\t.reloc .,R_PPC64_ENTRY\n"
)
;
fprintf
(
file
,
"\tld 2,"
)
;
ASM_GENERATE_INTERNAL_LABEL
(
buf
,
"LCL"
,
rs6000_pic_labelno
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"-"
)
;
ASM_GENERATE_INTERNAL_LABEL
(
buf
,
"LCF"
,
rs6000_pic_labelno
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"(12)\n"
)
;
fprintf
(
file
,
"\tadd 2,2,12\n"
)
;
}
fputs
(
"\t.localentry\t"
,
file
)
;
assemble_name
(
file
,
name
)
;
fputs
(
",.-"
,
file
)
;
assemble_name
(
file
,
name
)
;
fputs
(
"\n"
,
file
)
;
}
if
(
TARGET_PROFILE_KERNEL
&&
crtl
->
profile
)
{
gcc_assert
(
DEFAULT_ABI
==
ABI_AIX
||
DEFAULT_ABI
==
ABI_ELFv2
)
;
gcc_assert
(
!
TARGET_32BIT
)
;
asm_fprintf
(
file
,
"\tmflr %s\n"
,
reg_names
[
0
]
)
;
if
(
DEFAULT_ABI
!=
ABI_ELFv2
&&
cfun
->
static_chain_decl
!=
)
{
asm_fprintf
(
file
,
"\tstd %s,24(%s)\n"
,
reg_names
[
STATIC_CHAIN_REGNUM
]
,
reg_names
[
1
]
)
;
fprintf
(
file
,
"\tbl %s\n"
,
RS6000_MCOUNT
)
;
asm_fprintf
(
file
,
"\tld %s,24(%s)\n"
,
reg_names
[
STATIC_CHAIN_REGNUM
]
,
reg_names
[
1
]
)
;
}
else
fprintf
(
file
,
"\tbl %s\n"
,
RS6000_MCOUNT
)
;
}
rs6000_pic_labelno
++
;
}
</s>


<s> bool ARMAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getIdentifier ( ) ; if ( IDVal == ".word" ) return parseDirectiveWord ( 4 , DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".thumb" ) return parseDirectiveThumb ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".arm" ) return parseDirectiveARM ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".thumb_func" ) return parseDirectiveThumbFunc ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".code" ) return parseDirectiveCode ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".syntax" ) return parseDirectiveSyntax ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".unreq" ) return parseDirectiveUnreq ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".arch" ) return parseDirectiveArch ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".eabi_attribute" ) return parseDirectiveEabiAttr ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".fnstart" ) return parseDirectiveFnStart ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".fnend" ) return parseDirectiveFnEnd ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".cantunwind" ) return parseDirectiveCantUnwind ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".personality" ) return parseDirectivePersonality ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".handlerdata" ) return parseDirectiveHandlerData ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".setfp" ) return parseDirectiveSetFP ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".pad" ) return parseDirectivePad ( DirectiveID . getLoc ( ) ) ; else if ( IDVal == ".save" ) return parseDirectiveRegSave ( DirectiveID . getLoc ( ) , false ) ; else if ( IDVal == ".vsave" ) return parseDirectiveRegSave ( DirectiveID . getLoc ( ) , true ) ; return true ; } </s>

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


<s> unsigned getNumFixupKinds ( ) const override { return LEG :: NumTargetFixupKinds ; } </s>

Get the number of target specific fixup kinds .


<s> static int ix86_shift_rotate_cost ( const struct processor_costs * cost , enum rtx_code code , enum machine_mode mode , bool constant_op1 , HOST_WIDE_INT op1_val , bool speed , bool and_in_op1 , bool shift_and_truncate , bool * skip_op0 , bool * skip_op1 ) { if ( skip_op0 ) * skip_op0 = * skip_op1 = false ; if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) { if ( mode == V16QImode || mode == V32QImode ) { int count = 11 ; if ( TARGET_XOP && mode == V16QImode ) { if ( constant_op1 ) { if ( skip_op1 ) * skip_op1 = true ; return ix86_vec_cost ( mode , cost -> sse_op + ( speed ? 2 : COSTS_N_BYTES ( GET_MODE_UNIT_SIZE ( mode ) ) ) ) ; } count = 3 ; } else if ( TARGET_SSSE3 ) count = 7 ; return ix86_vec_cost ( mode , cost -> sse_op * count ) ; } else if ( code == ASHIFTRT && ( mode == V2DImode || mode == V4DImode ) && ! TARGET_XOP && ! TARGET_AVX512VL ) { int count = 4 ; if ( constant_op1 && op1_val == 63 && TARGET_SSE4_2 ) count = 2 ; else if ( constant_op1 ) count = 3 ; return ix86_vec_cost ( mode , cost -> sse_op * count ) ; } else return ix86_vec_cost ( mode , cost -> sse_op ) ; } if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) { if ( constant_op1 ) { if ( op1_val > 32 ) return cost -> shift_const + COSTS_N_INSNS ( 2 ) ; else return cost -> shift_const * 2 ; } else { if ( and_in_op1 ) return cost -> shift_var * 2 ; else return cost -> shift_var * 6 + COSTS_N_INSNS ( 2 ) ; } } else { if ( constant_op1 ) return cost -> shift_const ; else if ( shift_and_truncate ) { if ( skip_op0 ) * skip_op0 = * skip_op1 = true ; return cost -> shift_var ; } else return cost -> shift_var ; } } </s>

Return cost of shift in MODE . If CONSTANT_OP1 is true , the op1 value is known and set in OP1_VAL . AND_IN_OP1 specify in op1 is result of AND and SHIFT_AND_TRUNCATE if op1 is a result of subreg . SKIP_OP0/1 is set to true if cost of OP0/1 should be ignored .


<s> static rtx nios2_load_pic_address ( rtx sym , int unspec , rtx tmp ) { if ( flag_pic == 2 && GET_CODE ( sym ) == SYMBOL_REF && nios2_symbol_binds_local_p ( sym ) ) { rtx offset = nios2_unspec_offset ( sym , UNSPEC_PIC_GOTOFF_SYM ) ; crtl -> uses_pic_offset_table = 1 ; return nios2_large_got_address ( offset , tmp ) ; } return gen_const_mem ( Pmode , nios2_got_address ( sym , unspec ) ) ; } </s>


<s> unsigned getMinimumNopSize ( ) const override { return 2 ; } </s>

Returns the minimum size of a nop in bytes on this target .


<s> int getCycle ( ) { return cycle ; } </s>

Return the cycle that MI is scheduled at , or -1 .


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

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


<s> static bool isSigned ( Kind Cmp ) { return ( Cmp & ( L | G ) && ! ( Cmp & U ) ) ; } </s>

Returns true if all source operands of the recurrence are SExtInsts .


<s> explicit Entry ( const class Region * R ) : TheRegion ( R ) , NumBlocksLeft ( R -> getNumBlocks ( ) ) { } </s>


<s> bool hasLowDefLatency ( const InstrItineraryData * ItinData , const MachineInstr * DefMI , unsigned DefIdx ) const override { return false ; } </s>

Compute operand latency of a def of 'Reg ' .


<s>
const
char
*
output_in_line_mul
(
)
{
static
char
insns
[
200
]
;
int
i
;
strcpy
(
insns
,
"s %0,%0\n"
)
;
strcat
(
insns
,
"\tmts r10,%1\n"
)
;
for
(
i
=
0
;
i
<
16
;
i
++
)
strcat
(
insns
,
"\tm %0,%2\n"
)
;
strcat
(
insns
,
"\tmfs r10,%0"
)
;
return
insns
;
}
</s>

Generate the ( long ) string corresponding to an inline multiply insn . Note that ` r10 ' does not refer to the register r10 , but rather to the SCR used as the MQ .


"\t# pre-label NOPs for hotpatch (%d halfwords)\n"

"\t# post-label NOPs for hotpatch (%d halfwords)\n"

Write the extra assembler code needed to declare a function properly .


<s>
MachineBasicBlock
*
XCoreTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
*
MI
,
MachineBasicBlock
*
BB
)
const
{
const
TargetInstrInfo
&
TII
=
*
getTargetMachine
(
)
.
getSubtargetImpl
(
)
->
getInstrInfo
(
)
;
DebugLoc
dl
=
MI
->
getDebugLoc
(
)
;
assert
(
(
MI
->
getOpcode
(
)
==
XCore
::
SELECT_CC
)
&&
"Unexpected instr type to insert"
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
MachineFunction
::
iterator
It
=
BB
;
++
It
;
MachineBasicBlock
*
thisMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
copy0MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
sinkMBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
F
->
insert
(
It
,
copy0MBB
)
;
F
->
insert
(
It
,
sinkMBB
)
;
sinkMBB
->
splice
(
sinkMBB
->
begin
(
)
,
BB
,
std
::
next
(
MachineBasicBlock
::
iterator
(
MI
)
)
,
BB
->
end
(
)
)
;
sinkMBB
->
transferSuccessorsAndUpdatePHIs
(
BB
)
;
BB
->
addSuccessor
(
copy0MBB
)
;
BB
->
addSuccessor
(
sinkMBB
)
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
XCore
::
BRFT_lru6
)
)
.
addReg
(
MI
->
getOperand
(
1
)
.
getReg
(
)
)
.
addMBB
(
sinkMBB
)
;
BB
=
copy0MBB
;
BB
->
addSuccessor
(
sinkMBB
)
;
BB
=
sinkMBB
;
BuildMI
(
*
BB
,
BB
->
begin
(
)
,
dl
,
TII
.
get
(
XCore
::
PHI
)
,
MI
->
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
->
getOperand
(
3
)
.
getReg
(
)
)
.
addMBB
(
copy0MBB
)
.
addReg
(
MI
->
getOperand
(
2
)
.
getReg
(
)
)
.
addMBB
(
thisMBB
)
;
MI
->
eraseFromParent
(
)
;
return
BB
;
}
</s>

This method should be implemented by targets that mark instructions with the 'usesCustomInserter ' flag .


<s> void X86FrameLowering :: orderFrameObjects ( const MachineFunction & MF , SmallVectorImpl < int > & ObjectsToAllocate ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; if ( ObjectsToAllocate . empty ( ) ) return ; std :: vector < X86FrameSortingObject > SortingObjects ( MFI -> getObjectIndexEnd ( ) ) ; for ( auto & Obj : ObjectsToAllocate ) { SortingObjects [ Obj ] . IsValid = true ; SortingObjects [ Obj ] . ObjectIndex = Obj ; SortingObjects [ Obj ] . ObjectAlignment = MFI -> getObjectAlignment ( Obj ) ; int ObjectSize = MFI -> getObjectSize ( Obj ) ; if ( ObjectSize == 0 ) SortingObjects [ Obj ] . ObjectSize = 4 ; else SortingObjects [ Obj ] . ObjectSize = ObjectSize ; } for ( auto & MBB : MF ) { for ( auto & MI : MBB ) { for ( const MachineOperand & MO : MI . operands ( ) ) { if ( ! MO . isFI ( ) ) continue ; int Index = MO . getIndex ( ) ; if ( Index >= 0 && Index < MFI -> getObjectIndexEnd ( ) && SortingObjects [ Index ] . IsValid ) SortingObjects [ Index ] . ObjectNumUses ++ ; } } } std :: stable_sort ( SortingObjects . begin ( ) , SortingObjects . end ( ) , X86FrameSortingComparator ( ) ) ; int i = 0 ; for ( auto & Obj : SortingObjects ) { if ( ! Obj . IsValid ) break ; ObjectsToAllocate [ i ++ ] = Obj . ObjectIndex ; } if ( ! TRI -> needsStackRealignment ( MF ) && hasFP ( MF ) ) std :: reverse ( ObjectsToAllocate . begin ( ) , ObjectsToAllocate . end ( ) ) ; } </s>


<s> void MBlazeInstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned DestReg , int FI , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL ; BuildMI ( MBB , I , DL , get ( MBlaze :: LWI ) , DestReg ) . addImm ( 0 ) . addFrameIndex ( FI ) ; } </s>


"Instr doesn't have FrameIndex operand!"

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


<s> bool PPCTargetLowering :: SelectAddressRegReg ( SDValue N , SDValue & Base , SDValue & Index , SelectionDAG & DAG ) const { int16_t imm = 0 ; if ( N . getOpcode ( ) == ISD :: ADD ) { if ( isIntS16Immediate ( N . getOperand ( 1 ) , imm ) ) return false ; if ( N . getOperand ( 1 ) . getOpcode ( ) == PPCISD :: Lo ) return false ; Base = N . getOperand ( 0 ) ; Index = N . getOperand ( 1 ) ; return true ; } else if ( N . getOpcode ( ) == ISD :: OR ) { if ( isIntS16Immediate ( N . getOperand ( 1 ) , imm ) ) return false ; KnownBits LHSKnown = DAG . computeKnownBits ( N . getOperand ( 0 ) ) ; if ( LHSKnown . Zero . getBoolValue ( ) ) { KnownBits RHSKnown = DAG . computeKnownBits ( N . getOperand ( 1 ) ) ; if ( ~ ( LHSKnown . Zero | RHSKnown . Zero ) == 0 ) { Base = N . getOperand ( 0 ) ; Index = N . getOperand ( 1 ) ; return true ; } } } return false ; } </s>

SelectAddressRegReg - Given the specified addressed , check to see if it can be more efficiently represented as [ r+imm ] .


<s> PatmosTargetLowering :: ConstraintType PatmosTargetLowering :: getConstraintType ( const std :: string & Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'R' : case 'S' : case 'P' : return C_RegisterClass ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s> static void set_reg_plus_d ( int reg , int base , HOST_WIDE_INT disp , int note ) { rtx insn ; if ( VAL_14_BITS_P ( disp ) ) { insn = emit_move_insn ( gen_rtx_REG ( Pmode , reg ) , plus_constant ( gen_rtx_REG ( Pmode , base ) , disp ) ) ; } else if ( TARGET_64BIT && ! VAL_32_BITS_P ( disp ) ) { rtx basereg = gen_rtx_REG ( Pmode , base ) ; rtx delta = GEN_INT ( disp ) ; rtx tmpreg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( tmpreg , delta ) ; insn = emit_move_insn ( gen_rtx_REG ( Pmode , reg ) , gen_rtx_PLUS ( Pmode , tmpreg , basereg ) ) ; if ( DO_FRAME_NOTES ) REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , tmpreg , gen_rtx_PLUS ( Pmode , basereg , delta ) ) , REG_NOTES ( insn ) ) ; } else { rtx basereg = gen_rtx_REG ( Pmode , base ) ; rtx delta = GEN_INT ( disp ) ; rtx tmpreg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( tmpreg , gen_rtx_PLUS ( Pmode , basereg , gen_rtx_HIGH ( Pmode , delta ) ) ) ; insn = emit_move_insn ( gen_rtx_REG ( Pmode , reg ) , gen_rtx_LO_SUM ( Pmode , tmpreg , delta ) ) ; } if ( DO_FRAME_NOTES && note ) RTX_FRAME_RELATED_P ( insn ) = 1 ; } </s>

Emit RTL to set REG to the value specified by BASE+DISP . Handle case where DISP > 8k by using the add_high_const patterns . Note in DISP > 8k case , we will leave the high part of the address in % r1 . There is code in expand_hppa_ { prologue , epilogue } that knows this .


"%qE attribute only applies to functions"

Handle a `` force_align_arg_pointer '' attribute .


<s>
bool
ParseInstruction
(
ParseInstructionInfo
&
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
override
{
Operands
.
push_back
(
make_unique
<
WebAssemblyOperand
>
(
WebAssemblyOperand
::
Token
,
NameLoc
,
SMLoc
::
getFromPointer
(
NameLoc
.
getPointer
(
)
+
Name
.
size
(
)
)
,
WebAssemblyOperand
::
TokOp
{
StringRef
(
NameLoc
.
getPointer
(
)
,
Name
.
size
(
)
)
}
)
)
;
auto
NamePair
=
Name
.
split
(
'.'
)
;
if
(
NamePair
.
second
.
empty
(
)
)
std
::
swap
(
NamePair
.
first
,
NamePair
.
second
)
;
while
(
Lexer
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
auto
&
Tok
=
Lexer
.
getTok
(
)
;
switch
(
Tok
.
getKind
(
)
)
{
case
AsmToken
::
Identifier
:
{
auto
&
Id
=
Lexer
.
getTok
(
)
;
const
MCExpr
*
Val
;
SMLoc
End
;
if
(
Parser
.
parsePrimaryExpr
(
Val
,
End
)
)
return
Error
(
"Cannot parse symbol: "
,
Lexer
.
getTok
(
)
)
;
Operands
.
push_back
(
make_unique
<
WebAssemblyOperand
>
(
WebAssemblyOperand
::
Symbol
,
Id
.
getLoc
(
)
,
Id
.
getEndLoc
(
)
,
WebAssemblyOperand
::
SymOp
{
Val
}
)
)
;
break
;
}
case
AsmToken
::
Minus
:
Parser
.
Lex
(
)
;
if
(
Lexer
.
isNot
(
AsmToken
::
Integer
)
)
return
Error
(
"Expected integer instead got: "
,
Lexer
.
getTok
(
)
)
;
if
(
ParseOperandStartingWithInteger
(
true
,
Operands
,
NamePair
.
second
)
)
return
true
;
break
;
case
AsmToken
::
Integer
:
if
(
ParseOperandStartingWithInteger
(
false
,
Operands
,
NamePair
.
second
)
)
return
true
;
break
;
case
AsmToken
::
Real
:
{
double
Val
;
if
(
Tok
.
getString
(
)
.
getAsDouble
(
Val
,
false
)
)
return
Error
(
"Cannot parse real: "
,
Tok
)
;
Operands
.
push_back
(
make_unique
<
WebAssemblyOperand
>
(
WebAssemblyOperand
::
Float
,
Tok
.
getLoc
(
)
,
Tok
.
getEndLoc
(
)
,
WebAssemblyOperand
::
FltOp
{
Val
}
)
)
;
Parser
.
Lex
(
)
;
break
;
}
default
:
return
Error
(
"Unexpected token in operand: "
,
Tok
)
;
}
if
(
Lexer
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
if
(
Expect
(
AsmToken
::
Comma
,
","
)
)
return
true
;
}
}
Parser
.
Lex
(
)
;
if
(
NamePair
.
second
==
"block"
||
NamePair
.
second
==
"loop"
)
{
Operands
.
push_back
(
make_unique
<
WebAssemblyOperand
>
(
WebAssemblyOperand
::
Integer
,
NameLoc
,
NameLoc
,
WebAssemblyOperand
::
IntOp
{
1
}
)
)
;
}
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .

WebAssembly
WebAssembly
WebAssemblyOperand::Token
WebAssemblyOperand::TokOp
"Cannot parse symbol: "
WebAssembly
WebAssemblyOperand::Symbol
WebAssemblyOperand::SymOp
"Expected integer instead got: "
"Cannot parse real: "
WebAssembly
WebAssemblyOperand::Float
WebAssemblyOperand::FltOp
"Unexpected token in operand: "
","
"block"
"loop"
WebAssembly
WebAssemblyOperand::Integer
WebAssemblyOperand::IntOp
1


"XCore DAG->DAG Pattern Instruction Selection"

getPassName - Return a nice clean name for a pass .


<s> void ix86_emit_i387_log1p ( rtx op0 , rtx op1 ) { rtx label1 = gen_label_rtx ( ) ; rtx label2 = gen_label_rtx ( ) ; rtx tmp = gen_reg_rtx ( XFmode ) ; rtx tmp2 = gen_reg_rtx ( XFmode ) ; emit_insn ( gen_absxf2 ( tmp , op1 ) ) ; emit_insn ( gen_cmpxf ( tmp , CONST_DOUBLE_FROM_REAL_VALUE ( REAL_VALUE_ATOF ( "0.29289321881345247561810596348408353" , XFmode ) , XFmode ) ) ) ; emit_jump_insn ( gen_bge ( label1 ) ) ; emit_move_insn ( tmp2 , standard_80387_constant_rtx ( 4 ) ) ; emit_insn ( gen_fyl2xp1_xf3 ( op0 , tmp2 , op1 ) ) ; emit_jump ( label2 ) ; emit_label ( label1 ) ; emit_move_insn ( tmp , CONST1_RTX ( XFmode ) ) ; emit_insn ( gen_addxf3 ( tmp , op1 , tmp ) ) ; emit_move_insn ( tmp2 , standard_80387_constant_rtx ( 4 ) ) ; emit_insn ( gen_fyl2x_xf3 ( op0 , tmp2 , tmp ) ) ; emit_label ( label2 ) ; } </s>

Output code to perform a log1p XFmode calculation .


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

Implements EH_RETURN_STACKADJ_RTX . Saved and used later in m32c_emit_eh_epilogue .


<s>
static
unsigned
getHashValue
(
const
MemOpKey
&
Val
)
{
assert
(
Val
.
Disp
!=
PtrInfo
::
getEmptyKey
(
)
&&
"Cannot hash the empty key"
)
;
assert
(
Val
.
Disp
!=
PtrInfo
::
getTombstoneKey
(
)
&&
"Cannot hash the tombstone key"
)
;
hash_code
Hash
=
hash_combine
(
*
Val
.
Operands
[
0
]
,
*
Val
.
Operands
[
1
]
,
*
Val
.
Operands
[
2
]
,
*
Val
.
Operands
[
3
]
)
;
switch
(
Val
.
Disp
->
getType
(
)
)
{
case
MachineOperand
::
MO_Immediate
:
break
;
case
MachineOperand
::
MO_ConstantPoolIndex
:
case
MachineOperand
::
MO_JumpTableIndex
:
Hash
=
hash_combine
(
Hash
,
Val
.
Disp
->
getIndex
(
)
)
;
break
;
case
MachineOperand
::
MO_ExternalSymbol
:
Hash
=
hash_combine
(
Hash
,
Val
.
Disp
->
getSymbolName
(
)
)
;
break
;
case
MachineOperand
::
MO_GlobalAddress
:
Hash
=
hash_combine
(
Hash
,
Val
.
Disp
->
getGlobal
(
)
)
;
break
;
case
MachineOperand
::
MO_BlockAddress
:
Hash
=
hash_combine
(
Hash
,
Val
.
Disp
->
getBlockAddress
(
)
)
;
break
;
case
MachineOperand
::
MO_MCSymbol
:
Hash
=
hash_combine
(
Hash
,
Val
.
Disp
->
getMCSymbol
(
)
)
;
break
;
case
MachineOperand
::
MO_MachineBasicBlock
:
Hash
=
hash_combine
(
Hash
,
Val
.
Disp
->
getMBB
(
)
)
;
break
;
default
:
llvm_unreachable
(
"Invalid address displacement operand"
)
;
}
return
(
unsigned
)
Hash
;
}
</s>

Using name and line to get hash value . It should already be mostly unique .


<s> static bool forward_branch_p ( rtx_insn * insn ) { rtx lab = JUMP_LABEL ( insn ) ; gcc_assert ( lab != NULL_RTX ) ; if ( INSN_ADDRESSES_SET_P ( ) ) return INSN_ADDRESSES ( INSN_UID ( lab ) ) > INSN_ADDRESSES ( INSN_UID ( insn ) ) ; while ( insn ) { if ( insn == lab ) return true ; else insn = NEXT_INSN ( insn ) ; } return false ; } </s>

Return 1 if INSN branches forward . Should be using insn_addresses to avoid walking through all the insns ...


<s> void MOSPassConfig :: addPreGlobalInstructionSelect ( ) { addPass ( new Localizer ( ) ) ; } </s>

This method may be implemented by targets that want to run passes immediately before the ( global ) instruction selection .


<s> unsigned GBZ80InstrInfo :: insertIndirectBranch ( MachineBasicBlock & MBB , MachineBasicBlock & NewDestBB , const DebugLoc & DL , int64_t BrOffset , RegScavenger * RS ) const { auto & MI = * BuildMI ( & MBB , DL , get ( GB :: JP_nn ) ) . addMBB ( & NewDestBB ) ; return getInstSizeInBytes ( MI ) ; } </s>

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


<s> static bool xstormy16_rtx_costs ( rtx x , int code , int outer_code ATTRIBUTE_UNUSED , int opno ATTRIBUTE_UNUSED , int * total , bool speed ATTRIBUTE_UNUSED ) { switch ( code ) { case CONST_INT : if ( INTVAL ( x ) < 16 && INTVAL ( x ) >= 0 ) * total = COSTS_N_INSNS ( 1 ) / 2 ; else if ( INTVAL ( x ) < 256 && INTVAL ( x ) >= 0 ) * total = COSTS_N_INSNS ( 1 ) ; else * total = COSTS_N_INSNS ( 2 ) ; return true ; case CONST_DOUBLE : case CONST : case SYMBOL_REF : case LABEL_REF : * total = COSTS_N_INSNS ( 2 ) ; return true ; case MULT : * total = COSTS_N_INSNS ( 35 + 6 ) ; return true ; case DIV : * total = COSTS_N_INSNS ( 51 - 6 ) ; return true ; default : return false ; } } </s>

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


<s> bool M680x0AsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count ) const { if ( Count % 2 != 0 ) return false ; uint64_t NumNops = Count / 2 ; for ( uint64_t i = 0 ; i != NumNops ; ++ i ) { OS << "\x4E\x71" ; } return true ; } </s>

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


<s> SDNode * PPCDAGToDAGISel :: getGlobalBaseReg ( ) { if ( ! GlobalBaseReg ) { const TargetInstrInfo & TII = * TM . getInstrInfo ( ) ; MachineBasicBlock & FirstMBB = MF -> front ( ) ; MachineBasicBlock :: iterator MBBI = FirstMBB . begin ( ) ; DebugLoc dl = DebugLoc :: getUnknownLoc ( ) ; if ( PPCLowering . getPointerTy ( ) == MVT :: i32 ) { GlobalBaseReg = RegInfo -> createVirtualRegister ( PPC :: GPRCRegisterClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR ) , PPC :: LR ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; } else { GlobalBaseReg = RegInfo -> createVirtualRegister ( PPC :: G8RCRegisterClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR8 ) , PPC :: LR8 ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR8 ) , GlobalBaseReg ) ; } } return CurDAG -> getRegister ( GlobalBaseReg , PPCLowering . getPointerTy ( ) ) . getNode ( ) ; } </s>

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


"Some operands reg class are incompatible!"

optimizeCompareInstr - Check if there exists an earlier instruction that operates on the same source operands and sets flags in the same way as Compare ; remove Compare if possible .


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


<s> bool SIRegisterInfo :: requiresFrameIndexReplacementScavenging ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; if ( ! MFI . hasStackObjects ( ) ) return false ; if ( ! isUInt < 12 > ( MFI . getStackSize ( ) ) ) return true ; return MF . getSubtarget < GCNSubtarget > ( ) . hasScalarStores ( ) && MF . getInfo < SIMachineFunctionInfo > ( ) -> hasSpilledSGPRs ( ) ; } </s>

Returns true if the target requires using the RegScavenger directly for frame elimination despite using requiresFrameIndexScavenging .


<s> bool X86PassConfig :: addRegBankSelect ( ) { addPass ( new RegBankSelect ( ) ) ; return false ; } </s>

This method should install a register bank selector pass , which assigns register banks to virtual registers without a register class or register banks .


<s> bool SystemZFrameLowering :: hasReservedCallFrame ( const MachineFunction & MF ) const { return true ; } </s>

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


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

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


<s> static tree tilegx_gimplify_va_arg_expr ( tree valist , tree type , gimple_seq * pre_p , gimple_seq * post_p ATTRIBUTE_UNUSED ) { tree f_args , f_skip ; tree args , skip ; HOST_WIDE_INT size , rsize ; tree addr , tmp ; bool pass_by_reference_p ; f_args = TYPE_FIELDS ( va_list_type_node ) ; f_skip = TREE_CHAIN ( f_args ) ; args = build3 ( COMPONENT_REF , TREE_TYPE ( f_args ) , valist , f_args , NULL_TREE ) ; skip = build3 ( COMPONENT_REF , TREE_TYPE ( f_skip ) , valist , f_skip , NULL_TREE ) ; addr = create_tmp_var ( ptr_type_node , "va_arg" ) ; pass_by_reference_p = pass_va_arg_by_reference ( type ) ; if ( pass_by_reference_p ) type = build_pointer_type ( type ) ; size = int_size_in_bytes ( type ) ; rsize = ( ( size + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ) * UNITS_PER_WORD ; if ( TYPE_ALIGN ( type ) > PARM_BOUNDARY ) { gcc_assert ( STACK_BOUNDARY == PARM_BOUNDARY * 2 ) ; tmp = build2 ( BIT_AND_EXPR , sizetype , fold_convert ( sizetype , unshare_expr ( args ) ) , size_int ( PARM_BOUNDARY / 8 ) ) ; tmp = build2 ( POINTER_PLUS_EXPR , ptr_type_node , unshare_expr ( args ) , tmp ) ; gimplify_assign ( unshare_expr ( args ) , tmp , pre_p ) ; } tmp = fold_build_pointer_plus_hwi ( unshare_expr ( args ) , rsize ) ; tmp = build2 ( TRUTH_AND_EXPR , boolean_type_node , build2 ( GT_EXPR , boolean_type_node , tmp , unshare_expr ( skip ) ) , build2 ( LE_EXPR , boolean_type_node , unshare_expr ( args ) , unshare_expr ( skip ) ) ) ; tmp = build3 ( COND_EXPR , ptr_type_node , tmp , build2 ( POINTER_PLUS_EXPR , ptr_type_node , unshare_expr ( skip ) , size_int ( STACK_POINTER_OFFSET ) ) , unshare_expr ( args ) ) ; if ( BYTES_BIG_ENDIAN && rsize > size ) tmp = fold_build_pointer_plus_hwi ( tmp , rsize - size ) ; gimplify_assign ( addr , tmp , pre_p ) ; if ( BYTES_BIG_ENDIAN && rsize > size ) tmp = fold_build_pointer_plus_hwi ( addr , size ) ; else tmp = fold_build_pointer_plus_hwi ( addr , rsize ) ; gimplify_assign ( unshare_expr ( args ) , tmp , pre_p ) ; addr = fold_convert ( build_pointer_type ( type ) , addr ) ; if ( pass_by_reference_p ) addr = build_va_arg_indirect_ref ( addr ) ; return build_va_arg_indirect_ref ( addr ) ; } </s>

Implement TARGET_GIMPLIFY_VA_ARG_EXPR . Gimplify va_arg by updating the va_list structure VALIST as required to retrieve an argument of type TYPE , and returning that argument . ret = va_arg ( VALIST , TYPE ) ; generates code equivalent to : paddedsize = ( sizeof ( TYPE ) + 7 ) & -8 ; if ( ( VALIST.__args + paddedsize > VALIST.__skip ) & ( VALIST.__args < = VALIST.__skip ) ) addr = VALIST.__skip + STACK_POINTER_OFFSET ; else addr = VALIST.__args ; VALIST.__args = addr + paddedsize ; if ( BYTES_BIG_ENDIAN ) ret = * ( TYPE * ) ( addr + paddedsize - sizeof ( TYPE ) ) ; else ret = * ( TYPE * ) addr ;


<s>
bool
SparcCodeEmitter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
SparcTargetMachine
&
Target
=
static_cast
<
SparcTargetMachine
&
>
(
const_cast
<
TargetMachine
&
>
(
MF
.
getTarget
(
)
)
)
;
JTI
=
Target
.
getJITInfo
(
)
;
II
=
Target
.
getInstrInfo
(
)
;
TD
=
Target
.
getDataLayout
(
)
;
Subtarget
=
&
TM
.
getSubtarget
<
SparcSubtarget
>
(
)
;
MCPEs
=
&
MF
.
getConstantPool
(
)
->
getConstants
(
)
;
JTI
->
Initialize
(
MF
,
IsPIC
)
;
MCE
.
setModuleInfo
(
&
getAnalysis
<
MachineModuleInfo
>
(
)
)
;
do
{
DEBUG
(
errs
(
)
<<
"JITTing function '"
<<
MF
.
getName
(
)
<<
"'\n"
)
;
MCE
.
startFunction
(
MF
)
;
for
(
MachineFunction
::
iterator
MBB
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
MBB
!=
E
;
++
MBB
)
{
MCE
.
StartMachineBasicBlock
(
MBB
)
;
for
(
MachineBasicBlock
::
instr_iterator
I
=
MBB
->
instr_begin
(
)
,
E
=
MBB
->
instr_end
(
)
;
I
!=
E
;
)
emitInstruction
(
*
I
++
,
*
MBB
)
;
}
}
while
(
MCE
.
finishFunction
(
MF
)
)
;
return
false
;
}
</s>

runOnMachineFunction - Emit the function body .

Sparc
Sparc
Sparc
Sparc
Sparc
"JITTing function '"
"'\n"


<s> unsigned getNumFixupKinds ( ) const override { return llvm :: M680x0 :: NumTargetFixupKinds ; } </s>

Get the number of target specific fixup kinds .


<s> void TPCAsmBackend :: relaxInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI , MCInst & Res ) const { } </s>

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


<s> std :: unique_ptr < TargetInstrInfo :: PipelinerLoopInfo > ARMBaseInstrInfo :: analyzeLoopForPipelining ( MachineBasicBlock * LoopBB ) const { MachineBasicBlock :: iterator I = LoopBB -> getFirstTerminator ( ) ; MachineBasicBlock * Preheader = * LoopBB -> pred_begin ( ) ; if ( Preheader == LoopBB ) Preheader = * std :: next ( LoopBB -> pred_begin ( ) ) ; if ( I != LoopBB -> end ( ) && I -> getOpcode ( ) == ARM :: t2Bcc ) { MachineInstr * CCSetter = nullptr ; for ( auto & L : LoopBB -> instrs ( ) ) { if ( L . isCall ( ) ) return nullptr ; if ( isCPSRDefined ( L ) ) CCSetter = & L ; } if ( CCSetter ) return std :: make_unique < ARMPipelinerLoopInfo > ( & * I , CCSetter ) ; else return nullptr ; } if ( I != LoopBB -> end ( ) && I -> getOpcode ( ) == ARM :: t2LoopEnd ) { for ( auto & L : LoopBB -> instrs ( ) ) if ( L . isCall ( ) ) return nullptr ; else if ( isVCTP ( & L ) ) return nullptr ; Register LoopDecResult = I -> getOperand ( 0 ) . getReg ( ) ; MachineRegisterInfo & MRI = LoopBB -> getParent ( ) -> getRegInfo ( ) ; MachineInstr * LoopDec = MRI . getUniqueVRegDef ( LoopDecResult ) ; if ( ! LoopDec || LoopDec -> getOpcode ( ) != ARM :: t2LoopDec ) return nullptr ; MachineInstr * LoopStart = nullptr ; for ( auto & J : Preheader -> instrs ( ) ) if ( J . getOpcode ( ) == ARM :: t2DoLoopStart ) LoopStart = & J ; if ( ! LoopStart ) return nullptr ; return std :: make_unique < ARMPipelinerLoopInfo > ( & * I , LoopDec ) ; } return nullptr ; } </s>

Analyze loop L , which must be a single-basic-block loop , and if the conditions can be understood enough produce a PipelinerLoopInfo object .


"Constant Island pass failed to converge!"

"Branch Fix Up pass failed to converge!"


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


"********** Fixing br_table Default Targets **********\n"


<s> static bool ix86_return_in_memory ( const_tree type , const_tree fntype ATTRIBUTE_UNUSED ) { return SUBTARGET_RETURN_IN_MEMORY ( type , fntype ) ; const machine_mode mode = type_natural_mode ( type , NULL , true ) ; HOST_WIDE_INT size ; if ( POINTER_BOUNDS_TYPE_P ( type ) ) return false ; if ( TARGET_64BIT ) { if ( ix86_function_type_abi ( fntype ) == MS_ABI ) { size = int_size_in_bytes ( type ) ; if ( ( ! type || VECTOR_INTEGER_TYPE_P ( type ) || INTEGRAL_TYPE_P ( type ) || VECTOR_FLOAT_TYPE_P ( type ) ) && ( SCALAR_INT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) && ! COMPLEX_MODE_P ( mode ) && ( GET_MODE_SIZE ( mode ) == 16 || size == 16 ) ) return false ; return size != 1 && size != 2 && size != 4 && size != 8 ; } else { int needed_intregs , needed_sseregs ; return examine_argument ( mode , type , 1 , & needed_intregs , & needed_sseregs ) ; } } else { size = int_size_in_bytes ( type ) ; if ( TARGET_IAMCU ) return VECTOR_MODE_P ( mode ) || size < 0 || size > 8 ; if ( mode == BLKmode ) return true ; if ( MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P ( type ) && size <= 8 ) return false ; if ( VECTOR_MODE_P ( mode ) || mode == TImode ) { if ( size < 8 ) return false ; if ( size == 8 ) return TARGET_VECT8_RETURNS || ! TARGET_MMX ; if ( size == 16 ) return ! TARGET_SSE ; if ( size == 32 ) return ! TARGET_AVX ; if ( size == 64 ) return ! TARGET_AVX512F ; } if ( mode == XFmode ) return false ; if ( size > 12 ) return true ; gcc_assert ( mode != OImode ) ; return false ; } } </s>

Return false iff type is returned in memory .


<s> Value * AArch64TargetLowering :: emitLoadLinked ( IRBuilderBase & Builder , Type * ValueTy , Value * Addr , AtomicOrdering Ord ) const { Module * M = Builder . GetInsertBlock ( ) -> getParent ( ) -> getParent ( ) ; bool IsAcquire = isAcquireOrStronger ( Ord ) ; if ( ValueTy -> getPrimitiveSizeInBits ( ) == 128 ) { Intrinsic :: ID Int = IsAcquire ? Intrinsic :: aarch64_ldaxp : Intrinsic :: aarch64_ldxp ; Function * Ldxr = Intrinsic :: getDeclaration ( M , Int ) ; Addr = Builder . CreateBitCast ( Addr , Type :: getInt8PtrTy ( M -> getContext ( ) ) ) ; Value * LoHi = Builder . CreateCall ( Ldxr , Addr , "lohi" ) ; Value * Lo = Builder . CreateExtractValue ( LoHi , 0 , "lo" ) ; Value * Hi = Builder . CreateExtractValue ( LoHi , 1 , "hi" ) ; Lo = Builder . CreateZExt ( Lo , ValueTy , "lo64" ) ; Hi = Builder . CreateZExt ( Hi , ValueTy , "hi64" ) ; return Builder . CreateOr ( Lo , Builder . CreateShl ( Hi , ConstantInt :: get ( ValueTy , 64 ) ) , "val64" ) ; } Type * Tys [ ] = { Addr -> getType ( ) } ; Intrinsic :: ID Int = IsAcquire ? Intrinsic :: aarch64_ldaxr : Intrinsic :: aarch64_ldxr ; Function * Ldxr = Intrinsic :: getDeclaration ( M , Int , Tys ) ; const DataLayout & DL = M -> getDataLayout ( ) ; IntegerType * IntEltTy = Builder . getIntNTy ( DL . getTypeSizeInBits ( ValueTy ) ) ; CallInst * CI = Builder . CreateCall ( Ldxr , Addr ) ; CI -> addParamAttr ( 0 , Attribute :: get ( Builder . getContext ( ) , Attribute :: ElementType , ValueTy ) ) ; Value * Trunc = Builder . CreateTrunc ( CI , IntEltTy ) ; return Builder . CreateBitCast ( Trunc , ValueTy ) ; } </s>

Perform a load-linked operation on Addr , returning a `` Value * '' with the corresponding pointee type .


<s> static int const_costs_int ( HOST_WIDE_INT value , int zero_cost ) { if ( CONST_OK_FOR_I ( value ) ) return zero_cost ; else if ( CONST_OK_FOR_J ( value ) ) return 1 ; else if ( CONST_OK_FOR_K ( value ) ) return 2 ; else return 4 ; } </s>

Return the cost of the rtx R with code CODE .


<s> SDValue OR1KTargetLowering :: LowerCallResult ( SDValue Chain , SDValue InFlag , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , SDLoc dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallResult ( Ins , RetCC_OR1K32 ) ; for ( unsigned i = 0 ; i != RVLocs . size ( ) ; ++ i ) { Chain = DAG . getCopyFromReg ( Chain , dl , RVLocs [ i ] . getLocReg ( ) , RVLocs [ i ] . getValVT ( ) , InFlag ) . getValue ( 1 ) ; InFlag = Chain . getValue ( 2 ) ; InVals . push_back ( Chain . getValue ( 0 ) ) ; } return Chain ; } </s>

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


"Can't store this register to stack slot"

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


<s> OperandMatchResultTy MipsAsmParser :: tryParseRegister ( unsigned & RegNo , SMLoc & StartLoc , SMLoc & EndLoc ) { SmallVector < std :: unique_ptr < MCParsedAsmOperand > , 1 > Operands ; OperandMatchResultTy ResTy = parseAnyRegister ( Operands ) ; if ( ResTy == MatchOperand_Success ) { assert ( Operands . size ( ) == 1 ) ; MipsOperand & Operand = static_cast < MipsOperand & > ( * Operands . front ( ) ) ; StartLoc = Operand . getStartLoc ( ) ; EndLoc = Operand . getEndLoc ( ) ; if ( Operand . isGPRAsmReg ( ) ) { RegNo = isGP64bit ( ) ? Operand . getGPR64Reg ( ) : Operand . getGPR32Reg ( ) ; } return ( RegNo == ( unsigned ) - 1 ) ? MatchOperand_NoMatch : MatchOperand_Success ; } assert ( Operands . size ( ) == 0 ) ; return ( RegNo == ( unsigned ) - 1 ) ? MatchOperand_NoMatch : MatchOperand_Success ; } </s>

tryParseRegister - parse one register if possible


<s> void EmitInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI ) override { EmitA64MappingSymbol ( ) ; MCELFStreamer :: EmitInstruction ( Inst , STI ) ; } </s>

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


<s> bool RISCVTargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace = 0 , unsigned Align = 1 , MachineMemOperand :: Flags Flags = MachineMemOperand :: MONone , bool * Fast = nullptr ) const { if ( Subtarget . hasNonStdExtPulp ( ) ) { if ( Fast ) { * Fast = false ; } return true ; } return false ; } </s>

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


<s>
bool
ARMBaseInstrInfo
::
expandPostRAPseudo
(
MachineBasicBlock
::
iterator
MI
)
const
{
if
(
!
WidenVMOVS
||
!
MI
->
isCopy
(
)
)
return
false
;
unsigned
DstRegS
=
MI
->
getOperand
(
0
)
.
getReg
(
)
;
unsigned
SrcRegS
=
MI
->
getOperand
(
1
)
.
getReg
(
)
;
if
(
!
ARM
::
SPRRegClass
.
contains
(
DstRegS
,
SrcRegS
)
)
return
false
;
const
TargetRegisterInfo
*
TRI
=
&
getRegisterInfo
(
)
;
unsigned
DstRegD
=
TRI
->
getMatchingSuperReg
(
DstRegS
,
ARM
::
ssub_0
,
&
ARM
::
DPRRegClass
)
;
unsigned
SrcRegD
=
TRI
->
getMatchingSuperReg
(
SrcRegS
,
ARM
::
ssub_0
,
&
ARM
::
DPRRegClass
)
;
if
(
!
DstRegD
||
!
SrcRegD
)
return
false
;
if
(
!
MI
->
definesRegister
(
DstRegD
,
TRI
)
||
MI
->
readsRegister
(
DstRegD
,
TRI
)
)
return
false
;
if
(
MI
->
getOperand
(
0
)
.
isDead
(
)
)
return
false
;
DEBUG
(
dbgs
(
)
<<
"widening:    "
<<
*
MI
)
;
MachineInstrBuilder
MIB
(
*
MI
->
getParent
(
)
->
getParent
(
)
,
MI
)
;
int
ImpDefIdx
=
MI
->
findRegisterDefOperandIdx
(
DstRegD
)
;
if
(
ImpDefIdx
!=
1
)
MI
->
RemoveOperand
(
ImpDefIdx
)
;
MI
->
setDesc
(
get
(
ARM
::
VMOVD
)
)
;
MI
->
getOperand
(
0
)
.
setReg
(
DstRegD
)
;
MI
->
getOperand
(
1
)
.
setReg
(
SrcRegD
)
;
AddDefaultPred
(
MIB
)
;
MI
->
getOperand
(
1
)
.
setIsUndef
(
)
;
MIB
.
addReg
(
SrcRegS
,
RegState
::
Implicit
)
;
if
(
MI
->
getOperand
(
1
)
.
isKill
(
)
)
{
MI
->
getOperand
(
1
)
.
setIsKill
(
false
)
;
MI
->
addRegisterKilled
(
SrcRegS
,
TRI
,
true
)
;
}
DEBUG
(
dbgs
(
)
<<
"replaced by: "
<<
*
MI
)
;
return
true
;
}
</s>

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


<s> static void cmse_clear_registers ( sbitmap to_clear_bitmap , uint32_t * padding_bits_to_clear , int padding_bits_len , rtx scratch_reg , rtx clearing_reg ) { bool saved_clearing = false ; rtx saved_clearing_reg = NULL_RTX ; int i , regno , clearing_regno , minregno = R0_REGNUM , maxregno = minregno - 1 ; gcc_assert ( arm_arch_cmse ) ; if ( ! bitmap_empty_p ( to_clear_bitmap ) ) { minregno = bitmap_first_set_bit ( to_clear_bitmap ) ; maxregno = bitmap_last_set_bit ( to_clear_bitmap ) ; } clearing_regno = REGNO ( clearing_reg ) ; gcc_assert ( padding_bits_len <= NUM_ARG_REGS ) ; for ( i = 0 , regno = R0_REGNUM ; i < padding_bits_len ; i ++ , regno ++ ) { uint64_t mask ; rtx rtx16 , dest , cleared_reg = gen_rtx_REG ( SImode , regno ) ; if ( padding_bits_to_clear [ i ] == 0 ) continue ; if ( TARGET_THUMB1 && REGNO ( scratch_reg ) > LAST_LO_REGNUM ) { if ( ( clearing_regno > maxregno || ! bitmap_bit_p ( to_clear_bitmap , clearing_regno ) ) && ! saved_clearing ) { gcc_assert ( clearing_regno <= LAST_LO_REGNUM ) ; emit_move_insn ( scratch_reg , clearing_reg ) ; saved_clearing = true ; saved_clearing_reg = scratch_reg ; } scratch_reg = clearing_reg ; } mask = ( ~ padding_bits_to_clear [ i ] ) & 0xFFFF ; emit_move_insn ( scratch_reg , gen_int_mode ( mask , SImode ) ) ; mask = ( ~ padding_bits_to_clear [ i ] ) >> 16 ; rtx16 = gen_int_mode ( 16 , SImode ) ; dest = gen_rtx_ZERO_EXTRACT ( SImode , scratch_reg , rtx16 , rtx16 ) ; if ( mask ) emit_insn ( gen_rtx_SET ( dest , gen_int_mode ( mask , SImode ) ) ) ; emit_insn ( gen_andsi3 ( cleared_reg , cleared_reg , scratch_reg ) ) ; } if ( saved_clearing ) emit_move_insn ( clearing_reg , saved_clearing_reg ) ; if ( clearing_regno <= maxregno && bitmap_bit_p ( to_clear_bitmap , clearing_regno ) ) { emit_move_insn ( clearing_reg , const0_rtx ) ; emit_use ( clearing_reg ) ; bitmap_clear_bit ( to_clear_bitmap , clearing_regno ) ; } for ( regno = minregno ; regno <= maxregno ; regno ++ ) { if ( ! bitmap_bit_p ( to_clear_bitmap , regno ) ) continue ; if ( IS_VFP_REGNUM ( regno ) ) { if ( TARGET_VFP_DOUBLE && VFP_REGNO_OK_FOR_DOUBLE ( regno ) && bitmap_bit_p ( to_clear_bitmap , regno + 1 ) ) { emit_move_insn ( gen_rtx_REG ( DFmode , regno ) , CONST1_RTX ( DFmode ) ) ; emit_use ( gen_rtx_REG ( DFmode , regno ) ) ; regno ++ ; } else { emit_move_insn ( gen_rtx_REG ( SFmode , regno ) , CONST1_RTX ( SFmode ) ) ; emit_use ( gen_rtx_REG ( SFmode , regno ) ) ; } } else { emit_move_insn ( gen_rtx_REG ( SImode , regno ) , clearing_reg ) ; emit_use ( gen_rtx_REG ( SImode , regno ) ) ; } } } </s>

Clear registers secret before doing a cmse_nonsecure_call or returning from a cmse_nonsecure_entry function . TO_CLEAR_BITMAP indicates which registers are to be fully cleared , using the value in register CLEARING_REG if more efficient . The PADDING_BITS_LEN entries array PADDING_BITS_TO_CLEAR gives the bits that needs to be cleared in caller-saved core registers , with SCRATCH_REG used as a scratch register for that clearing . NOTE : one of three following assertions must hold : - SCRATCH_REG is a low register - CLEARING_REG is in the set of registers fully cleared ( ie . its bit is set in TO_CLEAR_BITMAP ) - CLEARING_REG is a low register .


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


<s> SCANode * getCaller ( ) const { return Caller ; } </s>

Helper to get the caller ( the parent function ) .


<s> void PrintSpecial ( const MCInst * MI , const char * Kind ) { } </s>

Print information related to the specified machine instr that is independent of the operand , and may be independent of the instr itself .


"\t ! references to jmptbl section entries\n"

"\t ! references to vector section entries\n"

Function to emit isr reset handler content . Including all jmptbl/vector references , jmptbl section , vector section , nmi handler section , and warm handler section .


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

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


<s> const MCExpr * getSubExpr ( ) const { return Expr ; } </s>

getSubExpr - Get the child of this expression .


<s> bool MSP430TargetLowering :: isZExtFree ( const Type * Ty1 , const Type * Ty2 ) const { return 0 && Ty1 -> isIntegerTy ( 8 ) && Ty2 -> isIntegerTy ( 16 ) ; } </s>

Return true if zero-extending the specific node Val to type VT2 is free ( either because it 's implicitly zero-extended such as ARM ldrb / ldrh or because it 's folded such as X86 zero-extending loads ) .


<s> static reg_class_t sh_preferred_reload_class ( rtx x ATTRIBUTE_UNUSED , reg_class_t rclass ) { return rclass ; } </s>


<s> bool hasFusion ( ) const { return hasArithmeticBccFusion ( ) || hasArithmeticCbzFusion ( ) || hasFuseAES ( ) || hasFuseArithmeticLogic ( ) || hasFuseCCSelect ( ) || hasFuseAdrpAdd ( ) || hasFuseLiterals ( ) ; } </s>

Return true if the CPU supports any kind of instruction fusion .


<s> void BPFAsmBackend :: applyFixup ( const MCFixup & Fixup , char * Data , unsigned DataSize , uint64_t Value , bool IsPCRel , MCContext & Ctx ) const { if ( Fixup . getKind ( ) == FK_SecRel_4 || Fixup . getKind ( ) == FK_SecRel_8 ) { assert ( Value == 0 ) ; } else if ( Fixup . getKind ( ) == FK_Data_4 || Fixup . getKind ( ) == FK_Data_8 ) { unsigned Size = Fixup . getKind ( ) == FK_Data_4 ? 4 : 8 ; for ( unsigned i = 0 ; i != Size ; ++ i ) { unsigned Idx = IsLittleEndian ? i : Size - i ; Data [ Fixup . getOffset ( ) + Idx ] = uint8_t ( Value >> ( i * 8 ) ) ; } } else { assert ( Fixup . getKind ( ) == FK_PCRel_2 ) ; Value = ( uint16_t ) ( ( Value - 8 ) / 8 ) ; if ( IsLittleEndian ) { Data [ Fixup . getOffset ( ) + 2 ] = Value & 0xFF ; Data [ Fixup . getOffset ( ) + 3 ] = Value >> 8 ; } else { Data [ Fixup . getOffset ( ) + 2 ] = Value >> 8 ; Data [ Fixup . getOffset ( ) + 3 ] = Value & 0xFF ; } } } </s>

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


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

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


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

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


"stack limit expression is not supported"

Emit the correct code for allocating stack space , as insns . If COPY_R12 , make sure a copy of the old frame is left in r12 . The generated code may use hard register 0 as a temporary .


<s> static void mips_annotate_pic_calls ( void ) { basic_block bb ; rtx_insn * insn ; FOR_EACH_BB_FN ( bb , cfun ) FOR_BB_INSNS ( bb , insn ) { rtx call , reg , symbol , second_call ; second_call = 0 ; call = mips_call_expr_from_insn ( insn , & second_call ) ; if ( ! call ) continue ; gcc_assert ( MEM_P ( XEXP ( call , 0 ) ) ) ; reg = XEXP ( XEXP ( call , 0 ) , 0 ) ; if ( ! REG_P ( reg ) ) continue ; symbol = mips_find_pic_call_symbol ( insn , reg , true ) ; if ( symbol ) { mips_annotate_pic_call_expr ( call , symbol ) ; if ( second_call ) mips_annotate_pic_call_expr ( second_call , symbol ) ; } } } </s>

Use DF to annotate PIC indirect calls with the function symbol they dispatch to .


<s>
static
void
mmix_file_start
(
void
)
{
default_file_start
(
)
;
fputs
(
"! mmixal:= 8H LOC Data_Section\n"
,
asm_out_file
)
;
switch_to_section
(
text_section
)
;
}
</s>

TARGET_ASM_FILE_START . We just emit a little comment for the time being .


"expected larger existing stack allocation"

Target-specific cleanup for formal ByVal parameters .


<s> bool hasFusion ( ) const { return hasArithmeticBccFusion ( ) || hasArithmeticCbzFusion ( ) || hasFuseAES ( ) || hasFuseArithmeticLogic ( ) || hasFuseCCSelect ( ) || hasFuseLiterals ( ) ; } </s>


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
{
const
static
MCFixupKindInfo
Infos
[
]
=
{
{
"fixup_arm_ldst_pcrel_12"
,
1
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_t2_ldst_pcrel_12"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
|
MCFixupKindInfo
::
FKF_IsAligned
}
,
{
"fixup_arm_pcrel_10"
,
1
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_t2_pcrel_10"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_arm_adr_pcrel_12"
,
1
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_arm_branch"
,
1
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_t2_branch"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
|
MCFixupKindInfo
::
FKF_IsAligned
}
,
{
"fixup_arm_thumb_bl"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_arm_thumb_blx"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_arm_thumb_cb"
,
0
,
16
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_arm_thumb_cp"
,
1
,
8
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_arm_movt_hi16"
,
0
,
16
,
0
}
,
{
"fixup_arm_movw_lo16"
,
0
,
16
,
0
}
,
}
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCCodeEmitter
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s>
static
void
rs6000_function_specific_print
(
FILE
*
file
,
int
indent
,
struct
cl_target_option
*
ptr
)
{
rs6000_print_isa_options
(
file
,
indent
,
"Isa options set"
,
ptr
->
x_rs6000_isa_flags
)
;
rs6000_print_isa_options
(
file
,
indent
,
"Isa options explicit"
,
ptr
->
x_rs6000_isa_flags_explicit
)
;
}
</s>

rs6000
"Isa options set"
"Isa options explicit"


<s> static int mips_move_from_gpr_cost ( reg_class_t to ) { switch ( to ) { case M16_REGS : case GENERAL_REGS : return 2 ; case ACC_REGS : return 6 ; case FP_REGS : return 4 ; case COP0_REGS : case COP2_REGS : case COP3_REGS : return 5 ; default : return 0 ; } } </s>

Return the cost of moving a value from a GPR to a register of class TO . Return 0 for classes that are unions of other classes handled by this function .


<s> bool mips_use_by_pieces_infrastructure_p ( unsigned HOST_WIDE_INT size , unsigned int align , enum by_pieces_operation op , bool speed_p ) { if ( op == STORE_BY_PIECES ) return mips_store_by_pieces_p ( size , align ) ; if ( op == MOVE_BY_PIECES && HAVE_cpymemsi ) { if ( currently_expanding_to_rtl ) return false ; if ( align < BITS_PER_WORD ) return size < UNITS_PER_WORD ; return size <= MIPS_MAX_MOVE_BYTES_STRAIGHT ; } return default_use_by_pieces_infrastructure_p ( size , align , op , speed_p ) ; } </s>


<s> void ix86_expand_round ( rtx operand0 , rtx operand1 ) { machine_mode mode = GET_MODE ( operand0 ) ; rtx res , TWO52 , xa , xi , half , mask ; rtx_code_label * label ; const struct real_format * fmt ; REAL_VALUE_TYPE pred_half , half_minus_pred_half ; res = copy_to_reg ( operand1 ) ; TWO52 = ix86_gen_TWO52 ( mode ) ; xa = ix86_expand_sse_fabs ( res , & mask ) ; label = ix86_expand_sse_compare_and_jump ( UNLE , TWO52 , xa , false ) ; fmt = REAL_MODE_FORMAT ( mode ) ; real_2expN ( & half_minus_pred_half , - ( fmt -> p ) - 1 , mode ) ; real_arithmetic ( & pred_half , MINUS_EXPR , & dconsthalf , & half_minus_pred_half ) ; half = force_reg ( mode , const_double_from_real_value ( pred_half , mode ) ) ; xa = expand_simple_binop ( mode , PLUS , xa , half , NULL_RTX , 0 , OPTAB_DIRECT ) ; xi = gen_reg_rtx ( int_mode_for_mode ( mode ) . require ( ) ) ; expand_fix ( xi , xa , 0 ) ; expand_float ( xa , xi , 0 ) ; ix86_sse_copysign_to_positive ( res , xa , res , mask ) ; emit_label ( label ) ; LABEL_NUSES ( label ) = 1 ; emit_move_insn ( operand0 , res ) ; } </s>

Expand SSE sequence for computing round from OPERAND1 storing into OPERAND0 .


<s> void MipsTargetELFStreamer :: finish ( ) { MCAssembler & MCA = getStreamer ( ) . getAssembler ( ) ; const MCObjectFileInfo & OFI = * MCA . getContext ( ) . getObjectFileInfo ( ) ; MCSection & TextSection = * OFI . getTextSection ( ) ; MCA . registerSection ( TextSection ) ; MCSection & DataSection = * OFI . getDataSection ( ) ; MCA . registerSection ( DataSection ) ; MCSection & BSSSection = * OFI . getBSSSection ( ) ; MCA . registerSection ( BSSSection ) ; TextSection . setAlignment ( std :: max ( 16u , TextSection . getAlignment ( ) ) ) ; DataSection . setAlignment ( std :: max ( 16u , DataSection . getAlignment ( ) ) ) ; BSSSection . setAlignment ( std :: max ( 16u , BSSSection . getAlignment ( ) ) ) ; if ( RoundSectionSizes ) { MCStreamer & OS = getStreamer ( ) ; for ( MCSection & S : MCA ) { MCSectionELF & Section = static_cast < MCSectionELF & > ( S ) ; unsigned Alignment = Section . getAlignment ( ) ; if ( Alignment ) { OS . SwitchSection ( & Section ) ; if ( Section . UseCodeAlign ( ) ) OS . EmitCodeAlignment ( Alignment , Alignment ) ; else OS . EmitValueToAlignment ( Alignment , 0 , 1 , Alignment ) ; } } } const FeatureBitset & Features = STI . getFeatureBits ( ) ; unsigned EFlags = MCA . getELFHeaderEFlags ( ) ; if ( getABI ( ) . IsO32 ( ) ) EFlags |= ELF :: EF_MIPS_ABI_O32 ; else if ( getABI ( ) . IsN32 ( ) ) EFlags |= ELF :: EF_MIPS_ABI2 ; if ( Features [ Mips :: FeatureGP64Bit ] ) { if ( getABI ( ) . IsO32 ( ) ) EFlags |= ELF :: EF_MIPS_32BITMODE ; } else if ( Features [ Mips :: FeatureMips64r2 ] || Features [ Mips :: FeatureMips64 ] ) EFlags |= ELF :: EF_MIPS_32BITMODE ; if ( ! Features [ Mips :: FeatureNoABICalls ] ) EFlags |= ELF :: EF_MIPS_CPIC ; if ( Pic ) EFlags |= ELF :: EF_MIPS_PIC | ELF :: EF_MIPS_CPIC ; MCA . setELFHeaderEFlags ( EFlags ) ; MipsELFStreamer & MEF = static_cast < MipsELFStreamer & > ( Streamer ) ; MEF . EmitMipsOptionRecords ( ) ; emitMipsAbiFlags ( ) ; } </s>

finish - after all the new live ranges have been created , compute the remaining live range , and rewrite instructions to use the new registers .


<s> MachineInstr * X86InstrInfo :: optimizeLoadInstr ( MachineInstr & MI , const MachineRegisterInfo * MRI , Register & FoldAsLoadDefReg , MachineInstr * & DefMI ) const { DefMI = MRI -> getVRegDef ( FoldAsLoadDefReg ) ; assert ( DefMI ) ; bool SawStore = false ; if ( ! DefMI -> isSafeToMove ( nullptr , SawStore ) ) return nullptr ; SmallVector < unsigned , 1 > SrcOperandIds ; for ( unsigned i = 0 , e = MI . getNumOperands ( ) ; i != e ; ++ i ) { MachineOperand & MO = MI . getOperand ( i ) ; if ( ! MO . isReg ( ) ) continue ; Register Reg = MO . getReg ( ) ; if ( Reg != FoldAsLoadDefReg ) continue ; if ( MO . getSubReg ( ) || MO . isDef ( ) ) return nullptr ; SrcOperandIds . push_back ( i ) ; } if ( SrcOperandIds . empty ( ) ) return nullptr ; if ( MachineInstr * FoldMI = foldMemoryOperand ( MI , SrcOperandIds , * DefMI ) ) { FoldAsLoadDefReg = 0 ; return FoldMI ; } return nullptr ; } </s>

optimizeLoadInstr - Try to remove the load by folding it to a register operand at the use .


<s> bool AArch64TargetLowering :: mergeStoresAfterLegalization ( EVT VT ) const { return ! Subtarget -> useSVEForFixedLengthVectors ( ) ; } </s>

Do not merge vector stores after legalization because that may conflict with x86-specific store splitting optimizations .


<s> static int ix86_nsaved_sseregs ( void ) { int nregs = 0 ; int regno ; if ( ! TARGET_64BIT_MS_ABI ) return 0 ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true ) ) nregs ++ ; return nregs ; } </s>


<s> void arc_ccfsm_record_branch_deleted ( void ) { arc_ccfsm_state += 2 ; current_insn_set_cc_p = last_insn_set_cc_p ; } </s>

Record a branch is n't output because subsequent insns can be conditionalized .


<s> bool HexagonFrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF -> getTarget ( ) . getInstrInfo ( ) ; if ( CSI . empty ( ) ) { return false ; } bool ContiguousRegs = true ; for ( unsigned i = 0 ; i < CSI . size ( ) ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; unsigned SuperReg = uniqueSuperReg ( Reg , TRI ) ; const TargetRegisterClass * SuperRegClass = nullptr ; bool CanUseDblLoad = false ; if ( ContiguousRegs && ( i < CSI . size ( ) - 1 ) ) { unsigned SuperRegNext = uniqueSuperReg ( CSI [ i + 1 ] . getReg ( ) , TRI ) ; SuperRegClass = TRI -> getMinimalPhysRegClass ( SuperReg ) ; CanUseDblLoad = ( SuperRegNext == SuperReg ) ; } if ( CanUseDblLoad ) { TII . loadRegFromStackSlot ( MBB , MI , SuperReg , CSI [ i + 1 ] . getFrameIdx ( ) , SuperRegClass , TRI ) ; MBB . addLiveIn ( SuperReg ) ; ++ i ; } else { ContiguousRegs = false ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . loadRegFromStackSlot ( MBB , MI , Reg , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; MBB . addLiveIn ( Reg ) ; } } return true ; } </s>

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


<s> static bool sh_use_by_pieces_infrastructure_p ( unsigned HOST_WIDE_INT size , unsigned int align , enum by_pieces_operation op , bool speed_p ) { switch ( op ) { case MOVE_BY_PIECES : return by_pieces_ninsns ( size , align , MOVE_MAX_PIECES + 1 , op ) < ( ! speed_p ? 2 : ( align >= 32 ) ? 16 : 2 ) ; case STORE_BY_PIECES : case SET_BY_PIECES : return by_pieces_ninsns ( size , align , STORE_MAX_PIECES + 1 , op ) < ( ! speed_p ? 2 : ( align >= 32 ) ? 16 : 2 ) ; default : return default_use_by_pieces_infrastructure_p ( size , align , op , speed_p ) ; } } </s>


"instruction requires a CPU feature not currently enabled"

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


<s> bool LanaiInstrInfo :: getMemOperandsWithOffsetWidth ( const MachineInstr & LdSt , SmallVectorImpl < const MachineOperand * > & BaseOps , int64_t & Offset , bool & OffsetIsScalable , unsigned & Width , const TargetRegisterInfo * TRI ) const { switch ( LdSt . getOpcode ( ) ) { default : return false ; case Lanai :: LDW_RI : case Lanai :: LDW_RR : case Lanai :: SW_RR : case Lanai :: SW_RI : case Lanai :: LDHs_RI : case Lanai :: LDHz_RI : case Lanai :: STH_RI : case Lanai :: LDBs_RI : case Lanai :: LDBz_RI : const MachineOperand * BaseOp ; OffsetIsScalable = false ; if ( ! getMemOperandWithOffsetWidth ( LdSt , BaseOp , Offset , Width , TRI ) ) return false ; BaseOps . push_back ( BaseOp ) ; return true ; } } </s>

Get zero or more base operands and the byte offset of an instruction that reads/writes memory .


<s> static int get_template ( state_t state , int pos ) { switch ( pos ) { case 3 : if ( cpu_unit_reservation_p ( state , _0mmi_ ) ) return 1 ; else if ( cpu_unit_reservation_p ( state , _0mii_ ) ) return 0 ; else if ( cpu_unit_reservation_p ( state , _0mmb_ ) ) return 7 ; else if ( cpu_unit_reservation_p ( state , _0mib_ ) ) return 6 ; else if ( cpu_unit_reservation_p ( state , _0mbb_ ) ) return 5 ; else if ( cpu_unit_reservation_p ( state , _0bbb_ ) ) return 4 ; else if ( cpu_unit_reservation_p ( state , _0mmf_ ) ) return 3 ; else if ( cpu_unit_reservation_p ( state , _0mfi_ ) ) return 2 ; else if ( cpu_unit_reservation_p ( state , _0mfb_ ) ) return 8 ; else if ( cpu_unit_reservation_p ( state , _0mlx_ ) ) return 9 ; else gcc_unreachable ( ) ; case 6 : if ( cpu_unit_reservation_p ( state , _1mmi_ ) ) return 1 ; else if ( cpu_unit_reservation_p ( state , _1mii_ ) ) return 0 ; else if ( cpu_unit_reservation_p ( state , _1mmb_ ) ) return 7 ; else if ( cpu_unit_reservation_p ( state , _1mib_ ) ) return 6 ; else if ( cpu_unit_reservation_p ( state , _1mbb_ ) ) return 5 ; else if ( cpu_unit_reservation_p ( state , _1bbb_ ) ) return 4 ; else if ( _1mmf_ >= 0 && cpu_unit_reservation_p ( state , _1mmf_ ) ) return 3 ; else if ( cpu_unit_reservation_p ( state , _1mfi_ ) ) return 2 ; else if ( cpu_unit_reservation_p ( state , _1mfb_ ) ) return 8 ; else if ( cpu_unit_reservation_p ( state , _1mlx_ ) ) return 9 ; else gcc_unreachable ( ) ; default : gcc_unreachable ( ) ; } } </s>

The function returns code of a possible template for given position and state . The function should be called only with 2 values of position equal to 3 or 6 . We avoid generating F NOPs by putting templates containing F insns at the end of the template search because undocumented anomaly in McKinley derived cores which can cause stalls if an F-unit insn ( including a NOP ) is issued within a six-cycle window after reading certain application registers ( such as ar.bsp ) . Furthermore , power-considerations also argue against the use of F-unit instructions unless they 're really needed .


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

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


<s> static bool sparc_function_value_regno_p ( const unsigned int regno ) { return ( regno == 8 || regno == 32 ) ; } </s>

Handle FUNCTION_VALUE_REGNO_P . On the SPARC , the first `` output '' reg is used for integer values , and the first floating point register is used for floating point values .


<s> EVT PatmosTargetLowering :: getSetCCResultType ( LLVMContext & Context , EVT VT ) const { return MVT :: i1 ; } </s>

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


<s> static reg_class_t ix86_preferred_output_reload_class ( rtx x , reg_class_t regclass ) { machine_mode mode = GET_MODE ( x ) ; mode = GET_MODE ( x ) ; if ( SSE_FLOAT_MODE_P ( mode ) && TARGET_SSE_MATH ) return MAYBE_SSE_CLASS_P ( regclass ) ? ALL_SSE_REGS : NO_REGS ; if ( IS_STACK_MODE ( mode ) ) return FLOAT_CLASS_P ( regclass ) ? regclass : NO_REGS ; return regclass ; } </s>

Discourage putting floating-point values in SSE registers unless SSE math is being used , and likewise for the 387 registers .


"passing %wd to argument %d of %qE, which expects"

Report that LOCATION has a call to FNDECL in which argument ARGNO has the value ACTUAL , whereas the function requires one of VALUE0 .. 3 . ARGNO counts from zero .


<s> bool X86TargetLowering :: shouldExpandAtomicLoadInIR ( LoadInst * LI ) const { auto PTy = cast < PointerType > ( LI -> getPointerOperand ( ) -> getType ( ) ) ; return needsCmpXchgNb ( PTy -> getElementType ( ) ) ; } </s>

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


<s> bool SystemZRegisterInfo :: getRegAllocationHints ( unsigned VirtReg , ArrayRef < MCPhysReg > Order , SmallVectorImpl < MCPhysReg > & Hints , const MachineFunction & MF , const VirtRegMap * VRM , const LiveRegMatrix * Matrix ) const { const MachineRegisterInfo * MRI = & MF . getRegInfo ( ) ; const TargetRegisterInfo * TRI = MF . getSubtarget ( ) . getRegisterInfo ( ) ; bool BaseImplRetVal = TargetRegisterInfo :: getRegAllocationHints ( VirtReg , Order , Hints , MF , VRM , Matrix ) ; if ( MRI -> getRegClass ( VirtReg ) == & SystemZ :: GRX32BitRegClass ) { SmallVector < unsigned , 8 > Worklist ; SmallSet < unsigned , 4 > DoneRegs ; Worklist . push_back ( VirtReg ) ; while ( Worklist . size ( ) ) { unsigned Reg = Worklist . pop_back_val ( ) ; if ( ! DoneRegs . insert ( Reg ) . second ) continue ; for ( auto & Use : MRI -> use_instructions ( Reg ) ) { if ( Use . getOpcode ( ) == SystemZ :: LOCRMux ) { MachineOperand & TrueMO = Use . getOperand ( 1 ) ; MachineOperand & FalseMO = Use . getOperand ( 2 ) ; const TargetRegisterClass * RC = TRI -> getCommonSubClass ( getRC32 ( FalseMO , VRM , MRI ) , getRC32 ( TrueMO , VRM , MRI ) ) ; if ( RC && RC != & SystemZ :: GRX32BitRegClass ) { addHints ( Order , Hints , RC , MRI ) ; return true ; } unsigned OtherReg = ( TrueMO . getReg ( ) == Reg ? FalseMO . getReg ( ) : TrueMO . getReg ( ) ) ; if ( MRI -> getRegClass ( OtherReg ) == & SystemZ :: GRX32BitRegClass ) Worklist . push_back ( OtherReg ) ; } else if ( Use . getOpcode ( ) == SystemZ :: CHIMux || Use . getOpcode ( ) == SystemZ :: CFIMux ) { if ( Use . getOperand ( 1 ) . getImm ( ) == 0 ) { bool OnlyLMuxes = true ; for ( MachineInstr & DefMI : MRI -> def_instructions ( VirtReg ) ) if ( DefMI . getOpcode ( ) != SystemZ :: LMux ) OnlyLMuxes = false ; if ( OnlyLMuxes ) { addHints ( Order , Hints , & SystemZ :: GR32BitRegClass , MRI ) ; return false ; } } } } } } return BaseImplRetVal ; } </s>

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


<s> void ix86_expand_convert_uns_sisf_sse ( rtx target , rtx input ) { REAL_VALUE_TYPE ONE16r ; rtx fp_hi , fp_lo , int_hi , int_lo , x ; real_ldexp ( & ONE16r , & dconst1 , 16 ) ; x = const_double_from_real_value ( ONE16r , SFmode ) ; int_lo = expand_simple_binop ( SImode , AND , input , GEN_INT ( 0xffff ) , NULL , 0 , OPTAB_DIRECT ) ; int_hi = expand_simple_binop ( SImode , LSHIFTRT , input , GEN_INT ( 16 ) , NULL , 0 , OPTAB_DIRECT ) ; fp_hi = gen_reg_rtx ( SFmode ) ; fp_lo = gen_reg_rtx ( SFmode ) ; emit_insn ( gen_floatsisf2 ( fp_hi , int_hi ) ) ; emit_insn ( gen_floatsisf2 ( fp_lo , int_lo ) ) ; if ( TARGET_FMA ) { x = validize_mem ( force_const_mem ( SFmode , x ) ) ; fp_hi = gen_rtx_FMA ( SFmode , fp_hi , x , fp_lo ) ; emit_move_insn ( target , fp_hi ) ; } else { fp_hi = expand_simple_binop ( SFmode , MULT , fp_hi , x , fp_hi , 0 , OPTAB_DIRECT ) ; fp_hi = expand_simple_binop ( SFmode , PLUS , fp_hi , fp_lo , target , 0 , OPTAB_DIRECT ) ; if ( ! rtx_equal_p ( target , fp_hi ) ) emit_move_insn ( target , fp_hi ) ; } } </s>

Convert an unsigned SImode value into a SFmode , using only SSE . For x86_32 , -mfpmath=sse , ! optimize_size only .


<s> virtual void initializePass ( ) override { pushTTIStack ( this ) ; } </s>

initializePass - This method may be overriden by immutable passes to allow them to perform various initialization actions they require .


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


<s> bool SIInstrInfo :: shouldClusterMemOps ( MachineInstr & FirstLdSt , unsigned BaseReg1 , MachineInstr & SecondLdSt , unsigned BaseReg2 , unsigned NumLoads ) const { if ( ! memOpsHaveSameBasePtr ( FirstLdSt , BaseReg1 , SecondLdSt , BaseReg2 ) ) return false ; const MachineOperand * FirstDst = nullptr ; const MachineOperand * SecondDst = nullptr ; if ( ( isMUBUF ( FirstLdSt ) && isMUBUF ( SecondLdSt ) ) || ( isMTBUF ( FirstLdSt ) && isMTBUF ( SecondLdSt ) ) || ( isFLAT ( FirstLdSt ) && isFLAT ( SecondLdSt ) ) ) { const unsigned MaxGlobalLoadCluster = 6 ; if ( NumLoads > MaxGlobalLoadCluster ) return false ; FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: vdata ) ; if ( ! FirstDst ) FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: vdst ) ; SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: vdata ) ; if ( ! SecondDst ) SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: vdst ) ; } else if ( isSMRD ( FirstLdSt ) && isSMRD ( SecondLdSt ) ) { FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: sdst ) ; SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: sdst ) ; } else if ( isDS ( FirstLdSt ) && isDS ( SecondLdSt ) ) { FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: vdst ) ; SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: vdst ) ; } if ( ! FirstDst || ! SecondDst ) return false ; unsigned LoadClusterThreshold = 16 ; const MachineRegisterInfo & MRI = FirstLdSt . getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; const TargetRegisterClass * DstRC = MRI . getRegClass ( FirstDst -> getReg ( ) ) ; return ( NumLoads * ( RI . getRegSizeInBits ( * DstRC ) / 8 ) ) <= LoadClusterThreshold ; } </s>

Returns true if the two given memory operations should be scheduled adjacent .

AMDGPU SI 6 AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName 16 8


<s> const TargetRegisterClass * MipsRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { const MipsSubtarget & Subtarget = MF . getSubtarget < MipsSubtarget > ( ) ; return Subtarget . isABI_N64 ( ) ? & Mips :: GPR64RegClass : & Mips :: GPR32RegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .

Mips Mips Mips Mips Mips::GPR64RegClass Mips::GPR32RegClass


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

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


<s> bool RISCVTTIImpl :: isHardwareLoopProfitable ( Loop * L , ScalarEvolution & SE , AssumptionCache & AC , TargetLibraryInfo * LibInfo , HardwareLoopInfo & HWLoopInfo ) { if ( ! ST -> hasNonStdExtPulp ( ) ) { return false ; } if ( ! SE . hasLoopInvariantBackedgeTakenCount ( L ) ) { return false ; } const SCEV * BackedgeTakenCount = SE . getBackedgeTakenCount ( L ) ; if ( isa < SCEVCouldNotCompute > ( BackedgeTakenCount ) ) { return false ; } const SCEV * TripCountSCEV = SE . getAddExpr ( BackedgeTakenCount , SE . getOne ( BackedgeTakenCount -> getType ( ) ) ) ; if ( SE . getUnsignedRangeMax ( TripCountSCEV ) . getBitWidth ( ) > 32 ) { return false ; } auto MaybeCall = [ this ] ( Instruction & I ) { const RISCVTargetLowering * TLI = getTLI ( ) ; unsigned ISD = TLI -> InstructionOpcodeToISD ( I . getOpcode ( ) ) ; EVT VT = TLI -> getValueType ( DL , I . getType ( ) , true ) ; if ( TLI -> getOperationAction ( ISD , VT ) == TargetLowering :: LibCall ) return true ; if ( auto * Call = dyn_cast < CallInst > ( & I ) ) { if ( isa < IntrinsicInst > ( Call ) ) { if ( const Function * F = Call -> getCalledFunction ( ) ) return isLoweredToCall ( F ) ; } return true ; } if ( VT . isFloatingPoint ( ) && ! TLI -> isOperationLegalOrCustom ( ISD , VT ) ) return true ; return false ; } ; auto IsHardwareLoopIntrinsic = [ ] ( Instruction & I ) { if ( auto * Call = dyn_cast < IntrinsicInst > ( & I ) ) { switch ( Call -> getIntrinsicID ( ) ) { default : break ; case Intrinsic :: set_loop_iterations : case Intrinsic :: test_set_loop_iterations : case Intrinsic :: loop_decrement : case Intrinsic :: loop_decrement_reg : return true ; } } return false ; } ; bool hasInnerHardwareLoop = false ; auto ScanLoop = [ & ] ( Loop * L ) { for ( auto * BB : L -> getBlocks ( ) ) { for ( auto & I : BB -> instructionsWithoutDebug ( ) ) { hasInnerHardwareLoop |= IsHardwareLoopIntrinsic ( I ) ; if ( MaybeCall ( I ) ) { return false ; } } } return true ; } ; for ( auto Inner : * L ) if ( ! ScanLoop ( Inner ) ) return false ; if ( ! ScanLoop ( L ) ) return false ; LLVMContext & C = L -> getHeader ( ) -> getContext ( ) ; HWLoopInfo . CounterInReg = false ; HWLoopInfo . IsNestingLegal = ! hasInnerHardwareLoop ; HWLoopInfo . PerformEntryTest = false ; HWLoopInfo . CountType = Type :: getInt32Ty ( C ) ; HWLoopInfo . LoopDecrement = ConstantInt :: get ( HWLoopInfo . CountType , 1 ) ; return true ; } </s>

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


<s>
void
dump
(
)
{
errs
(
)
<<
"SystemZAddressingMode "
<<
this
<<
'\n'
;
errs
(
)
<<
" Base "
;
if
(
Base
.
getNode
(
)
)
Base
.
getNode
(
)
->
dump
(
)
;
else
errs
(
)
<<
"null\n"
;
if
(
hasIndexField
(
)
)
{
errs
(
)
<<
" Index "
;
if
(
Index
.
getNode
(
)
)
Index
.
getNode
(
)
->
dump
(
)
;
else
errs
(
)
<<
"null\n"
;
}
errs
(
)
<<
" Disp "
<<
Disp
;
if
(
IncludesDynAlloc
)
errs
(
)
<<
" + ADJDYNALLOC"
;
errs
(
)
<<
'\n'
;
}
</s>

Dump the plan to stderr ( for debugging ) .

SystemZ
"SystemZAddressingMode "
" Base "
"null\n"
" Index "
"null\n"
" Disp "
" + ADJDYNALLOC"


<s> uint32_t getSize ( ) { return Size ; } </s>

Return the number of bytes in the encoding of this instruction , or zero if the encoding size can not be known from the opcode .


"Some operands reg class are incompatible!"

optimizeCompareInstr - Check if there exists an earlier instruction that operates on the same source operands and sets flags in the same way as Compare ; remove Compare if possible .


<s> void R600InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const DebugLoc & DL , MCRegister DestReg , MCRegister SrcReg , bool KillSrc ) const { unsigned VectorComponents = 0 ; if ( ( R600 :: R600_Reg128RegClass . contains ( DestReg ) || R600 :: R600_Reg128VerticalRegClass . contains ( DestReg ) ) && ( R600 :: R600_Reg128RegClass . contains ( SrcReg ) || R600 :: R600_Reg128VerticalRegClass . contains ( SrcReg ) ) ) { VectorComponents = 4 ; } else if ( ( R600 :: R600_Reg64RegClass . contains ( DestReg ) || R600 :: R600_Reg64VerticalRegClass . contains ( DestReg ) ) && ( R600 :: R600_Reg64RegClass . contains ( SrcReg ) || R600 :: R600_Reg64VerticalRegClass . contains ( SrcReg ) ) ) { VectorComponents = 2 ; } if ( VectorComponents > 0 ) { for ( unsigned I = 0 ; I < VectorComponents ; I ++ ) { unsigned SubRegIndex = AMDGPURegisterInfo :: getSubRegFromChannel ( I ) ; buildDefaultInstruction ( MBB , MI , R600 :: MOV , RI . getSubReg ( DestReg , SubRegIndex ) , RI . getSubReg ( SrcReg , SubRegIndex ) ) . addReg ( DestReg , RegState :: Define | RegState :: Implicit ) ; } } else { MachineInstr * NewMI = buildDefaultInstruction ( MBB , MI , R600 :: MOV , DestReg , SrcReg ) ; NewMI -> getOperand ( getOperandIdx ( * NewMI , R600 :: OpName :: src0 ) ) . setIsKill ( KillSrc ) ; } } </s>


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


"invalid feature modifier %qs in %<-march=%s%>"

Validate a command-line -march option . Parse the arch 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> SDNode * LC3bDagToDagISel :: Select ( SDNode * n ) { return NULL ; } </s>

Main hook for targets to transform nodes into machine nodes .


<s> static void rs6000_add_gc_roots ( ) { ggc_add_rtx_root ( & rs6000_compare_op0 , 1 ) ; ggc_add_rtx_root ( & rs6000_compare_op1 , 1 ) ; toc_hash_table = htab_create ( 1021 , toc_hash_function , toc_hash_eq , NULL ) ; ggc_add_root ( & toc_hash_table , 1 , sizeof ( toc_hash_table ) , toc_hash_mark_table ) ; machopic_add_gc_roots ( ) ; } </s>

Called to register all of our global variables with the garbage collector .


"Lower pointer arguments of CUDA kernels"

getPassName - Return a nice clean name for a pass .


<s>
static
void
write_fn_marker
(
std
::
stringstream
&
s
,
bool
is_defn
,
bool
globalize
,
const
char
*
name
)
{
s
<<
"\n// BEGIN"
;
if
(
globalize
)
s
<<
" GLOBAL"
;
s
<<
" FUNCTION "
<<
(
is_defn
"DEF: "
:
"DECL: "
)
;
s
<<
name
<<
"\n"
;
}
</s>

Emit a linker marker for a function decl or defn .

nvptx
"\n// BEGIN"
" GLOBAL"
" FUNCTION "
"DEF: "
"DECL: "
"\n"


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

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


<s> MachineInstr * GBZ80InstrInfo :: commuteInstructionImpl ( MachineInstr & MI , bool NewMI , unsigned OpIdx1 , unsigned OpIdx2 ) const { MachineRegisterInfo & MRI = MI . getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; if ( MRI . getRegClass ( MI . getOperand ( OpIdx2 ) . getReg ( ) ) -> hasSuperClassEq ( & GB :: R8RegClass ) ) { if ( ! safeToCommute ( MI , OpIdx1 , OpIdx2 ) ) return nullptr ; } 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 .


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

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


<s> static bool mn10300_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { rtx base , index ; if ( CONSTANT_ADDRESS_P ( x ) ) return ! flag_pic || mn10300_legitimate_pic_operand_p ( x ) ; if ( RTX_OK_FOR_BASE_P ( x , strict ) ) return true ; if ( TARGET_AM33 && ( mode == SImode || mode == SFmode || mode == HImode ) ) { if ( GET_CODE ( x ) == POST_INC ) return RTX_OK_FOR_BASE_P ( XEXP ( x , 0 ) , strict ) ; if ( GET_CODE ( x ) == POST_MODIFY ) return ( RTX_OK_FOR_BASE_P ( XEXP ( x , 0 ) , strict ) && CONSTANT_ADDRESS_P ( XEXP ( x , 1 ) ) ) ; } if ( GET_CODE ( x ) != PLUS ) return false ; base = XEXP ( x , 0 ) ; index = XEXP ( x , 1 ) ; if ( ! REG_P ( base ) ) return false ; if ( REG_P ( index ) ) { if ( ! TARGET_AM33 ) return false ; return ( REGNO_GENERAL_P ( REGNO ( base ) , strict ) && REGNO_GENERAL_P ( REGNO ( index ) , strict ) ) ; } if ( ! REGNO_STRICT_OK_FOR_BASE_P ( REGNO ( base ) , strict ) ) return false ; if ( CONST_INT_P ( index ) ) return IN_RANGE ( INTVAL ( index ) , - 1 - 0x7fffffff , 0x7fffffff ) ; if ( CONSTANT_ADDRESS_P ( index ) ) return ! flag_pic || mn10300_legitimate_pic_operand_p ( index ) ; return false ; } </s>

Return TRUE if the address X , taken from a ( MEM : MODE X ) rtx , is legitimate , and FALSE otherwise . On the mn10300 , the value in the address register must be in the same memory space/segment as the effective address . This is problematical for reload since it does not understand that base+index ! = index+base in a memory reference . Note it is still possible to use reg+reg addressing modes , it 's just much more difficult . For a discussion of a possible workaround and solution , see the comments in pa.cc before the function record_unscaled_index_insn_codes .


"SPU hazards don't yet support scoreboard lookahead"

getHazardType - Return the hazard type of emitting this node .


<s> void Warning ( SMLoc L , const Twine & Msg ) { Parser . Warning ( L , Msg ) ; } </s>

Emit a warning at the location L , with the message Msg .


<s> int aarch_accumulator_forwarding ( rtx_insn * producer , rtx_insn * consumer ) { rtx producer_set = single_set ( producer ) ; rtx consumer_set = single_set ( consumer ) ; if ( ! producer_set || ! consumer_set ) return 0 ; rtx dest = SET_DEST ( producer_set ) ; rtx mla = SET_SRC ( consumer_set ) ; if ( ! REG_P ( dest ) ) return 0 ; rtx accumulator ; if ( GET_CODE ( mla ) == ZERO_EXTEND ) mla = XEXP ( mla , 0 ) ; switch ( GET_CODE ( mla ) ) { case PLUS : if ( GET_CODE ( XEXP ( mla , 0 ) ) == MULT ) accumulator = XEXP ( mla , 1 ) ; else return 0 ; break ; case MINUS : if ( GET_CODE ( XEXP ( mla , 1 ) ) == MULT ) accumulator = XEXP ( mla , 0 ) ; else return 0 ; break ; case FMA : { if ( REG_P ( XEXP ( mla , 1 ) ) && REG_P ( XEXP ( mla , 2 ) ) && ( REG_P ( XEXP ( mla , 0 ) ) || GET_CODE ( XEXP ( mla , 0 ) ) == NEG ) ) { accumulator = XEXP ( mla , 2 ) ; } else if ( REG_P ( XEXP ( mla , 1 ) ) && GET_CODE ( XEXP ( mla , 2 ) ) == NEG && ( REG_P ( XEXP ( mla , 0 ) ) || GET_CODE ( XEXP ( mla , 0 ) ) == NEG ) ) { accumulator = XEXP ( XEXP ( mla , 2 ) , 0 ) ; } else return 0 ; break ; } default : return 0 ; } if ( SUBREG_P ( accumulator ) ) accumulator = SUBREG_REG ( accumulator ) ; if ( ! REG_P ( accumulator ) ) return 0 ; return ( REGNO ( dest ) == REGNO ( accumulator ) ) ; } </s>

Return non-zero if the destination of PRODUCER feeds the accumulator operand of an MLA-like operation .


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


"Should have dealt with 0- and 1-byte cases already"

Emit target-specific code that performs a memset .


<s> static void tilegx_file_end ( void ) { if ( NEED_INDICATE_EXEC_STACK ) file_end_indicate_exec_stack ( ) ; } </s>


<s> virtual const TargetFrameInfo * getFrameInfo ( ) const { return & FrameInfo ; } </s>

getFrameInfo - Return the frame info object for the current function .


<s> bool addInstSelector ( ) { addPass ( createLC3bISelDag ( getLC3bTargetMachine ( ) , getOptLevel ( ) ) ) ; return false ; } </s>

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


<s> static bool arm_block_set_non_vect_profit_p ( rtx val , unsigned HOST_WIDE_INT length , unsigned HOST_WIDE_INT align , bool unaligned_p , bool use_strd_p ) { int num = 0 ; const int leftover [ 8 ] = { 0 , 1 , 1 , 2 , 1 , 2 , 2 , 3 } ; if ( unaligned_p ) { num = arm_const_inline_cost ( SET , val ) ; num += length / align + length % align ; } else if ( use_strd_p ) { num = arm_const_double_inline_cost ( val ) ; num += ( length >> 3 ) + leftover [ length & 7 ] ; } else { num = arm_const_inline_cost ( SET , val ) ; num += ( length >> 2 ) + leftover [ length & 3 ] ; } if ( unaligned_access && length > 3 && ( length & 3 ) == 3 ) num -- ; return ( num <= arm_block_set_max_insns ( ) ) ; } </s>

Return TRUE if it 's profitable to set block of memory for non-vectorized case . VAL is the value to set the memory with . LENGTH is the number of bytes to set . ALIGN is the alignment of the destination memory in bytes . UNALIGNED_P is TRUE if we can only set the memory with instructions meeting alignment requirements . USE_STRD_P is TRUE if we can use strd to set the memory .


<s> struct rtx_def * m68hc11_function_arg ( const CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type ATTRIBUTE_UNUSED , int named ATTRIBUTE_UNUSED ) { if ( cum -> words != 0 ) { return NULL_RTX ; } if ( mode != BLKmode ) { if ( GET_MODE_SIZE ( mode ) == 2 * HARD_REG_SIZE ) return gen_rtx_REG ( mode , HARD_X_REGNUM ) ; if ( GET_MODE_SIZE ( mode ) > HARD_REG_SIZE ) { return NULL_RTX ; } return gen_rtx_REG ( mode , HARD_D_REGNUM ) ; } return NULL_RTX ; } </s>

Define where to put the arguments to a function . Value is zero to push the argument on the stack , or a hard register in which to store the argument . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) .


<s>
int
X86FrameLowering
::
getFrameIndexReferencePreferSP
(
const
MachineFunction
&
MF
,
int
FI
,
unsigned
&
FrameReg
,
bool
IgnoreSPUpdates
)
const
{
const
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
const
uint64_t
StackSize
=
MFI
.
getStackSize
(
)
;
if
(
MFI
.
isFixedObjectIndex
(
FI
)
&&
TRI
->
needsStackRealignment
(
MF
)
&&
!
STI
.
isTargetWin64
(
)
)
return
getFrameIndexReference
(
MF
,
FI
,
FrameReg
)
;
if
(
!
IgnoreSPUpdates
&&
!
hasReservedCallFrame
(
MF
)
)
return
getFrameIndexReference
(
MF
,
FI
,
FrameReg
)
;
assert
(
MF
.
getInfo
<
X86MachineFunctionInfo
>
(
)
->
getTCReturnAddrDelta
(
)
>=
0
&&
"we don't handle this case!"
)
;
return
getFrameIndexReferenceSP
(
MF
,
FI
,
FrameReg
,
StackSize
)
;
}
</s>

Same as getFrameIndexReference , except that the stack pointer ( as opposed to the frame pointer ) will be the preferred value for FrameReg .


<s> bool enableInterleavedAccessVectorization ( ) { return true ; } </s>

Enable matching of interleaved access groups .


<s> static bool arc_process_double_reg_moves ( rtx * operands ) { enum usesDxState { none , srcDx , destDx , maxDx } ; enum usesDxState state = none ; rtx dest = operands [ 0 ] ; rtx src = operands [ 1 ] ; if ( refers_to_regno_p ( 40 , 44 , src , 0 ) ) { state = srcDx ; gcc_assert ( REG_P ( dest ) ) ; } if ( refers_to_regno_p ( 40 , 44 , dest , 0 ) ) { gcc_assert ( REG_P ( src ) ) ; gcc_assert ( state == none ) ; state = destDx ; } if ( state == none ) return false ; if ( state == srcDx ) { if ( TARGET_DPFP_DISABLE_LRSR ) { rtx set = gen_rtx_SET ( dest , src ) ; rtx use1 = gen_rtx_USE ( VOIDmode , const1_rtx ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , set , use1 ) ) ) ; } else { rtx destHigh = simplify_gen_subreg ( SImode , dest , DFmode , TARGET_BIG_ENDIAN ? 0 : 4 ) ; rtx destLow = simplify_gen_subreg ( SImode , dest , DFmode , TARGET_BIG_ENDIAN ? 4 : 0 ) ; emit_insn ( gen_rtx_SET ( destHigh , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( 1 , src ) , VUNSPEC_ARC_LR_HIGH ) ) ) ; emit_insn ( gen_rtx_SET ( destLow , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( 1 , src ) , VUNSPEC_ARC_LR ) ) ) ; } } else if ( state == destDx ) { rtx srcHigh = simplify_gen_subreg ( SImode , src , DFmode , TARGET_BIG_ENDIAN ? 0 : 4 ) ; rtx srcLow = simplify_gen_subreg ( SImode , src , DFmode , TARGET_BIG_ENDIAN ? 4 : 0 ) ; emit_insn ( gen_dexcl_2op ( dest , srcHigh , srcLow ) ) ; } else gcc_unreachable ( ) ; return true ; } </s>

Handle DOUBLE_REGS uses . Operand 0 : destination register Operand 1 : source register


<s> int compute_logical_op_cc ( machine_mode mode , rtx * operands ) { enum rtx_code code = GET_CODE ( operands [ 3 ] ) ; const unsigned HOST_WIDE_INT intval = ( unsigned HOST_WIDE_INT ) ( ( GET_CODE ( operands [ 2 ] ) == CONST_INT ) && register_operand ( operands [ 1 ] , VOIDmode ) ? INTVAL ( operands [ 2 ] ) : 0x55555555 ) ; const unsigned HOST_WIDE_INT det = ( code != AND ) ? intval : ~ intval ; const unsigned HOST_WIDE_INT b0 = ( det >> 0 ) & 0xff ; const unsigned HOST_WIDE_INT b1 = ( det >> 8 ) & 0xff ; const unsigned HOST_WIDE_INT w0 = ( det >> 0 ) & 0xffff ; const unsigned HOST_WIDE_INT w1 = ( det >> 16 ) & 0xffff ; int lower_half_easy_p = 0 ; int upper_half_easy_p = 0 ; enum attr_old_cc cc = OLD_CC_CLOBBER ; switch ( mode ) { case E_HImode : if ( b0 != 0 && b1 != 0 ) { cc = OLD_CC_SET_ZNV ; } break ; case E_SImode : lower_half_easy_p = ( b0 == 0 || b1 == 0 || ( code != IOR && w0 == 0xffff ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == 0xffff ) || ( code == AND && w1 == 0xff00 ) ) ; if ( w0 != 0 && w1 != 0 && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == 0xffff && ( w0 & 0x8000 ) != 0 && lower_half_easy_p ) ) { cc = OLD_CC_SET_ZNV ; } else { if ( code == IOR && w1 == 0xffff && ( w0 & 0x8000 ) != 0 ) { cc = OLD_CC_SET_ZNV ; } } break ; default : gcc_unreachable ( ) ; } return cc ; } </s>

Compute which flag bits are valid after a logical insn .


<s> const MCPhysReg * MSP430RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { const MSP430FrameLowering * TFI = getFrameLowering ( * MF ) ; const Function * F = & MF -> getFunction ( ) ; static const MCPhysReg CalleeSavedRegs [ ] = { MSP430 :: R4 , MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , 0 } ; static const MCPhysReg CalleeSavedRegsFP [ ] = { MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , 0 } ; static const MCPhysReg CalleeSavedRegsIntr [ ] = { MSP430 :: R4 , MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , MSP430 :: R11 , MSP430 :: R12 , MSP430 :: R13 , MSP430 :: R14 , MSP430 :: R15 , 0 } ; static const MCPhysReg CalleeSavedRegsIntrFP [ ] = { MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , MSP430 :: R11 , MSP430 :: R12 , MSP430 :: R13 , MSP430 :: R14 , MSP430 :: R15 , 0 } ; if ( TFI -> hasFP ( * MF ) ) return ( F -> getCallingConv ( ) == CallingConv :: MSP430_INTR ? CalleeSavedRegsIntrFP : CalleeSavedRegsFP ) ; else return ( F -> getCallingConv ( ) == CallingConv :: MSP430_INTR ? CalleeSavedRegsIntr : CalleeSavedRegs ) ; } </s>


<s> rtx ia64_return_addr_rtx ( HOST_WIDE_INT count , rtx frame ATTRIBUTE_UNUSED ) { if ( count != 0 ) return NULL ; return gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , const0_rtx ) , UNSPEC_RET_ADDR ) ; } </s>

Return the magic cookie that we use to hold the return address during early compilation .


<s> bool X86TargetLowering :: shouldSplatInsEltVarIndex ( EVT VT ) const { return isTypeLegal ( VT ) ; } </s>

Return true if inserting a scalar into a variable element of an undef vector is more efficiently handled by splatting the scalar instead .


<s> void SystemZHazardRecognizer :: Reset ( ) { CurrGroupSize = 0 ; clearProcResCounters ( ) ; GrpCount = 0 ; LastFPdOpCycleIdx = UINT_MAX ; LastEmittedMI = nullptr ; LLVM_DEBUG ( CurGroupDbg = "" ; ) ; } </s>


"Inserting vccz bug work-around before: "

runOnMachineFunction - Emit the function body .


<s> VariantKind getKind ( ) const { return static_cast < VariantKind > ( Kind ) ; } </s>


<s> unsigned X86TargetLowering :: getNumRegistersForCallingConv ( LLVMContext & Context , CallingConv :: ID CC , EVT VT ) const { if ( VT . isVector ( ) && VT . getVectorElementType ( ) == MVT :: i1 && Subtarget . hasAVX512 ( ) ) { unsigned NumElts = VT . getVectorNumElements ( ) ; MVT RegisterVT ; unsigned NumRegisters ; std :: tie ( RegisterVT , NumRegisters ) = handleMaskRegisterForCallingConv ( NumElts , CC , Subtarget ) ; if ( RegisterVT != MVT :: INVALID_SIMPLE_VALUE_TYPE ) return NumRegisters ; } if ( ( VT == MVT :: v32i16 || VT == MVT :: v64i8 ) && ! EnableOldKNLABI && Subtarget . useAVX512Regs ( ) && ! Subtarget . hasBWI ( ) ) return 1 ; return TargetLowering :: getNumRegistersForCallingConv ( Context , CC , VT ) ; } </s>

Certain targets require unusual breakdowns of certain types .


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

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


<s>
void
WebAssemblyTargetAsmStreamer
::
emitGlobalType
(
const
MCSymbolWasm
*
Sym
)
{
assert
(
Sym
->
isGlobal
(
)
)
;
OS
<<
"\t.globaltype\t"
<<
Sym
->
getName
(
)
<<
", "
<<
WebAssembly
::
typeToString
(
static_cast
<
wasm
::
ValType
>
(
Sym
->
getGlobalType
(
)
.
Type
)
)
<<
'\n'
;
}
</s>

WebAssembly
WebAssembly
"\t.globaltype\t"
", "
WebAssembly::typeToString
wasm::ValType


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { Subtarget = & MF . getSubtarget < X86Subtarget > ( ) ; IndirectTlsSegRefs = MF . getFunction ( ) . hasFnAttribute ( "indirect-tls-seg-refs" ) ; SelectionDAGISel :: runOnMachineFunction ( MF ) ; return true ; } </s>


<s> void X86DAGToDAGISel :: PreprocessISelDAG ( ) { OptForSize = MF -> getFunction ( ) -> hasFnAttr ( Attribute :: OptimizeForSize ) ; for ( SelectionDAG :: allnodes_iterator I = CurDAG -> allnodes_begin ( ) , E = CurDAG -> allnodes_end ( ) ; I != E ; ) { SDNode * N = I ++ ; if ( OptLevel != CodeGenOpt :: None && ( N -> getOpcode ( ) == X86ISD :: CALL || N -> getOpcode ( ) == X86ISD :: TC_RETURN ) ) { bool HasCallSeq = N -> getOpcode ( ) == X86ISD :: CALL ; SDValue Chain = N -> getOperand ( 0 ) ; SDValue Load = N -> getOperand ( 1 ) ; if ( ! isCalleeLoad ( Load , Chain , HasCallSeq ) ) continue ; MoveBelowOrigChain ( CurDAG , Load , SDValue ( N , 0 ) , Chain ) ; ++ NumLoadMoved ; continue ; } if ( N -> getOpcode ( ) != ISD :: FP_ROUND && N -> getOpcode ( ) != ISD :: FP_EXTEND ) continue ; EVT SrcVT = N -> getOperand ( 0 ) . getValueType ( ) ; EVT DstVT = N -> getValueType ( 0 ) ; bool SrcIsSSE = X86Lowering . isScalarFPTypeInSSEReg ( SrcVT ) ; bool DstIsSSE = X86Lowering . isScalarFPTypeInSSEReg ( DstVT ) ; if ( SrcIsSSE && DstIsSSE ) continue ; if ( ! SrcIsSSE && ! DstIsSSE ) { if ( N -> getOpcode ( ) == ISD :: FP_EXTEND ) continue ; if ( N -> getConstantOperandVal ( 1 ) ) continue ; } EVT MemVT ; if ( N -> getOpcode ( ) == ISD :: FP_ROUND ) MemVT = DstVT ; else MemVT = SrcIsSSE ? SrcVT : DstVT ; SDValue MemTmp = CurDAG -> CreateStackTemporary ( MemVT ) ; DebugLoc dl = N -> getDebugLoc ( ) ; SDValue Store = CurDAG -> getTruncStore ( CurDAG -> getEntryNode ( ) , dl , N -> getOperand ( 0 ) , MemTmp , NULL , 0 , MemVT , false , false , 0 ) ; SDValue Result = CurDAG -> getExtLoad ( ISD :: EXTLOAD , dl , DstVT , Store , MemTmp , NULL , 0 , MemVT , false , false , 0 ) ; -- I ; CurDAG -> ReplaceAllUsesOfValueWith ( SDValue ( N , 0 ) , Result ) ; ++ I ; CurDAG -> DeleteNode ( N ) ; } } </s>

PreprocessISelDAG - This hook allows targets to hack on the graph before instruction selection starts .


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

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


<s> void BPFFrameLowering :: emitPrologue ( MachineFunction & MF ) const { } </s>


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

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