<s> static std :: unique_ptr < X86Operand > CreateReg ( unsigned RegNo , SMLoc StartLoc , SMLoc EndLoc , bool AddressOf = false , SMLoc OffsetOfLoc = SMLoc ( ) , StringRef SymName = StringRef ( ) , void * OpDecl = nullptr ) { auto Res = std :: make_unique < X86Operand > ( Register , StartLoc , EndLoc ) ; Res -> Reg . RegNo = RegNo ; Res -> AddressOf = AddressOf ; Res -> OffsetOfLoc = OffsetOfLoc ; Res -> SymName = SymName ; Res -> OpDecl = OpDecl ; return Res ; } </s>


<s> void pa_hpux_asm_output_external ( FILE * file , tree decl , const char * name ) { gcc_assert ( file == asm_out_file ) ; extern_symbol p = { decl , name } ; vec_safe_push ( extern_symbols , p ) ; } </s>

Mark DECL ( name NAME ) as an external reference ( assembler output file FILE ) . This saves the names to output at the end of the file if actually referenced .


"Missing call preserved mask for calling convention"

This function fills Ops , which is the list of operands that will later be used when a function call node is created .


<s> const char * i386_pe_strip_name_encoding_full ( const char * str ) { const char * p ; const char * name = i386_pe_strip_name_encoding ( str ) ; if ( * name == '@' ) name ++ ; p = strchr ( name , '@' ) ; if ( p ) return ggc_alloc_string ( name , p - name ) ; return name ; } </s>

Also strip the fastcall prefix and stdcall suffix .


<s>
bool
TPCLatencyResolver
::
runOnMachineFunction
(
MachineFunction
&
Fn
)
{
MF
=
&
Fn
;
TII
=
Fn
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
ItinData
=
Fn
.
getSubtarget
(
)
.
getInstrItineraryData
(
)
;
TRI
=
Fn
.
getSubtarget
(
)
.
getRegisterInfo
(
)
;
MLI
=
&
getAnalysis
<
MachineLoopInfo
>
(
)
;
TRI
=
Fn
.
getSubtarget
(
)
.
getRegisterInfo
(
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"\n\n*** TPC Latency Resolver\n\n"
)
;
for
(
auto
&
MBB
:
Fn
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"Processing BB#"
<<
MBB
.
getNumber
(
)
<<
"\n"
)
;
if
(
MBB
.
empty
(
)
)
{
continue
;
}
if
(
TPCNumDebugNops
)
{
insertDebugNops
(
MBB
,
TPCNumDebugNops
)
;
}
else
{
resolveBlockLatency
(
MBB
)
;
fixSmallLoops
(
MBB
)
;
}
}
if
(
TPCNumDebugNops
)
{
return
true
;
}
else
resolveFunctionLatency
(
Fn
)
;
for
(
auto
&
MBB
:
Fn
)
{
if
(
!
MBB
.
empty
(
)
)
{
resolveCrossBlockLatency
(
MBB
)
;
}
}
for
(
auto
&
MBB
:
Fn
)
{
if
(
!
MBB
.
empty
(
)
)
{
resolveCrossBlockLatency
(
MBB
,
false
,
true
)
;
}
}
for
(
auto
&
MBB
:
Fn
)
{
if
(
!
MBB
.
empty
(
)
)
{
fillLoopDelaySlot
(
MBB
)
;
}
}
for
(
auto
&
MBB
:
Fn
)
{
if
(
!
MBB
.
empty
(
)
)
{
ensureLoopEndAndJmpLatency
(
MBB
)
;
}
}
return
true
;
}
</s>

runOnMachineFunction - Emit the function body .

TPC
TPC
"\n\n*** TPC Latency Resolver\n\n"
"Processing BB#"
"\n"
TPC
TPC
TPC


<s> int legitimate_const_double_p ( rtx address ) { long sval [ 2 ] ; REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( address ) , sval ) ; if ( ( sval [ 0 ] & 0xffff ) == 0 && sval [ 1 ] == 0 ) return 1 ; return 0 ; } </s>

This function checks whether a real value can be encoded as a literal , i.e. , addressing mode 27 . In that mode , real values are one word values , so the remaining 48 bits have to be zero .


<s> unsigned PPCTargetLowering :: getNumRegistersForCallingConv ( LLVMContext & Context , EVT VT ) const { if ( Subtarget . hasSPE ( ) && VT == MVT :: f64 ) return 2 ; return PPCTargetLowering :: getNumRegisters ( Context , VT ) ; } </s>

Certain targets require unusual breakdowns of certain types .


<s> void emitImportName ( const MCSymbolWasm * , StringRef ) override { } </s>


<s> bool PPCFrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return ( MFI -> getStackSize ( ) ) && needsFP ( MF ) ; } </s>

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


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


<s> static void s390_function_specific_restore ( struct gcc_options * opts , struct gcc_options * , struct cl_target_option * ptr ATTRIBUTE_UNUSED ) { opts -> x_s390_cost_pointer = ( long ) processor_table [ opts -> x_s390_tune ] . cost ; } </s>

Restore the current options . This is a hook function and also called internally .


<s> bool FISCAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getString ( ) ; if ( IDVal == ".ent" ) { Parser . Lex ( ) ; return false ; } if ( IDVal == ".end" ) { Parser . Lex ( ) ; return false ; } if ( IDVal == ".frame" ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == ".set" ) { return parseDirectiveSet ( ) ; } if ( IDVal == ".fmask" ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == ".mask" ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == ".gpword" ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == ".byte" ) return parseDirectiveWord ( 1 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".half" ) return parseDirectiveWord ( 2 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".word" ) return parseDirectiveWord ( 4 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".nword" ) return parseDirectiveWord ( 8 , DirectiveID . getLoc ( ) ) ; if ( IDVal == ".xword" ) return parseDirectiveWord ( 8 , DirectiveID . getLoc ( ) ) ; return true ; } </s>

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


<s>
void
X86InstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
unsigned
SrcReg
,
bool
isKill
,
int
FrameIdx
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
const
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
assert
(
MF
.
getFrameInfo
(
)
->
getObjectSize
(
FrameIdx
)
>=
(
RC
->
getSize
(
)
/
8
)
&&
"Stack slot too small for store"
)
;
unsigned
Alignment
=
(
RC
->
getSize
(
)
/
8
)
==
32
32
:
16
;
bool
isAligned
=
(
TM
.
getFrameLowering
(
)
->
getStackAlignment
(
)
>=
Alignment
)
||
RI
.
canRealignStack
(
MF
)
;
unsigned
Opc
=
getStoreRegOpcode
(
SrcReg
,
RC
,
isAligned
,
TM
)
;
DebugLoc
DL
=
MBB
.
findDebugLoc
(
MI
)
;
addFrameReference
(
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
)
,
FrameIdx
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
;
}
</s>

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


"PRINT_OPERAND_ADDRESS, invalid insn #1"

Print a memory address as an operand to reference that memory location .


<s> bool isCompare ( ) const { return isa < ICmpInst > ( Operation ) ; } </s>

Return true if this instruction is a comparison .


<s> Value * RISCVTargetLowering :: emitMaskedAtomicCmpXchgIntrinsic ( IRBuilder < > & Builder , AtomicCmpXchgInst * CI , Value * AlignedAddr , Value * CmpVal , Value * NewVal , Value * Mask , AtomicOrdering Ord ) const { Value * Ordering = Builder . getInt32 ( static_cast < uint32_t > ( Ord ) ) ; Type * Tys [ ] = { AlignedAddr -> getType ( ) } ; Function * MaskedCmpXchg = Intrinsic :: getDeclaration ( CI -> getModule ( ) , Intrinsic :: riscv_masked_cmpxchg_i32 , Tys ) ; return Builder . CreateCall ( MaskedCmpXchg , { AlignedAddr , CmpVal , NewVal , Mask , Ordering } ) ; } </s>

Perform a masked cmpxchg using a target-specific intrinsic .

RISCV RISCV Intrinsic::getDeclaration Intrinsic::riscv_masked_cmpxchg_i32


<s> bool MipsHazardSchedule :: runOnMachineFunction ( MachineFunction & MF ) { const MipsSubtarget * STI = & static_cast < const MipsSubtarget & > ( MF . getSubtarget ( ) ) ; if ( ! STI -> hasMips32r6 ( ) || STI -> inMicroMipsMode ( ) ) return false ; bool Changed = false ; const MipsInstrInfo * TII = STI -> getInstrInfo ( ) ; for ( MachineFunction :: iterator FI = MF . begin ( ) ; FI != MF . end ( ) ; ++ FI ) { for ( Iter I = FI -> begin ( ) ; I != FI -> end ( ) ; ++ I ) { if ( ! TII -> HasForbiddenSlot ( * I ) ) continue ; bool InsertNop = false ; if ( std :: next ( I ) != FI -> end ( ) && ! TII -> SafeInForbiddenSlot ( * getNextMachineInstr ( std :: next ( I ) ) ) ) { InsertNop = true ; } else { for ( auto * Succ : FI -> successors ( ) ) { if ( FI -> isLayoutSuccessor ( Succ ) && getNextMachineInstr ( Succ -> begin ( ) ) != Succ -> end ( ) && ! TII -> SafeInForbiddenSlot ( * getNextMachineInstr ( Succ -> begin ( ) ) ) ) { InsertNop = true ; break ; } } } if ( InsertNop ) { Changed = true ; MIBundleBuilder ( I ) . append ( BuildMI ( MF , I -> getDebugLoc ( ) , TII -> get ( Mips :: NOP ) ) ) ; NumInsertedNops ++ ; } } } return Changed ; } </s>

Mips Mips Mips Mips Mips Mips Mips Mips::NOP


<s>
bool
Z80InstrInfo
::
reverseBranchCondition
(
SmallVectorImpl
<
MachineOperand
>
&
Cond
)
const
{
assert
(
Cond
.
size
(
)
==
1
&&
"Invalid Z80 branch condition!"
)
;
Z80
::
CondCode
CC
=
static_cast
<
Z80
::
CondCode
>
(
Cond
[
0
]
.
getImm
(
)
)
;
Cond
[
0
]
.
setImm
(
GetOppositeBranchCondition
(
CC
)
)
;
return
false
;
}
</s>

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


<s> void MipsAsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { SmallString < 128 > Str ; raw_svector_ostream OS ( Str ) ; if ( MI -> isDebugValue ( ) ) { PrintDebugValueComment ( MI , OS ) ; return ; } MipsMCInstLower MCInstLowering ( Mang , * MF , * this ) ; unsigned Opc = MI -> getOpcode ( ) ; MCInst TmpInst0 ; MCInstLowering . Lower ( MI , TmpInst0 ) ; if ( isUnalignedLoadStore ( Opc ) ) { MCInst Directive ; Directive . setOpcode ( Mips :: MACRO ) ; OutStreamer . EmitInstruction ( Directive ) ; OutStreamer . EmitInstruction ( TmpInst0 ) ; Directive . setOpcode ( Mips :: NOMACRO ) ; OutStreamer . EmitInstruction ( Directive ) ; return ; } OutStreamer . EmitInstruction ( TmpInst0 ) ; } </s>

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

Mips Mips 128 Mips Mips::MACRO Mips::NOMACRO


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s>
void
Cpu0InstPrinter
::
PrintSpecial
(
const
MCInst
*
MI
,
raw_ostream
&
O
,
const
char
*
Code
)
const
{
assert
(
strcmp
(
Code
,
"arguments"
)
==
0
)
;
for
(
unsigned
i
=
0
;
i
<
MI
->
getNumOperands
(
)
1
;
i
++
)
{
if
(
i
!=
0
)
{
O
<<
", "
;
}
O
<<
"$r"
<<
i
<<
"|0"
;
}
}
</s>

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


<s>
Sparc
::
Fixups
SparcMCExpr
::
getFixupKind
(
SparcMCExpr
::
VariantKind
Kind
)
{
switch
(
Kind
)
{
default
:
llvm_unreachable
(
"Unhandled SparcMCExpr::VariantKind"
)
;
case
VK_Sparc_LO
:
return
Sparc
::
fixup_sparc_lo10
;
case
VK_Sparc_HI
:
return
Sparc
::
fixup_sparc_hi22
;
case
VK_Sparc_H44
:
return
Sparc
::
fixup_sparc_h44
;
case
VK_Sparc_M44
:
return
Sparc
::
fixup_sparc_m44
;
case
VK_Sparc_L44
:
return
Sparc
::
fixup_sparc_l44
;
case
VK_Sparc_HH
:
return
Sparc
::
fixup_sparc_hh
;
case
VK_Sparc_HM
:
return
Sparc
::
fixup_sparc_hm
;
case
VK_Sparc_PC22
:
return
Sparc
::
fixup_sparc_pc22
;
case
VK_Sparc_PC10
:
return
Sparc
::
fixup_sparc_pc10
;
case
VK_Sparc_GOT22
:
return
Sparc
::
fixup_sparc_got22
;
case
VK_Sparc_GOT10
:
return
Sparc
::
fixup_sparc_got10
;
case
VK_Sparc_GOT13
:
return
Sparc
::
fixup_sparc_got13
;
case
VK_Sparc_13
:
return
Sparc
::
fixup_sparc_13
;
case
VK_Sparc_WPLT30
:
return
Sparc
::
fixup_sparc_wplt30
;
case
VK_Sparc_TLS_GD_HI22
:
return
Sparc
::
fixup_sparc_tls_gd_hi22
;
case
VK_Sparc_TLS_GD_LO10
:
return
Sparc
::
fixup_sparc_tls_gd_lo10
;
case
VK_Sparc_TLS_GD_ADD
:
return
Sparc
::
fixup_sparc_tls_gd_add
;
case
VK_Sparc_TLS_GD_CALL
:
return
Sparc
::
fixup_sparc_tls_gd_call
;
case
VK_Sparc_TLS_LDM_HI22
:
return
Sparc
::
fixup_sparc_tls_ldm_hi22
;
case
VK_Sparc_TLS_LDM_LO10
:
return
Sparc
::
fixup_sparc_tls_ldm_lo10
;
case
VK_Sparc_TLS_LDM_ADD
:
return
Sparc
::
fixup_sparc_tls_ldm_add
;
case
VK_Sparc_TLS_LDM_CALL
:
return
Sparc
::
fixup_sparc_tls_ldm_call
;
case
VK_Sparc_TLS_LDO_HIX22
:
return
Sparc
::
fixup_sparc_tls_ldo_hix22
;
case
VK_Sparc_TLS_LDO_LOX10
:
return
Sparc
::
fixup_sparc_tls_ldo_lox10
;
case
VK_Sparc_TLS_LDO_ADD
:
return
Sparc
::
fixup_sparc_tls_ldo_add
;
case
VK_Sparc_TLS_IE_HI22
:
return
Sparc
::
fixup_sparc_tls_ie_hi22
;
case
VK_Sparc_TLS_IE_LO10
:
return
Sparc
::
fixup_sparc_tls_ie_lo10
;
case
VK_Sparc_TLS_IE_LD
:
return
Sparc
::
fixup_sparc_tls_ie_ld
;
case
VK_Sparc_TLS_IE_LDX
:
return
Sparc
::
fixup_sparc_tls_ie_ldx
;
case
VK_Sparc_TLS_IE_ADD
:
return
Sparc
::
fixup_sparc_tls_ie_add
;
case
VK_Sparc_TLS_LE_HIX22
:
return
Sparc
::
fixup_sparc_tls_le_hix22
;
case
VK_Sparc_TLS_LE_LOX10
:
return
Sparc
::
fixup_sparc_tls_le_lox10
;
}
}
</s>

