<s>
std
::
unique_ptr
<
LanaiOperand
>
LanaiAsmParser
::
parseIdentifier
(
)
{
SMLoc
Start
=
Parser
.
getTok
(
)
.
getLoc
(
)
;
SMLoc
End
=
SMLoc
::
getFromPointer
(
Parser
.
getTok
(
)
.
getLoc
(
)
.
getPointer
(
)
1
)
;
const
MCExpr
*
Res
,
*
RHS
=
nullptr
;
LanaiMCExpr
::
VariantKind
Kind
=
LanaiMCExpr
::
VK_Lanai_None
;
if
(
Lexer
.
getKind
(
)
!=
AsmToken
::
Identifier
)
return
nullptr
;
StringRef
Identifier
;
if
(
Parser
.
parseIdentifier
(
Identifier
)
)
return
nullptr
;
if
(
Identifier
.
equals_lower
(
"hi"
)
)
Kind
=
LanaiMCExpr
::
VK_Lanai_ABS_HI
;
else
if
(
Identifier
.
equals_lower
(
"lo"
)
)
Kind
=
LanaiMCExpr
::
VK_Lanai_ABS_LO
;
if
(
Kind
!=
LanaiMCExpr
::
VK_Lanai_None
)
{
if
(
Lexer
.
getKind
(
)
!=
AsmToken
::
LParen
)
{
Error
(
Lexer
.
getLoc
(
)
,
"Expected '('"
)
;
return
nullptr
;
}
Lexer
.
Lex
(
)
;
if
(
Parser
.
parseIdentifier
(
Identifier
)
)
return
nullptr
;
}
if
(
Lexer
.
getKind
(
)
==
AsmToken
::
Plus
&&
Parser
.
parseExpression
(
RHS
)
)
return
nullptr
;
if
(
Kind
!=
LanaiMCExpr
::
VK_Lanai_None
)
{
if
(
Lexer
.
getKind
(
)
!=
AsmToken
::
RParen
)
{
Error
(
Lexer
.
getLoc
(
)
,
"Expected ')'"
)
;
return
nullptr
;
}
Lexer
.
Lex
(
)
;
}
End
=
SMLoc
::
getFromPointer
(
Parser
.
getTok
(
)
.
getLoc
(
)
.
getPointer
(
)
1
)
;
MCSymbol
*
Sym
=
getContext
(
)
.
getOrCreateSymbol
(
Identifier
)
;
const
MCExpr
*
Expr
=
MCSymbolRefExpr
::
create
(
Sym
,
getContext
(
)
)
;
Res
=
LanaiMCExpr
::
create
(
Kind
,
Expr
,
getContext
(
)
)
;
if
(
RHS
)
Res
=
MCBinaryExpr
::
createAdd
(
Res
,
RHS
,
getContext
(
)
)
;
return
LanaiOperand
::
createImm
(
Res
,
Start
,
End
)
;
}
</s>

Parse an identifier or string ( as a quoted identifier ) and set Res to the identifier contents .

Lanai
Lanai
Lanai
1
Lanai
Lanai
Lanai
"hi"
Lanai
Lanai
"lo"
Lanai
Lanai
Lanai
Lanai
"Expected '('"
Lanai
Lanai
"Expected ')'"
1
Lanai
LanaiOperand::createImm


<s> int m68hc11_initial_elimination_offset ( int from , int to ) { int trap_handler ; tree func_attr ; int size ; int regno ; func_attr = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ; current_function_interrupt = lookup_attribute ( "interrupt" , func_attr ) != NULL_TREE ; trap_handler = lookup_attribute ( "trap" , func_attr ) != NULL_TREE ; if ( lookup_attribute ( "far" , func_attr ) != 0 ) current_function_far = 1 ; else if ( lookup_attribute ( "near" , func_attr ) != 0 ) current_function_far = 0 ; else current_function_far = ( TARGET_LONG_CALLS != 0 && ! current_function_interrupt && ! trap_handler ) ; if ( trap_handler && from == ARG_POINTER_REGNUM ) size = 7 ; else if ( current_function_far && from == ARG_POINTER_REGNUM ) size = 1 ; else size = 0 ; if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) { return get_frame_size ( ) + 2 + m68hc11_sp_correction + size ; } if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) { return m68hc11_sp_correction ; } for ( regno = SOFT_REG_FIRST ; regno < SOFT_REG_LAST ; regno ++ ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) { size += 2 ; } } if ( from == ARG_POINTER_REGNUM && to == HARD_SP_REGNUM ) { return get_frame_size ( ) + size ; } if ( from == FRAME_POINTER_REGNUM && to == HARD_SP_REGNUM ) { return size ; } return 0 ; } </s>

Define the offset between two registers , one to be eliminated , and the other its replacement , at the start of a routine .


<s> const HSAILInstrInfo * getInstrInfo ( ) const override { return InstrInfo . get ( ) ; } </s>


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

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


<s> void AArch64AsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { if ( emitPseudoExpansionLowering ( OutStreamer , MI ) ) return ; switch ( MI -> getOpcode ( ) ) { case AArch64 :: DBG_VALUE : { if ( isVerbose ( ) && OutStreamer . hasRawTextSupport ( ) ) { SmallString < 128 > TmpStr ; raw_svector_ostream OS ( TmpStr ) ; PrintDebugValueComment ( MI , OS ) ; OutStreamer . EmitRawText ( StringRef ( OS . str ( ) ) ) ; } return ; } } MCInst TmpInst ; LowerAArch64MachineInstrToMCInst ( MI , TmpInst , * this ) ; OutStreamer . EmitInstruction ( TmpInst ) ; } </s>

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


<s> bool GCNSubtarget :: useAA ( ) const { return UseAA ; } </s>

Enable use of alias analysis during code generation ( during MI scheduling , DAGCombine , etc . ) .


<s> void LC3FrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; DebugLoc dl = MBBI -> getDebugLoc ( ) ; uint64_t StackSize = computeStackSize ( MF ) ; if ( ! StackSize ) { return ; } unsigned StackReg = LC3 :: SP ; unsigned OffsetReg = materializeOffset ( MF , MBB , MBBI , ( unsigned ) StackSize ) ; if ( OffsetReg ) { BuildMI ( MBB , MBBI , dl , TII . get ( LC3 :: ADDrr ) , StackReg ) . addReg ( StackReg ) . addReg ( OffsetReg ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } else { BuildMI ( MBB , MBBI , dl , TII . get ( LC3 :: ADDri ) , StackReg ) . addReg ( StackReg ) . addImm ( StackSize ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } } </s>


<s> bool AMDGPUPassConfig :: addInstSelector ( ) { addPass ( createAMDGPUPeepholeOpt ( * TM ) ) ; addPass ( createAMDGPUISelDag ( getAMDGPUTargetMachine ( ) ) ) ; const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . device ( ) -> getGeneration ( ) <= AMDGPUDeviceInfo :: HD6XXX ) { addPass ( createAMDGPUIndirectAddressingPass ( * TM ) ) ; } return false ; } </s>

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


"Searching for mode conversion candidates...\n"

"There are no candidates for optimization.\n"

"Chain #%d conversion is not profitable\n"

Main STV pass function . Find and convert scalar instructions into vector mode when profitable .


"eliminateCallFramePseudoInstr size too big: "

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


<s> bool nds32_n10_last_load_to_ex_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx last_def_reg = extract_nth_access_reg ( producer , - 1 ) ; return n10_consumed_by_ex_dep_p ( consumer , last_def_reg ) ; } </s>

Check dependencies from LMW ( N , N ) to EX .


<s>
void
HexagonFrameLowering
::
emitEpilogue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
MachineBasicBlock
::
iterator
MBBI
=
std
::
prev
(
MBB
.
end
(
)
)
;
DebugLoc
dl
=
MBBI
->
getDebugLoc
(
)
;
if
(
hasFP
(
MF
)
||
MF
.
getTarget
(
)
.
getOptLevel
(
)
==
CodeGenOpt
::
)
{
MachineBasicBlock
::
iterator
MBBI
=
std
::
prev
(
MBB
.
end
(
)
)
;
MachineBasicBlock
::
iterator
MBBI_end
=
MBB
.
end
(
)
;
const
TargetInstrInfo
&
TII
=
*
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
if
(
MBBI
->
getOpcode
(
)
==
Hexagon
::
EH_RETURN_JMPR
)
{
assert
(
MBBI
->
getOperand
(
0
)
.
isReg
(
)
&&
"Offset should be in register!"
)
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Hexagon
::
L2_deallocframe
)
)
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Hexagon
::
A2_add
)
,
Hexagon
::
R29
)
.
addReg
(
Hexagon
::
R29
)
.
addReg
(
Hexagon
::
R28
)
;
return
;
}
if
(
MF
.
getTarget
(
)
.
getSubtarget
<
HexagonSubtarget
>
(
)
.
hasV4TOps
(
)
&&
MBBI
->
getOpcode
(
)
==
Hexagon
::
JMPret
&&
!
DisableDeallocRet
)
{
MachineBasicBlock
::
iterator
BeforeJMPR
=
MBB
.
begin
(
)
==
MBBI
MBBI
:
std
::
prev
(
MBBI
)
;
if
(
BeforeJMPR
!=
MBBI
&&
BeforeJMPR
->
getOpcode
(
)
==
Hexagon
::
RESTORE_DEALLOC_RET_JMP_V4
)
{
MBB
.
erase
(
MBBI
)
;
return
;
}
MachineInstrBuilder
MIB
=
BuildMI
(
MBB
,
MBBI_end
,
dl
,
TII
.
get
(
Hexagon
::
L4_return
)
)
;
MIB
->
copyImplicitOps
(
*
MBB
.
getParent
(
)
,
&
*
MBBI
)
;
MBB
.
erase
(
MBBI
)
;
}
else
{
MachineBasicBlock
::
iterator
Term
=
MBB
.
getFirstTerminator
(
)
;
MachineBasicBlock
::
iterator
I
=
Term
==
MBB
.
begin
(
)
MBB
.
end
(
)
:
std
::
prev
(
Term
)
;
if
(
I
!=
MBB
.
end
(
)
&&
I
->
getOpcode
(
)
==
Hexagon
::
RESTORE_DEALLOC_BEFORE_TAILCALL_V4
)
return
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Hexagon
::
L2_deallocframe
)
)
;
}
}
}
</s>


<s> bool shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) override { switch ( ( PPC :: Fixups ) Fixup . getKind ( ) ) { default : return false ; case PPC :: fixup_ppc_br24 : case PPC :: fixup_ppc_br24abs : if ( const MCSymbolRefExpr * A = Target . getSymA ( ) ) { if ( const auto * S = dyn_cast < MCSymbolELF > ( & A -> getSymbol ( ) ) ) { unsigned Other = S -> getOther ( ) << 2 ; if ( ( Other & ELF :: STO_PPC64_LOCAL_MASK ) != 0 ) return true ; } } return false ; } } </s>

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


<s> ScheduleHazardRecognizer :: HazardType GCNHazardRecognizer :: getHazardType ( SUnit * SU , int Stalls ) { MachineInstr * MI = SU -> getInstr ( ) ; if ( SIInstrInfo :: isSMRD ( * MI ) && checkSMRDHazards ( MI ) > 0 ) return NoopHazard ; if ( SIInstrInfo :: isVMEM ( * MI ) && checkVMEMHazards ( MI ) > 0 ) return NoopHazard ; if ( SIInstrInfo :: isVALU ( * MI ) && checkVALUHazards ( MI ) > 0 ) return NoopHazard ; if ( SIInstrInfo :: isDPP ( * MI ) && checkDPPHazards ( MI ) > 0 ) return NoopHazard ; if ( isDivFMas ( MI -> getOpcode ( ) ) && checkDivFMasHazards ( MI ) > 0 ) return NoopHazard ; if ( isRWLane ( MI -> getOpcode ( ) ) && checkRWLaneHazards ( MI ) > 0 ) return NoopHazard ; if ( isSGetReg ( MI -> getOpcode ( ) ) && checkGetRegHazards ( MI ) > 0 ) return NoopHazard ; if ( isSSetReg ( MI -> getOpcode ( ) ) && checkSetRegHazards ( MI ) > 0 ) return NoopHazard ; if ( isRFE ( MI -> getOpcode ( ) ) && checkRFEHazards ( MI ) > 0 ) return NoopHazard ; if ( ( TII . isVINTRP ( * MI ) || isSMovRel ( MI -> getOpcode ( ) ) ) && checkReadM0Hazards ( MI ) > 0 ) return NoopHazard ; if ( checkAnyInstHazards ( MI ) > 0 ) return NoopHazard ; return NoHazard ; } </s>

getHazardType - Return the hazard type of emitting this node .


<s> bool AArch64InstrInfo :: isFunctionSafeToOutlineFrom ( MachineFunction & MF , bool OutlineFromLinkOnceODRs ) const { const Function & F = MF . getFunction ( ) ; if ( ! F . hasFnAttribute ( Attribute :: NoRedZone ) ) return false ; if ( ! OutlineFromLinkOnceODRs && F . hasLinkOnceODRLinkage ( ) ) return false ; return true ; } </s>

Return true if the function can safely be outlined from .


<s> std :: string AMDGPUMangledLibFunc :: getName ( ) const { SmallString < 128 > Buf ; raw_svector_ostream OS ( Buf ) ; writeName ( OS ) ; return OS . str ( ) ; } </s>

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


<s> bool lwsp_swsp_address_p ( rtx x , machine_mode mode ) { struct mips_address_info addr ; return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && REGNO ( addr . reg ) == STACK_POINTER_REGNUM && uw5_operand ( addr . offset , mode ) ) ; } </s>

Return true if X is a legitimate address that conforms to the requirements for a microMIPS LWSP or SWSP insn .