getFixupKind - Get the fixup kind of this expression .


<s> static void aarch64_init_builtins ( ) { aarch64_general_init_builtins ( ) ; aarch64_sve :: init_builtins ( ) ; SUBTARGET_INIT_BUILTINS ; } </s>


<s> static void emit_push_sfr ( rtx sfr , bool frame_related_p , bool clr_p , int treg ) { rtx_insn * insn ; gcc_assert ( MEM_P ( sfr ) ) ; insn = emit_move_insn ( all_regs_rtx [ treg ] , sfr ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = 1 ; emit_push_byte ( treg , frame_related_p ) ; if ( clr_p ) { insn = emit_move_insn ( sfr , const0_rtx ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = 1 ; } } </s>

Helper for expand_prologue . Emit a push of a SFR via tmp_reg . SFR is a MEM representing the memory location of the SFR . If CLR_P then clear the SFR after the push using zero_reg .


<s> void ix86_reset_previous_fndecl ( void ) { tree new_tree = target_option_current_node ; cl_target_option_restore ( & global_options , & global_options_set , TREE_TARGET_OPTION ( new_tree ) ) ; if ( TREE_TARGET_GLOBALS ( new_tree ) ) restore_target_globals ( TREE_TARGET_GLOBALS ( new_tree ) ) ; else if ( new_tree == target_option_default_node ) restore_target_globals ( & default_target_globals ) ; else TREE_TARGET_GLOBALS ( new_tree ) = save_target_globals_default_opts ( ) ; ix86_previous_fndecl = NULL_TREE ; } </s>

Set targets globals to the default ( or current # pragma GCC target if active ) . Invalidate ix86_previous_fndecl cache .


<s> bool HexagonSplitTFRCondSets :: runOnMachineFunction ( MachineFunction & Fn ) { const TargetInstrInfo * TII = QTM . getInstrInfo ( ) ; for ( MachineFunction :: iterator MBBb = Fn . begin ( ) , MBBe = Fn . end ( ) ; MBBb != MBBe ; ++ MBBb ) { MachineBasicBlock * MBB = MBBb ; for ( MachineBasicBlock :: iterator MII = MBB -> begin ( ) ; MII != MBB -> end ( ) ; ++ MII ) { MachineInstr * MI = MII ; int Opc = MI -> getOpcode ( ) ; if ( Opc == Hexagon :: TFR_condset_rr ) { int DestReg = MI -> getOperand ( 0 ) . getReg ( ) ; int SrcReg1 = MI -> getOperand ( 2 ) . getReg ( ) ; int SrcReg2 = MI -> getOperand ( 3 ) . getReg ( ) ; if ( DestReg != SrcReg1 ) { BuildMI ( * MBB , MII , MI -> getDebugLoc ( ) , TII -> get ( Hexagon :: TFR_cPt ) , DestReg ) . addReg ( MI -> getOperand ( 1 ) . getReg ( ) ) . addReg ( SrcReg1 ) ; } if ( DestReg != SrcReg2 ) { BuildMI ( * MBB , MII , MI -> getDebugLoc ( ) , TII -> get ( Hexagon :: TFR_cNotPt ) , DestReg ) . addReg ( MI -> getOperand ( 1 ) . getReg ( ) ) . addReg ( SrcReg2 ) ; } MII = MBB -> erase ( MI ) ; -- MII ; } else if ( Opc == Hexagon :: TFR_condset_ii ) { int DestReg = MI -> getOperand ( 0 ) . getReg ( ) ; int SrcReg1 = MI -> getOperand ( 1 ) . getReg ( ) ; int Immed1 = MI -> getOperand ( 2 ) . getImm ( ) ; int Immed2 = MI -> getOperand ( 3 ) . getImm ( ) ; BuildMI ( * MBB , MII , MI -> getDebugLoc ( ) , TII -> get ( Hexagon :: TFRI_cPt ) , DestReg ) . addReg ( SrcReg1 ) . addImm ( Immed1 ) ; BuildMI ( * MBB , MII , MI -> getDebugLoc ( ) , TII -> get ( Hexagon :: TFRI_cNotPt ) , DestReg ) . addReg ( SrcReg1 ) . addImm ( Immed2 ) ; MII = MBB -> erase ( MI ) ; -- MII ; } } } return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> AVRSubtarget :: AVRSubtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const AVRTargetMachine & TM ) : AVRGenSubtargetInfo ( TT , CPU , FS ) , InstrInfo ( ) , FrameLowering ( ) , TLInfo ( TM , initializeSubtargetDependencies ( CPU , FS , TM ) ) , TSInfo ( ) , m_hasSRAM ( false ) , m_hasJMPCALL ( false ) , m_hasIJMPCALL ( false ) , m_hasEIJMPCALL ( false ) , m_hasADDSUBIW ( false ) , m_hasSmallStack ( false ) , m_hasMOVW ( false ) , m_hasLPM ( false ) , m_hasLPMX ( false ) , m_hasELPM ( false ) , m_hasELPMX ( false ) , m_hasSPM ( false ) , m_hasSPMX ( false ) , m_hasDES ( false ) , m_supportsRMW ( false ) , m_supportsMultiplication ( false ) , m_hasBREAK ( false ) , m_hasTinyEncoding ( false ) , ELFArch ( false ) , m_FeatureSetDummy ( false ) { ParseSubtargetFeatures ( CPU , FS ) ; } </s>


"density %d%%, cost %d exceeds threshold, penalizing "

Test for likely overcommitment of vector hardware resources . If a loop iteration is relatively large , and too large a percentage of instructions in the loop are vectorized , the cost model may not adequately reflect delays from unavailable vector resources . Penalize the loop body cost for this case .


<s> void XCoreInstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned DestReg , int FrameIndex , const TargetRegisterClass * RC ) const { DebugLoc DL = DebugLoc :: getUnknownLoc ( ) ; if ( I != MBB . end ( ) ) DL = I -> getDebugLoc ( ) ; BuildMI ( MBB , I , DL , get ( XCore :: LDWFI ) , DestReg ) . addFrameIndex ( FrameIndex ) . addImm ( 0 ) ; } </s>

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


<s> bool XCoreFTAOElim :: runOnMachineFunction ( MachineFunction & MF ) { const XCoreInstrInfo & TII = * static_cast < const XCoreInstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; unsigned StackSize = MF . getFrameInfo ( ) -> getStackSize ( ) ; for ( MachineFunction :: iterator MFI = MF . begin ( ) , E = MF . end ( ) ; MFI != E ; ++ MFI ) { MachineBasicBlock & MBB = * MFI ; for ( MachineBasicBlock :: iterator MBBI = MBB . begin ( ) , EE = MBB . end ( ) ; MBBI != EE ; ++ MBBI ) { if ( MBBI -> getOpcode ( ) == XCore :: FRAME_TO_ARGS_OFFSET ) { MachineInstr * OldInst = MBBI ; unsigned Reg = OldInst -> getOperand ( 0 ) . getReg ( ) ; MBBI = TII . loadImmediate ( MBB , MBBI , Reg , StackSize ) ; OldInst -> eraseFromParent ( ) ; } } } return true ; } </s>

XCore XCore XCore XCore XCore::FRAME_TO_ARGS_OFFSET 0


<s> MCObjectWriter * createObjectWriter ( raw_ostream & OS ) const { return createELFObjectWriter ( new MBlazeELFObjectWriter ( OSType ) , OS , false ) ; } </s>

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


<s> unsigned getOccupancyWithLocalMemSize ( const MachineFunction & MF ) const { const auto * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; return getOccupancyWithLocalMemSize ( MFI -> getLDSSize ( ) , * MF . getFunction ( ) ) ; } </s>

Inverse of getMaxLocalMemWithWaveCount .


<s> bool ECLairAsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count ) const { if ( ( Count % 4 ) != 0 ) return false ; for ( uint64_t i = 0 ; i < Count ; i += 4 ) OS . write ( 224 ) ; return true ; } </s>

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


<s> uint32_t ARMMCCodeEmitter :: getBranchTargetOpValue ( const MCInst & MI , unsigned OpIdx , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { if ( isThumb2 ( STI ) ) return :: getBranchTargetOpValue ( MI , OpIdx , ARM :: fixup_t2_condbranch , Fixups , STI ) ; return getARMBranchTargetOpValue ( MI , OpIdx , Fixups , STI ) ; } </s>

getBranchTargetOpValue - Return binary encoding of the branch target operand .


<s> SDValue PPCTargetLowering :: getSqrtInputTest ( SDValue Op , SelectionDAG & DAG , const DenormalMode & Mode ) const { EVT VT = Op . getValueType ( ) ; if ( ! isTypeLegal ( MVT :: i1 ) || ( VT != MVT :: f64 && ( ( VT != MVT :: v2f64 && VT != MVT :: v4f32 ) || ! Subtarget . hasVSX ( ) ) ) ) return SDValue ( ) ; SDLoc DL ( Op ) ; SDValue FTSQRT = DAG . getNode ( PPCISD :: FTSQRT , DL , MVT :: i32 , Op ) ; SDValue SRIdxVal = DAG . getTargetConstant ( PPC :: sub_eq , DL , MVT :: i32 ) ; return SDValue ( DAG . getMachineNode ( TargetOpcode :: EXTRACT_SUBREG , DL , MVT :: i1 , FTSQRT , SRIdxVal ) , 0 ) ; } </s>

Return a target-dependent comparison result if the input operand is suitable for use with a square root estimate calculation .


<s> void function_builder :: add_overloaded_functions ( const function_group_info & group , mode_suffix_index mode ) { if ( m_direct_overloads ) return ; unsigned int explicit_type0 = ( * group . shape ) -> explicit_type_suffix_p ( 0 ) ; unsigned int explicit_type1 = ( * group . shape ) -> explicit_type_suffix_p ( 1 ) ; for ( unsigned int pi = 0 ; group . preds [ pi ] != NUM_PREDS ; ++ pi ) { if ( ! explicit_type0 && ! explicit_type1 ) { function_instance instance ( group . base_name , * group . base , * group . shape , mode , types_none [ 0 ] , group . preds [ pi ] ) ; add_overloaded_function ( instance , group . required_extensions ) ; } else for ( unsigned int ti = 0 ; group . types [ ti ] [ 0 ] != NUM_TYPE_SUFFIXES ; ++ ti ) { type_suffix_pair types = { explicit_type0 ? group . types [ ti ] [ 0 ] : NUM_TYPE_SUFFIXES , explicit_type1 ? group . types [ ti ] [ 1 ] : NUM_TYPE_SUFFIXES } ; function_instance instance ( group . base_name , * group . base , * group . shape , mode , types , group . preds [ pi ] ) ; add_overloaded_function ( instance , group . required_extensions ) ; } } } </s>

If we are using manual overload resolution , add one function decl for each overloaded function in GROUP . Take the function base name from GROUP and the mode from MODE .


<s> void ARMELFStreamer :: EmitRegSave ( const SmallVectorImpl < unsigned > & RegList , bool IsVector ) { } </s>

Emit unwind opcodes for .save directives .


<s>
void
RAInfo
::
dump
(
raw_ostream
&
os
,
unsigned
indent
)
const
{
os
.
indent
(
indent
)
<<
"[MBB#"
<<
Scope
->
getHeader
(
)
->
getMBB
(
)
->
getNumber
(
)
<<
"] depth="
<<
Scope
->
getDepth
(
)
<<
"\n"
;
for
(
auto
pair
:
Priv
->
LRs
)
{
os
.
indent
(
indent
)
<<
"  LR(p"
<<
pair
.
first
<<
") = ["
<<
pair
.
second
.
str
(
)
<<
"]\n"
;
}
auto
blocks
=
Scope
->
getBlocksTopoOrd
(
)
;
for
(
unsigned
i
=
0
,
e
=
blocks
.
size
(
)
;
i
<
e
;
i
++
)
{
MachineBasicBlock
*
MBB
=
blocks
[
i
]
->
getMBB
(
)
;
os
.
indent
(
indent
)
<<
"  "
<<
i
<<
"| MBB#"
<<
MBB
->
getNumber
(
)
;
os
<<
" UseLocs{\n"
;
for
(
auto
predUl
:
Priv
->
UseLocs
[
MBB
]
)
{
os
<<
"    (Pred: "
<<
predUl
.
first
<<
", loc="
<<
predUl
.
second
.
loc
<<
", load="
;
if
(
predUl
.
second
.
load
.
first
)
{
os
<<
predUl
.
second
.
load
.
second
;
}
else
{
os
<<
"none"
;
}
dbgs
(
)
<<
", spill="
;
if
(
predUl
.
second
.
spill
.
first
)
{
os
<<
predUl
.
second
.
spill
.
second
;
}
else
{
os
<<
"none"
;
}
os
<<
"), "
;
}
os
<<
"}\n"
;
}
os
.
indent
(
indent
)
<<
"  DefLocs:     "
;
for
(
auto
pair
:
Priv
->
DefLocs
)
{
os
<<
" p"
<<
pair
.
first
<<
"="
<<
pair
.
second
<<
", "
;
}
os
<<
"\n"
;
os
.
indent
(
indent
)
<<
"  NumLocs:      "
<<
Priv
->
NumLocs
<<
"\n"
"  CumLocs:      "
<<
Priv
->
getCumLocs
(
)
<<
"\n"
"  Offset:       "
<<
Priv
->
FirstUsableReg
<<
"\n"
"  SpillOffset:  "
<<
Priv
->
FirstUsableStackSlot
<<
"\n"
;
}
</s>

Dump the plan to stderr ( for debugging ) .


<s> static unsigned int mips_multi_last_index ( void ) { return mips_multi_members . length ( ) - 1 ; } </s>

Return the index of the last member of the current multi-insn sequence .


<s> void WebAssemblyDebugValueManager :: move ( MachineInstr * Insert ) { MachineBasicBlock * MBB = Insert -> getParent ( ) ; for ( MachineInstr * DBI : reverse ( DbgValues ) ) MBB -> splice ( Insert , DBI -> getParent ( ) , DBI ) ; } </s>

Move in the provide values in ValuesToLink from Src .


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

Gets the name of the pass we are mixed into .


<s>
const
TargetRegisterClass
*
ARMBaseRegisterInfo
::
getMatchingSuperRegClass
(
const
TargetRegisterClass
*
A
,
const
TargetRegisterClass
*
B
,
unsigned
SubIdx
)
const
{
switch
(
SubIdx
)
{
default
:
return
0
;
case
ARM
::
ssub_0
:
case
ARM
::
ssub_1
:
case
ARM
::
ssub_2
:
case
ARM
::
ssub_3
:
{
if
(
A
->
getSize
(
)
==
8
)
{
if
(
B
==
&
ARM
::
SPR_8RegClass
)
return
&
ARM
::
DPR_8RegClass
;
assert
(
B
==
&
ARM
::
SPRRegClass
&&
"Expecting SPR register class!"
)
;
if
(
A
==
&
ARM
::
DPR_8RegClass
)
return
A
;
return
&
ARM
::
DPR_VFP2RegClass
;
}
if
(
A
->
getSize
(
)
==
16
)
{
if
(
B
==
&
ARM
::
SPR_8RegClass
)
return
&
ARM
::
QPR_8RegClass
;
return
&
ARM
::
QPR_VFP2RegClass
;
}
if
(
A
->
getSize
(
)
==
32
)
{
if
(
B
==
&
ARM
::
SPR_8RegClass
)
return
0
;
return
&
ARM
::
QQPR_VFP2RegClass
;
}
assert
(
A
->
getSize
(
)
==
64
&&
"Expecting a QQQQ register class!"
)
;
return
0
;
}
case
ARM
::
dsub_0
:
case
ARM
::
dsub_1
:
case
ARM
::
dsub_2
:
case
ARM
::
dsub_3
:
{
if
(
A
->
getSize
(
)
==
16
)
{
if
(
B
==
&
ARM
::
DPR_VFP2RegClass
)
return
&
ARM
::
QPR_VFP2RegClass
;
if
(
B
==
&
ARM
::
DPR_8RegClass
)
return
0
;
return
A
;
}
if
(
A
->
getSize
(
)
==
32
)
{
if
(
B
==
&
ARM
::
DPR_VFP2RegClass
)
return
&
ARM
::
QQPR_VFP2RegClass
;
if
(
B
==
&
ARM
::
DPR_8RegClass
)
return
0
;
return
A
;
}
assert
(
A
->
getSize
(
)
==
64
&&
"Expecting a QQQQ register class!"
)
;
if
(
B
!=
&
ARM
::
DPRRegClass
)
return
0
;
return
A
;
}
case
ARM
::
dsub_4
:
case
ARM
::
dsub_5
:
case
ARM
::
dsub_6
:
case
ARM
::
dsub_7
:
{
if
(
A
->
getSize
(
)
==
64
&&
B
==
&
ARM
::
DPRRegClass
)
return
A
;
return
0
;
}
case
ARM
::
qsub_0
:
case
ARM
::
qsub_1
:
{
if
(
A
->
getSize
(
)
==
32
)
{
if
(
B
==
&
ARM
::
QPR_VFP2RegClass
)
return
&
ARM
::
QQPR_VFP2RegClass
;
if
(
B
==
&
ARM
::
QPR_8RegClass
)
return
0
;
return
A
;
}
assert
(
A
->
getSize
(
)
==
64
&&
"Expecting a QQQQ register class!"
)
;
if
(
B
==
&
ARM
::
QPRRegClass
)
return
A
;
return
0
;
}
case
ARM
::
qsub_2
:
case
ARM
::
qsub_3
:
{
if
(
A
->
getSize
(
)
==
64
&&
B
==
&
ARM
::
QPRRegClass
)
return
A
;
return
0
;
}
}
return
0
;
}
</s>

getMatchingSuperRegClass - Return a subclass of the specified register class A so that each register in it has a sub-register of the specified sub-register index which is in the specified register class B .


<s> void print ( std :: ostream * O ) const { if ( O ) print ( * O ) ; } </s>

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


<s> void AMDGPUPassConfig :: addCodeGenPrepare ( ) { if ( TM -> getTargetTriple ( ) . getArch ( ) == Triple :: amdgcn ) addPass ( createAMDGPUAnnotateKernelFeaturesPass ( ) ) ; if ( TM -> getTargetTriple ( ) . getArch ( ) == Triple :: amdgcn && EnableLowerKernelArguments ) addPass ( createAMDGPULowerKernelArgumentsPass ( ) ) ; addPass ( & AMDGPUPerfHintAnalysisID ) ; TargetPassConfig :: addCodeGenPrepare ( ) ; if ( EnableLoadStoreVectorizer ) addPass ( createLoadStoreVectorizerPass ( ) ) ; addPass ( createLowerSwitchPass ( ) ) ; } </s>

Add pass to prepare the LLVM IR for code generation .


"Error: check for a non-legal type in this operation\n"

LowerOperation - Provide custom lowering hooks for some operations .


<s> void emitFill ( const MCExpr & NumBytes , uint64_t FillValue , SMLoc Loc ) override { EmitDataMappingSymbol ( ) ; MCObjectStreamer :: emitFill ( NumBytes , FillValue , Loc ) ; } </s>

Emit Size bytes worth of the value specified by FillValue .


<s> X86Subtarget :: X86Subtarget ( const std :: string & TT , const std :: string & CPU , const std :: string & FS , unsigned StackAlignOverride ) : X86GenSubtargetInfo ( TT , CPU , FS ) , X86ProcFamily ( Others ) , PICStyle ( PICStyles :: None ) , TargetTriple ( TT ) , StackAlignOverride ( StackAlignOverride ) , In64BitMode ( TargetTriple . getArch ( ) == Triple :: x86_64 ) , In32BitMode ( TargetTriple . getArch ( ) == Triple :: x86 && TargetTriple . getEnvironment ( ) != Triple :: CODE16 ) , In16BitMode ( TargetTriple . getArch ( ) == Triple :: x86 && TargetTriple . getEnvironment ( ) == Triple :: CODE16 ) { initializeEnvironment ( ) ; resetSubtargetFeatures ( CPU , FS ) ; } </s>

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


<s>
StringRef
getPassName
(
)
const
override
{
return
"SI Peephole SDWA"
;
}
</s>

getPassName - Return a nice clean name for a pass .


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

Print the specified MCInst to the specified raw_ostream .


<s> unsigned PPCFrameLowering :: determineFrameLayout ( const MachineFunction & MF , bool UseEstimate , unsigned * NewMaxCallFrameSize ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const PPCFunctionInfo * FI = MF . getInfo < PPCFunctionInfo > ( ) ; unsigned FrameSize = UseEstimate ? MFI . estimateStackSize ( MF ) : MFI . getStackSize ( ) ; Align TargetAlign = getStackAlign ( ) ; Align MaxAlign = MFI . getMaxAlign ( ) ; Align Alignment = std :: max ( TargetAlign , MaxAlign ) ; const PPCRegisterInfo * RegInfo = Subtarget . getRegisterInfo ( ) ; unsigned LR = RegInfo -> getRARegister ( ) ; bool DisableRedZone = MF . getFunction ( ) . hasFnAttribute ( Attribute :: NoRedZone ) ; bool CanUseRedZone = ! MFI . hasVarSizedObjects ( ) && ! MFI . adjustsStack ( ) && ! MustSaveLR ( MF , LR ) && ! FI -> mustSaveTOC ( ) && ! RegInfo -> hasBasePointer ( MF ) ; bool FitsInRedZone = FrameSize <= Subtarget . getRedZoneSize ( ) ; if ( ! DisableRedZone && CanUseRedZone && FitsInRedZone ) { return 0 ; } unsigned maxCallFrameSize = MFI . getMaxCallFrameSize ( ) ; unsigned minCallFrameSize = getLinkageSize ( ) ; maxCallFrameSize = std :: max ( maxCallFrameSize , minCallFrameSize ) ; if ( MFI . hasVarSizedObjects ( ) ) maxCallFrameSize = alignTo ( maxCallFrameSize , Alignment ) ; if ( NewMaxCallFrameSize ) * NewMaxCallFrameSize = maxCallFrameSize ; FrameSize += maxCallFrameSize ; FrameSize = alignTo ( FrameSize , Alignment ) ; return FrameSize ; } </s>

Determine the frame layout but do not update the machine function .


<s> void mips_set_return_address ( rtx address , rtx scratch ) { rtx slot_address ; gcc_assert ( BITSET_P ( cfun -> machine -> frame . mask , RETURN_ADDR_REGNUM ) ) ; slot_address = mips_add_offset ( scratch , stack_pointer_rtx , cfun -> machine -> frame . gp_sp_offset ) ; mips_emit_move ( gen_frame_mem ( GET_MODE ( address ) , slot_address ) , address ) ; } </s>

Emit code to change the current function 's return address to ADDRESS . SCRATCH is available as a scratch register , if needed . ADDRESS and SCRATCH are both word-mode GPRs .


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

True if the machine scheduler should disable the TLI preference for preRA scheduling with the source level scheduler .


<s> static bool s390_fix_long_loop_prediction ( rtx_insn * insn ) { rtx set = single_set ( insn ) ; rtx code_label , label_ref , new_label ; rtx_insn * uncond_jump ; rtx_insn * cur_insn ; rtx tmp ; int distance ; if ( ! set || SET_DEST ( set ) != pc_rtx || GET_CODE ( SET_SRC ( set ) ) != IF_THEN_ELSE ) return false ; if ( ANY_RETURN_P ( XEXP ( SET_SRC ( set ) , 1 ) ) && XEXP ( SET_SRC ( set ) , 2 ) == pc_rtx ) return false ; label_ref = ( GET_CODE ( XEXP ( SET_SRC ( set ) , 1 ) ) == LABEL_REF ? XEXP ( SET_SRC ( set ) , 1 ) : XEXP ( SET_SRC ( set ) , 2 ) ) ; gcc_assert ( GET_CODE ( label_ref ) == LABEL_REF ) ; code_label = XEXP ( label_ref , 0 ) ; if ( INSN_ADDRESSES ( INSN_UID ( code_label ) ) == - 1 || INSN_ADDRESSES ( INSN_UID ( insn ) ) == - 1 || ( INSN_ADDRESSES ( INSN_UID ( insn ) ) - INSN_ADDRESSES ( INSN_UID ( code_label ) ) < PREDICT_DISTANCE ) ) return false ; for ( distance = 0 , cur_insn = PREV_INSN ( insn ) ; distance < PREDICT_DISTANCE - 6 ; distance += get_attr_length ( cur_insn ) , cur_insn = PREV_INSN ( cur_insn ) ) if ( ! cur_insn || JUMP_P ( cur_insn ) || LABEL_P ( cur_insn ) ) return false ; new_label = gen_label_rtx ( ) ; uncond_jump = emit_jump_insn_after ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_LABEL_REF ( VOIDmode , code_label ) ) , insn ) ; emit_label_after ( new_label , uncond_jump ) ; tmp = XEXP ( SET_SRC ( set ) , 1 ) ; XEXP ( SET_SRC ( set ) , 1 ) = XEXP ( SET_SRC ( set ) , 2 ) ; XEXP ( SET_SRC ( set ) , 2 ) = tmp ; INSN_CODE ( insn ) = - 1 ; XEXP ( label_ref , 0 ) = new_label ; JUMP_LABEL ( insn ) = new_label ; JUMP_LABEL ( uncond_jump ) = code_label ; return true ; } </s>

On z10 and later the dynamic branch prediction must see the backward jump within a certain windows . If not it falls back to the static prediction . This function rearranges the loop backward branch in a way which makes the static prediction always correct . The function returns true if it added an instruction .


<s> void MOSTargetAsmStreamer :: changeSection ( const MCSection * CurSection , MCSection * Section , const MCExpr * SubSection , raw_ostream & OS ) { MCTargetStreamer :: changeSection ( CurSection , Section , SubSection , OS ) ; HasBSS |= Section -> getName ( ) . startswith ( ".bss" ) ; HasData |= Section -> getName ( ) . startswith ( ".data" ) ; HasInitArray |= Section -> getName ( ) . startswith ( ".init_array" ) ; HasFiniArray |= Section -> getName ( ) . startswith ( ".fini_array" ) ; } </s>

Update streamer for a new active section .


"shouldAssumeDSOLocal gave inconsistent answer"

Classify a global function reference for the current subtarget .


<s> void BPFAsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { BPFMCInstLower MCInstLowering ( OutContext , * this ) ; MCInst TmpInst ; MCInstLowering . Lower ( MI , TmpInst ) ; EmitToStreamer ( * OutStreamer , TmpInst ) ; } </s>

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


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

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


<s> bool ARMTargetLowering :: isDesirableToCommuteWithShift ( const SDNode * N , CombineLevel Level ) const { if ( Level == BeforeLegalizeTypes ) return true ; if ( Subtarget -> isThumb ( ) && Subtarget -> isThumb1Only ( ) ) return true ; if ( N -> getOpcode ( ) != ISD :: SHL ) return true ; return false ; } </s>

Return true if it is profitable to move this shift by a constant amount through its operand , adjusting any immediate operands as necessary to preserve semantics .


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


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

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

ARM ARM::GPRRegClass ARM::tGPRRegClass ARM::tcGPRRegClass ARM::rGPRRegClass ARM::GPRnopcRegClass ARM::t2STRi12 0 ARM


<s>
bool
SILoadStoreOptimizer
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
if
(
skipFunction
(
MF
.
getFunction
(
)
)
)
return
false
;
STM
=
&
MF
.
getSubtarget
<
SISubtarget
>
(
)
;
if
(
!
STM
->
loadStoreOptEnabled
(
)
)
return
false
;
TII
=
STM
->
getInstrInfo
(
)
;
TRI
=
&
TII
->
getRegisterInfo
(
)
;
MRI
=
&
MF
.
getRegInfo
(
)
;
AA
=
&
getAnalysis
<
AAResultsWrapperPass
>
(
)
.
getAAResults
(
)
;
assert
(
MRI
->
isSSA
(
)
&&
"Must be run on SSA"
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"Running SILoadStoreOptimizer\n"
)
;
bool
Modified
=
false
;
for
(
MachineBasicBlock
&
MBB
:
MF
)
{
CreatedX2
=
0
;
Modified
|=
optimizeBlock
(
MBB
)
;
if
(
CreatedX2
>=
1
)
Modified
|=
optimizeBlock
(
MBB
)
;
}
return
Modified
;
}
</s>

runOnMachineFunction - Emit the function body .