<s> unsigned Mips16InstrInfo :: loadImmediate ( int64_t Imm , MachineBasicBlock & MBB , MachineBasicBlock :: iterator II , DebugLoc DL , unsigned * NewImm ) const { return 0 ; } </s>

Emit a series of instructions to load an immediate .


<s> static void sparc32_initialize_trampoline ( rtx m_tramp , rtx fnaddr , rtx cxt ) { emit_move_insn ( adjust_address ( m_tramp , SImode , 0 ) , expand_binop ( SImode , ior_optab , expand_shift ( RSHIFT_EXPR , SImode , fnaddr , 10 , 0 , 1 ) , GEN_INT ( trunc_int_for_mode ( 0x03000000 , SImode ) ) , NULL_RTX , 1 , OPTAB_DIRECT ) ) ; emit_move_insn ( adjust_address ( m_tramp , SImode , 4 ) , expand_binop ( SImode , ior_optab , expand_shift ( RSHIFT_EXPR , SImode , cxt , 10 , 0 , 1 ) , GEN_INT ( trunc_int_for_mode ( 0x05000000 , SImode ) ) , NULL_RTX , 1 , OPTAB_DIRECT ) ) ; emit_move_insn ( adjust_address ( m_tramp , SImode , 8 ) , expand_binop ( SImode , ior_optab , expand_and ( SImode , fnaddr , GEN_INT ( 0x3ff ) , NULL_RTX ) , GEN_INT ( trunc_int_for_mode ( 0x81c06000 , SImode ) ) , NULL_RTX , 1 , OPTAB_DIRECT ) ) ; emit_move_insn ( adjust_address ( m_tramp , SImode , 12 ) , expand_binop ( SImode , ior_optab , expand_and ( SImode , cxt , GEN_INT ( 0x3ff ) , NULL_RTX ) , GEN_INT ( trunc_int_for_mode ( 0x8410a000 , SImode ) ) , NULL_RTX , 1 , OPTAB_DIRECT ) ) ; emit_insn ( gen_flushsi ( validize_mem ( adjust_address ( m_tramp , SImode , 0 ) ) ) ) ; if ( sparc_cpu != PROCESSOR_ULTRASPARC && sparc_cpu != PROCESSOR_ULTRASPARC3 && sparc_cpu != PROCESSOR_NIAGARA && sparc_cpu != PROCESSOR_NIAGARA2 && sparc_cpu != PROCESSOR_NIAGARA3 && sparc_cpu != PROCESSOR_NIAGARA4 && sparc_cpu != PROCESSOR_NIAGARA7 ) emit_insn ( gen_flushsi ( validize_mem ( adjust_address ( m_tramp , SImode , 8 ) ) ) ) ; emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , "__enable_execute_stack" ) , LCT_NORMAL , VOIDmode , 1 , XEXP ( m_tramp , 0 ) , Pmode ) ; } </s>

Emit RTL insns to initialize the variable parts of a trampoline . FNADDR is an RTX for the address of the function 's pure code . CXT is an RTX for the static chain value for the function . This takes 16 insns : 2 shifts & 2 ands ( to split up addresses ) , 4 sethi ( to load in opcodes ) , 4 iors ( to merge address and opcodes ) , and 4 writes ( to store insns ) . This is a bit excessive . Perhaps a different mechanism would be better here . Emit enough FLUSH insns to synchronize the data and instruction caches .


<s>
void
CSKYAsmBackend
::
relaxInstruction
(
MCInst
&
Inst
,
const
MCSubtargetInfo
&
STI
)
const
{
MCInst
Res
;
switch
(
Inst
.
getOpcode
(
)
)
{
default
:
LLVM_DEBUG
(
Inst
.
dump
(
)
)
;
llvm_unreachable
(
"Opcode not expected!"
)
;
case
CSKY
::
LRW16
:
Res
.
setOpcode
(
CSKY
::
LRW32
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
0
)
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
1
)
)
;
break
;
case
CSKY
::
BR16
:
Res
.
setOpcode
(
CSKY
::
BR32
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
0
)
)
;
break
;
case
CSKY
::
JBSR32
:
Res
.
setOpcode
(
CSKY
::
JSRI32
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
1
)
)
;
break
;
case
CSKY
::
JBR32
:
Res
.
setOpcode
(
CSKY
::
JMPI32
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
1
)
)
;
break
;
case
CSKY
::
JBT32
:
case
CSKY
::
JBF32
:
Res
.
setOpcode
(
Inst
.
getOpcode
(
)
==
CSKY
::
JBT32
CSKY
::
JBT_E
:
CSKY
::
JBF_E
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
0
)
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
1
)
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
2
)
)
;
break
;
case
CSKY
::
JBR16
:
Res
.
setOpcode
(
CSKY
::
JBR32
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
0
)
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
1
)
)
;
break
;
case
CSKY
::
JBT16
:
case
CSKY
::
JBF16
:
unsigned
opcode
;
if
(
STI
.
getFeatureBits
(
)
[
CSKY
::
HasE2
]
)
opcode
=
Inst
.
getOpcode
(
)
==
CSKY
::
JBT16
CSKY
::
JBT32
:
CSKY
::
JBF32
;
else
opcode
=
Inst
.
getOpcode
(
)
==
CSKY
::
JBT16
CSKY
::
JBT_E
:
CSKY
::
JBF_E
;
Res
.
setOpcode
(
opcode
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
0
)
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
1
)
)
;
Res
.
addOperand
(
Inst
.
getOperand
(
2
)
)
;
break
;
}
Inst
=
std
::
move
(
Res
)
;
}
</s>

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


<s> static bool noncall_uses_reg ( rtx reg , rtx_insn * insn , rtx * set ) { rtx pattern , reg2 ; * set = NULL_RTX ; reg2 = sfunc_uses_reg ( insn ) ; if ( reg2 && REGNO ( reg2 ) == REGNO ( reg ) ) { pattern = single_set ( insn ) ; if ( pattern && REG_P ( SET_DEST ( pattern ) ) && REGNO ( reg ) == REGNO ( SET_DEST ( pattern ) ) ) * set = pattern ; return false ; } if ( ! CALL_P ( insn ) ) { pattern = single_set ( insn ) ; if ( pattern && REG_P ( SET_DEST ( pattern ) ) && REGNO ( reg ) == REGNO ( SET_DEST ( pattern ) ) ) { rtx par , part ; int i ; * set = pattern ; par = PATTERN ( insn ) ; if ( GET_CODE ( par ) == PARALLEL ) for ( i = XVECLEN ( par , 0 ) - 1 ; i >= 0 ; i -- ) { part = XVECEXP ( par , 0 , i ) ; if ( GET_CODE ( part ) != SET && reg_mentioned_p ( reg , part ) ) return true ; } return reg_mentioned_p ( reg , SET_SRC ( pattern ) ) ; } return true ; } pattern = PATTERN ( insn ) ; if ( GET_CODE ( pattern ) == PARALLEL ) { int i ; for ( i = XVECLEN ( pattern , 0 ) - 1 ; i >= 1 ; i -- ) if ( reg_mentioned_p ( reg , XVECEXP ( pattern , 0 , i ) ) ) return true ; pattern = XVECEXP ( pattern , 0 , 0 ) ; } if ( GET_CODE ( pattern ) == SET ) { if ( reg_mentioned_p ( reg , SET_DEST ( pattern ) ) ) { if ( ! REG_P ( SET_DEST ( pattern ) ) || REGNO ( reg ) != REGNO ( SET_DEST ( pattern ) ) ) return true ; * set = pattern ; } pattern = SET_SRC ( pattern ) ; } if ( GET_CODE ( pattern ) != CALL || ! MEM_P ( XEXP ( pattern , 0 ) ) || ! rtx_equal_p ( reg , XEXP ( XEXP ( pattern , 0 ) , 0 ) ) ) return true ; return false ; } </s>

See if the only way in which INSN uses REG is by calling it , or by setting it while calling it . Set * SET to a SET rtx if the register is set by INSN .


<s> bool XCoreRegisterInfo :: hasFP ( const MachineFunction & MF ) const { return NoFramePointerElim || MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ; } </s>

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


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

Enable the MachineScheduler pass for all X86 subtargets .


<s> static void rs6000_live_on_entry ( bitmap regs ) { if ( flag_split_stack ) bitmap_set_bit ( regs , 12 ) ; } </s>

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


<s> BitVector ARMRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( ARM :: SP ) ; Reserved . set ( ARM :: PC ) ; if ( STI . isTargetDarwin ( ) || hasFP ( MF ) ) Reserved . set ( FramePtr ) ; if ( STI . isR9Reserved ( ) ) Reserved . set ( ARM :: R9 ) ; return Reserved ; } </s>

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


<s> SDNode * PPCDAGToDAGISel :: getGlobalBaseReg ( ) { if ( ! GlobalBaseReg ) { const TargetInstrInfo & TII = * Subtarget -> getInstrInfo ( ) ; MachineBasicBlock & FirstMBB = MF -> front ( ) ; MachineBasicBlock :: iterator MBBI = FirstMBB . begin ( ) ; const Module * M = MF -> getFunction ( ) . getParent ( ) ; DebugLoc dl ; if ( PPCLowering -> getPointerTy ( CurDAG -> getDataLayout ( ) ) == MVT :: i32 ) { if ( Subtarget -> isTargetELF ( ) ) { GlobalBaseReg = PPC :: R30 ; if ( ! Subtarget -> isSecurePlt ( ) && M -> getPICLevel ( ) == PICLevel :: SmallPIC ) { BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MoveGOTtoLR ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; MF -> getInfo < PPCFunctionInfo > ( ) -> setUsesPICBase ( true ) ; } else { BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; Register TempReg = RegInfo -> createVirtualRegister ( & PPC :: GPRCRegClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: UpdateGBR ) , GlobalBaseReg ) . addReg ( TempReg , RegState :: Define ) . addReg ( GlobalBaseReg ) ; MF -> getInfo < PPCFunctionInfo > ( ) -> setUsesPICBase ( true ) ; } } else { GlobalBaseReg = RegInfo -> createVirtualRegister ( & PPC :: GPRC_and_GPRC_NOR0RegClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; } } else { MF -> getInfo < PPCFunctionInfo > ( ) -> setShrinkWrapDisabled ( true ) ; GlobalBaseReg = RegInfo -> createVirtualRegister ( & PPC :: G8RC_and_G8RC_NOX0RegClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR8 ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR8 ) , GlobalBaseReg ) ; } } return CurDAG -> getRegister ( GlobalBaseReg , PPCLowering -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) . getNode ( ) ; } </s>

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

PowerPC PPC PPC MVT::i32 PPC::R30 PPC::MoveGOTtoLR PPC::MFLR PPC PPC::MovePCtoLR PPC::MFLR PPC::GPRCRegClass PPC::UpdateGBR PPC PPC::GPRC_and_GPRC_NOR0RegClass PPC::MovePCtoLR PPC::MFLR PPC PPC::G8RC_and_G8RC_NOX0RegClass PPC::MovePCtoLR8 PPC::MFLR8 PPC


<s> bool isProfitableToIfCvt ( MachineBasicBlock & TMBB , unsigned NumTCycles , unsigned ExtraTCycles , MachineBasicBlock & FMBB , unsigned NumFCycles , unsigned ExtraFCycles , BranchProbability Probability ) const override { const MCInstrDesc & TMCID = std :: prev ( TMBB . end ( ) ) -> getDesc ( ) ; if ( TMCID . isReturn ( ) || TMCID . isCall ( ) ) return false ; const MCInstrDesc & FMCID = std :: prev ( FMBB . end ( ) ) -> getDesc ( ) ; if ( FMCID . isReturn ( ) || FMCID . isCall ( ) ) return false ; if ( ( NumTCycles + NumFCycles ) > 16 ) return false ; return ! mayStall ( TMBB ) && ! mayStall ( FMBB ) ; } </s>


<s> int h8300_shift_needs_scratch_p ( int count , machine_mode mode ) { enum h8_cpu cpu ; int a , lr , ar ; if ( GET_MODE_BITSIZE ( mode ) <= count ) return 1 ; if ( TARGET_H8300 ) cpu = H8_300 ; else if ( TARGET_H8300H ) cpu = H8_300H ; else cpu = H8_S ; switch ( mode ) { case QImode : a = shift_alg_qi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_qi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_qi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case HImode : a = shift_alg_hi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_hi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_hi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case SImode : a = shift_alg_si [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_si [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_si [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; default : gcc_unreachable ( ) ; } return ( a == SHIFT_LOOP || lr == SHIFT_LOOP || ar == SHIFT_LOOP || ( TARGET_H8300H && mode == SImode && count == 8 ) ) ; } </s>

Given COUNT and MODE of a shift , return 1 if a scratch reg may be needed for some shift with COUNT and MODE . Return 0 otherwise .


<s>
void
AArch64TargetLowering
::
computeKnownBitsForTargetNode
(
const
SDValue
Op
,
APInt
&
KnownZero
,
APInt
&
KnownOne
,
const
SelectionDAG
&
DAG
,
unsigned
Depth
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
break
;
case
AArch64ISD
::
CSEL
:
{
APInt
KnownZero2
,
KnownOne2
;
DAG
.
computeKnownBits
(
Op
->
getOperand
(
0
)
,
KnownZero
,
KnownOne
,
Depth
+
1
)
;
DAG
.
computeKnownBits
(
Op
->
getOperand
(
1
)
,
KnownZero2
,
KnownOne2
,
Depth
+
1
)
;
KnownZero
&=
KnownZero2
;
KnownOne
&=
KnownOne2
;
break
;
}
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
::
aarch64_ldaxr
:
case
Intrinsic
::
aarch64_ldxr
:
{
unsigned
BitWidth
=
KnownOne
.
getBitWidth
(
)
;
EVT
VT
=
cast
<
MemIntrinsicSDNode
>
(
Op
)
->
getMemoryVT
(
)
;
unsigned
MemBits
=
VT
.
getScalarType
(
)
.
getSizeInBits
(
)
;
KnownZero
|=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
MemBits
)
;
return
;
}
}
break
;
}
case
ISD
::
INTRINSIC_WO_CHAIN
:
case
ISD
::
INTRINSIC_VOID
:
{
unsigned
IntNo
=
cast
<
ConstantSDNode
>
(
Op
.
getOperand
(
0
)
)
->
getZExtValue
(
)
;
switch
(
IntNo
)
{
default
:
break
;
case
Intrinsic
::
aarch64_neon_umaxv
:
case
Intrinsic
::
aarch64_neon_uminv
:
{
MVT
VT
=
Op
.
getOperand
(
1
)
.
getValueType
(
)
.
getSimpleVT
(
)
;
unsigned
BitWidth
=
KnownZero
.
getBitWidth
(
)
;
if
(
VT
==
MVT
::
v8i8
||
VT
==
MVT
::
v16i8
)
{
assert
(
BitWidth
>=
8
&&
"Unexpected width!"
)
;
APInt
Mask
=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
8
)
;
KnownZero
|=
Mask
;
}
else
if
(
VT
==
MVT
::
v4i16
||
VT
==
MVT
::
v8i16
)
{
assert
(
BitWidth
>=
16
&&
"Unexpected width!"
)
;
APInt
Mask
=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
16
)
;
KnownZero
|=
Mask
;
}
break
;
}
break
;
}
}
}
}
</s>

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


<s> bool X86TTIImpl :: isLegalMaskedLoad ( Type * DataTy , MaybeAlign Alignment ) { if ( ! ST -> hasAVX ( ) ) return false ; if ( isa < VectorType > ( DataTy ) && DataTy -> getVectorNumElements ( ) == 1 ) return false ; Type * ScalarTy = DataTy -> getScalarType ( ) ; if ( ScalarTy -> isPointerTy ( ) ) return true ; if ( ScalarTy -> isFloatTy ( ) || ScalarTy -> isDoubleTy ( ) ) return true ; if ( ! ScalarTy -> isIntegerTy ( ) ) return false ; unsigned IntWidth = ScalarTy -> getIntegerBitWidth ( ) ; return IntWidth == 32 || IntWidth == 64 || ( ( IntWidth == 8 || IntWidth == 16 ) && ST -> hasBWI ( ) ) ; } </s>

Return true if the target supports masked load .


<s> static rtx_insn * next_insn_to_bundle ( rtx_insn * r , rtx_insn * end ) { for ( ; r != end ; r = NEXT_INSN ( r ) ) { if ( NONDEBUG_INSN_P ( r ) && GET_CODE ( PATTERN ( r ) ) != USE && GET_CODE ( PATTERN ( r ) ) != CLOBBER ) return r ; } return NULL ; } </s>

Skip over irrelevant NOTEs and such and look for the next insn we would consider bundling .


<s> const TargetRegisterClass * VideoCore4RegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { assert ( 0 && "Unimplemented" ) ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s> std :: pair < unsigned , unsigned > AMDGPUCommonSubtarget :: getWavesPerEU ( const Function & F ) const { std :: pair < unsigned , unsigned > Default ( 1 , getMaxWavesPerEU ( ) ) ; std :: pair < unsigned , unsigned > FlatWorkGroupSizes = getFlatWorkGroupSizes ( F ) ; unsigned MinImpliedByFlatWorkGroupSize = getMaxWavesPerEU ( FlatWorkGroupSizes . second ) ; bool RequestedFlatWorkGroupSize = false ; if ( F . hasFnAttribute ( "amdgpu-max-work-group-size" ) || F . hasFnAttribute ( "amdgpu-flat-work-group-size" ) ) { Default . first = MinImpliedByFlatWorkGroupSize ; RequestedFlatWorkGroupSize = true ; } std :: pair < unsigned , unsigned > Requested = AMDGPU :: getIntegerPairAttribute ( F , "amdgpu-waves-per-eu" , Default , true ) ; if ( Requested . second && Requested . first > Requested . second ) return Default ; if ( Requested . first < getMinWavesPerEU ( ) || Requested . first > getMaxWavesPerEU ( ) ) return Default ; if ( Requested . second > getMaxWavesPerEU ( ) ) return Default ; if ( RequestedFlatWorkGroupSize && Requested . first < MinImpliedByFlatWorkGroupSize ) return Default ; return Requested ; } </s>

Overload which uses the specified values for the flat work group sizes , rather than querying the function itself .

AMDGPU AMDGPU 1 "amdgpu-max-work-group-size" "amdgpu-flat-work-group-size" AMDGPU::getIntegerPairAttribute "amdgpu-waves-per-eu"


<s> void changeSection ( const MCSection * CurSection , MCSection * Section , const MCExpr * SubSection , raw_ostream & OS ) override { } </s>

Update streamer for a new active section .


<s> static bool is_microcoded_insn ( rtx insn ) { if ( ! insn || ! INSN_P ( insn ) || GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) return false ; if ( rs6000_sched_groups ) { enum attr_type type = get_attr_type ( insn ) ; if ( type == TYPE_LOAD_EXT_U || type == TYPE_LOAD_EXT_UX || type == TYPE_LOAD_UX || type == TYPE_STORE_UX || type == TYPE_MFCR ) return true ; } return false ; } </s>

The function returns a true if INSN is microcoded . Return false otherwise .


<s> bool MSP430FrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , MutableArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; if ( MF . getSubtarget < MSP430Subtarget > ( ) . hasMSP430X ( ) ) BuildMI ( MBB , MI , DL , TII . get ( MSP430 :: POPM16r ) ) . addImm ( CSI . size ( ) ) . addReg ( CSI [ CSI . size ( ) - 1 ] . getReg ( ) ) . setMIFlag ( MachineInstr :: FrameDestroy ) ; else { for ( unsigned I = 0 , E = CSI . size ( ) ; I != E ; ++ I ) BuildMI ( MBB , MI , DL , TII . get ( MSP430 :: POP16r ) , CSI [ I ] . getReg ( ) ) . setMIFlag ( MachineInstr :: FrameDestroy ) ; } 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 ( ) .


"Instruction should be in a basic block!"

Select the ( possibly generic ) instruction I to only use target-specific opcodes .


<s> int non_hard_reg_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { return ! ( GET_CODE ( op ) == REG && REGNO ( op ) < FIRST_PSEUDO_REGISTER ) ; } </s>

Return 1 if this operand is anything other than a hard register .


<s> const char * HexagonTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( ( HexagonISD :: NodeType ) Opcode ) { case HexagonISD :: ALLOCA : return "HexagonISD::ALLOCA" ; case HexagonISD :: ARGEXTEND : return "HexagonISD::ARGEXTEND" ; case HexagonISD :: AT_GOT : return "HexagonISD::AT_GOT" ; case HexagonISD :: AT_PCREL : return "HexagonISD::AT_PCREL" ; case HexagonISD :: BARRIER : return "HexagonISD::BARRIER" ; case HexagonISD :: CALLR : return "HexagonISD::CALLR" ; case HexagonISD :: CALLv3nr : return "HexagonISD::CALLv3nr" ; case HexagonISD :: CALLv3 : return "HexagonISD::CALLv3" ; case HexagonISD :: COMBINE : return "HexagonISD::COMBINE" ; case HexagonISD :: CONST32_GP : return "HexagonISD::CONST32_GP" ; case HexagonISD :: CONST32 : return "HexagonISD::CONST32" ; case HexagonISD :: CP : return "HexagonISD::CP" ; case HexagonISD :: DCFETCH : return "HexagonISD::DCFETCH" ; case HexagonISD :: EH_RETURN : return "HexagonISD::EH_RETURN" ; case HexagonISD :: EXTRACTU : return "HexagonISD::EXTRACTU" ; case HexagonISD :: EXTRACTURP : return "HexagonISD::EXTRACTURP" ; case HexagonISD :: FCONST32 : return "HexagonISD::FCONST32" ; case HexagonISD :: INSERT : return "HexagonISD::INSERT" ; case HexagonISD :: INSERTRP : return "HexagonISD::INSERTRP" ; case HexagonISD :: JT : return "HexagonISD::JT" ; case HexagonISD :: PACKHL : return "HexagonISD::PACKHL" ; case HexagonISD :: POPCOUNT : return "HexagonISD::POPCOUNT" ; case HexagonISD :: RET_FLAG : return "HexagonISD::RET_FLAG" ; case HexagonISD :: SHUFFEB : return "HexagonISD::SHUFFEB" ; case HexagonISD :: SHUFFEH : return "HexagonISD::SHUFFEH" ; case HexagonISD :: SHUFFOB : return "HexagonISD::SHUFFOB" ; case HexagonISD :: SHUFFOH : return "HexagonISD::SHUFFOH" ; case HexagonISD :: TC_RETURN : return "HexagonISD::TC_RETURN" ; case HexagonISD :: VCMPBEQ : return "HexagonISD::VCMPBEQ" ; case HexagonISD :: VCMPBGT : return "HexagonISD::VCMPBGT" ; case HexagonISD :: VCMPBGTU : return "HexagonISD::VCMPBGTU" ; case HexagonISD :: VCMPHEQ : return "HexagonISD::VCMPHEQ" ; case HexagonISD :: VCMPHGT : return "HexagonISD::VCMPHGT" ; case HexagonISD :: VCMPHGTU : return "HexagonISD::VCMPHGTU" ; case HexagonISD :: VCMPWEQ : return "HexagonISD::VCMPWEQ" ; case HexagonISD :: VCMPWGT : return "HexagonISD::VCMPWGT" ; case HexagonISD :: VCMPWGTU : return "HexagonISD::VCMPWGTU" ; case HexagonISD :: VCOMBINE : return "HexagonISD::VCOMBINE" ; case HexagonISD :: VSHLH : return "HexagonISD::VSHLH" ; case HexagonISD :: VSHLW : return "HexagonISD::VSHLW" ; case HexagonISD :: VSPLATB : return "HexagonISD::VSPLTB" ; case HexagonISD :: VSPLATH : return "HexagonISD::VSPLATH" ; case HexagonISD :: VSRAH : return "HexagonISD::VSRAH" ; case HexagonISD :: VSRAW : return "HexagonISD::VSRAW" ; case HexagonISD :: VSRLH : return "HexagonISD::VSRLH" ; case HexagonISD :: VSRLW : return "HexagonISD::VSRLW" ; case HexagonISD :: VSXTBH : return "HexagonISD::VSXTBH" ; case HexagonISD :: VSXTBW : return "HexagonISD::VSXTBW" ; case HexagonISD :: OP_END : break ; } return nullptr ; } </s>

getTargetNodeName - This method returns the name of a target specific

Hexagon Hexagon HexagonISD::NodeType HexagonISD::ALLOCA "HexagonISD::ALLOCA" HexagonISD::ARGEXTEND "HexagonISD::ARGEXTEND" HexagonISD::AT_GOT "HexagonISD::AT_GOT" HexagonISD::AT_PCREL "HexagonISD::AT_PCREL" HexagonISD::BARRIER "HexagonISD::BARRIER" HexagonISD::CALLR "HexagonISD::CALLR" HexagonISD::CALLv3nr "HexagonISD::CALLv3nr" HexagonISD::CALLv3 "HexagonISD::CALLv3" HexagonISD::COMBINE "HexagonISD::COMBINE" HexagonISD::CONST32_GP "HexagonISD::CONST32_GP" HexagonISD::CONST32 "HexagonISD::CONST32" HexagonISD::CP "HexagonISD::CP" HexagonISD::DCFETCH "HexagonISD::DCFETCH" HexagonISD::EH_RETURN "HexagonISD::EH_RETURN" HexagonISD::EXTRACTU "HexagonISD::EXTRACTU" HexagonISD::EXTRACTURP "HexagonISD::EXTRACTURP" HexagonISD::FCONST32 "HexagonISD::FCONST32" HexagonISD::INSERT "HexagonISD::INSERT" HexagonISD::INSERTRP "HexagonISD::INSERTRP" HexagonISD::JT "HexagonISD::JT" HexagonISD::PACKHL "HexagonISD::PACKHL" HexagonISD::POPCOUNT "HexagonISD::POPCOUNT" HexagonISD::RET_FLAG "HexagonISD::RET_FLAG" HexagonISD::SHUFFEB "HexagonISD::SHUFFEB" HexagonISD::SHUFFEH "HexagonISD::SHUFFEH" HexagonISD::SHUFFOB "HexagonISD::SHUFFOB" HexagonISD::SHUFFOH "HexagonISD::SHUFFOH" HexagonISD::TC_RETURN "HexagonISD::TC_RETURN" HexagonISD::VCMPBEQ "HexagonISD::VCMPBEQ" HexagonISD::VCMPBGT "HexagonISD::VCMPBGT" HexagonISD::VCMPBGTU "HexagonISD::VCMPBGTU" HexagonISD::VCMPHEQ "HexagonISD::VCMPHEQ" HexagonISD::VCMPHGT "HexagonISD::VCMPHGT" HexagonISD::VCMPHGTU "HexagonISD::VCMPHGTU" HexagonISD::VCMPWEQ "HexagonISD::VCMPWEQ" HexagonISD::VCMPWGT "HexagonISD::VCMPWGT" HexagonISD::VCMPWGTU "HexagonISD::VCMPWGTU" HexagonISD::VCOMBINE "HexagonISD::VCOMBINE" HexagonISD::VSHLH "HexagonISD::VSHLH" HexagonISD::VSHLW "HexagonISD::VSHLW" HexagonISD::VSPLATB "HexagonISD::VSPLTB" HexagonISD::VSPLATH "HexagonISD::VSPLATH" HexagonISD::VSRAH "HexagonISD::VSRAH" HexagonISD::VSRAW "HexagonISD::VSRAW" HexagonISD::VSRLH "HexagonISD::VSRLH" HexagonISD::VSRLW "HexagonISD::VSRLW" HexagonISD::VSXTBH "HexagonISD::VSXTBH" HexagonISD::VSXTBW "HexagonISD::VSXTBW" HexagonISD::OP_END