AMDGPU
SI
SI
"Must be run on SSA"
"Running SILoadStoreOptimizer\n"
0
1


<s> static void tilegx_gen_bundles ( void ) { basic_block bb ; FOR_EACH_BB_FN ( bb , cfun ) { rtx_insn * insn , * next , * prev ; rtx_insn * end = NEXT_INSN ( BB_END ( bb ) ) ; prev = NULL ; for ( insn = next_insn_to_bundle ( BB_HEAD ( bb ) , end ) ; insn ; prev = insn , insn = next ) { next = next_insn_to_bundle ( NEXT_INSN ( insn ) , end ) ; if ( GET_CODE ( PATTERN ( insn ) ) != ASM_INPUT ) { if ( next == NULL_RTX || GET_MODE ( next ) == TImode || CALL_P ( insn ) ) { PUT_MODE ( insn , QImode ) ; } else { PUT_MODE ( insn , SImode ) ; } } if ( get_attr_type ( insn ) == TYPE_NOTHING ) { if ( GET_MODE ( insn ) == QImode && prev != NULL && GET_MODE ( prev ) == SImode ) { PUT_MODE ( prev , QImode ) ; } delete_insn ( insn ) ; } } } } </s>

Go through all insns , and use the information generated during scheduling to generate SEQUENCEs to represent bundles of instructions issued simultaneously .


<s> bool arc_epilogue_uses ( int regno ) { unsigned int fn_type ; if ( regno == arc_tp_regno ) return true ; fn_type = arc_compute_function_type ( cfun ) ; if ( reload_completed ) { if ( ARC_INTERRUPT_P ( cfun -> machine -> fn_type ) ) { if ( ! fixed_regs [ regno ] ) return true ; return ( ( regno == arc_return_address_register ( fn_type ) ) || ( regno == RETURN_ADDR_REGNUM ) ) ; } else return regno == RETURN_ADDR_REGNUM ; } else return regno == arc_return_address_register ( fn_type ) ; } </s>

Implement EPILOGUE__USES . Return true if REGNO should be added to the deemed uses of the epilogue . We use the return address arc_return_address_regs [ arc_compute_function_type ( cfun ) ] . But also , we have to make sure all the register restore instructions are known to be live in interrupt functions , plus the blink register if it is clobbered by the isr .


"********** Moving materializable close to their usage **********\n"


<s> bool MipsPassConfig :: 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> int loongarch_address_insns ( rtx x , machine_mode mode , bool might_split_p ) { struct loongarch_address_info addr ; int factor ; if ( ! loongarch_classify_address ( & addr , x , mode , false ) ) return 0 ; if ( mode != BLKmode && might_split_p ) factor = ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; else factor = 1 ; if ( loongarch_classify_address ( & addr , x , mode , false ) ) switch ( addr . type ) { case ADDRESS_REG : return factor ; case ADDRESS_REG_REG : return factor ; case ADDRESS_CONST_INT : return factor ; case ADDRESS_SYMBOLIC : return factor * loongarch_symbol_insns ( addr . symbol_type , mode ) ; } return 0 ; } </s>

Return the number of instructions needed to load or store a value of mode MODE at address X . Return 0 if X is n't valid for MODE . Assume that multiword moves may need to be split into word moves if MIGHT_SPLIT_P , otherwise assume that a single load or store is enough .


<s> static bool s390_call_saved_register_used ( tree call_expr ) { CUMULATIVE_ARGS cum_v ; cumulative_args_t cum ; tree parameter ; machine_mode mode ; tree type ; rtx parm_rtx ; int reg , i ; INIT_CUMULATIVE_ARGS ( cum_v , NULL , NULL , 0 , 0 ) ; cum = pack_cumulative_args ( & cum_v ) ; for ( i = 0 ; i < call_expr_nargs ( call_expr ) ; i ++ ) { parameter = CALL_EXPR_ARG ( call_expr , i ) ; gcc_assert ( parameter ) ; if ( TREE_CODE ( parameter ) == ERROR_MARK ) return true ; type = TREE_TYPE ( parameter ) ; gcc_assert ( type ) ; mode = TYPE_MODE ( type ) ; gcc_assert ( mode ) ; if ( pass_by_reference ( & cum_v , mode , type , true ) ) { mode = Pmode ; type = build_pointer_type ( type ) ; } parm_rtx = s390_function_arg ( cum , mode , type , 0 ) ; s390_function_arg_advance ( cum , mode , type , 0 ) ; if ( ! parm_rtx ) continue ; if ( REG_P ( parm_rtx ) ) { for ( reg = 0 ; reg < HARD_REGNO_NREGS ( REGNO ( parm_rtx ) , GET_MODE ( parm_rtx ) ) ; reg ++ ) if ( ! call_used_regs [ reg + REGNO ( parm_rtx ) ] ) return true ; } if ( GET_CODE ( parm_rtx ) == PARALLEL ) { int i ; for ( i = 0 ; i < XVECLEN ( parm_rtx , 0 ) ; i ++ ) { rtx r = XEXP ( XVECEXP ( parm_rtx , 0 , i ) , 0 ) ; gcc_assert ( REG_P ( r ) ) ; for ( reg = 0 ; reg < HARD_REGNO_NREGS ( REGNO ( r ) , GET_MODE ( r ) ) ; reg ++ ) if ( ! call_used_regs [ reg + REGNO ( r ) ] ) return true ; } } } return false ; } </s>

Checks whether the given ARGUMENT_LIST would use a caller saved register . This is used to decide whether sibling call optimization could be performed on the respective function call .


<s> unsigned AAPRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; return TFI -> hasFP ( MF ) ? getFramePtrRegister ( ) : getStackPtrRegister ( ) ; } </s>


<s> bool SITargetLowering :: canMergeStoresTo ( unsigned AS , EVT MemVT , const SelectionDAG & DAG ) const { if ( AS == AMDGPUASI . GLOBAL_ADDRESS || AS == AMDGPUASI . FLAT_ADDRESS ) { return ( MemVT . getSizeInBits ( ) <= 4 * 32 ) ; } else if ( AS == AMDGPUASI . PRIVATE_ADDRESS ) { unsigned MaxPrivateBits = 8 * getSubtarget ( ) -> getMaxPrivateElementSize ( ) ; return ( MemVT . getSizeInBits ( ) <= MaxPrivateBits ) ; } else if ( AS == AMDGPUASI . LOCAL_ADDRESS ) { return ( MemVT . getSizeInBits ( ) <= 2 * 32 ) ; } return true ; } </s>

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


<s>
void
SIInstrInfo
::
loadRegFromStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
unsigned
DestReg
,
int
FrameIndex
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
MachineFunction
*
MF
=
MBB
.
getParent
(
)
;
SIMachineFunctionInfo
*
MFI
=
MF
->
getInfo
<
SIMachineFunctionInfo
>
(
)
;
MachineFrameInfo
&
FrameInfo
=
MF
->
getFrameInfo
(
)
;
const
DebugLoc
&
DL
=
MBB
.
findDebugLoc
(
MI
)
;
unsigned
Align
=
FrameInfo
.
getObjectAlignment
(
FrameIndex
)
;
unsigned
Size
=
FrameInfo
.
getObjectSize
(
FrameIndex
)
;
unsigned
SpillSize
=
TRI
->
getSpillSize
(
*
RC
)
;
MachinePointerInfo
PtrInfo
=
MachinePointerInfo
::
getFixedStack
(
*
MF
,
FrameIndex
)
;
MachineMemOperand
*
MMO
=
MF
->
getMachineMemOperand
(
PtrInfo
,
MachineMemOperand
::
MOLoad
,
Size
,
Align
)
;
if
(
RI
.
isSGPRClass
(
RC
)
)
{
MFI
->
setHasSpilledSGPRs
(
)
;
assert
(
DestReg
!=
AMDGPU
::
M0
&&
"m0 should not be reloaded into"
)
;
const
MCInstrDesc
&
OpDesc
=
get
(
getSGPRSpillRestoreOpcode
(
SpillSize
)
)
;
if
(
Register
::
isVirtualRegister
(
DestReg
)
&&
SpillSize
==
4
)
{
MachineRegisterInfo
&
MRI
=
MF
->
getRegInfo
(
)
;
MRI
.
constrainRegClass
(
DestReg
,
&
AMDGPU
::
SReg_32_XM0RegClass
)
;
}
if
(
RI
.
spillSGPRToVGPR
(
)
)
FrameInfo
.
setStackID
(
FrameIndex
,
TargetStackID
::
SGPRSpill
)
;
BuildMI
(
MBB
,
MI
,
DL
,
OpDesc
,
DestReg
)
.
addFrameIndex
(
FrameIndex
)
.
addMemOperand
(
MMO
)
.
addReg
(
MFI
->
getScratchRSrcReg
(
)
,
RegState
::
Implicit
)
.
addReg
(
MFI
->
getStackPtrOffsetReg
(
)
,
RegState
::
Implicit
)
;
return
;
}
unsigned
Opcode
=
RI
.
hasAGPRs
(
RC
)
getAGPRSpillRestoreOpcode
(
SpillSize
)
:
getVGPRSpillRestoreOpcode
(
SpillSize
)
;
auto
MIB
=
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opcode
)
,
DestReg
)
;
if
(
RI
.
hasAGPRs
(
RC
)
)
{
MachineRegisterInfo
&
MRI
=
MF
->
getRegInfo
(
)
;
Register
Tmp
=
MRI
.
createVirtualRegister
(
&
AMDGPU
::
VGPR_32RegClass
)
;
MIB
.
addReg
(
Tmp
,
RegState
::
Define
)
;
}
MIB
.
addFrameIndex
(
FrameIndex
)
.
addReg
(
MFI
->
getScratchRSrcReg
(
)
)
.
addReg
(
MFI
->
getStackPtrOffsetReg
(
)
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
;
}
</s>

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


<s> static rtx h8300_libcall_value ( machine_mode mode , const_rtx fun ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( mode , R0_REG ) ; } </s>

Worker function for TARGET_LIBCALL_VALUE . On the H8 the return value is in R0/R1 .


<s> bool cris_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { const_rtx x1 , x2 ; if ( cris_base_or_autoincr_p ( x , strict ) ) return true ; else if ( CONSTANT_P ( x ) ) return true ; else if ( GET_CODE ( x ) == PLUS ) { x1 = XEXP ( x , 0 ) ; x2 = XEXP ( x , 1 ) ; if ( ( cris_base_p ( x1 , strict ) && CONSTANT_P ( x2 ) ) || ( cris_base_p ( x2 , strict ) && CONSTANT_P ( x1 ) ) || ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD && ( ( cris_base_p ( x1 , strict ) && cris_bdap_index_p ( x2 , strict ) ) || ( cris_base_p ( x2 , strict ) && cris_bdap_index_p ( x1 , strict ) ) || ( cris_base_p ( x1 , strict ) && cris_biap_index_p ( x2 , strict ) ) || ( cris_base_p ( x2 , strict ) && cris_biap_index_p ( x1 , strict ) ) ) ) ) return true ; } else if ( MEM_P ( x ) ) { if ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD && cris_base_or_autoincr_p ( XEXP ( x , 0 ) , strict ) ) return true ; } return false ; } </s>

Worker function for TARGET_LEGITIMATE_ADDRESS_P .


<s> bool ARMSubtarget :: useFastISel ( ) const { return TM . Options . EnableFastISel && ( ( isTargetMachO ( ) && ! isThumb1Only ( ) ) || ( isTargetLinux ( ) && ! isThumb ( ) ) || ( isTargetNaCl ( ) && ! isThumb ( ) ) ) ; } </s>


<s> const MCPhysReg * JVMRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * ) const { static const MCPhysReg CalleeSavedRegs [ ] = { 0 } ; return CalleeSavedRegs ; } </s>


<s> void RISCVELFTargetObjectFile :: getModuleMetadata ( Module & M ) { TargetLoweringObjectFileELF :: getModuleMetadata ( M ) ; SmallVector < Module :: ModuleFlagEntry , 8 > ModuleFlags ; M . getModuleFlagsMetadata ( ModuleFlags ) ; for ( const auto & MFE : ModuleFlags ) { StringRef Key = MFE . Key -> getString ( ) ; if ( Key == "SmallDataLimit" ) { SSThreshold = mdconst :: extract < ConstantInt > ( MFE . Val ) -> getZExtValue ( ) ; break ; } } } </s>

Get the module-level metadata that the platform cares about .


<s> static rtx frv_expand_load_builtin ( enum insn_code icode , machine_mode target_mode , tree call , rtx target ) { rtx op0 = frv_read_argument ( call , 0 ) ; rtx cookie = frv_io_address_cookie ( op0 ) ; if ( target == 0 || ! REG_P ( target ) ) target = gen_reg_rtx ( target_mode ) ; op0 = frv_volatile_memref ( insn_data [ icode ] . operand [ 0 ] . mode , op0 ) ; convert_move ( target , op0 , 1 ) ; emit_insn ( GEN_FCN ( icode ) ( copy_rtx ( op0 ) , cookie , GEN_INT ( FRV_IO_READ ) ) ) ; cfun -> machine -> has_membar_p = 1 ; return target ; } </s>

Expand a __builtin_read * function . ICODE is the instruction code for the membar and TARGET_MODE is the mode that the loaded value should have .


<s>
void
MCS51MCInstLower
::
lowerInstruction
(
const
MachineInstr
&
MI
,
MCInst
&
OutMI
)
const
{
OutMI
.
setOpcode
(
MI
.
getOpcode
(
)
)
;
for
(
MachineOperand
const
&
MO
:
MI
.
operands
(
)
)
{
MCOperand
MCOp
;
switch
(
MO
.
getType
(
)
)
{
default
:
MI
.
print
(
errs
(
)
)
;
llvm_unreachable
(
"unknown operand type"
)
;
case
MachineOperand
::
MO_Register
:
if
(
MO
.
isImplicit
(
)
)
continue
;
MCOp
=
MCOperand
::
createReg
(
MO
.
getReg
(
)
)
;
break
;
case
MachineOperand
::
MO_Immediate
:
MCOp
=
MCOperand
::
createImm
(
MO
.
getImm
(
)
)
;
break
;
case
MachineOperand
::
MO_GlobalAddress
:
MCOp
=
lowerSymbolOperand
(
MO
,
Printer
.
getSymbol
(
MO
.
getGlobal
(
)
)
)
;
break
;
case
MachineOperand
::
MO_ExternalSymbol
:
MCOp
=
lowerSymbolOperand
(
MO
,
Printer
.
GetExternalSymbolSymbol
(
MO
.
getSymbolName
(
)
)
)
;
break
;
case
MachineOperand
::
MO_MachineBasicBlock
:
MCOp
=
MCOperand
::
createExpr
(
MCSymbolRefExpr
::
create
(
MO
.
getMBB
(
)
->
getSymbol
(
)
,
Ctx
)
)
;
break
;
case
MachineOperand
::
MO_RegisterMask
:
continue
;
case
MachineOperand
::
MO_BlockAddress
:
MCOp
=
lowerSymbolOperand
(
MO
,
Printer
.
GetBlockAddressSymbol
(
MO
.
getBlockAddress
(
)
)
)
;
break
;
case
MachineOperand
::
MO_JumpTableIndex
:
MCOp
=
lowerSymbolOperand
(
MO
,
Printer
.
GetJTISymbol
(
MO
.
getIndex
(
)
)
)
;
break
;
case
MachineOperand
::
MO_ConstantPoolIndex
:
MCOp
=
lowerSymbolOperand
(
MO
,
Printer
.
GetCPISymbol
(
MO
.
getIndex
(
)
)
)
;
break
;
}
OutMI
.
addOperand
(
MCOp
)
;
}
}
</s>


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

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