<s> bool clear_operation_p ( rtx op , bool vfp ) { unsigned regno ; unsigned last_regno = INVALID_REGNUM ; rtx elt , reg , zero ; int count = XVECLEN ( op , 0 ) ; int first_set = vfp ? 1 : 0 ; machine_mode expected_mode = vfp ? E_SFmode : E_SImode ; for ( int i = first_set ; i < count ; i ++ ) { elt = XVECEXP ( op , 0 , i ) ; if ( ! vfp && GET_CODE ( elt ) == UNSPEC_VOLATILE ) { if ( XINT ( elt , 1 ) != VUNSPEC_CLRM_APSR || XVECLEN ( elt , 0 ) != 1 || XVECEXP ( elt , 0 , 0 ) != CONST0_RTX ( SImode ) || i != count - 2 ) return false ; continue ; } if ( GET_CODE ( elt ) == CLOBBER ) continue ; if ( GET_CODE ( elt ) != SET ) return false ; reg = SET_DEST ( elt ) ; zero = SET_SRC ( elt ) ; if ( ! REG_P ( reg ) || GET_MODE ( reg ) != expected_mode || zero != CONST0_RTX ( SImode ) ) return false ; regno = REGNO ( reg ) ; if ( vfp ) { if ( i != first_set && regno != last_regno + 1 ) return false ; } else { if ( regno == SP_REGNUM || regno == PC_REGNUM ) return false ; if ( i != first_set && regno <= last_regno ) return false ; } last_regno = regno ; } return true ; } </s>

Checks whether OP is a valid parallel pattern for a CLRM ( if VFP is false ) or VSCCLRM ( otherwise ) insn . To be a valid CLRM pattern , OP must have the following form : [ ( set ( reg : SI < N > ) ( const_int 0 ) ) ( set ( reg : SI < M > ) ( const_int 0 ) ) ... ( unspec_volatile [ ( const_int 0 ) ] VUNSPEC_CLRM_APSR ) ( clobber ( reg : CC CC_REGNUM ) ) ] Any number ( including 0 ) of set expressions is valid , the volatile unspec is optional . All registers but SP and PC are allowed and registers must be in strict increasing order . To be a valid VSCCLRM pattern , OP must have the following form : [ ( unspec_volatile [ ( const_int 0 ) ] VUNSPEC_VSCCLRM_VPR ) ( set ( reg : SF < N > ) ( const_int 0 ) ) ( set ( reg : SF < M > ) ( const_int 0 ) ) ... ] As with CLRM , any number ( including 0 ) of set expressions is valid , however the volatile unspec is mandatory here . Any VFP single-precision register is accepted but all registers must be consecutive and in increasing order .


<s>
void
cris_expand_pic_call_address
(
rtx
*
opp
)
{
rtx
op
=
*
opp
;
gcc_assert
(
MEM_P
(
op
)
)
;
op
=
XEXP
(
op
,
0
)
;
if
(
CONSTANT_ADDRESS_P
(
op
)
&&
GET_CODE
(
op
)
!=
CONST_INT
)
{
enum
cris_pic_symbol_type
t
=
cris_pic_symbol_type_of
(
op
)
;
CRIS_ASSERT
(
!
no_new_pseudos
)
;
if
(
t
==
cris_gotrel_symbol
)
op
=
force_reg
(
Pmode
,
op
)
;
else
if
(
t
==
cris_got_symbol
)
{
if
(
TARGET_AVOID_GOTPLT
)
{
rtx
tem
,
rm
,
ro
;
gcc_assert
(
!
no_new_pseudos
)
;
current_function_uses_pic_offset_table
=
1
;
tem
=
gen_rtx_UNSPEC
(
Pmode
,
gen_rtvec
(
1
,
op
)
,
CRIS_UNSPEC_PLT
)
;
rm
=
gen_reg_rtx
(
Pmode
)
;
emit_move_insn
(
rm
,
gen_rtx_CONST
(
Pmode
,
tem
)
)
;
ro
=
gen_reg_rtx
(
Pmode
)
;
if
(
expand_binop
(
Pmode
,
add_optab
,
rm
,
pic_offset_table_rtx
,
ro
,
0
,
OPTAB_LIB_WIDEN
)
!=
ro
)
internal_error
(
"expand_binop failed in movsi got"
)
;
op
=
ro
;
}
else
{
rtx
tem
,
mem
,
rm
,
ro
;
gcc_assert
(
!
no_new_pseudos
)
;
current_function_uses_pic_offset_table
=
1
;
tem
=
gen_rtx_UNSPEC
(
Pmode
,
gen_rtvec
(
1
,
op
)
,
CRIS_UNSPEC_PLTGOTREAD
)
;
rm
=
gen_reg_rtx
(
Pmode
)
;
emit_move_insn
(
rm
,
gen_rtx_CONST
(
Pmode
,
tem
)
)
;
ro
=
gen_reg_rtx
(
Pmode
)
;
if
(
expand_binop
(
Pmode
,
add_optab
,
rm
,
pic_offset_table_rtx
,
ro
,
0
,
OPTAB_LIB_WIDEN
)
!=
ro
)
internal_error
(
"expand_binop failed in movsi got"
)
;
mem
=
gen_rtx_MEM
(
Pmode
,
ro
)
;
set_mem_alias_set
(
mem
,
new_alias_set
(
)
)
;
MEM_NOTRAP_P
(
mem
)
=
1
;
op
=
mem
;
}
}
else
fatal_insn
(
"Unidentifiable call op"
,
op
)
;
*
opp
=
replace_equiv_address
(
*
opp
,
op
)
;
}
}
</s>

Worker function for expanding the address for PIC function calls .


<s> void Initialize ( MCContext & ctx , const TargetMachine & TM ) override { TargetLoweringObjectFile :: Initialize ( ctx , TM ) ; TextSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getText ( ) ) ; DataSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getDataRel ( ) ) ; BSSSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getBSS ( ) ) ; ReadOnlySection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getReadOnly ( ) ) ; StaticCtorSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; StaticDtorSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; LSDASection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; EHFrameSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfAbbrevSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfInfoSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfLineSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfFrameSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfPubTypesSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfDebugInlineSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfStrSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfLocSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfARangesSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfRangesSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfMacroInfoSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; } </s>

This method must be called before any actual lowering is done .

NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX


<s> bool arc_legitimate_pic_addr_p ( rtx addr ) { if ( GET_CODE ( addr ) != CONST ) return false ; addr = XEXP ( addr , 0 ) ; if ( GET_CODE ( addr ) == PLUS ) { if ( GET_CODE ( XEXP ( addr , 1 ) ) != CONST_INT ) return false ; addr = XEXP ( addr , 0 ) ; } if ( GET_CODE ( addr ) != UNSPEC || XVECLEN ( addr , 0 ) != 1 ) return false ; if ( XINT ( addr , 1 ) != ARC_UNSPEC_GOT && XINT ( addr , 1 ) != ARC_UNSPEC_GOTOFF && XINT ( addr , 1 ) != ARC_UNSPEC_GOTOFFPC && XINT ( addr , 1 ) != UNSPEC_TLS_GD && XINT ( addr , 1 ) != UNSPEC_TLS_IE ) return false ; if ( GET_CODE ( XVECEXP ( addr , 0 , 0 ) ) != SYMBOL_REF && GET_CODE ( XVECEXP ( addr , 0 , 0 ) ) != LABEL_REF ) return false ; return true ; } </s>

Return true if ADDR is a valid pic address . A valid pic address on arc should look like const ( unspec ( SYMBOL_REF/LABEL ) ( ARC_UNSPEC_GOTOFF/ARC_UNSPEC_GOT ) )


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

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