<s>
unsigned
getMemSize
(
)
const
{
assert
(
Kind
==
Memory
&&
"Invalid access!"
)
;
return
Mem
.
Size
;
}
</s>

Returns the size in bytes of the memory access .


<s> static int ep_memory_offset ( machine_mode mode , int unsignedp ATTRIBUTE_UNUSED ) { int max_offset = 0 ; switch ( mode ) { case QImode : if ( TARGET_SMALL_SLD ) max_offset = ( 1 << 4 ) ; else if ( ( TARGET_V850E_UP ) && unsignedp ) max_offset = ( 1 << 4 ) ; else max_offset = ( 1 << 7 ) ; break ; case HImode : if ( TARGET_SMALL_SLD ) max_offset = ( 1 << 5 ) ; else if ( ( TARGET_V850E_UP ) && unsignedp ) max_offset = ( 1 << 5 ) ; else max_offset = ( 1 << 8 ) ; break ; case SImode : case SFmode : max_offset = ( 1 << 8 ) ; break ; default : break ; } return max_offset ; } </s>

Return maximum offset supported for a short EP memory reference of mode MODE and signedness UNSIGNEDP .


<s> bool AMDGPUAnnotateKernelFeatures :: runOnModule ( Module & M ) { Triple TT ( M . getTargetTriple ( ) ) ; static const StringRef IntrinsicToAttr [ ] [ 2 ] = { { "llvm.amdgcn.workitem.id.y" , "amdgpu-work-item-id-y" } , { "llvm.amdgcn.workitem.id.z" , "amdgpu-work-item-id-z" } , { "llvm.amdgcn.workgroup.id.y" , "amdgpu-work-group-id-y" } , { "llvm.amdgcn.workgroup.id.z" , "amdgpu-work-group-id-z" } , { "llvm.r600.read.tgid.y" , "amdgpu-work-group-id-y" } , { "llvm.r600.read.tgid.z" , "amdgpu-work-group-id-z" } , { "llvm.r600.read.tidig.y" , "amdgpu-work-item-id-y" } , { "llvm.r600.read.tidig.z" , "amdgpu-work-item-id-z" } } ; static const StringRef HSAIntrinsicToAttr [ ] [ 2 ] = { { "llvm.amdgcn.dispatch.ptr" , "amdgpu-dispatch-ptr" } , { "llvm.amdgcn.queue.ptr" , "amdgpu-queue-ptr" } , { "llvm.amdgcn.dispatch.id" , "amdgpu-dispatch-id" } } ; bool Changed = addAttrsForIntrinsics ( M , IntrinsicToAttr ) ; if ( TT . getOS ( ) == Triple :: AMDHSA ) { Changed |= addAttrsForIntrinsics ( M , HSAIntrinsicToAttr ) ; for ( Function & F : M ) { if ( F . hasFnAttribute ( "amdgpu-queue-ptr" ) ) continue ; if ( hasAddrSpaceCast ( F ) ) F . addFnAttr ( "amdgpu-queue-ptr" ) ; } } return Changed ; } </s>

runOnModule - Virtual method overriden by subclasses to process the module being operated on .


<s> bool PTXInstrInfo :: isUnpredicatedTerminator ( const MachineInstr * MI ) const { return ! isPredicated ( MI ) && get ( MI -> getOpcode ( ) ) . isTerminator ( ) ; } </s>

Returns true if the instruction is a terminator instruction that has not been predicated .


<s> bool mayNeedRelaxation ( MCInst const & Inst ) const override { return true ; } </s>

Check whether the given instruction may need relaxation .


<s>
bool
MatchAndEmitInstruction
(
SMLoc
IDLoc
,
unsigned
&
,
OperandVector
&
Operands
,
MCStreamer
&
Out
,
uint64_t
&
ErrorInfo
,
bool
MatchingInlineAsm
)
override
{
MCInst
Inst
;
Inst
.
setLoc
(
IDLoc
)
;
FeatureBitset
MissingFeatures
;
unsigned
MatchResult
=
MatchInstructionImpl
(
Operands
,
Inst
,
ErrorInfo
,
MissingFeatures
,
MatchingInlineAsm
)
;
switch
(
MatchResult
)
{
case
Match_Success
:
{
ensureLocals
(
Out
)
;
auto
Align
=
WebAssembly
::
GetDefaultP2AlignAny
(
Inst
.
getOpcode
(
)
)
;
if
(
Align
!=
1U
)
{
auto
&
Op0
=
Inst
.
getOperand
(
0
)
;
if
(
Op0
.
getImm
(
)
==
1
)
Op0
.
setImm
(
Align
)
;
}
if
(
is64
)
{
auto
Opc64
=
WebAssembly
::
getWasm64Opcode
(
static_cast
<
uint16_t
>
(
Inst
.
getOpcode
(
)
)
)
;
if
(
Opc64
>=
0
)
{
Inst
.
setOpcode
(
Opc64
)
;
}
}
if
(
!
SkipTypeCheck
&&
TC
.
typeCheck
(
IDLoc
,
Inst
)
)
return
true
;
Out
.
emitInstruction
(
Inst
,
getSTI
(
)
)
;
if
(
CurrentState
==
EndFunction
)
{
onEndOfFunction
(
IDLoc
)
;
}
else
{
CurrentState
=
Instructions
;
}
return
false
;
}
case
Match_MissingFeature
:
{
assert
(
MissingFeatures
.
count
(
)
>
0
&&
"Expected missing features"
)
;
SmallString
<
128
>
Message
;
raw_svector_ostream
OS
(
Message
)
;
OS
<<
"instruction requires:"
;
for
(
unsigned
i
=
0
,
e
=
MissingFeatures
.
size
(
)
;
i
!=
e
;
++
i
)
if
(
MissingFeatures
.
test
(
i
)
)
OS
<<
' '
<<
getSubtargetFeatureName
(
i
)
;
return
Parser
.
Error
(
IDLoc
,
Message
)
;
}
case
Match_MnemonicFail
:
return
Parser
.
Error
(
IDLoc
,
"invalid instruction"
)
;
case
Match_NearMisses
:
return
Parser
.
Error
(
IDLoc
,
"ambiguous instruction"
)
;
case
Match_InvalidTiedOperand
:
case
Match_InvalidOperand
:
{
SMLoc
ErrorLoc
=
IDLoc
;
if
(
ErrorInfo
!=
~
0ULL
)
{
if
(
ErrorInfo
>=
Operands
.
size
(
)
)
return
Parser
.
Error
(
IDLoc
,
"too few operands for instruction"
)
;
ErrorLoc
=
Operands
[
ErrorInfo
]
->
getStartLoc
(
)
;
if
(
ErrorLoc
==
SMLoc
(
)
)
ErrorLoc
=
IDLoc
;
}
return
Parser
.
Error
(
ErrorLoc
,
"invalid operand for instruction"
)
;
}
}
llvm_unreachable
(
"Implement any new match types added!"
)
;
}
</s>

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


<s> void ARMTargetLowering :: computeKnownBitsForTargetNode ( const SDValue Op , KnownBits & Known , const APInt & DemandedElts , const SelectionDAG & DAG , unsigned Depth ) const { unsigned BitWidth = Known . getBitWidth ( ) ; Known . resetAll ( ) ; switch ( Op . getOpcode ( ) ) { default : break ; case ARMISD :: ADDC : case ARMISD :: ADDE : case ARMISD :: SUBC : case ARMISD :: SUBE : if ( Op . getResNo ( ) == 0 ) { SDValue LHS = Op . getOperand ( 0 ) ; SDValue RHS = Op . getOperand ( 1 ) ; if ( Op -> getOpcode ( ) == ARMISD :: ADDE && isNullConstant ( LHS ) && isNullConstant ( RHS ) ) { Known . Zero |= APInt :: getHighBitsSet ( BitWidth , BitWidth - 1 ) ; return ; } } break ; case ARMISD :: CMOV : { Known = DAG . computeKnownBits ( Op . getOperand ( 0 ) , Depth + 1 ) ; if ( Known . isUnknown ( ) ) return ; KnownBits KnownRHS = DAG . computeKnownBits ( Op . getOperand ( 1 ) , Depth + 1 ) ; Known . Zero &= KnownRHS . Zero ; Known . One &= KnownRHS . One ; return ; } case ISD :: INTRINSIC_W_CHAIN : { ConstantSDNode * CN = cast < ConstantSDNode > ( Op -> getOperand ( 1 ) ) ; Intrinsic :: ID IntID = static_cast < Intrinsic :: ID > ( CN -> getZExtValue ( ) ) ; switch ( IntID ) { default : return ; case Intrinsic :: arm_ldaex : case Intrinsic :: arm_ldrex : { EVT VT = cast < MemIntrinsicSDNode > ( Op ) -> getMemoryVT ( ) ; unsigned MemBits = VT . getScalarSizeInBits ( ) ; Known . Zero |= APInt :: getHighBitsSet ( BitWidth , BitWidth - MemBits ) ; return ; } } } case ARMISD :: BFI : { Known = DAG . computeKnownBits ( Op . getOperand ( 0 ) , Depth + 1 ) ; ConstantSDNode * CI = cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; const APInt & Mask = CI -> getAPIntValue ( ) ; Known . Zero &= Mask ; Known . One &= Mask ; return ; } } } </s>

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


<s> TargetLoweringObjectFile * getObjFileLowering ( ) const override { return TLOF . get ( ) ; } </s>

Return information about object file lowering .


<s> LanaiSubtarget & LanaiSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { initSubtargetFeatures ( CPU , FS ) ; return * this ; } </s>

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


<s> static bool rs6000_legitimate_address_p ( machine_mode mode , rtx x , bool reg_ok_strict ) { bool reg_offset_p = reg_offset_addressing_ok_p ( mode ) ; bool quad_offset_p = mode_supports_vsx_dform_quad ( mode ) ; if ( VECTOR_MEM_ALTIVEC_P ( mode ) && GET_CODE ( x ) == AND && GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT && INTVAL ( XEXP ( x , 1 ) ) == - 16 ) x = XEXP ( x , 0 ) ; if ( TARGET_ELF && RS6000_SYMBOL_REF_TLS_P ( x ) ) return 0 ; if ( legitimate_indirect_address_p ( x , reg_ok_strict ) ) return 1 ; if ( TARGET_UPDATE && ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == PRE_DEC ) && mode_supports_pre_incdec_p ( mode ) && legitimate_indirect_address_p ( XEXP ( x , 0 ) , reg_ok_strict ) ) return 1 ; if ( quad_offset_p ) { if ( quad_address_p ( x , mode , reg_ok_strict ) ) return 1 ; } else if ( virtual_stack_registers_memory_p ( x ) ) return 1 ; else if ( reg_offset_p ) { if ( legitimate_small_data_p ( mode , x ) ) return 1 ; if ( legitimate_constant_pool_address_p ( x , mode , reg_ok_strict || lra_in_progress ) ) return 1 ; if ( reg_addr [ mode ] . fused_toc && GET_CODE ( x ) == UNSPEC && XINT ( x , 1 ) == UNSPEC_FUSION_ADDIS ) return 1 ; } if ( mode == TImode && TARGET_VSX ) return 0 ; if ( ! reg_ok_strict && reg_offset_p && GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , 0 ) ) == REG && ( XEXP ( x , 0 ) == virtual_stack_vars_rtx || XEXP ( x , 0 ) == arg_pointer_rtx ) && GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT ) return 1 ; if ( rs6000_legitimate_offset_address_p ( mode , x , reg_ok_strict , false ) ) return 1 ; if ( ! FLOAT128_2REG_P ( mode ) && ( ( TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT ) || TARGET_POWERPC64 || ( mode != DFmode && mode != DDmode ) ) && ( TARGET_POWERPC64 || mode != DImode ) && ( mode != TImode || VECTOR_MEM_VSX_P ( TImode ) ) && mode != PTImode && ! avoiding_indexed_address_p ( mode ) && legitimate_indexed_address_p ( x , reg_ok_strict ) ) return 1 ; if ( TARGET_UPDATE && GET_CODE ( x ) == PRE_MODIFY && mode_supports_pre_modify_p ( mode ) && legitimate_indirect_address_p ( XEXP ( x , 0 ) , reg_ok_strict ) && ( rs6000_legitimate_offset_address_p ( mode , XEXP ( x , 1 ) , reg_ok_strict , false ) || ( ! avoiding_indexed_address_p ( mode ) && legitimate_indexed_address_p ( XEXP ( x , 1 ) , reg_ok_strict ) ) ) && rtx_equal_p ( XEXP ( XEXP ( x , 1 ) , 0 ) , XEXP ( x , 0 ) ) ) return 1 ; if ( reg_offset_p && ! quad_offset_p && legitimate_lo_sum_address_p ( mode , x , reg_ok_strict ) ) return 1 ; return 0 ; } </s>

TARGET_LEGITIMATE_ADDRESS_P recognizes an RTL expression that is a valid memory address for an instruction . The MODE argument is the machine mode for the MEM expression that wants to use this address . On the RS/6000 , there are four valid address : a SYMBOL_REF that refers to a constant pool entry of an address ( or the sum of it plus a constant ) , a short ( 16-bit signed ) constant plus a register , the sum of two registers , or a register indirect , possibly with an auto-increment . For DFmode , DDmode and DImode with a constant plus register , we must ensure that both words are addressable or PowerPC64 with offset word aligned . For modes spanning multiple registers ( DFmode and DDmode in 32-bit GPRs , 32-bit DImode , TImode , TFmode , TDmode ) , indexed addressing can not be used because adjacent memory cells are accessed by adding word-sized offsets during assembly output .