<s>
SDValue
CAHPTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
report_fatal_error
(
"unimplemented operand"
)
;
case
ISD
::
BR_CC
:
return
LowerBR_CC
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
SELECT
:
return
LowerSELECT
(
Op
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .

CAHP
CAHP
"unimplemented operand"
ISD::BR_CC
ISD::GlobalAddress
ISD::SELECT
ISD::FRAMEADDR
ISD::RETURNADDR


<s> void TPCFrameLowering :: determineCalleeSaves ( MachineFunction & MF , BitVector & SavedRegs , RegScavenger * RS ) const { } </s>

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


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

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


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


<s> SDValue XCoreSelectionDAGInfo :: EmitTargetCodeForMemcpy ( SelectionDAG & DAG , const SDLoc & dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , unsigned Align , bool isVolatile , bool AlwaysInline , MachinePointerInfo DstPtrInfo , MachinePointerInfo SrcPtrInfo ) const { unsigned SizeBitWidth = Size . getValueSizeInBits ( ) ; if ( ! AlwaysInline && ( Align & 3 ) == 0 && DAG . MaskedValueIsZero ( Size , APInt ( SizeBitWidth , 3 ) ) ) { const TargetLowering & TLI = * DAG . getSubtarget ( ) . getTargetLowering ( ) ; TargetLowering :: ArgListTy Args ; TargetLowering :: ArgListEntry Entry ; Entry . Ty = DAG . getDataLayout ( ) . getIntPtrType ( * DAG . getContext ( ) ) ; Entry . Node = Dst ; Args . push_back ( Entry ) ; Entry . Node = Src ; Args . push_back ( Entry ) ; Entry . Node = Size ; Args . push_back ( Entry ) ; TargetLowering :: CallLoweringInfo CLI ( DAG ) ; CLI . setDebugLoc ( dl ) . setChain ( Chain ) . setLibCallee ( TLI . getLibcallCallingConv ( RTLIB :: MEMCPY ) , Type :: getVoidTy ( * DAG . getContext ( ) ) , DAG . getExternalSymbol ( "__memcpy_4" , TLI . getPointerTy ( DAG . getDataLayout ( ) ) ) , std :: move ( Args ) ) . setDiscardResult ( ) ; std :: pair < SDValue , SDValue > CallResult = TLI . LowerCallTo ( CLI ) ; return CallResult . second ; } return SDValue ( ) ; } </s>

Emit target-specific code that performs a memcpy .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . setPreservesCFG ( ) ; AU . addRequired < AAResultsWrapperPass > ( ) ; AU . addRequired < LiveIntervals > ( ) ; AU . addPreserved < LiveIntervals > ( ) ; AU . addPreservedID ( LiveVariablesID ) ; MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> MachineInstr * ARMBaseInstrInfo :: commuteInstruction ( MachineInstr * MI , bool NewMI ) const { switch ( MI -> getOpcode ( ) ) { case ARM :: MOVCCr : case ARM :: t2MOVCCr : { unsigned PredReg = 0 ; ARMCC :: CondCodes CC = getInstrPredicate ( MI , PredReg ) ; if ( CC == ARMCC :: AL || PredReg != ARM :: CPSR ) return nullptr ; MI = TargetInstrInfo :: commuteInstruction ( MI , NewMI ) ; if ( ! MI ) return nullptr ; MI -> getOperand ( MI -> findFirstPredOperandIdx ( ) ) . setImm ( ARMCC :: getOppositeCondition ( CC ) ) ; return MI ; } } return TargetInstrInfo :: commuteInstruction ( MI , NewMI ) ; } </s>

This method commutes the operands of the given machine instruction MI .

ARM ARM ARM::MOVCCr ARM::t2MOVCCr 0 ARMCC::CondCodes ARMCC::AL ARM::CPSR ARMCC::getOppositeCondition


<s> const AMDGPUInstrInfo * getInstrInfo ( ) const override { return InstrInfo . get ( ) ; } </s>


<s> bool X86InstrInfo :: isUnpredicatedTerminator ( const MachineInstr * MI ) const { if ( ! MI -> isTerminator ( ) ) return false ; if ( MI -> isBranch ( ) && ! MI -> isBarrier ( ) ) return true ; if ( ! MI -> isPredicable ( ) ) return true ; return ! isPredicated ( MI ) ; } </s>

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


<s> bool alpha_expand_mov ( enum machine_mode mode , rtx * operands ) { if ( GET_CODE ( operands [ 0 ] ) == MEM && ! reg_or_0_operand ( operands [ 1 ] , mode ) ) operands [ 1 ] = force_reg ( mode , operands [ 1 ] ) ; if ( mode == Pmode && symbolic_operand ( operands [ 1 ] , mode ) ) { rtx tmp ; tmp = alpha_legitimize_address ( operands [ 1 ] , operands [ 0 ] , mode ) ; if ( tmp ) { if ( tmp == operands [ 0 ] ) return true ; operands [ 1 ] = tmp ; return false ; } } if ( ! CONSTANT_P ( operands [ 1 ] ) || input_operand ( operands [ 1 ] , mode ) ) return false ; if ( GET_CODE ( operands [ 1 ] ) == CONST_INT || GET_CODE ( operands [ 1 ] ) == CONST_DOUBLE || GET_CODE ( operands [ 1 ] ) == CONST_VECTOR ) { if ( alpha_split_const_mov ( mode , operands ) ) return true ; } operands [ 1 ] = force_const_mem ( mode , operands [ 1 ] ) ; if ( reload_in_progress ) { emit_move_insn ( operands [ 0 ] , XEXP ( operands [ 1 ] , 0 ) ) ; operands [ 1 ] = copy_rtx ( operands [ 1 ] ) ; XEXP ( operands [ 1 ] , 0 ) = operands [ 0 ] ; } else operands [ 1 ] = validize_mem ( operands [ 1 ] ) ; return false ; } </s>

Expand a move instruction ; return true if all work is done . We do n't handle non-bwx subword loads here .


<s>
static
void
ix86_code_end
(
void
)
{
rtx
xops
[
2
]
;
int
regno
;
for
(
regno
=
AX_REG
;
regno
<=
SP_REG
;
regno
++
)
{
char
name
[
32
]
;
tree
decl
;
if
(
!
(
pic_labels_used
&
(
1
<<
regno
)
)
)
continue
;
get_pc_thunk_name
(
name
,
regno
)
;
decl
=
build_decl
(
BUILTINS_LOCATION
,
FUNCTION_DECL
,
get_identifier
(
name
)
,
build_function_type_list
(
void_type_node
,
NULL_TREE
)
)
;
DECL_RESULT
(
decl
)
=
build_decl
(
BUILTINS_LOCATION
,
RESULT_DECL
,
NULL_TREE
,
void_type_node
)
;
TREE_PUBLIC
(
decl
)
=
1
;
TREE_STATIC
(
decl
)
=
1
;
DECL_IGNORED_P
(
decl
)
=
1
;
if
(
TARGET_MACHO
)
{
switch_to_section
(
darwin_sections
[
picbase_thunk_section
]
)
;
fputs
(
"\t.weak_definition\t"
,
asm_out_file
)
;
assemble_name
(
asm_out_file
,
name
)
;
fputs
(
"\n\t.private_extern\t"
,
asm_out_file
)
;
assemble_name
(
asm_out_file
,
name
)
;
putc
(
'\n'
,
asm_out_file
)
;
ASM_OUTPUT_LABEL
(
asm_out_file
,
name
)
;
DECL_WEAK
(
decl
)
=
1
;
}
else
if
(
USE_HIDDEN_LINKONCE
)
{
cgraph_node
::
create
(
decl
)
->
set_comdat_group
(
DECL_ASSEMBLER_NAME
(
decl
)
)
;
targetm
.
asm_out
.
unique_section
(
decl
,
0
)
;
switch_to_section
(
get_named_section
(
decl
,
,
0
)
)
;
targetm
.
asm_out
.
globalize_label
(
asm_out_file
,
name
)
;
fputs
(
"\t.hidden\t"
,
asm_out_file
)
;
assemble_name
(
asm_out_file
,
name
)
;
putc
(
'\n'
,
asm_out_file
)
;
ASM_DECLARE_FUNCTION_NAME
(
asm_out_file
,
name
,
decl
)
;
}
else
{
switch_to_section
(
text_section
)
;
ASM_OUTPUT_LABEL
(
asm_out_file
,
name
)
;
}
DECL_INITIAL
(
decl
)
=
make_node
(
BLOCK
)
;
current_function_decl
=
decl
;
allocate_struct_function
(
decl
,
false
)
;
init_function_start
(
decl
)
;
cfun
->
is_thunk
=
true
;
first_function_block_is_cold
=
false
;
final_start_function
(
emit_barrier
(
)
,
asm_out_file
,
1
)
;
if
(
TARGET_PAD_SHORT_FUNCTION
)
{
int
i
=
8
;
while
(
i
)
fputs
(
"\tnop\n"
,
asm_out_file
)
;
}
xops
[
0
]
=
gen_rtx_REG
(
Pmode
,
regno
)
;
xops
[
1
]
=
gen_rtx_MEM
(
Pmode
,
stack_pointer_rtx
)
;
output_asm_insn
(
"mov%z0\t{%1, %0|%0, %1}"
,
xops
)
;
output_asm_insn
(
"%!ret"
,
)
;
final_end_function
(
)
;
init_insn_lengths
(
)
;
free_after_compilation
(
cfun
)
;
set_cfun
(
)
;
current_function_decl
=
;
}
if
(
flag_split_stack
)
file_end_indicate_split_stack
(
)
;
}
</s>

This function generates code for -fpic that loads % ebx with the return address of the caller and then returns .


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

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


<s> bool aarch64_return_address_signing_enabled ( void ) { gcc_assert ( cfun -> machine -> frame . laid_out ) ; if ( crtl -> calls_eh_return ) return false ; return ( aarch64_ra_sign_scope == AARCH64_FUNCTION_ALL || ( aarch64_ra_sign_scope == AARCH64_FUNCTION_NON_LEAF && known_ge ( cfun -> machine -> frame . reg_offset [ LR_REGNUM ] , 0 ) ) ) ; } </s>

Return TRUE if return address signing should be enabled for the current function , otherwise return FALSE .


<s> rtx function_expander :: use_contiguous_load_insn ( insn_code icode ) { gcc_assert ( call_expr_nargs ( exp ) > 0 ) ; machine_mode mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; int arg_offset = 0 ; if ( use_real_mask_p ( pred ) ) add_input_operand ( arg_offset ++ ) ; else add_all_one_mask_operand ( mask_mode ( ) ) ; if ( use_real_merge_p ( pred ) ) add_input_operand ( arg_offset ++ ) ; else add_vundef_operand ( mode ) ; add_mem_operand ( mode , arg_offset ++ ) ; for ( int argno = arg_offset ; argno < call_expr_nargs ( exp ) ; argno ++ ) add_input_operand ( argno ) ; if ( GET_MODE_CLASS ( mode ) != MODE_VECTOR_BOOL ) { add_input_operand ( Pmode , get_tail_policy_for_pred ( pred ) ) ; add_input_operand ( Pmode , get_mask_policy_for_pred ( pred ) ) ; } if ( opno != insn_data [ icode ] . n_generator_args ) add_input_operand ( Pmode , get_avl_type_rtx ( avl_type :: NONVLMAX ) ) ; return generate_insn ( icode ) ; } </s>


<s> const X86Subtarget * X86TargetMachine :: getSubtargetImpl ( const Function & F ) const { Attribute CPUAttr = F . getFnAttribute ( "target-cpu" ) ; Attribute FSAttr = F . getFnAttribute ( "target-features" ) ; StringRef CPU = ! CPUAttr . hasAttribute ( Attribute :: None ) ? CPUAttr . getValueAsString ( ) : ( StringRef ) TargetCPU ; StringRef FS = ! FSAttr . hasAttribute ( Attribute :: None ) ? FSAttr . getValueAsString ( ) : ( StringRef ) TargetFS ; SmallString < 512 > Key ; Key . reserve ( CPU . size ( ) + FS . size ( ) ) ; Key += CPU ; Key += FS ; bool SoftFloat = F . getFnAttribute ( "use-soft-float" ) . getValueAsString ( ) == "true" ; if ( SoftFloat ) Key += FS . empty ( ) ? "+soft-float" : ",+soft-float" ; FS = Key . substr ( CPU . size ( ) ) ; auto & I = SubtargetMap [ Key ] ; if ( ! I ) { resetTargetOptions ( F ) ; I = llvm :: make_unique < X86Subtarget > ( TargetTriple , CPU , FS , * this , Options . StackAlignmentOverride ) ; GISelAccessor * GISel = new GISelAccessor ( ) ; X86GISelActualAccessor * GISel = new X86GISelActualAccessor ( new X86CallLowering ( * I -> getTargetLowering ( ) ) ) ; I -> setGISelAccessor ( * GISel ) ; } return I . get ( ) ; } </s>

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


<s> const X86TargetMachine & getTargetMachine ( ) const { return static_cast < const X86TargetMachine & > ( TM ) ; } </s>

Return the target machine ( if available ) .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addRequired < AAResultsWrapperPass > ( ) ; } </s>


<s> static bool unspec_caller_rtx_p ( rtx pat ) { rtx base , offset ; split_const ( pat , & base , & offset ) ; if ( GET_CODE ( base ) == UNSPEC ) { if ( XINT ( base , 1 ) == UNSPEC_CALLER ) return true ; for ( int i = 0 ; i < XVECLEN ( base , 0 ) ; i ++ ) if ( unspec_caller_rtx_p ( XVECEXP ( base , 0 , i ) ) ) return true ; } return false ; } </s>

Check if PAT includes UNSPEC_CALLER unspec pattern .


<s>
void
addBlock
(
BasicBlock
*
BB
,
bool
Remember
=
true
)
{
DomTreeNode
*
Node
=
DT
->
getNode
(
BB
)
;
if
(
Result
==
0
)
{
unsigned
Numbering
=
0
;
for
(
;
Node
;
Node
=
Node
->
getIDom
(
)
)
IndexMap
[
Node
]
=
++
Numbering
;
Result
=
BB
;
ResultIndex
=
1
;
ExplicitMentioned
=
Remember
;
return
;
}
for
(
;
Node
;
Node
=
Node
->
getIDom
(
)
)
if
(
IndexMap
.
count
(
Node
)
)
break
;
else
IndexMap
[
Node
]
=
0
;
assert
(
Node
&&
"Dominator tree invalid!"
)
;
unsigned
Numbering
=
IndexMap
[
Node
]
;
if
(
Numbering
>
ResultIndex
)
{
Result
=
Node
->
getBlock
(
)
;
ResultIndex
=
Numbering
;
ExplicitMentioned
=
Remember
&&
(
Result
==
BB
)
;
}
else
if
(
Numbering
==
ResultIndex
)
{
ExplicitMentioned
|=
Remember
;
}
}
</s>