<s> static bool rs6000_function_ok_for_sibcall ( tree decl , tree exp ) { tree fntype ; if ( decl ) fntype = TREE_TYPE ( decl ) ; else fntype = TREE_TYPE ( TREE_TYPE ( CALL_EXPR_FN ( exp ) ) ) ; if ( TARGET_ALTIVEC_ABI && TARGET_ALTIVEC_VRSAVE && ! ( decl && decl == current_function_decl ) ) { function_args_iterator args_iter ; tree type ; int nvreg = 0 ; FOREACH_FUNCTION_ARGS ( fntype , type , args_iter ) if ( TREE_CODE ( type ) == VECTOR_TYPE && ALTIVEC_OR_VSX_VECTOR_MODE ( TYPE_MODE ( type ) ) ) nvreg ++ ; FOREACH_FUNCTION_ARGS ( TREE_TYPE ( current_function_decl ) , type , args_iter ) if ( TREE_CODE ( type ) == VECTOR_TYPE && ALTIVEC_OR_VSX_VECTOR_MODE ( TYPE_MODE ( type ) ) ) nvreg -- ; if ( nvreg > 0 ) return false ; } if ( DEFAULT_ABI == ABI_DARWIN || ( ( DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_ELFv2 ) && decl && ! DECL_EXTERNAL ( decl ) && ! DECL_WEAK ( decl ) && ( * targetm . binds_local_p ) ( decl ) ) || ( DEFAULT_ABI == ABI_V4 && ( ! TARGET_SECURE_PLT || ! flag_pic || ( decl && ( * targetm . binds_local_p ) ( decl ) ) ) ) ) { tree attr_list = TYPE_ATTRIBUTES ( fntype ) ; if ( ! lookup_attribute ( "longcall" , attr_list ) || lookup_attribute ( "shortcall" , attr_list ) ) return true ; } return false ; } </s>

Say whether a function is a candidate for sibcall handling or not . We do not allow indirect calls to be optimized into sibling calls . Also , we ca n't do it if there are any vector parameters ; there 's nowhere to put the VRsave code so it works ; note that functions with vector parameters are required to have a prototype , so the argument type info must be available here . ( The tail recursion case can work with vector parameters , but there 's no way to distinguish here . )


<s> unsigned ARMTargetLowering :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { switch ( RC -> getID ( ) ) { default : return 0 ; case ARM :: tGPRRegClassID : return RegInfo -> hasFP ( MF ) ? 4 : 5 ; case ARM :: GPRRegClassID : { unsigned FP = RegInfo -> hasFP ( MF ) ? 1 : 0 ; return 10 - FP - ( Subtarget -> isR9Reserved ( ) ? 1 : 0 ) ; } case ARM :: SPRRegClassID : case ARM :: DPRRegClassID : return 32 - 10 ; } } </s>

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


<s> DecodeStatus MMIXDisassembler :: getInstruction ( MCInst & MI , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & OS , raw_ostream & CS ) const { Size = 4 ; if ( Bytes . size ( ) < 4 ) { Size = 0 ; return MCDisassembler :: Fail ; } uint32_t Inst = support :: endian :: read32be ( Bytes . data ( ) ) ; return decodeInstruction ( DecoderTableMMIX32 , MI , Inst , Address , this , STI ) ; } </s>

Returns the disassembly of a single instruction .


<s> bool X86TargetMachine :: addPreRegAlloc ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { return false ; } </s>

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


<s> static int ix86_fp_comparison_cost ( enum rtx_code code ) { int arith_cost ; switch ( code ) { case UNLE : case UNLT : case LTGT : case GT : case GE : case UNORDERED : case ORDERED : case UNEQ : arith_cost = 4 ; break ; case LT : case NE : case EQ : case UNGE : arith_cost = TARGET_IEEE_FP ? 5 : 4 ; break ; case LE : case UNGT : arith_cost = TARGET_IEEE_FP ? 6 : 4 ; break ; default : gcc_unreachable ( ) ; } switch ( ix86_fp_comparison_strategy ( code ) ) { case IX86_FPCMP_COMI : return arith_cost > 4 ? 3 : 2 ; case IX86_FPCMP_SAHF : return arith_cost > 4 ? 4 : 3 ; default : return arith_cost ; } } </s>

Compute cost of the comparison done using any method . See ix86_fp_comparison_arithmetics_cost for the metrics .


<s> int fp_zero_operand ( rtx op ) { REAL_VALUE_TYPE r ; if ( GET_MODE ( op ) != SFmode ) return 0 ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; return REAL_VALUES_EQUAL ( r , dconst0 ) && ! REAL_VALUE_MINUS_ZERO ( r ) ; } </s>

Returns true if OP is a floating point value with value 0.0 .


"Can't return value from vararg function in memory"

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


"FP elimination on a non-leaf function is not supported"


<s>
const
RegisterBankInfo
*
X86Subtarget
::
getRegBankInfo
(
)
const
{
assert
(
GISel
&&
"Access to GlobalISel APIs not set"
)
;
return
GISel
->
getRegBankInfo
(
)
;
}
</s>

If the information for the register banks is available , return it .


<s> void AArch64TTIImpl :: getUnrollingPreferences ( Loop * L , ScalarEvolution & SE , TTI :: UnrollingPreferences & UP , OptimizationRemarkEmitter * ORE ) { BaseT :: getUnrollingPreferences ( L , SE , UP , ORE ) ; UP . UpperBound = true ; if ( L -> getLoopDepth ( ) > 1 ) UP . PartialThreshold *= 2 ; UP . PartialOptSizeThreshold = 0 ; if ( ST -> getProcFamily ( ) == AArch64Subtarget :: Falkor && EnableFalkorHWPFUnrollFix ) getFalkorUnrollingPreferences ( L , SE , UP ) ; for ( auto * BB : L -> getBlocks ( ) ) { for ( auto & I : * BB ) { if ( I . getType ( ) -> isVectorTy ( ) ) return ; if ( isa < CallInst > ( I ) || isa < InvokeInst > ( I ) ) { if ( const Function * F = cast < CallBase > ( I ) . getCalledFunction ( ) ) { if ( ! isLoweredToCall ( F ) ) continue ; } return ; } } } if ( ST -> getProcFamily ( ) != AArch64Subtarget :: Others && ! ST -> getSchedModel ( ) . isOutOfOrder ( ) ) { UP . Runtime = true ; UP . Partial = true ; UP . UnrollRemainder = true ; UP . DefaultUnrollRuntimeCount = 4 ; UP . UnrollAndJam = true ; UP . UnrollAndJamInnerLoopThreshold = 60 ; } } </s>

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


<s> static bool unspec_caller_rtx_p ( rtx pat ) { switch ( GET_CODE ( pat ) ) { case CONST : return unspec_caller_rtx_p ( XEXP ( pat , 0 ) ) ; case PLUS : case MINUS : if ( unspec_caller_rtx_p ( XEXP ( pat , 0 ) ) ) return true ; return unspec_caller_rtx_p ( XEXP ( pat , 1 ) ) ; case UNSPEC : if ( XINT ( pat , 1 ) == UNSPEC_CALLER ) return true ; default : break ; } return false ; } </s>

Check if PAT includes UNSPEC_CALLER unspec pattern .


<s>
const
char
*
aarch64_output_probe_stack_range
(
rtx
reg1
,
rtx
reg2
)
{
static
int
labelno
=
0
;
char
loop_lab
[
32
]
;
rtx
xops
[
2
]
;
ASM_GENERATE_INTERNAL_LABEL
(
loop_lab
,
"LPSRL"
,
labelno
++
)
;
ASM_OUTPUT_INTERNAL_LABEL
(
asm_out_file
,
loop_lab
)
;
xops
[
0
]
=
reg1
;
xops
[
1
]
=
GEN_INT
(
PROBE_INTERVAL
)
;
output_asm_insn
(
"sub\t%0, %0, %1"
,
xops
)
;
output_asm_insn
(
"str\txzr, [%0]"
,
xops
)
;
xops
[
1
]
=
reg2
;
output_asm_insn
(
"cmp\t%0, %1"
,
xops
)
;
fputs
(
"\tb.ne\t"
,
asm_out_file
)
;
assemble_name_raw
(
asm_out_file
,
loop_lab
)
;
fputc
(
'\n'
,
asm_out_file
)
;
return
""
;
}
</s>

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


<s> int iq2000_reg_mode_ok_for_base_p ( rtx reg , machine_mode mode ATTRIBUTE_UNUSED , int strict ) { return ( strict ? REGNO_MODE_OK_FOR_BASE_P ( REGNO ( reg ) , mode ) : GP_REG_OR_PSEUDO_NONSTRICT_P ( REGNO ( reg ) , mode ) ) ; } </s>

Return nonzero if REG is valid for MODE .


<s> void ARMPassConfig :: addPreSched2 ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) { if ( EnableARMLoadStoreOpt ) addPass ( createARMLoadStoreOptimizationPass ( ) ) ; addPass ( new ARMExecutionDomainFix ( ) ) ; addPass ( createBreakFalseDeps ( ) ) ; } addPass ( createARMExpandPseudoPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createThumb2SizeReductionPass ( [ this ] ( const Function & F ) { return this -> TM -> getSubtarget < ARMSubtarget > ( F ) . restrictIT ( ) ; } ) ) ; addPass ( createIfConverter ( [ ] ( const MachineFunction & MF ) { return ! MF . getSubtarget < ARMSubtarget > ( ) . isThumb1Only ( ) ; } ) ) ; } addPass ( createMVEVPTBlockPass ( ) ) ; addPass ( createThumb2ITBlockPass ( ) ) ; } </s>

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


<s> static int avr_regs_to_save ( HARD_REG_SET * set ) { int reg , count ; int int_or_sig_p = cfun -> machine -> is_interrupt || cfun -> machine -> is_signal ; if ( set ) CLEAR_HARD_REG_SET ( * set ) ; count = 0 ; if ( TREE_THIS_VOLATILE ( current_function_decl ) || cfun -> machine -> is_OS_task || cfun -> machine -> is_OS_main ) return 0 ; for ( reg = 0 ; reg < 32 ; reg ++ ) { if ( fixed_regs [ reg ] ) continue ; if ( ( int_or_sig_p && ! crtl -> is_leaf && call_used_regs [ reg ] ) || ( df_regs_ever_live_p ( reg ) && ( int_or_sig_p || ! call_used_regs [ reg ] ) && ! ( frame_pointer_needed && ( reg == REG_Y || reg == ( REG_Y + 1 ) ) ) ) ) { if ( set ) SET_HARD_REG_BIT ( * set , reg ) ; count ++ ; } } return count ; } </s>

Return the number of hard registers to push/pop in the prologue/epilogue of the current function , and optionally store these registers in SET .


<s> void AMDGPUTTI :: getUnrollingPreferences ( Loop * L , UnrollingPreferences & UP ) const { UP . Threshold = 300 ; UP . Count = UINT_MAX ; UP . Partial = true ; for ( const BasicBlock * BB : L -> getBlocks ( ) ) { for ( const Instruction & I : * BB ) { const GetElementPtrInst * GEP = dyn_cast < GetElementPtrInst > ( & I ) ; if ( ! GEP || GEP -> getAddressSpace ( ) != AMDGPUAS :: PRIVATE_ADDRESS ) continue ; const Value * Ptr = GEP -> getPointerOperand ( ) ; const AllocaInst * Alloca = dyn_cast < AllocaInst > ( GetUnderlyingObject ( Ptr ) ) ; if ( Alloca ) { UP . Threshold = 800 ; } } } } </s>


<s> static int riscv_binary_cost ( rtx x , int single_insns , int double_insns ) { if ( ! riscv_v_ext_vector_mode_p ( GET_MODE ( x ) ) && GET_MODE_SIZE ( GET_MODE ( x ) ) . to_constant ( ) == UNITS_PER_WORD * 2 ) return COSTS_N_INSNS ( double_insns ) ; return COSTS_N_INSNS ( single_insns ) ; } </s>

Return the cost of binary operation X , given that the instruction sequence for a word-sized or smaller operation takes SIGNLE_INSNS instructions and that the sequence of a double-word operation takes DOUBLE_INSNS instructions .


<s> MCObjectWriter * createObjectWriter ( raw_ostream & OS ) const override { return createAArch64ELFObjectWriter ( OS , OSABI , IsLittleEndian ) ; } </s>

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


<s> const TargetRegisterClass * X86RegisterInfo :: getGPRsForTailCall ( const MachineFunction & MF ) const { const Function * F = MF . getFunction ( ) ; if ( IsWin64 || ( F && F -> getCallingConv ( ) == CallingConv :: X86_64_Win64 ) ) return & X86 :: GR64_TCW64RegClass ; else if ( Is64Bit ) return & X86 :: GR64_TCRegClass ; bool hasHipeCC = ( F ? F -> getCallingConv ( ) == CallingConv :: HiPE : false ) ; if ( hasHipeCC ) return & X86 :: GR32RegClass ; return & X86 :: GR32_TCRegClass ; } </s>

getGPRsForTailCall - Returns a register class with registers that can be used in forming tail calls .


<s> static bool mips_valid_offset_p ( rtx x , machine_mode mode ) { if ( ! const_arith_operand ( x , Pmode ) ) return false ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && ! SMALL_OPERAND ( INTVAL ( x ) + GET_MODE_SIZE ( mode ) - UNITS_PER_WORD ) ) return false ; return true ; } </s>