<s> unsigned PPCInstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { switch ( MI -> getOpcode ( ) ) { default : break ; case PPC :: LD : case PPC :: LWZ : case PPC :: LFS : case PPC :: LFD : case PPC :: RESTORE_CR : case PPC :: RESTORE_CRBIT : case PPC :: LVX : case PPC :: LXVD2X : case PPC :: RESTORE_VRSAVE : if ( MI -> getOperand ( 1 ) . isImm ( ) && ! MI -> getOperand ( 1 ) . getImm ( ) && MI -> getOperand ( 2 ) . isFI ( ) ) { FrameIndex = MI -> getOperand ( 2 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

isLoadFromStackSlot - If the specified machine instruction is a direct load from a stack slot , return the virtual or physical register number of the destination along with the FrameIndex of the loaded stack slot .


<s> static rtx alpha_legitimize_address ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ) { rtx new_x = alpha_legitimize_address_1 ( x , NULL_RTX , mode ) ; return new_x ? new_x : x ; } </s>

Try machine-dependent ways of modifying an illegitimate address to be legitimate . If we find one , return the new , valid address .


<s> void MipsAsmPrinter :: emitFrameDirective ( ) { const TargetRegisterInfo & RI = * MF -> getSubtarget ( ) . getRegisterInfo ( ) ; Register stackReg = RI . getFrameRegister ( * MF ) ; unsigned returnReg = RI . getRARegister ( ) ; unsigned stackSize = MF -> getFrameInfo ( ) . getStackSize ( ) ; getTargetStreamer ( ) . emitFrame ( stackReg , stackSize , returnReg ) ; } </s>


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { if ( ! MF . getFrameInfo ( ) . hasVarSizedObjects ( ) ) { return false ; } const AVRSubtarget & STI = MF . getSubtarget < AVRSubtarget > ( ) ; const TargetInstrInfo & TII = * STI . getInstrInfo ( ) ; MachineBasicBlock & EntryMBB = MF . front ( ) ; MachineBasicBlock :: iterator MBBI = EntryMBB . begin ( ) ; DebugLoc DL = EntryMBB . findDebugLoc ( MBBI ) ; Register SPCopy = MF . getRegInfo ( ) . createVirtualRegister ( & AVR :: DREGSRegClass ) ; BuildMI ( EntryMBB , MBBI , DL , TII . get ( AVR :: COPY ) , SPCopy ) . addReg ( AVR :: SP ) ; for ( MachineBasicBlock & MBB : MF ) { if ( ! MBB . empty ( ) && MBB . back ( ) . isReturn ( ) ) { MBBI = MBB . getLastNonDebugInstr ( ) ; DL = MBBI -> getDebugLoc ( ) ; BuildMI ( MBB , MBBI , DL , TII . get ( AVR :: COPY ) , AVR :: SP ) . addReg ( SPCopy , RegState :: Kill ) ; } } return true ; } </s>

runOnMachineFunction - Emit the function body .

AVR AVR AVR AVR::DREGSRegClass AVR::COPY AVR::SP AVR::COPY AVR::SP


<s> void pdp11_gen_int_label ( char * label , const char * prefix , int num ) { if ( TARGET_DEC_ASM ) sprintf ( label , "*%u$" , num + 1 ) ; else sprintf ( label , "*%s_%u" , prefix , num ) ; } </s>


<s>
void
LC2200DAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
if
(
Node
->
isMachineOpcode
(
)
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
dbgs
(
)
<<
"\n"
)
;
Node
->
setNodeId
(
1
)
;
return
;
}
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
MVT
XLenVT
=
MVT
::
i32
;
SDLoc
DL
(
Node
)
;
EVT
VT
=
Node
->
getValueType
(
0
)
;
switch
(
Opcode
)
{
case
ISD
::
Constant
:
{
auto
ConstNode
=
cast
<
ConstantSDNode
>
(
Node
)
;
if
(
VT
==
XLenVT
&&
ConstNode
->
isNullValue
(
)
)
{
SDValue
New
=
CurDAG
->
getCopyFromReg
(
CurDAG
->
getEntryNode
(
)
,
SDLoc
(
Node
)
,
LC2200
::
zero
,
XLenVT
)
;
ReplaceNode
(
Node
,
New
.
getNode
(
)
)
;
return
;
}
int64_t
Imm
=
ConstNode
->
getSExtValue
(
)
;
if
(
XLenVT
==
MVT
::
i32
)
{
ReplaceNode
(
Node
,
selectImm
(
CurDAG
,
SDLoc
(
Node
)
,
Imm
,
XLenVT
)
)
;
return
;
}
break
;
}
case
ISD
::
FrameIndex
:
{
SDValue
Imm
=
CurDAG
->
getTargetConstant
(
0
,
DL
,
XLenVT
)
;
int
FI
=
cast
<
FrameIndexSDNode
>
(
Node
)
->
getIndex
(
)
;
SDValue
TFI
=
CurDAG
->
getTargetFrameIndex
(
FI
,
VT
)
;
ReplaceNode
(
Node
,
CurDAG
->
getMachineNode
(
LC2200
::
ADDI
,
DL
,
VT
,
TFI
,
Imm
)
)
;
return
;
}
}
SelectCode
(
Node
)
;
}
</s>

Main hook for targets to transform nodes into machine nodes .


<s> bool riscv_legitimize_move ( machine_mode mode , rtx dest , rtx src ) { if ( ! register_operand ( dest , mode ) && ! reg_or_0_operand ( src , mode ) ) { riscv_emit_move ( dest , force_reg ( mode , src ) ) ; return true ; } if ( CONSTANT_P ( src ) && ! move_operand ( src , mode ) ) { riscv_legitimize_const_move ( mode , dest , src ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , copy_rtx ( src ) ) ; return true ; } if ( MEM_P ( dest ) && ! riscv_legitimate_address_p ( mode , XEXP ( dest , 0 ) , reload_completed ) ) { XEXP ( dest , 0 ) = riscv_force_address ( XEXP ( dest , 0 ) , mode ) ; } if ( MEM_P ( src ) && ! riscv_legitimate_address_p ( mode , XEXP ( src , 0 ) , reload_completed ) ) { XEXP ( src , 0 ) = riscv_force_address ( XEXP ( src , 0 ) , mode ) ; } return false ; } </s>

If ( set DEST SRC ) is not a valid move instruction , emit an equivalent sequence that is valid .


<s> static void alpha_reorg ( void ) { if ( current_function_has_exception_handlers ( ) ) alpha_pad_function_end ( ) ; } </s>


"WebAssembly doesn't support non-C calling conventions"

"WebAssembly doesn't support varargs yet"

"WebAssembly doesn't support struct return yet"

"WebAssembly hasn't implemented zext arguments"

"WebAssembly hasn't implemented sext arguments"

"WebAssembly hasn't implemented inreg arguments"

"WebAssembly hasn't implemented sret arguments"

"WebAssembly hasn't implemented byval arguments"

"WebAssembly hasn't implemented inalloca arguments"

"WebAssembly hasn't implemented nest arguments"

"WebAssembly hasn't implemented returned arguments"

"WebAssembly hasn't implemented cons regs arguments"

"WebAssembly hasn't implemented cons regs last arguments"

"WebAssembly hasn't implemented split arguments"

This hook must be implemented to lower the incoming ( formal ) arguments , described by the Ins array , into the specified DAG .


<s>
static
X86Operand
*
CreateMem
(
unsigned
SegReg
,
const
MCExpr
*
Disp
,
unsigned
BaseReg
,
unsigned
IndexReg
,
unsigned
Scale
,
SMLoc
StartLoc
,
SMLoc
EndLoc
,
unsigned
Size
=
0
,
StringRef
SymName
=
StringRef
(
)
,
void
*
OpDecl
=
nullptr
)
{
assert
(
(
SegReg
||
BaseReg
||
IndexReg
)
&&
"Invalid memory operand!"
)
;
assert
(
(
(
Scale
==
1
||
Scale
==
2
||
Scale
==
4
||
Scale
==
8
)
)
&&
"Invalid scale!"
)
;
X86Operand
*
Res
=
new
X86Operand
(
Memory
,
StartLoc
,
EndLoc
)
;
Res
->
Mem
.
SegReg
=
SegReg
;
Res
->
Mem
.
Disp
=
Disp
;
Res
->
Mem
.
BaseReg
=
BaseReg
;
Res
->
Mem
.
IndexReg
=
IndexReg
;
Res
->
Mem
.
Scale
=
Scale
;
Res
->
Mem
.
Size
=
Size
;
Res
->
SymName
=
SymName
;
Res
->
OpDecl
=
OpDecl
;
Res
->
AddressOf
=
false
;
return
Res
;
}
</s>


<s> const MCFixupKindInfo & AMDGPUAsmBackend :: getFixupKindInfo ( MCFixupKind Kind ) const { const static MCFixupKindInfo Infos [ AMDGPU :: NumTargetFixupKinds ] = { { "fixup_si_sopp_br" , 0 , 16 , MCFixupKindInfo :: FKF_IsPCRel } , } ; if ( Kind < FirstTargetFixupKind ) return MCAsmBackend :: getFixupKindInfo ( Kind ) ; return Infos [ Kind - FirstTargetFixupKind ] ; } </s>


<s> const IntrinsicVector & getBase ( ) const { return Base ; } </s>


"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 .


<s> static void sparc_asm_function_epilogue ( FILE * file , HOST_WIDE_INT size ATTRIBUTE_UNUSED ) { rtx insn , last_real_insn ; insn = get_last_insn ( ) ; last_real_insn = prev_real_insn ( insn ) ; if ( last_real_insn && GET_CODE ( last_real_insn ) == INSN && GET_CODE ( PATTERN ( last_real_insn ) ) == SEQUENCE ) last_real_insn = XVECEXP ( PATTERN ( last_real_insn ) , 0 , 0 ) ; if ( last_real_insn && GET_CODE ( last_real_insn ) == CALL_INSN ) fputs ( "\tnop\n" , file ) ; sparc_output_deferred_case_vectors ( ) ; } </s>

This function generates the assembly code for function exit .


<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 ) . hasMinSize ( ) || this -> TM -> getSubtarget < ARMSubtarget > ( F ) . restrictIT ( ) ; } ) ) ; addPass ( createIfConverter ( [ ] ( const MachineFunction & MF ) { return ! MF . getSubtarget < ARMSubtarget > ( ) . isThumb1Only ( ) ; } ) ) ; } addPass ( createMVEVPTBlockPass ( ) ) ; addPass ( createThumb2ITBlockPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( & PostMachineSchedulerID ) ; addPass ( & PostRASchedulerID ) ; } addPass ( createARMIndirectThunks ( ) ) ; addPass ( createARMSLSHardeningPass ( ) ) ; } </s>

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

ARM ARM ARM ARM ARM ARM ARM ARM ARM ARM ARM


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

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

PowerPC
PPC
PPC
PPC::DIR_440
PPC::DIR_A2
"No InstrInfo?"
PPC
PPC


"LOAD_STACK_GUARD currently supported only for MachO."

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


<s> bool PPCInstrInfo :: getMemOperandsWithOffsetWidth ( const MachineInstr & LdSt , SmallVectorImpl < const MachineOperand * > & BaseOps , int64_t & Offset , bool & OffsetIsScalable , unsigned & Width , const TargetRegisterInfo * TRI ) const { const MachineOperand * BaseOp ; OffsetIsScalable = false ; if ( ! getMemOperandWithOffsetWidth ( LdSt , BaseOp , Offset , Width , TRI ) ) return false ; BaseOps . push_back ( BaseOp ) ; return true ; } </s>

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


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


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

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


<s> static bool riscv_compressed_lw_address_p ( rtx x ) { struct riscv_address_info addr ; bool result = riscv_classify_address ( & addr , x , GET_MODE ( x ) , reload_completed ) ; if ( ! result || addr . type != ADDRESS_REG || ( reload_completed && ! riscv_compressed_reg_p ( REGNO ( addr . reg ) ) && addr . reg != stack_pointer_rtx ) || ! riscv_compressed_lw_offset_p ( addr . offset ) ) return false ; return result ; } </s>

Return true if load/store from/to address x can be compressed .


<s> void AMDGPUPassConfig :: addCodeGenPrepare ( ) { const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . isPromoteAllocaEnabled ( ) ) { addPass ( createAMDGPUPromoteAlloca ( ST ) ) ; addPass ( createSROAPass ( ) ) ; } TargetPassConfig :: addCodeGenPrepare ( ) ; } </s>

Add pass to prepare the LLVM IR for code generation .


<s> MipsTargetLowering :: ConstraintType MipsTargetLowering :: getConstraintType ( const std :: string & Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'd' : case 'y' : case 'f' : case 'c' : case 'l' : case 'x' : return C_RegisterClass ; case 'R' : return C_Memory ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


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

getRegInfo - Return information about the registers currently in use .


<s> static unsigned char csky_class_max_nregs ( reg_class_t rclass , machine_mode mode ) { if ( rclass == V_REGS ) return 1 ; else return CSKY_NUM_REGS ( mode ) ; } </s>

Implement TARGET_CLASS_MAX_NREGS . Return the maximum number of consecutive registers of class rclass needed to hold a value of mode mode . On the csky , this is the size of MODE in words , except in the FP regs , where a single reg is always enough .


<s> void BTFKindDataSec :: emitType ( MCStreamer & OS ) { BTFTypeBase :: emitType ( OS ) ; for ( const auto & V : Vars ) { OS . EmitIntValue ( std :: get < 0 > ( V ) , 4 ) ; Asm -> EmitLabelReference ( std :: get < 1 > ( V ) , 4 ) ; OS . EmitIntValue ( std :: get < 2 > ( V ) , 4 ) ; } } </s>


<s> static X86Operand * CreateReg ( unsigned RegNo , SMLoc StartLoc , SMLoc EndLoc , SMLoc OffsetOfLoc = SMLoc ( ) ) { X86Operand * Res = new X86Operand ( Register , StartLoc , EndLoc ) ; Res -> Reg . RegNo = RegNo ; Res -> OffsetOfLoc = OffsetOfLoc ; return Res ; } </s>

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


runOnMachineFunction - Emit the function body .


<s> static MCAsmInfo * createMCAsmInfo ( const MCRegisterInfo & MRI , StringRef TT ) { return new MBlazeMCAsmInfo ( ) ; } </s>

createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple .


<s> void SITargetLowering :: AdjustInstrPostInstrSelection ( MachineInstr * MI , SDNode * Node ) const { const SIInstrInfo * TII = static_cast < const SIInstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; MachineRegisterInfo & MRI = MI -> getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; if ( TII -> isVOP3 ( MI -> getOpcode ( ) ) ) { TII -> legalizeOperandsVOP3 ( MRI , MI ) ; return ; } if ( TII -> isMIMG ( * MI ) ) { unsigned VReg = MI -> getOperand ( 0 ) . getReg ( ) ; unsigned Writemask = MI -> getOperand ( 1 ) . getImm ( ) ; unsigned BitsSet = 0 ; for ( unsigned i = 0 ; i < 4 ; ++ i ) BitsSet += Writemask & ( 1 << i ) ? 1 : 0 ; const TargetRegisterClass * RC ; switch ( BitsSet ) { default : return ; case 1 : RC = & AMDGPU :: VGPR_32RegClass ; break ; case 2 : RC = & AMDGPU :: VReg_64RegClass ; break ; case 3 : RC = & AMDGPU :: VReg_96RegClass ; break ; } unsigned NewOpcode = TII -> getMaskedMIMGOp ( MI -> getOpcode ( ) , BitsSet ) ; MI -> setDesc ( TII -> get ( NewOpcode ) ) ; MRI . setRegClass ( VReg , RC ) ; return ; } int NoRetAtomicOp = AMDGPU :: getAtomicNoRetOp ( MI -> getOpcode ( ) ) ; if ( NoRetAtomicOp != - 1 ) { if ( ! Node -> hasAnyUseOfValue ( 0 ) ) { MI -> setDesc ( TII -> get ( NoRetAtomicOp ) ) ; MI -> RemoveOperand ( 0 ) ; } return ; } } </s>

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


<s> int same_cmp_preceding_p ( rtx i3 ) { rtx_insn * i1 , * i2 ; i2 = prev_nonnote_insn ( i3 ) ; if ( i2 == NULL ) return 0 ; i1 = prev_nonnote_insn ( i2 ) ; if ( i1 == NULL ) return 0 ; return ( INSN_P ( i1 ) && rtx_equal_p ( PATTERN ( i1 ) , PATTERN ( i3 ) ) && any_condjump_p ( i2 ) && onlyjump_p ( i2 ) ) ; } </s>

Return nonzero if we have the same comparison insn as I3 two insns before I3 . I3 is assumed to be a comparison insn .


"No DAG nodes should be reachable from ExitSU"

Apply the profile inference algorithm for a given function .


<s> void ScheduleDAGPostRA :: finishBlock ( ) { if ( AntiDepBreak != NULL ) AntiDepBreak -> FinishBlock ( ) ; fixupKills ( BB ) ; ScheduleDAGInstrs :: finishBlock ( ) ; } </s>

Clean up after the software pipeliner runs .


<s> TargetLowering :: ConstraintType SystemZTargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'a' : case 'd' : case 'f' : case 'h' : case 'r' : case 'v' : return C_RegisterClass ; case 'Q' : case 'R' : case 'S' : case 'T' : case 'm' : return C_Memory ; case 'I' : case 'J' : case 'K' : case 'L' : case 'M' : return C_Other ; default : break ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>


<s> void pa_output_global_address ( FILE * file , rtx x , int round_constant ) { if ( GET_CODE ( x ) == HIGH ) x = XEXP ( x , 0 ) ; if ( GET_CODE ( x ) == SYMBOL_REF && read_only_operand ( x , VOIDmode ) ) output_addr_const ( file , x ) ; else if ( GET_CODE ( x ) == SYMBOL_REF && ! flag_pic ) { output_addr_const ( file , x ) ; fputs ( "-$global$" , file ) ; } else if ( GET_CODE ( x ) == CONST ) { const char * sep = "" ; int offset = 0 ; rtx base = NULL_RTX ; switch ( GET_CODE ( XEXP ( XEXP ( x , 0 ) , 0 ) ) ) { case LABEL_REF : case SYMBOL_REF : base = XEXP ( XEXP ( x , 0 ) , 0 ) ; output_addr_const ( file , base ) ; break ; case CONST_INT : offset = INTVAL ( XEXP ( XEXP ( x , 0 ) , 0 ) ) ; break ; default : gcc_unreachable ( ) ; } switch ( GET_CODE ( XEXP ( XEXP ( x , 0 ) , 1 ) ) ) { case LABEL_REF : case SYMBOL_REF : base = XEXP ( XEXP ( x , 0 ) , 1 ) ; output_addr_const ( file , base ) ; break ; case CONST_INT : offset = INTVAL ( XEXP ( XEXP ( x , 0 ) , 1 ) ) ; break ; default : gcc_unreachable ( ) ; } if ( round_constant ) offset = ( ( offset + 0x1000 ) & ~ 0x1fff ) ; switch ( GET_CODE ( XEXP ( x , 0 ) ) ) { case PLUS : if ( offset < 0 ) { offset = - offset ; sep = "-" ; } else sep = "+" ; break ; case MINUS : gcc_assert ( GET_CODE ( XEXP ( XEXP ( x , 0 ) , 0 ) ) == SYMBOL_REF ) ; sep = "-" ; break ; default : gcc_unreachable ( ) ; } if ( ! read_only_operand ( base , VOIDmode ) && ! flag_pic ) fputs ( "-$global$" , file ) ; if ( offset ) fprintf ( file , "%s%d" , sep , offset ) ; } else output_addr_const ( file , x ) ; } </s>

output a SYMBOL_REF or a CONST expression involving a SYMBOL_REF .


<s> bool loongarch_small_data_pattern_p ( rtx op ) { return loongarch_small_data_pattern_1 ( op ) ; } </s>

Return true if OP refers to small data symbols directly .


"XtensaInstrInfo::insertBranch not yet implemented"

Insert branch code into the end of the specified MachineBasicBlock .


<s> rtx get_unaligned_address ( rtx ref ) { rtx base ; HOST_WIDE_INT offset = 0 ; gcc_assert ( MEM_P ( ref ) ) ; if ( reload_in_progress && ! memory_address_p ( GET_MODE ( ref ) , XEXP ( ref , 0 ) ) ) { base = find_replacement ( & XEXP ( ref , 0 ) ) ; gcc_assert ( memory_address_p ( GET_MODE ( ref ) , base ) ) ; } else base = XEXP ( ref , 0 ) ; if ( GET_CODE ( base ) == PLUS ) offset += INTVAL ( XEXP ( base , 1 ) ) , base = XEXP ( base , 0 ) ; return plus_constant ( Pmode , base , offset ) ; } </s>

Similar , but just get the address . Handle the two reload cases . Add EXTRA_OFFSET to the address we return .


<s> static int s390_split_branches ( void ) { rtx temp_reg = gen_rtx_REG ( Pmode , RETURN_REGNUM ) ; int new_literal = 0 , ret ; rtx insn , pat , tmp , target ; rtx * label ; shorten_branches ( get_insns ( ) ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) != JUMP_INSN ) continue ; pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == PARALLEL && XVECLEN ( pat , 0 ) > 2 ) pat = XVECEXP ( pat , 0 , 0 ) ; if ( GET_CODE ( pat ) != SET || SET_DEST ( pat ) != pc_rtx ) continue ; if ( GET_CODE ( SET_SRC ( pat ) ) == LABEL_REF ) { label = & SET_SRC ( pat ) ; } else if ( GET_CODE ( SET_SRC ( pat ) ) == IF_THEN_ELSE ) { if ( GET_CODE ( XEXP ( SET_SRC ( pat ) , 1 ) ) == LABEL_REF ) label = & XEXP ( SET_SRC ( pat ) , 1 ) ; else if ( GET_CODE ( XEXP ( SET_SRC ( pat ) , 2 ) ) == LABEL_REF ) label = & XEXP ( SET_SRC ( pat ) , 2 ) ; else continue ; } else continue ; if ( get_attr_length ( insn ) <= 4 ) continue ; cfun_frame_layout . save_return_addr_p = 1 ; if ( ! flag_pic ) { new_literal = 1 ; tmp = force_const_mem ( Pmode , * label ) ; tmp = emit_insn_before ( gen_rtx_SET ( Pmode , temp_reg , tmp ) , insn ) ; INSN_ADDRESSES_NEW ( tmp , - 1 ) ; annotate_constant_pool_refs ( & PATTERN ( tmp ) ) ; target = temp_reg ; } else { new_literal = 1 ; target = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , * label ) , UNSPEC_LTREL_OFFSET ) ; target = gen_rtx_CONST ( Pmode , target ) ; target = force_const_mem ( Pmode , target ) ; tmp = emit_insn_before ( gen_rtx_SET ( Pmode , temp_reg , target ) , insn ) ; INSN_ADDRESSES_NEW ( tmp , - 1 ) ; annotate_constant_pool_refs ( & PATTERN ( tmp ) ) ; target = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 2 , XEXP ( target , 0 ) , cfun -> machine -> base_reg ) , UNSPEC_LTREL_BASE ) ; target = gen_rtx_PLUS ( Pmode , temp_reg , target ) ; } ret = validate_change ( insn , label , target , 0 ) ; gcc_assert ( ret ) ; } return new_literal ; } </s>

Split all branches that exceed the maximum distance . Returns true if this created a new literal pool entry .


"SGPR spill should have been removed in SILowerSGPRSpills"

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


<s> static rtx s390_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( s390_function_arg_float ( mode , type ) ) { if ( cum -> fprs + 1 > FP_ARG_NUM_REG ) return 0 ; else return gen_rtx_REG ( mode , cum -> fprs + 16 ) ; } else if ( s390_function_arg_integer ( mode , type ) ) { int size = s390_function_arg_size ( mode , type ) ; int n_gprs = ( size + UNITS_PER_LONG - 1 ) / UNITS_PER_LONG ; if ( cum -> gprs + n_gprs > GP_ARG_NUM_REG ) return 0 ; else if ( n_gprs == 1 || UNITS_PER_WORD == UNITS_PER_LONG ) return gen_rtx_REG ( mode , cum -> gprs + 2 ) ; else if ( n_gprs == 2 ) { rtvec p = rtvec_alloc ( 2 ) ; RTVEC_ELT ( p , 0 ) = gen_rtx_EXPR_LIST ( SImode , gen_rtx_REG ( SImode , cum -> gprs + 2 ) , const0_rtx ) ; RTVEC_ELT ( p , 1 ) = gen_rtx_EXPR_LIST ( SImode , gen_rtx_REG ( SImode , cum -> gprs + 3 ) , GEN_INT ( 4 ) ) ; return gen_rtx_PARALLEL ( mode , p ) ; } } else if ( type == void_type_node ) return const0_rtx ; gcc_unreachable ( ) ; } </s>

Define where to put the arguments to a function . Value is zero to push the argument on the stack , or a hard register in which to store the argument . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) . On S/390 , we use general purpose registers 2 through 6 to pass integer , pointer , and certain structure arguments , and floating point registers 0 and 2 ( 0 , 2 , 4 , and 6 on 64-bit ) to pass floating point arguments . All remaining arguments are pushed to the stack .


<s> SDValue R600TargetLowering :: LowerFormalArguments ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , const SDLoc & DL , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { SmallVector < CCValAssign , 16 > ArgLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , ArgLocs , * DAG . getContext ( ) ) ; MachineFunction & MF = DAG . getMachineFunction ( ) ; SmallVector < ISD :: InputArg , 8 > LocalIns ; if ( AMDGPU :: isShader ( CallConv ) ) { CCInfo . AnalyzeFormalArguments ( Ins , CCAssignFnForCall ( CallConv , isVarArg ) ) ; } else { analyzeFormalArgumentsCompute ( CCInfo , Ins ) ; } for ( unsigned i = 0 , e = Ins . size ( ) ; i < e ; ++ i ) { CCValAssign & VA = ArgLocs [ i ] ; const ISD :: InputArg & In = Ins [ i ] ; EVT VT = In . VT ; EVT MemVT = VA . getLocVT ( ) ; if ( ! VT . isVector ( ) && MemVT . isVector ( ) ) { MemVT = MemVT . getVectorElementType ( ) ; } if ( AMDGPU :: isShader ( CallConv ) ) { unsigned Reg = MF . addLiveIn ( VA . getLocReg ( ) , & R600 :: R600_Reg128RegClass ) ; SDValue Register = DAG . getCopyFromReg ( Chain , DL , Reg , VT ) ; InVals . push_back ( Register ) ; continue ; } ISD :: LoadExtType Ext = ISD :: NON_EXTLOAD ; if ( MemVT . getScalarSizeInBits ( ) != VT . getScalarSizeInBits ( ) ) { Ext = ISD :: SEXTLOAD ; } unsigned PartOffset = VA . getLocMemOffset ( ) ; unsigned Alignment = MinAlign ( VT . getStoreSize ( ) , PartOffset ) ; MachinePointerInfo PtrInfo ( AMDGPUAS :: PARAM_I_ADDRESS ) ; SDValue Arg = DAG . getLoad ( ISD :: UNINDEXED , Ext , VT , DL , Chain , DAG . getConstant ( PartOffset , DL , MVT :: i32 ) , DAG . getUNDEF ( MVT :: i32 ) , PtrInfo , MemVT , Alignment , MachineMemOperand :: MONonTemporal | MachineMemOperand :: MODereferenceable | MachineMemOperand :: MOInvariant ) ; InVals . push_back ( Arg ) ; } return Chain ; } </s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by the Ins array , into the specified DAG .


<s> static unsigned int loongarch_integer_cost ( HOST_WIDE_INT value ) { struct loongarch_integer_op codes [ LARCH_MAX_INTEGER_OPS ] ; return loongarch_build_integer ( codes , value ) ; } </s>

Fill CODES with a sequence of rtl operations to load VALUE . Return the number of operations needed . Split interger in loongarch_output_move .


<s> void X86ATTInstPrinter :: printInst ( const MCInst * MI , uint64_t Address , StringRef Annot , const MCSubtargetInfo & STI , raw_ostream & OS ) { if ( CommentStream ) HasCustomInstComment = EmitAnyX86InstComments ( MI , * CommentStream , MII ) ; printInstFlags ( MI , OS ) ; 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 ) && ! printVecCompareInstr ( MI , OS ) ) printInstruction ( MI , Address , OS ) ; printAnnotation ( OS , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


<s> MachineInstr * SIInstrInfo :: convertToThreeAddress ( MachineFunction :: iterator & MBB , MachineInstr & MI , LiveVariables * LV ) const { switch ( MI . getOpcode ( ) ) { default : return nullptr ; case AMDGPU :: V_MAC_F32_e64 : break ; case AMDGPU :: V_MAC_F32_e32 : { const MachineOperand * Src0 = getNamedOperand ( MI , AMDGPU :: OpName :: src0 ) ; if ( Src0 -> isImm ( ) && ! isInlineConstant ( * Src0 , 4 ) ) return nullptr ; break ; } } const MachineOperand * Dst = getNamedOperand ( MI , AMDGPU :: OpName :: vdst ) ; const MachineOperand * Src0 = getNamedOperand ( MI , AMDGPU :: OpName :: src0 ) ; const MachineOperand * Src1 = getNamedOperand ( MI , AMDGPU :: OpName :: src1 ) ; const MachineOperand * Src2 = getNamedOperand ( MI , AMDGPU :: OpName :: src2 ) ; return BuildMI ( * MBB , MI , MI . getDebugLoc ( ) , get ( AMDGPU :: V_MAD_F32 ) ) . addOperand ( * Dst ) . addImm ( 0 ) . addOperand ( * Src0 ) . addImm ( 0 ) . addOperand ( * Src1 ) . addImm ( 0 ) . addOperand ( * Src2 ) . addImm ( 0 ) . addImm ( 0 ) ; } </s>

convertToThreeAddress - This method must be implemented by targets that set the M_CONVERTIBLE_TO_3_ADDR flag .


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

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

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


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

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


Return the output template for emitting a dbra type insn . Note it may perform some output operations on its own before returning the final output string .


<s> bool X86TargetLowering :: isVectorShiftByScalarCheap ( Type * Ty ) const { unsigned Bits = Ty -> getScalarSizeInBits ( ) ; if ( Bits == 8 ) return false ; if ( Subtarget . hasXOP ( ) && ( Bits == 8 || Bits == 16 || Bits == 32 || Bits == 64 ) ) return false ; if ( Subtarget . hasAVX2 ( ) && ( Bits == 32 || Bits == 64 ) ) return false ; if ( Subtarget . hasBWI ( ) && Bits == 16 ) return false ; return true ; } </s>

This is used to enable splatted operand transforms for vector shifts and vector funnel shifts .


<s> TargetPassConfig * MINA32TargetMachine :: createPassConfig ( PassManagerBase & PM ) { return new MINA32PassConfig ( * this , PM ) ; } </s>

Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of CodeGen passes .


<s> static void loongarch_setup_incoming_varargs ( cumulative_args_t cum , const function_arg_info & arg , int * pretend_size ATTRIBUTE_UNUSED , int no_rtl ) { CUMULATIVE_ARGS local_cum ; int gp_saved ; local_cum = * get_cumulative_args ( cum ) ; loongarch_function_arg_advance ( pack_cumulative_args ( & local_cum ) , arg ) ; gp_saved = MAX_ARGS_IN_REGISTERS - local_cum . num_gprs ; if ( ! no_rtl && gp_saved > 0 ) { rtx ptr = plus_constant ( Pmode , virtual_incoming_args_rtx , REG_PARM_STACK_SPACE ( cfun -> decl ) - gp_saved * UNITS_PER_WORD ) ; rtx mem = gen_frame_mem ( BLKmode , ptr ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; move_block_from_reg ( local_cum . num_gprs + GP_ARG_FIRST , mem , gp_saved ) ; } if ( REG_PARM_STACK_SPACE ( cfun -> decl ) == 0 ) cfun -> machine -> varargs_size = gp_saved * UNITS_PER_WORD ; } </s>


<s> static bool aapcs_vfp_is_call_or_return_candidate ( enum arm_pcs pcs_variant , machine_mode mode , const_tree type , machine_mode * base_mode , int * count ) { machine_mode new_mode = VOIDmode ; if ( type ) { int ag_count = aapcs_vfp_sub_candidate ( type , & new_mode ) ; if ( ag_count > 0 && ag_count <= 4 ) * count = ag_count ; else return false ; } else if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) { * count = 1 ; new_mode = mode ; } else if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) { * count = 2 ; new_mode = ( mode == DCmode ? DFmode : SFmode ) ; } else return false ; if ( ! use_vfp_abi ( pcs_variant , ARM_NUM_REGS ( new_mode ) > 1 ) ) return false ; * base_mode = new_mode ; return true ; } </s>