Return true if , for every base register BASE_REG , ( plus BASE_REG X ) can address a value of mode MODE .


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

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


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { GlobalBaseReg = 0 ; PPCLowering = TM . getSubtargetImpl ( ) -> getTargetLowering ( ) ; PPCSubTarget = TM . getSubtargetImpl ( ) ; SelectionDAGISel :: runOnMachineFunction ( MF ) ; if ( ! PPCSubTarget -> isSVR4ABI ( ) ) InsertVRSaveCode ( MF ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool ARMTargetLowering :: shouldExpandAtomicCmpXchgInIR ( AtomicCmpXchgInst * AI ) const { return true ; } </s>

Returns how the given atomic cmpxchg should be expanded by the IR-level AtomicExpand pass .


<s> bool movd44_even_dep_p ( rtx_insn * insn , rtx def_reg ) { if ( ! movd44_insn_p ( insn ) ) return false ; rtx use_rtx = SET_SRC ( PATTERN ( insn ) ) ; if ( REG_P ( def_reg ) ) { return rtx_equal_p ( def_reg , use_rtx ) ; } else if ( GET_CODE ( def_reg ) == SUBREG && GET_MODE ( def_reg ) == SImode && rtx_equal_p ( SUBREG_REG ( def_reg ) , use_rtx ) ) { if ( TARGET_BIG_ENDIAN && SUBREG_BYTE ( def_reg ) == 4 ) return true ; if ( ! TARGET_BIG_ENDIAN && SUBREG_BYTE ( def_reg ) == 0 ) return true ; return false ; } return false ; } </s>

Check if INSN is a movd44 insn consuming DEF_REG .


<s> static bool mips16_unextended_reference_p ( machine_mode mode , rtx base , unsigned HOST_WIDE_INT offset ) { if ( mode != BLKmode && offset % GET_MODE_SIZE ( mode ) == 0 ) { if ( GET_MODE_SIZE ( mode ) == 4 && base == stack_pointer_rtx ) return offset < 256U * GET_MODE_SIZE ( mode ) ; return offset < 32U * GET_MODE_SIZE ( mode ) ; } return false ; } </s>

Return true if a value at OFFSET bytes from BASE can be accessed using an unextended mips16 instruction . MODE is the mode of the value . Usually the offset in an unextended instruction is a 5-bit field . The offset is unsigned and shifted left once for HIs , twice for SIs , and so on . An exception is SImode accesses off the stack pointer , which have an 8-bit immediate field .


<s> static int res_mii ( unit_req_table reqs ) { int side , req ; int worst = 1 ; for ( side = 0 ; side < 2 ; side ++ ) for ( req = 0 ; req < UNIT_REQ_MAX ; req ++ ) { int factor = unit_req_factor ( ( enum unitreqs ) req ) ; worst = MAX ( ( reqs [ side ] [ UNIT_REQ_D ] + factor - 1 ) / factor , worst ) ; } return worst ; } </s>

Return the resource-constrained minimum iteration interval given the data in the REQS table . This must have been processed with merge_unit_reqs already .


<s> bool restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , MutableArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const override { return true ; } </s>

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


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

targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack frame ( probably at emitPrologue time ) .


<s> void update ( Register R , const LatticeCell & L ) { Map [ R ] = L ; } </s>


<s>
bool
OR1KAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
{
Operands
.
push_back
(
OR1KOperand
::
CreateToken
(
Name
,
NameLoc
)
)
;
if
(
getLexer
(
)
.
is
(
AsmToken
::
EndOfStatement
)
)
return
false
;
if
(
ParseOperand
(
Operands
)
)
return
true
;
while
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
&&
getLexer
(
)
.
is
(
AsmToken
::
Comma
)
)
{
getLexer
(
)
.
Lex
(
)
;
if
(
ParseOperand
(
Operands
)
)
return
true
;
}
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
return
Error
(
getLexer
(
)
.
getTok
(
)
.
getLoc
(
)
,
"unexpected token in operand list"
)
;
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .


"Can only insert epilog into returning blocks"


<s> int aarch64_partial_ptrue_length ( rtx_vector_builder & builder , unsigned int elt_size ) { if ( builder . nelts_per_pattern ( ) == 3 ) return 0 ; unsigned int nelts = builder . encoded_nelts ( ) ; unsigned int i = 0 ; for ( ; i < nelts ; i += elt_size ) if ( INTVAL ( builder . elt ( i ) ) == 0 ) break ; unsigned int vl = i / elt_size ; if ( i == nelts ) return - 1 ; if ( builder . nelts_per_pattern ( ) != 2 ) return 0 ; if ( i > builder . npatterns ( ) && maybe_ne ( nelts , builder . full_nelts ( ) ) ) return 0 ; for ( ; i < nelts ; i += elt_size ) if ( INTVAL ( builder . elt ( i ) ) != 0 ) return 0 ; return vl ; } </s>

BUILDER is a predicate constant of mode VNx16BI . Consider the value that the constant would have with predicate element size ELT_SIZE ( ignoring the upper bits in each element ) and return : * -1 if all bits are set * N if the predicate has N leading set bits followed by all clear bits * 0 if the predicate does not have any of these forms .


<s> LLT AArch64TargetLowering :: getOptimalMemOpLLT ( const MemOp & Op , const AttributeList & FuncAttributes ) const { bool CanImplicitFloat = ! FuncAttributes . hasFnAttribute ( Attribute :: NoImplicitFloat ) ; bool CanUseNEON = Subtarget -> hasNEON ( ) && CanImplicitFloat ; bool CanUseFP = Subtarget -> hasFPARMv8 ( ) && CanImplicitFloat ; bool IsSmallMemset = Op . isMemset ( ) && Op . size ( ) < 32 ; auto AlignmentIsAcceptable = [ & ] ( EVT VT , Align AlignCheck ) { if ( Op . isAligned ( AlignCheck ) ) return true ; bool Fast ; return allowsMisalignedMemoryAccesses ( VT , 0 , 1 , MachineMemOperand :: MONone , & Fast ) && Fast ; } ; if ( CanUseNEON && Op . isMemset ( ) && ! IsSmallMemset && AlignmentIsAcceptable ( MVT :: v2i64 , Align ( 16 ) ) ) return LLT :: vector ( 2 , 64 ) ; if ( CanUseFP && ! IsSmallMemset && AlignmentIsAcceptable ( MVT :: f128 , Align ( 16 ) ) ) return LLT :: scalar ( 128 ) ; if ( Op . size ( ) >= 8 && AlignmentIsAcceptable ( MVT :: i64 , Align ( 8 ) ) ) return LLT :: scalar ( 64 ) ; if ( Op . size ( ) >= 4 && AlignmentIsAcceptable ( MVT :: i32 , Align ( 4 ) ) ) return LLT :: scalar ( 32 ) ; return LLT ( ) ; } </s>


<s> rtx legitimize_pic_address ( rtx orig , enum machine_mode mode ATTRIBUTE_UNUSED , rtx reg ) { if ( tls_symbolic_operand ( orig , Pmode ) ) return orig ; if ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_LOCAL_P ( orig ) ) ) { if ( reg == 0 ) reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_symGOTOFF2reg ( reg , orig ) ) ; return reg ; } else if ( GET_CODE ( orig ) == SYMBOL_REF ) { if ( reg == 0 ) reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_symGOT2reg ( reg , orig ) ) ; return reg ; } return orig ; } </s>

Legitimize PIC addresses . If the address is already position-independent , we return ORIG . Newly generated position-independent addresses go into a reg . This is REG if nonzero , otherwise we allocate register ( s ) as necessary .


<s> bool X86FrameLowering :: assignCalleeSavedSpillSlots ( MachineFunction & MF , const TargetRegisterInfo * TRI , std :: vector < CalleeSavedInfo > & CSI ) const { MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; X86MachineFunctionInfo * X86FI = MF . getInfo < X86MachineFunctionInfo > ( ) ; unsigned CalleeSavedFrameSize = 0 ; int SpillSlotOffset = getOffsetOfLocalArea ( ) + X86FI -> getTCReturnAddrDelta ( ) ; if ( hasFP ( MF ) ) { SpillSlotOffset -= SlotSize ; MFI . CreateFixedSpillStackObject ( SlotSize , SpillSlotOffset ) ; unsigned FPReg = TRI -> getFrameRegister ( MF ) ; for ( unsigned i = 0 ; i < CSI . size ( ) ; ++ i ) { if ( TRI -> regsOverlap ( CSI [ i ] . getReg ( ) , FPReg ) ) { CSI . erase ( CSI . begin ( ) + i ) ; break ; } } } for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; if ( ! X86 :: GR64RegClass . contains ( Reg ) && ! X86 :: GR32RegClass . contains ( Reg ) ) continue ; SpillSlotOffset -= SlotSize ; CalleeSavedFrameSize += SlotSize ; int SlotIndex = MFI . CreateFixedSpillStackObject ( SlotSize , SpillSlotOffset ) ; CSI [ i - 1 ] . setFrameIdx ( SlotIndex ) ; } X86FI -> setCalleeSavedFrameSize ( CalleeSavedFrameSize ) ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; if ( X86 :: GR64RegClass . contains ( Reg ) || X86 :: GR32RegClass . contains ( Reg ) ) continue ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; SpillSlotOffset -= std :: abs ( SpillSlotOffset ) % RC -> getAlignment ( ) ; SpillSlotOffset -= RC -> getSize ( ) ; int SlotIndex = MFI . CreateFixedSpillStackObject ( RC -> getSize ( ) , SpillSlotOffset ) ; CSI [ i - 1 ] . setFrameIdx ( SlotIndex ) ; MFI . ensureMaxAlignment ( RC -> getAlignment ( ) ) ; } return true ; } </s>

This function will assign callee saved gprs to volatile vector registers for prologue spills when applicable .


<s> bool HexagonTargetLowering :: getTgtMemIntrinsic ( IntrinsicInfo & Info , const CallInst & I , MachineFunction & MF , unsigned Intrinsic ) const { switch ( Intrinsic ) { case Intrinsic :: hexagon_L2_loadrd_pbr : case Intrinsic :: hexagon_L2_loadri_pbr : case Intrinsic :: hexagon_L2_loadrh_pbr : case Intrinsic :: hexagon_L2_loadruh_pbr : case Intrinsic :: hexagon_L2_loadrb_pbr : case Intrinsic :: hexagon_L2_loadrub_pbr : { Info . opc = ISD :: INTRINSIC_W_CHAIN ; auto & DL = I . getCalledFunction ( ) -> getParent ( ) -> getDataLayout ( ) ; auto & Cont = I . getCalledFunction ( ) -> getParent ( ) -> getContext ( ) ; PointerType * PtrTy = I . getCalledFunction ( ) -> getReturnType ( ) -> getContainedType ( 0 ) -> getPointerTo ( ) ; Info . memVT = MVT :: getVT ( PtrTy -> getElementType ( ) ) ; llvm :: Value * BasePtrVal = I . getOperand ( 0 ) ; Info . ptrVal = getUnderLyingObjectForBrevLdIntr ( BasePtrVal ) ; Info . offset = 0 ; Info . align = DL . getABITypeAlignment ( Info . memVT . getTypeForEVT ( Cont ) ) ; Info . flags = MachineMemOperand :: MOLoad ; return true ; } case Intrinsic :: hexagon_V6_vgathermw : case Intrinsic :: hexagon_V6_vgathermw_128B : case Intrinsic :: hexagon_V6_vgathermh : case Intrinsic :: hexagon_V6_vgathermh_128B : case Intrinsic :: hexagon_V6_vgathermhw : case Intrinsic :: hexagon_V6_vgathermhw_128B : case Intrinsic :: hexagon_V6_vgathermwq : case Intrinsic :: hexagon_V6_vgathermwq_128B : case Intrinsic :: hexagon_V6_vgathermhq : case Intrinsic :: hexagon_V6_vgathermhq_128B : case Intrinsic :: hexagon_V6_vgathermhwq : case Intrinsic :: hexagon_V6_vgathermhwq_128B : { const Module & M = * I . getParent ( ) -> getParent ( ) -> getParent ( ) ; Info . opc = ISD :: INTRINSIC_W_CHAIN ; Type * VecTy = I . getArgOperand ( 1 ) -> getType ( ) ; Info . memVT = MVT :: getVT ( VecTy ) ; Info . ptrVal = I . getArgOperand ( 0 ) ; Info . offset = 0 ; Info . align = M . getDataLayout ( ) . getTypeAllocSizeInBits ( VecTy ) / 8 ; Info . flags = MachineMemOperand :: MOLoad | MachineMemOperand :: MOStore | MachineMemOperand :: MOVolatile ; return true ; } default : break ; } return false ; } </s>

Given an intrinsic , checks if on the target the intrinsic will need to map to a MemIntrinsicNode ( touches memory ) .


<s> std :: pair < uint16_t , uint16_t > ARMBaseInstrInfo :: getExecutionDomain ( const MachineInstr * MI ) const { if ( MI -> getOpcode ( ) == ARM :: VMOVD && ! isPredicated ( MI ) ) return std :: make_pair ( ExeVFP , ( 1 << ExeVFP ) | ( 1 << ExeNEON ) ) ; if ( Subtarget . isLikeA9 ( ) && ! isPredicated ( MI ) && ( MI -> getOpcode ( ) == ARM :: VMOVRS || MI -> getOpcode ( ) == ARM :: VMOVSR || MI -> getOpcode ( ) == ARM :: VMOVS ) ) return std :: make_pair ( ExeVFP , ( 1 << ExeVFP ) | ( 1 << ExeNEON ) ) ; unsigned Domain = MI -> getDesc ( ) . TSFlags & ARMII :: DomainMask ; if ( Domain & ARMII :: DomainNEON ) return std :: make_pair ( ExeNEON , 0 ) ; if ( ( Domain & ARMII :: DomainNEONA8 ) && Subtarget . isCortexA8 ( ) ) return std :: make_pair ( ExeNEON , 0 ) ; if ( Domain & ARMII :: DomainVFP ) return std :: make_pair ( ExeVFP , 0 ) ; return std :: make_pair ( ExeGeneric , 0 ) ; } </s>

Return the current execution domain and bit mask of possible domains for instruction .


<s>
void
AVRInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
DebugLoc
&
DL
,
MCRegister
DestReg
,
MCRegister
SrcReg
,
bool
KillSrc
)
const
{
const
AVRSubtarget
&
STI
=
MBB
.
getParent
(
)
->
getSubtarget
<
AVRSubtarget
>
(
)
;
const
AVRRegisterInfo
&
TRI
=
*
STI
.
getRegisterInfo
(
)
;
unsigned
Opc
;
if
(
AVR
::
DREGSRegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
if
(
STI
.
hasMOVW
(
)
&&
AVR
::
DREGSMOVWRegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
AVR
::
MOVWRdRr
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
{
Register
DestLo
,
DestHi
,
SrcLo
,
SrcHi
;
TRI
.
splitReg
(
DestReg
,
DestLo
,
DestHi
)
;
TRI
.
splitReg
(
SrcReg
,
SrcLo
,
SrcHi
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
AVR
::
MOVRdRr
)
,
DestLo
)
.
addReg
(
SrcLo
,
getKillRegState
(
KillSrc
)
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
AVR
::
MOVRdRr
)
,
DestHi
)
.
addReg
(
SrcHi
,
getKillRegState
(
KillSrc
)
)
;
}
}
else
{
if
(
AVR
::
GPR8RegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
Opc
=
AVR
::
MOVRdRr
;
}
else
if
(
SrcReg
==
AVR
::
SP
&&
AVR
::
DREGSRegClass
.
contains
(
DestReg
)
)
{
Opc
=
AVR
::
SPREAD
;
}
else
if
(
DestReg
==
AVR
::
SP
&&
AVR
::
DREGSRegClass
.
contains
(
SrcReg
)
)
{
Opc
=
AVR
::
SPWRITE
;
}
else
{
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
}
</s>

AVR
AVR
AVR
AVR
AVR
AVR::DREGSRegClass
AVR::DREGSMOVWRegClass
AVR::MOVWRdRr
AVR::MOVRdRr
AVR::MOVRdRr
AVR::GPR8RegClass
AVR::MOVRdRr
AVR::SP
AVR::DREGSRegClass
AVR::SPREAD
AVR::SP
AVR::DREGSRegClass
AVR::SPWRITE
"Impossible reg-to-reg copy"


<s> const WebAssemblySubtarget * WebAssemblyTargetMachine :: getSubtargetImpl ( std :: string CPU , std :: string FS ) const { auto & I = SubtargetMap [ CPU + FS ] ; if ( ! I ) { I = llvm :: make_unique < WebAssemblySubtarget > ( TargetTriple , CPU , FS , * this ) ; } return I . get ( ) ; } </s>

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

WebAssembly WebAssembly WebAssembly WebAssembly


<s> bool isMem ( ) const { return Kind == Memory ; } </s>


"Expected a reg or frame index operand."

Return true if this is a load/store that can be potentially paired/merged .


<s> SDValue rvexTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { SelectionDAG & DAG = DCI . DAG ; unsigned opc = N -> getOpcode ( ) ; switch ( opc ) { default : break ; case ISD :: SDIVREM : case ISD :: UDIVREM : return PerformDivRemCombine ( N , DAG , DCI , Subtarget ) ; } return SDValue ( ) ; } </s>

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


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"ARCompact Assembly Printer"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> unsigned getBaseReg ( ) { return BaseReg ; } </s>

Get the base register of the pointer value .


<s> static bool check_required_extensions ( location_t location , tree fndecl , aarch64_feature_flags required_extensions ) { auto missing_extensions = required_extensions & ~ aarch64_asm_isa_flags ; if ( missing_extensions == 0 ) return check_required_registers ( location , fndecl ) ; static const struct { aarch64_feature_flags flag ; const char * name ; } extensions [ ] = { { AARCH64_FL_ ## IDENT , EXT_NAME } , } ; for ( unsigned int i = 0 ; i < ARRAY_SIZE ( extensions ) ; ++ i ) if ( missing_extensions & extensions [ i ] . flag ) { report_missing_extension ( location , fndecl , extensions [ i ] . name ) ; return false ; } gcc_unreachable ( ) ; } </s>

Check whether all the RVV_REQUIRE_ * values in REQUIRED_EXTENSIONS are enabled .


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"Mips Machine Code Emitter"
;
}
</s>


<s> bool HexagonTargetLowering :: isOffsetFoldingLegal ( const GlobalAddressSDNode * GA ) const { return HTM . getRelocationModel ( ) == Reloc :: Static ; } </s>

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


"Offset must be aligned to 4 bytes because memory is "

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


<s> unsigned X86FrameLowering :: getWinEHParentFrameOffset ( const MachineFunction & MF ) const { unsigned Offset = 16 ; Offset += SlotSize ; Offset += MF . getInfo < X86MachineFunctionInfo > ( ) -> getCalleeSavedFrameSize ( ) ; Offset += getWinEHFuncletFrameSize ( MF ) ; return Offset ; } </s>

The parent frame offset ( aka dispFrame ) is only used on X86_64 to retrieve the parent 's frame pointer .


<s> void gas_output_ascii ( FILE * file , const char * str , size_t length ) { const unsigned char * _ascii_bytes = ( const unsigned char * ) str ; const unsigned char * limit = _ascii_bytes + length ; unsigned bytes_in_chunk = 0 ; for ( ; _ascii_bytes < limit ; _ascii_bytes ++ ) { const unsigned char * p ; if ( bytes_in_chunk >= 60 ) { fprintf ( file , "\"\n" ) ; bytes_in_chunk = 0 ; } for ( p = _ascii_bytes ; p < limit && * p != '\0' ; p ++ ) continue ; if ( p < limit && ( p - _ascii_bytes ) <= ( signed ) STRING_LIMIT ) { if ( bytes_in_chunk > 0 ) { fprintf ( file , "\"\n" ) ; bytes_in_chunk = 0 ; } gas_output_limited_string ( file , ( char * ) _ascii_bytes ) ; _ascii_bytes = p ; } else { int escape ; unsigned ch ; if ( bytes_in_chunk == 0 ) fprintf ( file , "\t.ascii\t\"" ) ; switch ( escape = ESCAPES [ ch = * _ascii_bytes ] ) { case 0 : putc ( ch , file ) ; bytes_in_chunk ++ ; break ; case 1 : fprintf ( file , "\\%03o" , ch ) ; bytes_in_chunk += 4 ; break ; default : putc ( '\\' , file ) ; putc ( escape , file ) ; bytes_in_chunk += 2 ; break ; } } } if ( bytes_in_chunk > 0 ) fprintf ( file , "\"\n" ) ; } </s>

The routine used to output sequences of byte values . We use a special version of this for most svr4 targets because doing so makes the generated assembly code more compact ( and thus faster to assemble ) as well as more readable . Note that if we find subparts of the character sequence which end with NUL ( and which are shorter than STRING_LIMIT ) we output those using ASM_OUTPUT_LIMITED_STRING .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


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


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

AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU R600 AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU


<s> static int ix86_mode_needed ( int entity , rtx_insn * insn ) { switch ( entity ) { case X86_DIRFLAG : return ix86_dirflag_mode_needed ( insn ) ; case AVX_U128 : return ix86_avx_u128_mode_needed ( insn ) ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL : return ix86_i387_mode_needed ( entity , insn ) ; default : gcc_unreachable ( ) ; } return 0 ; } </s>

Return needed mode for entity in optimize_mode_switching pass .


<s> bool GCNPassConfig :: addPreISel ( ) { AMDGPUPassConfig :: addPreISel ( ) ; addPass ( createAMDGPULateCodeGenPreparePass ( ) ) ; if ( EnableAtomicOptimizations ) { addPass ( createAMDGPUAtomicOptimizerPass ( ) ) ; } addPass ( createSinkingPass ( ) ) ; addPass ( & AMDGPUUnifyDivergentExitNodesID ) ; if ( ! LateCFGStructurize ) { if ( EnableStructurizerWorkarounds ) { addPass ( createFixIrreduciblePass ( ) ) ; addPass ( createUnifyLoopExitsPass ( ) ) ; } addPass ( createStructurizeCFGPass ( false ) ) ; } addPass ( createAMDGPUAnnotateUniformValues ( ) ) ; if ( ! LateCFGStructurize ) { addPass ( createSIAnnotateControlFlowPass ( ) ) ; } addPass ( createLCSSAPass ( ) ) ; return false ; } </s>

AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU AMDGPU SI


<s> void ix86_expand_fp_absneg_operator ( enum rtx_code code , enum machine_mode mode , rtx operands [ ] ) { rtx mask , set , use , clob , dst , src ; bool matching_memory ; bool use_sse = false ; bool vector_mode = VECTOR_MODE_P ( mode ) ; enum machine_mode elt_mode = mode ; if ( vector_mode ) { elt_mode = GET_MODE_INNER ( mode ) ; use_sse = true ; } else if ( TARGET_SSE_MATH ) use_sse = SSE_FLOAT_MODE_P ( mode ) ; if ( use_sse ) mask = ix86_build_signbit_mask ( elt_mode , vector_mode , code == ABS ) ; else { mask = const0_rtx ; } dst = operands [ 0 ] ; src = operands [ 1 ] ; matching_memory = false ; if ( MEM_P ( dst ) ) { if ( rtx_equal_p ( dst , src ) ) matching_memory = true ; else dst = gen_reg_rtx ( mode ) ; } if ( MEM_P ( src ) && ! matching_memory ) src = force_reg ( mode , src ) ; if ( vector_mode ) { set = gen_rtx_fmt_ee ( code == NEG ? XOR : AND , mode , src , mask ) ; set = gen_rtx_SET ( VOIDmode , dst , set ) ; emit_insn ( set ) ; } else { set = gen_rtx_fmt_e ( code , mode , src ) ; set = gen_rtx_SET ( VOIDmode , dst , set ) ; use = gen_rtx_USE ( VOIDmode , mask ) ; clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 3 , set , use , clob ) ) ) ; } if ( dst != operands [ 0 ] ) emit_move_insn ( operands [ 0 ] , dst ) ; } </s>

Generate code for floating point ABS or NEG .


<s> static machine_mode mips_preferred_simd_mode ( scalar_mode mode ) { if ( TARGET_PAIRED_SINGLE_FLOAT && mode == SFmode ) return V2SFmode ; if ( ! ISA_HAS_MSA ) return word_mode ; switch ( mode ) { case E_QImode : return V16QImode ; case E_HImode : return V8HImode ; case E_SImode : return V4SImode ; case E_DImode : return V2DImode ; case E_SFmode : return V4SFmode ; case E_DFmode : return V2DFmode ; default : break ; } return word_mode ; } </s>


<s> static bool pru_assemble_integer ( rtx x , unsigned int size , int aligned_p ) { if ( size == POINTER_SIZE / BITS_PER_UNIT && aligned_p && text_segment_operand ( x , VOIDmode ) ) { fputs ( "\t.4byte\t%pmem(" , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( ")\n" , asm_out_file ) ; return true ; } else if ( size == INIT_ARRAY_ENTRY_BYTES && aligned_p && text_segment_operand ( x , VOIDmode ) ) { fputs ( "\t.2byte\t%pmem(" , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( ")\n" , asm_out_file ) ; return true ; } else { return default_assemble_integer ( x , size , aligned_p ) ; } } </s>

Implement ` TARGET_ASM_INTEGER ' . Target hook for assembling integer objects . PRU version needs special handling for references to pmem . Code copied from AVR .


<s> bool X86CallLowering :: lowerFormalArguments ( MachineIRBuilder & MIRBuilder , const Function & F , ArrayRef < unsigned > VRegs ) const { if ( F . arg_empty ( ) ) return true ; if ( F . isVarArg ( ) ) return false ; MachineFunction & MF = MIRBuilder . getMF ( ) ; MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; auto DL = MF . getDataLayout ( ) ; SmallVector < ArgInfo , 8 > SplitArgs ; unsigned Idx = 0 ; for ( auto & Arg : F . args ( ) ) { if ( Arg . hasAttribute ( Attribute :: ByVal ) || Arg . hasAttribute ( Attribute :: InReg ) || Arg . hasAttribute ( Attribute :: StructRet ) || Arg . hasAttribute ( Attribute :: SwiftSelf ) || Arg . hasAttribute ( Attribute :: SwiftError ) || Arg . hasAttribute ( Attribute :: Nest ) ) return false ; ArgInfo OrigArg ( VRegs [ Idx ] , Arg . getType ( ) ) ; setArgFlags ( OrigArg , Idx + AttributeList :: FirstArgIndex , DL , F ) ; if ( ! splitToValueTypes ( OrigArg , SplitArgs , DL , MRI , [ & ] ( ArrayRef < unsigned > Regs ) { MIRBuilder . buildMerge ( VRegs [ Idx ] , Regs ) ; } ) ) return false ; Idx ++ ; } MachineBasicBlock & MBB = MIRBuilder . getMBB ( ) ; if ( ! MBB . empty ( ) ) MIRBuilder . setInstr ( * MBB . begin ( ) ) ; FormalArgHandler Handler ( MIRBuilder , MRI , CC_X86 , DL ) ; if ( ! handleAssignments ( MIRBuilder , SplitArgs , Handler ) ) return false ; MIRBuilder . setMBB ( MBB ) ; return true ; } </s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by VRegs , for GlobalISel .


<s> Instruction * RISCVTargetLowering :: emitLeadingFence ( IRBuilder < > & Builder , Instruction * Inst , AtomicOrdering Ord ) const { if ( isa < LoadInst > ( Inst ) && Ord == AtomicOrdering :: SequentiallyConsistent ) return Builder . CreateFence ( Ord ) ; if ( isa < StoreInst > ( Inst ) && isReleaseOrStronger ( Ord ) ) return Builder . CreateFence ( AtomicOrdering :: Release ) ; return nullptr ; } </s>


Expand code to store the currently installed user VMS condition handler into TARGET and install HANDLER as the new condition handler .


<s>
SDValue
AMDGPUTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
Op
->
print
(
errs
(
)
,
&
DAG
)
;
llvm_unreachable
(
"Custom lowering code for this"
"instruction is not implemented yet!"
)
;
break
;
case
ISD
::
SIGN_EXTEND_INREG
:
return
LowerSIGN_EXTEND_INREG
(
Op
,
DAG
)
;
case
ISD
::
CONCAT_VECTORS
:
return
LowerCONCAT_VECTORS
(
Op
,
DAG
)
;
case
ISD
::
EXTRACT_SUBVECTOR
:
return
LowerEXTRACT_SUBVECTOR
(
Op
,
DAG
)
;
case
ISD
::
UDIVREM
:
return
LowerUDIVREM
(
Op
,
DAG
)
;
case
ISD
::
SDIVREM
:
return
LowerSDIVREM
(
Op
,
DAG
)
;
case
ISD
::
FREM
:
return
LowerFREM
(
Op
,
DAG
)
;
case
ISD
::
FCEIL
:
return
LowerFCEIL
(
Op
,
DAG
)
;
case
ISD
::
FTRUNC
:
return
LowerFTRUNC
(
Op
,
DAG
)
;
case
ISD
::
FRINT
:
return
LowerFRINT
(
Op
,
DAG
)
;
case
ISD
::
FNEARBYINT
:
return
LowerFNEARBYINT
(
Op
,
DAG
)
;
case
ISD
::
FROUND
:
return
LowerFROUND
(
Op
,
DAG
)
;
case
ISD
::
FFLOOR
:
return
LowerFFLOOR
(
Op
,
DAG
)
;
case
ISD
::
SINT_TO_FP
:
return
LowerSINT_TO_FP
(
Op
,
DAG
)
;
case
ISD
::
UINT_TO_FP
:
return
LowerUINT_TO_FP
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_FP16
:
return
LowerFP_TO_FP16
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_SINT
:
return
LowerFP_TO_SINT
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_UINT
:
return
LowerFP_TO_UINT
(
Op
,
DAG
)
;
case
ISD
::
CTTZ
:
case
ISD
::
CTTZ_ZERO_UNDEF
:
case
ISD
::
CTLZ
:
case
ISD
::
CTLZ_ZERO_UNDEF
:
return
LowerCTLZ_CTTZ
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
}
return
Op
;
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> static const char * section_for_sym ( rtx sym ) { nvptx_data_area area = SYMBOL_DATA_AREA ( sym ) ; static char const * const areas [ ] = { "" , ".global" , ".shared" , ".local" , ".const" , ".param" } ; return areas [ area ] ; } </s>

Return the PTX name of the data area in which SYM should be placed . The symbol must have already been processed by nvptx_encode_seciton_info , or equivalent .


<s> void BPFPassConfig :: addIRPasses ( ) { addPass ( createBPFAbstractMemberAccess ( & getBPFTargetMachine ( ) ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>


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