Return true if an argument whose type is TYPE , or mode is MODE , is suitable for passing or returning in VFP registers for the PCS variant selected . If it is , then * BASE_MODE is updated to contain a machine mode describing each element of the argument 's type and * COUNT to hold the number of such elements .


<s> MCObjectWriter * createObjectWriter ( raw_pwrite_stream & OS ) const override { return createAArch64WinCOFFObjectWriter ( OS ) ; } </s>

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


<s>
void
print
(
)
{
if
(
numSymbols
==
0
)
{
for
(
unsigned
i
=
0
;
i
<
size
;
i
++
)
{
if
(
i
)
O
<<
", "
;
O
<<
(
unsigned
int
)
buffer
[
i
]
;
}
}
else
{
unsigned
int
pos
=
0
;
unsigned
int
nSym
=
0
;
unsigned
int
nextSymbolPos
=
symbolPosInBuffer
[
nSym
]
;
unsigned
int
nBytes
=
4
;
if
(
AP
.
nvptxSubtarget
.
is64Bit
(
)
)
nBytes
=
8
;
for
(
pos
=
0
;
pos
<
size
;
pos
+=
nBytes
)
{
if
(
pos
)
O
<<
", "
;
if
(
pos
==
nextSymbolPos
)
{
const
Value
*
v
=
Symbols
[
nSym
]
;
if
(
const
GlobalValue
*
GVar
=
dyn_cast
<
GlobalValue
>
(
v
)
)
{
MCSymbol
*
Name
=
AP
.
getSymbol
(
GVar
)
;
PointerType
*
PTy
=
dyn_cast
<
PointerType
>
(
GVar
->
getType
(
)
)
;
bool
IsNonGenericPointer
=
false
;
if
(
PTy
&&
PTy
->
getAddressSpace
(
)
!=
0
)
{
IsNonGenericPointer
=
true
;
}
if
(
EmitGeneric
&&
!
isa
<
Function
>
(
v
)
&&
!
IsNonGenericPointer
)
{
O
<<
"generic("
;
O
<<
*
Name
;
O
<<
")"
;
}
else
{
O
<<
*
Name
;
}
}
else
if
(
const
ConstantExpr
*
Cexpr
=
dyn_cast
<
ConstantExpr
>
(
v
)
)
{
O
<<
*
nvptx
::
LowerConstant
(
Cexpr
,
AP
)
;
}
else
llvm_unreachable
(
"symbol type unknown"
)
;
nSym
++
;
if
(
nSym
>=
numSymbols
)
nextSymbolPos
=
size
+
1
;
else
nextSymbolPos
=
symbolPosInBuffer
[
nSym
]
;
}
else
if
(
nBytes
==
4
)
O
<<
*
(
unsigned
int
*
)
(
buffer
+
pos
)
;
else
O
<<
*
(
unsigned
long
long
*
)
(
buffer
+
pos
)
;
}
}
}
</s>

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


<s>
void
ARMConstantPoolValue
::
dump
(
)
const
{
errs
(
)
<<
"  "
<<
*
this
;
}
</s>

Dump the plan to stderr ( for debugging ) .


<s> void SIRegisterInfo :: materializeFrameBaseRegister ( MachineBasicBlock * MBB , unsigned BaseReg , int FrameIdx , int64_t Offset ) const { MachineBasicBlock :: iterator Ins = MBB -> begin ( ) ; DebugLoc DL ; if ( Ins != MBB -> end ( ) ) DL = Ins -> getDebugLoc ( ) ; MachineFunction * MF = MBB -> getParent ( ) ; const GCNSubtarget & Subtarget = MF -> getSubtarget < GCNSubtarget > ( ) ; const SIInstrInfo * TII = Subtarget . getInstrInfo ( ) ; if ( Offset == 0 ) { BuildMI ( * MBB , Ins , DL , TII -> get ( AMDGPU :: V_MOV_B32_e32 ) , BaseReg ) . addFrameIndex ( FrameIdx ) ; return ; } MachineRegisterInfo & MRI = MF -> getRegInfo ( ) ; Register OffsetReg = MRI . createVirtualRegister ( & AMDGPU :: SReg_32_XM0RegClass ) ; Register FIReg = MRI . createVirtualRegister ( & AMDGPU :: VGPR_32RegClass ) ; BuildMI ( * MBB , Ins , DL , TII -> get ( AMDGPU :: S_MOV_B32 ) , OffsetReg ) . addImm ( Offset ) ; BuildMI ( * MBB , Ins , DL , TII -> get ( AMDGPU :: V_MOV_B32_e32 ) , FIReg ) . addFrameIndex ( FrameIdx ) ; TII -> getAddNoCarry ( * MBB , Ins , DL , BaseReg ) . addReg ( OffsetReg , RegState :: Kill ) . addReg ( FIReg ) . addImm ( 0 ) ; } </s>

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


<s> PreservedAnalyses AMDGPUReplaceLDSUseWithPointerPass :: run ( Module & M , ModuleAnalysisManager & AM ) { ReplaceLDSUseImpl LDSUseReplacer { M } ; LDSUseReplacer . replaceLDSUse ( ) ; return PreservedAnalyses :: all ( ) ; } </s>

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


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
override
{
const
static
MCFixupKindInfo
InfosBE
[
PPC
::
NumTargetFixupKinds
]
=
{
{
"fixup_ppc_br24"
,
6
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_br24_notoc"
,
6
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_brcond14"
,
16
,
14
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_br24abs"
,
6
,
24
,
0
}
,
{
"fixup_ppc_brcond14abs"
,
16
,
14
,
0
}
,
{
"fixup_ppc_half16"
,
0
,
16
,
0
}
,
{
"fixup_ppc_half16ds"
,
0
,
14
,
0
}
,
{
"fixup_ppc_pcrel34"
,
0
,
34
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_imm34"
,
0
,
34
,
0
}
,
{
"fixup_ppc_nofixup"
,
0
,
0
,
0
}
}
;
const
static
MCFixupKindInfo
InfosLE
[
PPC
::
NumTargetFixupKinds
]
=
{
{
"fixup_ppc_br24"
,
2
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_br24_notoc"
,
2
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_brcond14"
,
2
,
14
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_br24abs"
,
2
,
24
,
0
}
,
{
"fixup_ppc_brcond14abs"
,
2
,
14
,
0
}
,
{
"fixup_ppc_half16"
,
0
,
16
,
0
}
,
{
"fixup_ppc_half16ds"
,
2
,
14
,
0
}
,
{
"fixup_ppc_pcrel34"
,
0
,
34
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_imm34"
,
0
,
34
,
0
}
,
{
"fixup_ppc_nofixup"
,
0
,
0
,
0
}
}
;
if
(
Kind
>=
FirstLiteralRelocationKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
FK_NONE
)
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
(
Endian
==
support
::
little
InfosLE
:
InfosBE
)
[
Kind
FirstTargetFixupKind
]
;
}
</s>


"missing %<target%> attribute for multi-versioned %D"

This function returns true if FN1 and FN2 are versions of the same function , that is , the target strings of the function decls are different . This assumes that FN1 and FN2 have the same signature .


<s> bool X86AsmPrinter :: PrintAsmMemoryOperand ( const MachineInstr * MI , unsigned OpNo , const char * ExtraCode , raw_ostream & O ) { if ( ExtraCode && ExtraCode [ 0 ] ) { if ( ExtraCode [ 1 ] != 0 ) return true ; switch ( ExtraCode [ 0 ] ) { default : return true ; case 'b' : case 'h' : case 'w' : case 'k' : case 'q' : break ; case 'H' : if ( MI -> getInlineAsmDialect ( ) == InlineAsm :: AD_Intel ) { return true ; } else { PrintMemReference ( MI , OpNo , O , "H" ) ; } return false ; case 'P' : if ( MI -> getInlineAsmDialect ( ) == InlineAsm :: AD_Intel ) { PrintIntelMemReference ( MI , OpNo , O , "no-rip" ) ; } else { PrintMemReference ( MI , OpNo , O , "no-rip" ) ; } return false ; } } if ( MI -> getInlineAsmDialect ( ) == InlineAsm :: AD_Intel ) { PrintIntelMemReference ( MI , OpNo , O , nullptr ) ; } else { PrintMemReference ( MI , OpNo , O , nullptr ) ; } return false ; } </s>

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


<s> int arm_memory_move_cost ( machine_mode mode , reg_class_t rclass , bool in ATTRIBUTE_UNUSED ) { if ( TARGET_32BIT ) return 10 ; else { if ( GET_MODE_SIZE ( mode ) < 4 ) return 8 ; else return ( ( 2 * GET_MODE_SIZE ( mode ) ) * ( rclass == LO_REGS ? 1 : 2 ) ) ; } } </s>


<s> bool isLegalMaskedLoad ( Type * DataType ) { return ST -> hasSVE ( ) ; } </s>

Return true if the target supports masked load .


<s> static rtx ix86_function_value_bounds ( const_tree valtype , const_tree fntype_or_decl ATTRIBUTE_UNUSED , bool outgoing ATTRIBUTE_UNUSED ) { rtx res = NULL_RTX ; if ( BOUNDED_TYPE_P ( valtype ) ) res = gen_rtx_REG ( BNDmode , FIRST_BND_REG ) ; else if ( chkp_type_has_pointer ( valtype ) ) { bitmap slots ; rtx bounds [ 2 ] ; bitmap_iterator bi ; unsigned i , bnd_no = 0 ; bitmap_obstack_initialize ( NULL ) ; slots = BITMAP_ALLOC ( NULL ) ; chkp_find_bound_slots ( valtype , slots ) ; EXECUTE_IF_SET_IN_BITMAP ( slots , 0 , i , bi ) { rtx reg = gen_rtx_REG ( BNDmode , FIRST_BND_REG + bnd_no ) ; rtx offs = GEN_INT ( i * POINTER_SIZE / BITS_PER_UNIT ) ; gcc_assert ( bnd_no < 2 ) ; bounds [ bnd_no ++ ] = gen_rtx_EXPR_LIST ( VOIDmode , reg , offs ) ; } res = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec_v ( bnd_no , bounds ) ) ; BITMAP_FREE ( slots ) ; bitmap_obstack_release ( NULL ) ; } else res = NULL_RTX ; return res ; } </s>

Return an RTX representing a place where a function returns or recieves pointer bounds or NULL if no bounds are returned . VALTYPE is a data type of a value returned by the function . FN_DECL_OR_TYPE is a tree node representing FUNCTION_DECL or FUNCTION_TYPE of the function . If OUTGOING is false , return a place in which the caller will see the return value . Otherwise , return a place where a function returns a value .


<s> SDValue WebAssemblySelectionDAGInfo :: EmitTargetCodeForMemcpy ( SelectionDAG & DAG , const SDLoc & DL , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , Align Alignment , bool IsVolatile , bool AlwaysInline , MachinePointerInfo DstPtrInfo , MachinePointerInfo SrcPtrInfo ) const { auto & ST = DAG . getMachineFunction ( ) . getSubtarget < WebAssemblySubtarget > ( ) ; if ( ! ST . hasBulkMemory ( ) ) return SDValue ( ) ; SDValue MemIdx = DAG . getConstant ( 0 , DL , MVT :: i32 ) ; auto LenMVT = ST . hasAddr64 ( ) ? MVT :: i64 : MVT :: i32 ; return DAG . getNode ( WebAssemblyISD :: MEMORY_COPY , DL , MVT :: Other , { Chain , MemIdx , MemIdx , Dst , Src , DAG . getZExtOrTrunc ( Size , DL , LenMVT ) } ) ; } </s>

Emit target-specific code that performs a memcpy .


"Mips pseudo instruction expansion pass"

getPassName - Return a nice clean name for a pass .


<s> static void c6x_mark_reg_read ( rtx reg , bool cross ) { unsigned regno = REGNO ( reg ) ; unsigned nregs = hard_regno_nregs [ regno ] [ GET_MODE ( reg ) ] ; while ( nregs -- > 0 ) c6x_mark_regno_read ( regno + nregs , cross ) ; } </s>

Note that REG is read in the insn being examined . If CROSS , it means the access is through a cross path . Update the temporary reg access arrays , and set REG_ACCESS_STALL if the insn ca n't be issued in the current cycle .