<s> bool MipsSEInstrInfo :: expandPostRAPseudo ( MachineInstr & MI ) const { MachineBasicBlock & MBB = * MI . getParent ( ) ; bool isMicroMips = Subtarget . inMicroMipsMode ( ) ; unsigned Opc ; switch ( MI . getDesc ( ) . getOpcode ( ) ) { default : return false ; case Mips :: RetRA : expandRetRA ( MBB , MI ) ; break ; case Mips :: ERet : expandERet ( MBB , MI ) ; break ; case Mips :: PseudoMFHI : Opc = isMicroMips ? Mips :: MFHI16_MM : Mips :: MFHI ; expandPseudoMFHiLo ( MBB , MI , Opc ) ; break ; case Mips :: PseudoMFLO : Opc = isMicroMips ? Mips :: MFLO16_MM : Mips :: MFLO ; expandPseudoMFHiLo ( MBB , MI , Opc ) ; break ; case Mips :: PseudoMFHI64 : expandPseudoMFHiLo ( MBB , MI , Mips :: MFHI64 ) ; break ; case Mips :: PseudoMFLO64 : expandPseudoMFHiLo ( MBB , MI , Mips :: MFLO64 ) ; break ; case Mips :: PseudoMTLOHI : expandPseudoMTLoHi ( MBB , MI , Mips :: MTLO , Mips :: MTHI , false ) ; break ; case Mips :: PseudoMTLOHI64 : expandPseudoMTLoHi ( MBB , MI , Mips :: MTLO64 , Mips :: MTHI64 , false ) ; break ; case Mips :: PseudoMTLOHI_DSP : expandPseudoMTLoHi ( MBB , MI , Mips :: MTLO_DSP , Mips :: MTHI_DSP , true ) ; break ; case Mips :: PseudoCVT_S_W : expandCvtFPInt ( MBB , MI , Mips :: CVT_S_W , Mips :: MTC1 , false ) ; break ; case Mips :: PseudoCVT_D32_W : expandCvtFPInt ( MBB , MI , Mips :: CVT_D32_W , Mips :: MTC1 , false ) ; break ; case Mips :: PseudoCVT_S_L : expandCvtFPInt ( MBB , MI , Mips :: CVT_S_L , Mips :: DMTC1 , true ) ; break ; case Mips :: PseudoCVT_D64_W : expandCvtFPInt ( MBB , MI , Mips :: CVT_D64_W , Mips :: MTC1 , true ) ; break ; case Mips :: PseudoCVT_D64_L : expandCvtFPInt ( MBB , MI , Mips :: CVT_D64_L , Mips :: DMTC1 , true ) ; break ; case Mips :: BuildPairF64 : expandBuildPairF64 ( MBB , MI , false ) ; break ; case Mips :: BuildPairF64_64 : expandBuildPairF64 ( MBB , MI , true ) ; break ; case Mips :: ExtractElementF64 : expandExtractElementF64 ( MBB , MI , false ) ; break ; case Mips :: ExtractElementF64_64 : expandExtractElementF64 ( MBB , MI , true ) ; break ; case Mips :: MIPSeh_return32 : case Mips :: MIPSeh_return64 : expandEhReturn ( MBB , MI ) ; break ; } MBB . erase ( MI ) ; return true ; } </s>

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


<s> bool AMDGPUAsmBackend :: writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { OW -> WriteZeros ( Count ) ; return true ; } </s>

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


<s>
bool
X86FrameLowering
::
canUseAsPrologue
(
const
MachineBasicBlock
&
MBB
)
const
{
assert
(
MBB
.
getParent
(
)
&&
"Block is not attached to a function!"
)
;
const
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
if
(
!
MBB
.
isLiveIn
(
X86
::
EFLAGS
)
)
return
true
;
const
X86MachineFunctionInfo
*
X86FI
=
MF
.
getInfo
<
X86MachineFunctionInfo
>
(
)
;
return
!
TRI
->
hasStackRealignment
(
MF
)
&&
!
X86FI
->
hasSwiftAsyncContext
(
)
;
}
</s>

Check whether or not the given MBB can be used as a prologue for the target .


<s> int ia64_load_pair_ok ( rtx dst , rtx src ) { if ( GET_CODE ( dst ) != REG || ! FP_REGNO_P ( REGNO ( dst ) ) ) return 0 ; if ( GET_CODE ( src ) != MEM || MEM_VOLATILE_P ( src ) ) return 0 ; switch ( GET_CODE ( XEXP ( src , 0 ) ) ) { case REG : case POST_INC : break ; case POST_DEC : return 0 ; case POST_MODIFY : { rtx adjust = XEXP ( XEXP ( XEXP ( src , 0 ) , 1 ) , 1 ) ; if ( GET_CODE ( adjust ) != CONST_INT || INTVAL ( adjust ) != GET_MODE_SIZE ( GET_MODE ( src ) ) ) return 0 ; } break ; default : abort ( ) ; } return 1 ; } </s>

Return 1 if the operands are ok for a floating point load pair .


<s> bool ok_for_simple_move_operands ( rtx * operands , enum machine_mode mode ) { if ( ! register_operand ( operands [ 0 ] , mode ) && ! reg_or_0_operand ( operands [ 1 ] , mode ) ) return false ; if ( visium_flags_exposed && gpc_reg_operand ( operands [ 0 ] , mode ) && gpc_reg_operand ( operands [ 1 ] , mode ) ) return false ; return true ; } </s>

Return true if the operands are valid for a simple move insn .


<s> static rtx move_acc_to_reg ( rtx acc , int regno , rtx before ) { machine_mode mode = GET_MODE ( acc ) ; rtx reg ; reg = gen_rtx_REG ( mode , regno ) ; return gen_and_emit_move ( reg , acc , before , true ) ; } </s>

Copy accumulator ( A or AX ) to REGNO , placing any generated insns before BEFORE . Returns reg RTX .


<s> void altivec_expand_lvx_be ( rtx op0 , rtx op1 , machine_mode mode , unsigned unspec ) { rtx tmp = gen_reg_rtx ( mode ) ; rtx load = gen_rtx_SET ( tmp , op1 ) ; rtx lvx = gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , const0_rtx ) , unspec ) ; rtx par = gen_rtx_PARALLEL ( mode , gen_rtvec ( 2 , load , lvx ) ) ; rtx sel = swap_selector_for_mode ( mode ) ; rtx vperm = gen_rtx_UNSPEC ( mode , gen_rtvec ( 3 , tmp , tmp , sel ) , UNSPEC_VPERM ) ; gcc_assert ( REG_P ( op0 ) ) ; emit_insn ( par ) ; emit_insn ( gen_rtx_SET ( op0 , vperm ) ) ; } </s>

Generate code for an `` lvx '' , `` lvxl '' , or `` lve * x '' built-in for a little endian target with -maltivec=be specified . Issue the load followed by an element-reversing permute .


<s> const MIRFormatter * getMIRFormatter ( ) const override { if ( ! Formatter . get ( ) ) Formatter = std :: make_unique < AMDGPUMIRFormatter > ( ) ; return Formatter . get ( ) ; } </s>

Return MIR formatter to format/parse MIR operands .


<s> const uint32_t * PPCRegisterInfo :: getCallPreservedMask ( const MachineFunction & MF , CallingConv :: ID CC ) const { const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; if ( CC == CallingConv :: AnyReg ) { if ( Subtarget . hasVSX ( ) ) { if ( Subtarget . pairedVectorMemops ( ) ) return CSR_64_AllRegs_VSRP_RegMask ; if ( Subtarget . isAIXABI ( ) && ! TM . getAIXExtendedAltivecABI ( ) ) return CSR_64_AllRegs_AIX_Dflt_VSX_RegMask ; return CSR_64_AllRegs_VSX_RegMask ; } if ( Subtarget . hasAltivec ( ) ) { if ( Subtarget . isAIXABI ( ) && ! TM . getAIXExtendedAltivecABI ( ) ) return CSR_64_AllRegs_AIX_Dflt_Altivec_RegMask ; return CSR_64_AllRegs_Altivec_RegMask ; } return CSR_64_AllRegs_RegMask ; } if ( Subtarget . isAIXABI ( ) ) { return TM . isPPC64 ( ) ? ( ( Subtarget . hasAltivec ( ) && TM . getAIXExtendedAltivecABI ( ) ) ? CSR_PPC64_Altivec_RegMask : CSR_PPC64_RegMask ) : ( ( Subtarget . hasAltivec ( ) && TM . getAIXExtendedAltivecABI ( ) ) ? CSR_AIX32_Altivec_RegMask : CSR_AIX32_RegMask ) ; } if ( CC == CallingConv :: Cold ) { if ( TM . isPPC64 ( ) ) return Subtarget . pairedVectorMemops ( ) ? CSR_SVR64_ColdCC_VSRP_RegMask : ( Subtarget . hasAltivec ( ) ? CSR_SVR64_ColdCC_Altivec_RegMask : CSR_SVR64_ColdCC_RegMask ) ; else return Subtarget . pairedVectorMemops ( ) ? CSR_SVR32_ColdCC_VSRP_RegMask : ( Subtarget . hasAltivec ( ) ? CSR_SVR32_ColdCC_Altivec_RegMask : ( Subtarget . hasSPE ( ) ? CSR_SVR32_ColdCC_SPE_RegMask : CSR_SVR32_ColdCC_RegMask ) ) ; } if ( TM . isPPC64 ( ) ) return Subtarget . pairedVectorMemops ( ) ? CSR_SVR464_VSRP_RegMask : ( Subtarget . hasAltivec ( ) ? CSR_PPC64_Altivec_RegMask : CSR_PPC64_RegMask ) ; else return Subtarget . pairedVectorMemops ( ) ? CSR_SVR432_VSRP_RegMask : ( Subtarget . hasAltivec ( ) ? CSR_SVR432_Altivec_RegMask : ( Subtarget . hasSPE ( ) ? CSR_SVR432_SPE_RegMask : CSR_SVR432_RegMask ) ) ; } </s>

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

PowerPC PPC PPC PPC PPC PPC PPC PPC PPC PPC PPC


<s> unsigned WebAssemblyFastISel :: fastMaterializeConstant ( const Constant * C ) { if ( const GlobalValue * GV = dyn_cast < GlobalValue > ( C ) ) { if ( TLI . isPositionIndependent ( ) ) return 0 ; unsigned ResultReg = createResultReg ( Subtarget -> hasAddr64 ( ) ? & WebAssembly :: I64RegClass : & WebAssembly :: I32RegClass ) ; unsigned Opc = Subtarget -> hasAddr64 ( ) ? WebAssembly :: CONST_I64 : WebAssembly :: CONST_I32 ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( Opc ) , ResultReg ) . addGlobalAddress ( GV ) ; return ResultReg ; } return 0 ; } </s>

Emit a constant in a register using target-specific logic , such as constant pool loads .


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s>
bool
RISCVInstrInfo
::
verifyInstruction
(
const
MachineInstr
&
MI
,
StringRef
&
ErrInfo
)
const
{
const
MCInstrInfo
*
MCII
=
STI
.
getInstrInfo
(
)
;
MCInstrDesc
const
&
Desc
=
MCII
->
get
(
MI
.
getOpcode
(
)
)
;
for
(
auto
&
OI
:
enumerate
(
Desc
.
operands
(
)
)
)
{
unsigned
OpType
=
OI
.
value
(
)
.
OperandType
;
if
(
OpType
>=
RISCVOp
::
OPERAND_FIRST_RISCV_IMM
&&
OpType
<=
RISCVOp
::
OPERAND_LAST_RISCV_IMM
)
{
const
MachineOperand
&
MO
=
MI
.
getOperand
(
OI
.
index
(
)
)
;
if
(
MO
.
isImm
(
)
)
{
int64_t
Imm
=
MO
.
getImm
(
)
;
bool
Ok
;
switch
(
OpType
)
{
default
:
llvm_unreachable
(
"Unexpected operand type"
)
;
case
RISCVOp
::
OPERAND_UIMM4
:
Ok
=
isUInt
<
4
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM5
:
Ok
=
isUInt
<
5
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM12
:
Ok
=
isUInt
<
12
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_SIMM12
:
Ok
=
isInt
<
12
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_SIMM13_LSB0
:
Ok
=
isShiftedInt
<
12
,
1
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMM20
:
Ok
=
isUInt
<
20
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_SIMM21_LSB0
:
Ok
=
isShiftedInt
<
20
,
1
>
(
Imm
)
;
break
;
case
RISCVOp
::
OPERAND_UIMMLOG2XLEN
:
if
(
STI
.
getTargetTriple
(
)
.
isArch64Bit
(
)
)
Ok
=
isUInt
<
6
>
(
Imm
)
;
else
Ok
=
isUInt
<
5
>
(
Imm
)
;
break
;
}
if
(
!
Ok
)
{
ErrInfo
=
"Invalid immediate"
;
return
false
;
}
}
}
}
return
true
;
}
</s>

Perform target-specific instruction verification .


<s> static void fold_compare_helper ( gimple_stmt_iterator * gsi , tree_code code , gimple * stmt ) { tree arg0 = gimple_call_arg ( stmt , 0 ) ; tree arg1 = gimple_call_arg ( stmt , 1 ) ; tree lhs = gimple_call_lhs ( stmt ) ; tree cmp = fold_build_vec_cmp ( code , TREE_TYPE ( lhs ) , arg0 , arg1 ) ; gimple * g = gimple_build_assign ( lhs , cmp ) ; gimple_set_location ( g , gimple_location ( stmt ) ) ; gsi_replace ( gsi , g , true ) ; } </s>

Helper function to handle the in-between steps for the vector compare built-ins .


<s> const CallLowering * getCallLowering ( ) const override { return & CallLoweringInfo ; } </s>


<s>
bool
SITargetLowering
::
isLegalAddressingMode
(
const
DataLayout
&
DL
,
const
AddrMode
&
AM
,
Type
*
Ty
,
unsigned
AS
)
const
{
if
(
AM
.
BaseGV
)
return
false
;
switch
(
AS
)
{
case
AMDGPUAS
::
GLOBAL_ADDRESS
:
{
if
(
Subtarget
->
getGeneration
(
)
>=
SISubtarget
::
VOLCANIC_ISLANDS
)
{
return
isLegalFlatAddressingMode
(
AM
)
;
}
return
isLegalMUBUFAddressingMode
(
AM
)
;
}
case
AMDGPUAS
::
CONSTANT_ADDRESS
:
{
if
(
AM
.
BaseOffs
%
4
!=
0
)
return
isLegalMUBUFAddressingMode
(
AM
)
;
if
(
DL
.
getTypeStoreSize
(
Ty
)
<
4
)
return
isLegalMUBUFAddressingMode
(
AM
)
;
if
(
Subtarget
->
getGeneration
(
)
==
SISubtarget
::
SOUTHERN_ISLANDS
)
{
if
(
!
isUInt
<
8
>
(
AM
.
BaseOffs
/
4
)
)
return
false
;
}
else
if
(
Subtarget
->
getGeneration
(
)
==
SISubtarget
::
SEA_ISLANDS
)
{
if
(
!
isUInt
<
32
>
(
AM
.
BaseOffs
/
4
)
)
return
false
;
}
else
if
(
Subtarget
->
getGeneration
(
)
==
SISubtarget
::
VOLCANIC_ISLANDS
)
{
if
(
!
isUInt
<
20
>
(
AM
.
BaseOffs
)
)
return
false
;
}
else
llvm_unreachable
(
"unhandled generation"
)
;
if
(
AM
.
Scale
==
0
)
return
true
;
if
(
AM
.
Scale
==
1
&&
AM
.
HasBaseReg
)
return
true
;
return
false
;
}
case
AMDGPUAS
::
PRIVATE_ADDRESS
:
return
isLegalMUBUFAddressingMode
(
AM
)
;
case
AMDGPUAS
::
LOCAL_ADDRESS
:
case
AMDGPUAS
::
REGION_ADDRESS
:
{
if
(
!
isUInt
<
16
>
(
AM
.
BaseOffs
)
)
return
false
;
if
(
AM
.
Scale
==
0
)
return
true
;
if
(
AM
.
Scale
==
1
&&
AM
.
HasBaseReg
)
return
true
;
return
false
;
}
case
AMDGPUAS
::
FLAT_ADDRESS
:
case
AMDGPUAS
::
UNKNOWN_ADDRESS_SPACE
:
return
isLegalFlatAddressingMode
(
AM
)
;
default
:
llvm_unreachable
(
"unhandled address space"
)
;
}
}
</s>

isLegalAddressingMode - Return true if the addressing mode represented by AM is legal for this target , for a load/store of the specified type .


<s> void MipsPreLegalizerCombiner :: getAnalysisUsage ( AnalysisUsage & AU ) const { AU . addRequired < TargetPassConfig > ( ) ; AU . setPreservesCFG ( ) ; getSelectionDAGFallbackAnalysisUsage ( AU ) ; MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> static void rs6000_output_dwarf_dtprel ( FILE * file , int size , rtx x ) { switch ( size ) { case 4 : fputs ( "\t.long\t" , file ) ; break ; case 8 : fputs ( DOUBLE_INT_ASM_OP , file ) ; break ; default : gcc_unreachable ( ) ; } output_addr_const ( file , x ) ; if ( TARGET_ELF ) fputs ( "@dtprel+0x8000" , file ) ; else if ( TARGET_XCOFF && GET_CODE ( x ) == SYMBOL_REF ) { switch ( SYMBOL_REF_TLS_MODEL ( x ) ) { case 0 : break ; case TLS_MODEL_LOCAL_EXEC : fputs ( "@le" , file ) ; break ; case TLS_MODEL_INITIAL_EXEC : fputs ( "@ie" , file ) ; break ; case TLS_MODEL_GLOBAL_DYNAMIC : case TLS_MODEL_LOCAL_DYNAMIC : fputs ( "@m" , file ) ; break ; default : gcc_unreachable ( ) ; } } } </s>

This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL . We need to emit DTP-relative relocations .


<s> static void xtensa_function_arg_advance ( cumulative_args_t cum , const function_arg_info & arg ) { int words , max ; int * arg_words ; arg_words = & get_cumulative_args ( cum ) -> arg_words ; max = MAX_ARGS_IN_REGISTERS ; words = ( ( arg . promoted_size_in_bytes ( ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ) ; if ( * arg_words < max && ( targetm . calls . must_pass_in_stack ( arg ) || * arg_words + words > max ) ) * arg_words = max ; * arg_words += words ; } </s>

Advance the argument to the next argument position .


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

runOnMachineFunction - Emit the function body .

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


<s> bool MipsAsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count ) const { OS . write_zeros ( Count ) ; return true ; } </s>

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


<s> bool R600InstrInfo :: isPredicable ( MachineInstr * MI ) const { if ( MI -> getOpcode ( ) == AMDGPU :: KILLGT ) { return false ; } else if ( MI -> getOpcode ( ) == AMDGPU :: CF_ALU ) { if ( MI -> getParent ( ) -> begin ( ) != MachineBasicBlock :: iterator ( MI ) ) return false ; if ( MI -> getOperand ( 3 ) . getImm ( ) != 0 || MI -> getOperand ( 4 ) . getImm ( ) != 0 ) return false ; return true ; } else if ( isVector ( * MI ) ) { return false ; } else { return AMDGPUInstrInfo :: isPredicable ( MI ) ; } } </s>

Return true if the specified instruction can be predicated .


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

lowerCRSpilling - Generate the code for spilling a CR register .


<s> static void alpha_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr , mem , word1 , word2 ; fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; chain_value = convert_memory_address ( Pmode , chain_value ) ; if ( TARGET_ABI_OPEN_VMS ) { const char * fnname ; char * trname ; fnname = XSTR ( fnaddr , 0 ) ; trname = ( char * ) alloca ( strlen ( fnname ) + 5 ) ; strcpy ( trname , fnname ) ; strcat ( trname , "..tr" ) ; fnname = ggc_alloc_string ( trname , strlen ( trname ) + 1 ) ; word2 = gen_rtx_SYMBOL_REF ( Pmode , fnname ) ; word1 = force_reg ( DImode , gen_const_mem ( DImode , fnaddr ) ) ; word1 = expand_and ( DImode , word1 , GEN_INT ( HOST_WIDE_INT_C ( 0xffff0fff0000fff0 ) ) , NULL ) ; } else { word1 = GEN_INT ( HOST_WIDE_INT_C ( 0xa77b0010a43b0018 ) ) ; word2 = GEN_INT ( HOST_WIDE_INT_C ( 0x47ff041f6bfb0000 ) ) ; } mem = adjust_address ( m_tramp , DImode , 0 ) ; emit_move_insn ( mem , word1 ) ; mem = adjust_address ( m_tramp , DImode , 8 ) ; emit_move_insn ( mem , word2 ) ; mem = adjust_address ( m_tramp , Pmode , 16 ) ; emit_move_insn ( mem , fnaddr ) ; mem = adjust_address ( m_tramp , Pmode , 24 ) ; emit_move_insn ( mem , chain_value ) ; if ( TARGET_ABI_OSF ) { emit_insn ( gen_imb ( ) ) ; emit_library_call ( init_one_libfunc ( "__enable_execute_stack" ) , LCT_NORMAL , VOIDmode , XEXP ( m_tramp , 0 ) , Pmode ) ; } } </s>

Emit RTL insns to initialize the variable parts of a trampoline at M_TRAMP . FNDECL is target function 's decl . CHAIN_VALUE is an rtx for the static chain value for the function .


<s> static void expand_block_set_2 ( rtx dst , rtx dst_reg , rtx value_rtx , rtx bytes_rtx ) { unsigned HOST_WIDE_INT bytes = UINTVAL ( bytes_rtx ) ; unsigned int rem = bytes % 2 ; value_rtx = convert_to_mode ( Pmode , value_rtx , 1 ) ; emit_library_call ( wrd_memset_libfunc , LCT_NORMAL , VOIDmode , dst_reg , Pmode , value_rtx , Pmode , convert_to_mode ( TYPE_MODE ( sizetype ) , GEN_INT ( bytes >> 1 ) , TYPE_UNSIGNED ( sizetype ) ) , TYPE_MODE ( sizetype ) ) ; if ( rem == 0 ) return ; dst = replace_equiv_address_nv ( dst , dst_reg ) ; bytes -= rem ; emit_move_insn ( adjust_address_nv ( dst , QImode , bytes ) , convert_to_mode ( QImode , value_rtx , 1 ) ) ; } </s>

Generate a call to a library function to set BYTES_RTX bytes of DST with address DST_REG to VALUE_RTX in 2-byte chunks .


"READ_CYCLE_WIDE is only used on riscv32"

Main hook for targets to transform nodes into machine nodes .


<s>
unsigned
getReg
(
)
const
override
{
assert
(
Kind
==
k_Register
&&
"Invalid access!"
)
;
return
Reg
.
RegNum
;
}
</s>

Returns the register associated with this edge .


<s> bool arm_tls_referenced_p ( rtx x ) { if ( ! TARGET_HAVE_TLS ) return false ; subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , x , ALL ) { const_rtx x = * iter ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != 0 ) return true ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , 1 ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ; } return false ; } </s>

Return TRUE if X contains any TLS symbol references .


<s> bool hasAndNot ( SDValue Y ) const override { EVT VT = Y . getValueType ( ) ; if ( ! VT . isVector ( ) ) return hasAndNotCompare ( Y ) ; return VT . getSizeInBits ( ) >= 64 ; } </s>

Return true if the target has a bitwise and-not operation : X = ~A & B This can be used to simplify select or other instructions .


<s> static const char * get_decl_name ( tree fn ) { tree name ; if ( ! fn ) return "<null>" ; name = DECL_NAME ( fn ) ; if ( ! name ) return "<no-name>" ; return IDENTIFIER_POINTER ( name ) ; } </s>

Helper function for printing the function name when debugging .


<s> static unsigned int tilepro_function_arg_boundary ( machine_mode mode , const_tree type ) { unsigned int alignment ; alignment = type ? TYPE_ALIGN ( type ) : GET_MODE_ALIGNMENT ( mode ) ; if ( alignment < PARM_BOUNDARY ) alignment = PARM_BOUNDARY ; if ( alignment > STACK_BOUNDARY ) alignment = STACK_BOUNDARY ; return alignment ; } </s>


<s> void pdp11_expand_prologue ( void ) { HOST_WIDE_INT fsize = get_frame_size ( ) ; unsigned regno ; rtx x , via_ac = NULL ; if ( MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) && TARGET_FPU ) { emit_insn ( gen_setd ( ) ) ; emit_insn ( gen_seti ( ) ) ; } if ( frame_pointer_needed ) { x = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; x = gen_frame_mem ( Pmode , x ) ; emit_move_insn ( x , hard_frame_pointer_rtx ) ; emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; } if ( fsize ) { emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - fsize ) ) ) ; if ( frame_pointer_needed ) emit_insn ( gen_blockage ( ) ) ; } for ( regno = R0_REGNUM ; regno <= PC_REGNUM ; regno ++ ) if ( pdp11_saved_regno ( regno ) && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) ) { x = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; x = gen_frame_mem ( Pmode , x ) ; emit_move_insn ( x , gen_rtx_REG ( Pmode , regno ) ) ; } for ( regno = AC0_REGNUM ; regno <= AC3_REGNUM ; regno ++ ) if ( pdp11_saved_regno ( regno ) ) { x = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; x = gen_frame_mem ( DFmode , x ) ; via_ac = gen_rtx_REG ( DFmode , regno ) ; emit_move_insn ( x , via_ac ) ; } for ( regno = AC4_REGNUM ; regno <= AC5_REGNUM ; regno ++ ) if ( pdp11_saved_regno ( regno ) ) { gcc_assert ( via_ac != NULL ) ; emit_move_insn ( via_ac , gen_rtx_REG ( DFmode , regno ) ) ; x = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; x = gen_frame_mem ( DFmode , x ) ; emit_move_insn ( x , via_ac ) ; } } </s>


<s> unsigned WebAssemblyFastISel :: fastMaterializeAlloca ( const AllocaInst * AI ) { DenseMap < const AllocaInst * , int > :: iterator SI = FuncInfo . StaticAllocaMap . find ( AI ) ; if ( SI != FuncInfo . StaticAllocaMap . end ( ) ) { Register ResultReg = createResultReg ( Subtarget -> hasAddr64 ( ) ? & WebAssembly :: I64RegClass : & WebAssembly :: I32RegClass ) ; unsigned Opc = Subtarget -> hasAddr64 ( ) ? WebAssembly :: COPY_I64 : WebAssembly :: COPY_I32 ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( Opc ) , ResultReg ) . addFrameIndex ( SI -> second ) ; return ResultReg ; } return 0 ; } </s>

Emit an alloca address in a register using target-specific logic .


<s>
void
print
(
raw_ostream
&
OS
)
const
override
{
switch
(
Kind
)
{
case
k_Immediate
:
OS
<<
"Imm<"
;
OS
<<
*
Imm
.
Val
;
OS
<<
">"
;
break
;
case
k_Memory
:
OS
<<
"Mem<"
;
OS
<<
Mem
.
Base
;
OS
<<
", "
;
OS
<<
*
Mem
.
Off
;
OS
<<
">"
;
break
;
case
k_Register
:
OS
<<
"Register<"
<<
Reg
.
RegNum
<<
">"
;
break
;
case
k_Token
:
OS
<<
Tok
.
Data
;
break
;
}
}
</s>

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


<s>
bool
runOnMachineFunction
(
MachineFunction
&
MF
)
{
if
(
DisableFunctionSplitter
)
return
false
;
unsigned
max_subfunc_size
=
MaxSubfunctionSize
MaxSubfunctionSize
:
STC
.
getMethodCacheSize
(
)
;
max_subfunc_size
=
std
::
min
(
max_subfunc_size
,
STC
.
getMethodCacheSize
(
)
)
;
unsigned
prefer_subfunc_size
=
PreferSubfunctionSize
PreferSubfunctionSize
:
max_subfunc_size
;
unsigned
prefer_scc_size
=
PreferSCCSize
PreferSCCSize
:
prefer_subfunc_size
;
prefer_subfunc_size
=
std
::
min
(
max_subfunc_size
,
prefer_subfunc_size
)
;
prefer_scc_size
=
std
::
min
(
max_subfunc_size
,
prefer_scc_size
)
;
unsigned
total_size
=
0
;
bool
blocks_splitted
=
false
;
MachineDominatorTree
&
MDT
=
getAnalysis
<
MachineDominatorTree
>
(
)
;
MachinePostDominatorTree
&
MPDT
=
getAnalysis
<
MachinePostDominatorTree
>
(
)
;
for
(
MachineFunction
::
iterator
i
(
MF
.
begin
(
)
)
,
ie
(
MF
.
end
(
)
)
;
i
!=
ie
;
i
++
)
{
unsigned
bb_size
=
agraph
::
getBBSize
(
i
,
PTM
)
;
if
(
bb_size
+
agraph
::
getMaxBlockMargin
(
PTM
,
i
)
>
max_subfunc_size
)
{
bb_size
=
agraph
::
splitBlock
(
i
,
max_subfunc_size
,
PTM
,
MDT
,
MPDT
)
;
blocks_splitted
=
true
;
}
total_size
+=
bb_size
;
}
DEBUG
(
dbgs
(
)
<<
"\nPatmos Function Splitter: "
<<
MF
.
getFunction
(
)
->
getName
(
)
<<
": "
<<
total_size
<<
"\n"
)
;
TotalFunctions
++
;
if
(
total_size
>
prefer_subfunc_size
)
{
bool
CollectStats
=
!
StatsFile
.
empty
(
)
;
TimeRecord
Time
;
if
(
CollectStats
)
Time
-=
TimeRecord
::
getCurrentTime
(
true
)
;
PMLImport
&
PI
=
getAnalysis
<
PMLImport
>
(
)
;
agraph
G
(
&
MF
,
PTM
,
PI
.
createMCQuery
(
*
this
,
MF
)
,
MPDT
,
prefer_subfunc_size
,
prefer_scc_size
,
max_subfunc_size
)
;
G
.
transformSCCs
(
)
;
ablocks
order
;
G
.
computeRegions
(
order
)
;
assert
(
order
.
size
(
)
==
MF
.
size
(
)
)
;
G
.
applyRegions
(
order
)
;
if
(
CollectStats
)
{
Time
+=
TimeRecord
::
getCurrentTime
(
false
)
;
writeStats
(
StatsFile
,
MF
,
G
,
order
,
total_size
,
Time
)
;
}
SplitFunctions
++
;
return
true
;
}
return
blocks_splitted
;
}
</s>

Patmos
0
"\nPatmos Function Splitter: "
": "
"\n"


<s> static int shmedia_target_regs_stack_space ( HARD_REG_SET * live_regs_mask ) { int reg ; int stack_space = 0 ; int interrupt_handler = sh_cfun_interrupt_handler_p ( ) ; for ( reg = LAST_TARGET_REG ; reg >= FIRST_TARGET_REG ; reg -- ) if ( ( ! call_really_used_regs [ reg ] || interrupt_handler ) && ! TEST_HARD_REG_BIT ( * live_regs_mask , reg ) ) stack_space += GET_MODE_SIZE ( REGISTER_NATURAL_MODE ( reg ) ) ; return stack_space ; } </s>

Calculate how much extra space is needed to save all callee-saved target registers . LIVE_REGS_MASK is the register mask calculated by calc_live_regs .


<s> bool SystemZPassConfig :: addInstSelector ( ) { addPass ( createSystemZISelDag ( getSystemZTargetMachine ( ) , getOptLevel ( ) ) ) ; return false ; } </s>

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


<s> rtx csky_legitimize_tls_address ( rtx x , rtx reg ) { rtx dest , tp , label , labelno , unspec , ret , eqv , addend , tmp ; rtx_insn * insns ; unsigned int model = SYMBOL_REF_TLS_MODEL ( x ) ; if ( ! reg ) reg = gen_reg_rtx ( SImode ) ; switch ( model ) { case TLS_MODEL_GLOBAL_DYNAMIC : insns = csky_call_tls_get_addr ( x , reg , & ret , TLS_GD32 ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , x ) ; return dest ; case TLS_MODEL_LOCAL_DYNAMIC : insns = csky_call_tls_get_addr ( x , reg , & ret , TLS_LDM32 ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , eqv ) ; addend = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 2 , x , GEN_INT ( TLS_LDO32 ) ) , UNSPEC_TLS ) ; addend = force_reg ( SImode , addend ) ; return gen_rtx_PLUS ( Pmode , dest , addend ) ; case TLS_MODEL_INITIAL_EXEC : labelno = GEN_INT ( tls_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , labelno ) , UNSPEC_TLS_LABEL ) ; unspec = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 3 , x , GEN_INT ( TLS_IE32 ) , label ) , UNSPEC_TLS ) ; tmp = gen_reg_rtx ( SImode ) ; emit_move_insn ( reg , unspec ) ; emit_move_insn ( tmp , label ) ; emit_insn ( gen_addsi3 ( reg , reg , tmp ) ) ; emit_move_insn ( reg , gen_const_mem ( Pmode , reg ) ) ; tp = gen_rtx_REG ( SImode , CSKY_TLS_REGNUM ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; case TLS_MODEL_LOCAL_EXEC : unspec = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 2 , x , GEN_INT ( TLS_LE32 ) ) , UNSPEC_TLS ) ; emit_move_insn ( reg , unspec ) ; tp = gen_rtx_REG ( SImode , CSKY_TLS_REGNUM ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; default : abort ( ) ; } } </s>

Helper function for csky_legitimize_address , to handle the TLS cases . REG is a scratch register and may be null .


<s> static bool s390_loadrelative_operand_p ( rtx addr , rtx * symref , HOST_WIDE_INT * addend ) { HOST_WIDE_INT tmpaddend = 0 ; if ( GET_CODE ( addr ) == CONST ) addr = XEXP ( addr , 0 ) ; if ( GET_CODE ( addr ) == PLUS ) { if ( ! CONST_INT_P ( XEXP ( addr , 1 ) ) ) return false ; tmpaddend = INTVAL ( XEXP ( addr , 1 ) ) ; addr = XEXP ( addr , 0 ) ; } if ( ( GET_CODE ( addr ) == SYMBOL_REF && ! CONSTANT_POOL_ADDRESS_P ( addr ) ) || ( GET_CODE ( addr ) == UNSPEC && ( XINT ( addr , 1 ) == UNSPEC_GOTENT || ( TARGET_CPU_ZARCH && XINT ( addr , 1 ) == UNSPEC_PLT ) ) ) ) { if ( symref ) * symref = addr ; if ( addend ) * addend = tmpaddend ; return true ; } return false ; } </s>

Return TRUE if ADDR is an operand valid for a load/store relative instruction . Be aware that the alignment of the operand needs to be checked separately . Valid addresses are single references or a sum of a reference and a constant integer . Return these parts in SYMREF and ADDEND . You can pass NULL in REF and/or ADDEND if you are not interested in these values . Literal pool references are * not * considered symbol references .


<s> static bool frv_cannot_force_const_mem ( rtx x ATTRIBUTE_UNUSED ) { return TARGET_FDPIC ; } </s>

Decide whether we can force certain constants to memory . If we decide we ca n't , the caller should be able to cope with it in another way . We never allow constants to be forced into memory for TARGET_FDPIC . This is necessary for several reasons : 1 . Since LEGITIMATE_CONSTANT_P rejects constant pool addresses , the target-independent code will try to force them into the constant pool , thus leading to infinite recursion . 2 . We can never introduce new constant pool references during reload . Any such reference would require use of the pseudo FDPIC register . 3 . We ca n't represent a constant added to a function pointer ( which is not the same as a pointer to a function+constant ) . 4 . In many cases , it 's more efficient to calculate the constant in-line .


<s> bool ARMCallLowering :: lowerFormalArguments ( MachineIRBuilder & MIRBuilder , const Function & F , ArrayRef < unsigned > VRegs ) const { if ( F . arg_empty ( ) ) return true ; if ( F . isVarArg ( ) ) return false ; auto DL = MIRBuilder . getMF ( ) . getDataLayout ( ) ; auto & TLI = * getTLI < ARMTargetLowering > ( ) ; if ( TLI . getSubtarget ( ) -> isThumb ( ) ) return false ; auto & Args = F . getArgumentList ( ) ; for ( auto & Arg : Args ) if ( ! isSupportedType ( DL , TLI , Arg . getType ( ) ) ) return false ; CCAssignFn * AssignFn = TLI . CCAssignFnForCall ( F . getCallingConv ( ) , F . isVarArg ( ) ) ; SmallVector < ArgInfo , 8 > ArgInfos ; unsigned Idx = 0 ; for ( auto & Arg : Args ) { ArgInfo AInfo ( VRegs [ Idx ] , Arg . getType ( ) ) ; setArgFlags ( AInfo , Idx + 1 , DL , F ) ; ArgInfos . push_back ( AInfo ) ; Idx ++ ; } FormalArgHandler ArgHandler ( MIRBuilder , MIRBuilder . getMF ( ) . getRegInfo ( ) , AssignFn ) ; return handleAssignments ( MIRBuilder , ArgInfos , ArgHandler ) ; } </s>

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


<s> const unsigned * IA64RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const unsigned CalleeSavedRegs [ ] = { IA64 :: r5 , 0 } ; return CalleeSavedRegs ; } </s>


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

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


<s> void vax_expand_prologue ( void ) { int regno , offset ; int mask = 0 ; HOST_WIDE_INT size ; rtx insn ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) mask |= 1 << regno ; insn = emit_insn ( gen_procedure_entry_mask ( GEN_INT ( mask ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; vax_add_reg_cfa_offset ( insn , 4 , arg_pointer_rtx ) ; vax_add_reg_cfa_offset ( insn , 8 , frame_pointer_rtx ) ; vax_add_reg_cfa_offset ( insn , 12 , pc_rtx ) ; offset = 16 ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( mask & ( 1 << regno ) ) { vax_add_reg_cfa_offset ( insn , offset , gen_rtx_REG ( SImode , regno ) ) ; offset += 4 ; } add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , frame_pointer_rtx , offset ) ) ; size = get_frame_size ( ) ; size -= vax_starting_frame_offset ( ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) ) ) ; emit_insn ( gen_blockage ( ) ) ; } </s>

Generate the assembly code for function entry . FILE is a stdio stream to output the code to . SIZE is an int : how many units of temporary storage to allocate . Refer to the array ` regs_ever_live ' to determine which registers to save ; ` regs_ever_live [ I ] ' is nonzero if register number I is ever used in the function . This function is responsible for knowing which registers should not be saved even if used .


"Unknown opcode to check as cheap as a move!"

Return true if the instruction is as cheap as a move instruction .


<s> int XCoreRegisterInfo :: getDwarfRegNum ( unsigned RegNum , bool isEH ) const { return XCoreGenRegisterInfo :: getDwarfRegNumFull ( RegNum , 0 ) ; } </s>

Map a target register to an equivalent dwarf register number .


<s> bool KudeyarFrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return ( MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) || MFI -> isFrameAddressTaken ( ) ) ; } </s>

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


<s>
void
MipsInstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
SrcReg
,
bool
isKill
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
if
(
RC
==
Mips
::
CPURegsRegisterClass
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
SW
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
else
if
(
RC
==
Mips
::
FGR32RegisterClass
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
SWC1
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
else
if
(
RC
==
Mips
::
AFGR64RegisterClass
)
{
if
(
!
TM
.
getSubtarget
<
MipsSubtarget
>
(
)
.
isMips1
(
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
SDC1
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
}
else
{
const
TargetRegisterInfo
*
TRI
=
MBB
.
getParent
(
)
->
getTarget
(
)
.
getRegisterInfo
(
)
;
const
unsigned
*
SubSet
=
TRI
->
getSubRegisters
(
SrcReg
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
SWC1
)
)
.
addReg
(
SubSet
[
0
]
,
getKillRegState
(
isKill
)
)
.
addImm
(
0
)
.
addFrameIndex
(
FI
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Mips
::
SWC1
)
)
.
addReg
(
SubSet
[
1
]
,
getKillRegState
(
isKill
)
)
.
addImm
(
4
)
.
addFrameIndex
(
FI
)
;
}
}
else
llvm_unreachable
(
"Register class not handled!"
)
;
}
</s>

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


<s> unsigned getStackAlignment ( ) const { return 4 * 256 / getWavefrontSize ( ) ; } </s>

Returns the minimum alignment known to hold of the stack frame on entry to the function and which must be maintained by every function for this subtarget .


"SIInstrInfo::storeRegToStackSlot - Can't spill VGPR!"


<s> static bool ix86_is_empty_record ( const_tree type ) { if ( ! TARGET_64BIT ) return false ; return default_is_empty_record ( type ) ; } </s>


"getJumpTargetOpValue expects only expressions or an immediate"

getJumpTargetOpValue - Return binary encoding of the jump target operand .


<s> InstructionCost GCNTTIImpl :: getIntrinsicInstrCost ( const IntrinsicCostAttributes & ICA , TTI :: TargetCostKind CostKind ) { if ( ICA . getID ( ) == Intrinsic :: fabs ) return 0 ; if ( ! intrinsicHasPackedVectorBenefit ( ICA . getID ( ) ) ) return BaseT :: getIntrinsicInstrCost ( ICA , CostKind ) ; Type * RetTy = ICA . getReturnType ( ) ; EVT OrigTy = TLI -> getValueType ( DL , RetTy ) ; if ( ! OrigTy . isSimple ( ) ) { if ( CostKind != TTI :: TCK_CodeSize ) return BaseT :: getIntrinsicInstrCost ( ICA , CostKind ) ; if ( ICA . isTypeBasedOnly ( ) ) return getTypeBasedIntrinsicInstrCost ( ICA , CostKind ) ; unsigned RetVF = ( RetTy -> isVectorTy ( ) ? cast < FixedVectorType > ( RetTy ) -> getNumElements ( ) : 1 ) ; const IntrinsicInst * I = ICA . getInst ( ) ; const SmallVectorImpl < const Value * > & Args = ICA . getArgs ( ) ; FastMathFlags FMF = ICA . getFlags ( ) ; InstructionCost ScalarizationCost = InstructionCost :: getInvalid ( ) ; if ( RetVF > 1 ) { ScalarizationCost = 0 ; if ( ! RetTy -> isVoidTy ( ) ) ScalarizationCost += getScalarizationOverhead ( cast < VectorType > ( RetTy ) , true , false ) ; ScalarizationCost += getOperandsScalarizationOverhead ( Args , ICA . getArgTypes ( ) ) ; } IntrinsicCostAttributes Attrs ( ICA . getID ( ) , RetTy , ICA . getArgTypes ( ) , FMF , I , ScalarizationCost ) ; return getIntrinsicInstrCost ( Attrs , CostKind ) ; } std :: pair < InstructionCost , MVT > LT = TLI -> getTypeLegalizationCost ( DL , RetTy ) ; unsigned NElts = LT . second . isVector ( ) ? LT . second . getVectorNumElements ( ) : 1 ; MVT :: SimpleValueType SLT = LT . second . getScalarType ( ) . SimpleTy ; if ( SLT == MVT :: f64 ) return LT . first * NElts * get64BitInstrCost ( CostKind ) ; if ( ( ST -> has16BitInsts ( ) && SLT == MVT :: f16 ) || ( ST -> hasPackedFP32Ops ( ) && SLT == MVT :: f32 ) ) NElts = ( NElts + 1 ) / 2 ; unsigned InstRate = getQuarterRateInstrCost ( CostKind ) ; switch ( ICA . getID ( ) ) { case Intrinsic :: fma : InstRate = ST -> hasFastFMAF32 ( ) ? getHalfRateInstrCost ( CostKind ) : getQuarterRateInstrCost ( CostKind ) ; break ; case Intrinsic :: uadd_sat : case Intrinsic :: usub_sat : case Intrinsic :: sadd_sat : case Intrinsic :: ssub_sat : static const auto ValidSatTys = { MVT :: v2i16 , MVT :: v4i16 } ; if ( any_of ( ValidSatTys , [ & LT ] ( MVT M ) { return M == LT . second ; } ) ) NElts = 1 ; break ; } return LT . first * NElts * InstRate ; } </s>


<s> static void nvptx_goacc_reduction_init ( gcall * call ) { gimple_stmt_iterator gsi = gsi_for_stmt ( call ) ; tree lhs = gimple_call_lhs ( call ) ; tree var = gimple_call_arg ( call , 2 ) ; int level = TREE_INT_CST_LOW ( gimple_call_arg ( call , 3 ) ) ; enum tree_code rcode = ( enum tree_code ) TREE_INT_CST_LOW ( gimple_call_arg ( call , 4 ) ) ; tree init = omp_reduction_init_op ( gimple_location ( call ) , rcode , TREE_TYPE ( var ) ) ; gimple_seq seq = NULL ; push_gimplify_context ( true ) ; if ( level == GOMP_DIM_VECTOR ) { tree tid = make_ssa_name ( integer_type_node ) ; tree dim_vector = gimple_call_arg ( call , 3 ) ; gimple * tid_call = gimple_build_call_internal ( IFN_GOACC_DIM_POS , 1 , dim_vector ) ; gimple * cond_stmt = gimple_build_cond ( NE_EXPR , tid , integer_zero_node , NULL_TREE , NULL_TREE ) ; gimple_call_set_lhs ( tid_call , tid ) ; gimple_seq_add_stmt ( & seq , tid_call ) ; gimple_seq_add_stmt ( & seq , cond_stmt ) ; edge init_edge = split_block ( gsi_bb ( gsi ) , call ) ; basic_block init_bb = init_edge -> dest ; basic_block call_bb = init_edge -> src ; init_edge -> flags ^= EDGE_FALLTHRU | EDGE_TRUE_VALUE ; gimple_seq init_seq = NULL ; tree init_var = make_ssa_name ( TREE_TYPE ( var ) ) ; gimplify_assign ( init_var , init , & init_seq ) ; gsi = gsi_start_bb ( init_bb ) ; gsi_insert_seq_before ( & gsi , init_seq , GSI_SAME_STMT ) ; gsi_prev ( & gsi ) ; edge inited_edge = split_block ( gsi_bb ( gsi ) , gsi_stmt ( gsi ) ) ; basic_block dst_bb = inited_edge -> dest ; edge nop_edge = make_edge ( call_bb , dst_bb , EDGE_FALSE_VALUE ) ; gphi * phi = create_phi_node ( lhs , dst_bb ) ; add_phi_arg ( phi , init_var , inited_edge , gimple_location ( call ) ) ; add_phi_arg ( phi , var , nop_edge , gimple_location ( call ) ) ; set_immediate_dominator ( CDI_DOMINATORS , dst_bb , call_bb ) ; gsi = gsi_for_stmt ( call ) ; } else { if ( level == GOMP_DIM_GANG ) { tree ref_to_res = gimple_call_arg ( call , 1 ) ; if ( integer_zerop ( ref_to_res ) ) init = var ; } gimplify_assign ( lhs , init , & seq ) ; } pop_gimplify_context ( NULL ) ; gsi_replace_with_seq ( & gsi , seq , true ) ; } </s>

NVPTX implementation of GOACC_REDUCTION_INIT .


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


<s> bool MipsFastISel :: isTypeLegal ( Type * Ty , MVT & VT ) { EVT evt = TLI . getValueType ( Ty , true ) ; if ( evt == MVT :: Other || ! evt . isSimple ( ) ) return false ; VT = evt . getSimpleVT ( ) ; return TLI . isTypeLegal ( VT ) ; } </s>


<s> static void or1k_init_pic_reg ( void ) { if ( crtl -> profile ) cfun -> machine -> set_got_insn = emit_insn_after ( gen_set_got_tmp ( pic_offset_table_rtx ) , cfun -> machine -> set_mcount_arg_insn ) ; else { start_sequence ( ) ; cfun -> machine -> set_got_insn = emit_insn ( gen_set_got_tmp ( pic_offset_table_rtx ) ) ; rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; edge entry_edge = single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ; insert_insn_on_edge ( seq , entry_edge ) ; commit_one_edge_insertion ( entry_edge ) ; } } </s>

Worker for TARGET_INIT_PIC_REG . Initialize the cfun- > machine- > set_got_insn rtx and insert it at the entry of the current function . The rtx is just a temporary placeholder for the GOT and will be replaced or removed during or1k_expand_prologue .


<s>
bool
ARMPassConfig
::
addPreSched2
(
)
{
if
(
getOptLevel
(
)
!=
CodeGenOpt
::
)
{
addPass
(
createARMLoadStoreOptimizationPass
(
)
)
;
printAndVerify
(
"After ARM load / store optimizer"
)
;
if
(
getARMSubtarget
(
)
.
hasNEON
(
)
)
addPass
(
createExecutionDependencyFixPass
(
&
ARM
::
DPRRegClass
)
)
;
}
addPass
(
createARMExpandPseudoPass
(
)
)
;
if
(
getOptLevel
(
)
!=
CodeGenOpt
::
)
{
if
(
!
getARMSubtarget
(
)
.
isThumb1Only
(
)
)
{
if
(
getARMSubtarget
(
)
.
restrictIT
(
)
&&
!
getARMSubtarget
(
)
.
prefers32BitThumb
(
)
)
addPass
(
createThumb2SizeReductionPass
(
)
)
;
addPass
(
&
IfConverterID
)
;
}
}
if
(
getARMSubtarget
(
)
.
isThumb2
(
)
)
addPass
(
createThumb2ITBlockPass
(
)
)
;
return
true
;
}
</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
"After ARM load / store optimizer"
ARM
ARM::DPRRegClass
ARM
ARM
ARM
ARM
ARM


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

Return information about object file lowering .


<s> bool MSP430AsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { if ( MF . getFunction ( ) . hasFnAttribute ( "interrupt" ) ) { EmitInterruptVectorSection ( MF ) ; } SetupMachineFunction ( MF ) ; emitFunctionBody ( ) ; return false ; } </s>

runOnMachineFunction - Emit the function body .


"Can only insert epilog into returning blocks"


"dynamic alloca in the static alloca map?"

Emit an alloca address in a register using target-specific logic .


<s> int mmix_data_alignment ( tree type ATTRIBUTE_UNUSED , int basic_align ) { if ( basic_align < 32 ) return 32 ; return basic_align ; } </s>

DATA_ALIGNMENT . We have trouble getting the address of stuff that is located at other than 32-bit alignments ( GETA requirements ) , so try to give everything at least 32-bit alignment .


<s>
bool
AVRAsmParser
::
MatchAndEmitInstruction
(
SMLoc
Loc
,
unsigned
&
Opcode
,
OperandVector
&
Operands
,
MCStreamer
&
Out
,
uint64_t
&
ErrorInfo
,
bool
MatchingInlineAsm
)
{
MCInst
Inst
;
unsigned
MatchResult
=
MatchInstructionImpl
(
Operands
,
Inst
,
ErrorInfo
,
MatchingInlineAsm
)
;
switch
(
MatchResult
)
{
case
Match_Success
:
return
emit
(
Inst
,
Loc
,
Out
)
;
case
Match_MissingFeature
:
return
missingFeature
(
Loc
,
ErrorInfo
)
;
case
Match_InvalidOperand
:
return
invalidOperand
(
Loc
,
Operands
,
ErrorInfo
)
;
case
Match_MnemonicFail
:
return
Error
(
Loc
,
"invalid instruction"
)
;
default
:
return
true
;
}
}
</s>

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


<s>
MachineBasicBlock
*
SparcTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
*
MI
,
MachineBasicBlock
*
BB
)
const
{
const
TargetInstrInfo
&
TII
=
*
getTargetMachine
(
)
.
getInstrInfo
(
)
;
unsigned
BROpcode
;
unsigned
CC
;
DebugLoc
dl
=
MI
->
getDebugLoc
(
)
;
switch
(
MI
->
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Unknown SELECT_CC!"
)
;
case
SP
::
SELECT_CC_Int_ICC
:
case
SP
::
SELECT_CC_FP_ICC
:
case
SP
::
SELECT_CC_DFP_ICC
:
BROpcode
=
SP
::
BCOND
;
break
;
case
SP
::
SELECT_CC_Int_FCC
:
case
SP
::
SELECT_CC_FP_FCC
:
case
SP
::
SELECT_CC_DFP_FCC
:
BROpcode
=
SP
::
FBCOND
;
break
;
}
CC
=
(
SPCC
::
CondCodes
)
MI
->
getOperand
(
3
)
.
getImm
(
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
MachineFunction
::
iterator
It
=
BB
;
++
It
;
MachineBasicBlock
*
thisMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
copy0MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
sinkMBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
BROpcode
)
)
.
addMBB
(
sinkMBB
)
.
addImm
(
CC
)
;
F
->
insert
(
It
,
copy0MBB
)
;
F
->
insert
(
It
,
sinkMBB
)
;
sinkMBB
->
transferSuccessors
(
BB
)
;
BB
->
addSuccessor
(
copy0MBB
)
;
BB
->
addSuccessor
(
sinkMBB
)
;
BB
=
copy0MBB
;
BB
->
addSuccessor
(
sinkMBB
)
;
BB
=
sinkMBB
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
SP
::
PHI
)
,
MI
->
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
->
getOperand
(
2
)
.
getReg
(
)
)
.
addMBB
(
copy0MBB
)
.
addReg
(
MI
->
getOperand
(
1
)
.
getReg
(
)
)
.
addMBB
(
thisMBB
)
;
F
->
DeleteMachineInstr
(
MI
)
;
return
BB
;
}
</s>

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


<s> ARMRelocator :: Result none ( Relocation & pReloc , ARMRelocator & pParent ) { return Relocator :: OK ; } </s>

Returns true if none of the bits are set .


<s> static void mips_sim_issue_insn ( struct mips_sim * state , rtx insn ) { state_transition ( state -> dfa_state , insn ) ; state -> insns_left -- ; mips_sim_insn = insn ; note_stores ( PATTERN ( insn ) , mips_sim_record_set , state ) ; } </s>

Issue instruction INSN in scheduler state STATE . Assume that INSN can issue immediately ( i.e. , that mips_sim_wait_insn has already been called ) .


<s> FastISel * ARMTargetLowering :: createFastISel ( FunctionLoweringInfo & funcInfo , const TargetLibraryInfo * libInfo ) const { return ARM :: createFastISel ( funcInfo , libInfo ) ; } </s>

This method returns a target specific FastISel object , or null if the target does not support `` fast '' ISel .


<s> static rtx spe_synthesize_frame_save ( rtx real ) { rtx synth , offset , reg , real2 ; if ( GET_CODE ( real ) != SET || GET_MODE ( SET_SRC ( real ) ) != V2SImode ) return real ; gcc_assert ( GET_CODE ( SET_DEST ( real ) ) == MEM && GET_CODE ( XEXP ( SET_DEST ( real ) , 0 ) ) == PLUS && GET_CODE ( SET_SRC ( real ) ) == REG ) ; real2 = copy_rtx ( real ) ; PUT_MODE ( SET_DEST ( real2 ) , SImode ) ; reg = SET_SRC ( real2 ) ; real2 = replace_rtx ( real2 , reg , gen_rtx_REG ( SImode , REGNO ( reg ) ) ) ; synth = copy_rtx ( real2 ) ; if ( BYTES_BIG_ENDIAN ) { offset = XEXP ( XEXP ( SET_DEST ( real2 ) , 0 ) , 1 ) ; real2 = replace_rtx ( real2 , offset , GEN_INT ( INTVAL ( offset ) + 4 ) ) ; } reg = SET_SRC ( synth ) ; synth = replace_rtx ( synth , reg , gen_rtx_REG ( SImode , REGNO ( reg ) + 1200 ) ) ; offset = XEXP ( XEXP ( SET_DEST ( synth ) , 0 ) , 1 ) ; synth = replace_rtx ( synth , offset , GEN_INT ( INTVAL ( offset ) + ( BYTES_BIG_ENDIAN ? 0 : 4 ) ) ) ; RTX_FRAME_RELATED_P ( synth ) = 1 ; RTX_FRAME_RELATED_P ( real2 ) = 1 ; if ( BYTES_BIG_ENDIAN ) real = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , synth , real2 ) ) ; else real = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , real2 , synth ) ) ; return real ; } </s>

Given an SPE frame note , return a PARALLEL of SETs with the original note , plus a synthetic register save .


<s> bool GCNTTIImpl :: isSourceOfDivergence ( const Value * V ) const { if ( const Argument * A = dyn_cast < Argument > ( V ) ) return ! isArgPassedInSGPR ( A ) ; if ( const LoadInst * Load = dyn_cast < LoadInst > ( V ) ) return Load -> getPointerAddressSpace ( ) == AMDGPUAS :: PRIVATE_ADDRESS || Load -> getPointerAddressSpace ( ) == AMDGPUAS :: FLAT_ADDRESS ; if ( isa < AtomicRMWInst > ( V ) || isa < AtomicCmpXchgInst > ( V ) ) return true ; if ( const IntrinsicInst * Intrinsic = dyn_cast < IntrinsicInst > ( V ) ) return AMDGPU :: isIntrinsicSourceOfDivergence ( Intrinsic -> getIntrinsicID ( ) ) ; if ( const CallInst * CI = dyn_cast < CallInst > ( V ) ) { if ( CI -> isInlineAsm ( ) ) return isInlineAsmSourceOfDivergence ( CI ) ; return true ; } if ( isa < InvokeInst > ( V ) ) return true ; return false ; } </s>

Returns whether V is a source of divergence .

AMDGPU AMDGPU AMDGPU AMDGPU::isIntrinsicSourceOfDivergence


<s> static rtx ix86_expand_ti_to_v1ti ( rtx x ) { if ( TARGET_SSE2 ) { rtx lo = gen_lowpart ( DImode , x ) ; rtx hi = gen_highpart ( DImode , x ) ; rtx tmp = gen_reg_rtx ( V2DImode ) ; emit_insn ( gen_vec_concatv2di ( tmp , lo , hi ) ) ; return force_reg ( V1TImode , gen_lowpart ( V1TImode , tmp ) ) ; } return force_reg ( V1TImode , gen_lowpart ( V1TImode , x ) ) ; } </s>

Expand move of TI mode register X to a new V1TI mode register .


<s> static void rl78_alloc_physical_registers_umul ( rtx_insn * insn ) { rtx_insn * prev = prev_nonnote_nondebug_insn ( insn ) ; rtx_insn * first ; int tmp_id ; rtx saved_op1 ; OP ( 0 ) = transcode_memory_rtx ( OP ( 0 ) , BC , insn ) ; OP ( 1 ) = transcode_memory_rtx ( OP ( 1 ) , DE , insn ) ; OP ( 2 ) = transcode_memory_rtx ( OP ( 2 ) , HL , insn ) ; MAYBE_OK ( insn ) ; if ( recog_data . constraints [ 1 ] [ 0 ] == '%' && is_virtual_register ( OP ( 1 ) ) && ! is_virtual_register ( OP ( 2 ) ) && ! CONSTANT_P ( OP ( 2 ) ) ) { rtx tmp = OP ( 1 ) ; OP ( 1 ) = OP ( 2 ) ; OP ( 2 ) = tmp ; } OP ( 0 ) = move_from_acc ( 0 , insn ) ; tmp_id = get_max_insn_count ( ) ; saved_op1 = OP ( 1 ) ; if ( rtx_equal_p ( OP ( 1 ) , OP ( 2 ) ) ) { gcc_assert ( GET_MODE ( OP ( 2 ) ) == QImode ) ; OP ( 2 ) = move_to_x ( 2 , insn ) ; OP ( 1 ) = A ; } else OP ( 1 ) = move_to_acc ( 1 , insn ) ; MAYBE_OK ( insn ) ; if ( tmp_id == get_max_insn_count ( ) ) force_into_acc ( saved_op1 , insn ) ; if ( prev ) first = next_nonnote_nondebug_insn ( prev ) ; else for ( first = insn ; prev_nonnote_nondebug_insn ( first ) ; first = prev_nonnote_nondebug_insn ( first ) ) ; OP ( 2 ) = move_to_x ( 2 , first ) ; MUST_BE_OK ( insn ) ; } </s>


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

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


<s> static reg_class_t ia64_preferred_reload_class ( rtx x , reg_class_t rclass ) { switch ( rclass ) { case FR_REGS : case FP_REGS : if ( MEM_P ( x ) && MEM_VOLATILE_P ( x ) ) return NO_REGS ; if ( CONSTANT_P ( x ) ) return NO_REGS ; break ; case AR_M_REGS : case AR_I_REGS : if ( ! OBJECT_P ( x ) ) return NO_REGS ; break ; default : break ; } return rclass ; } </s>

Implement PREFERRED_RELOAD_CLASS . Place additional restrictions on CLASS to use when copying X into that class .


<s> ARCSubtarget :: ARCSubtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const TargetMachine & TM ) : ARCGenSubtargetInfo ( TT , CPU , CPU , FS ) , FrameLowering ( * this ) , TLInfo ( TM , * this ) { } </s>

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


Return a composite value in a pair of floating-point registers . MODE1 and OFFSET1 are the mode and byte offset for the first value , likewise MODE2 and OFFSET2 for the second . MODE is the mode of the complete value . For n32 & n64 , $ f0 always holds the first value and $ f2 the second . Otherwise the values are packed together as closely as possible .


"Instr doesn't have FrameIndex operand!"

Returns true if the instruction 's frame index reference would be better served by a base register other than FP or SP .


"Don't know how to handle that operation"


<s> SparcTargetLowering :: ConstraintType SparcTargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'r' : return C_RegisterClass ; case 'I' : return C_Other ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s> TargetLoweringBase :: LegalizeTypeAction getPreferredVectorAction ( MVT VT ) const override { if ( VT . isScalableVector ( ) || VT . getVectorNumElements ( ) == 1 ) return TargetLoweringBase :: getPreferredVectorAction ( VT ) ; if ( VT . getScalarSizeInBits ( ) == 1 && VT . getSizeInBits ( ) > 16 ) return TypeSplitVector ; if ( VT . getScalarSizeInBits ( ) == 1 ) return TypePromoteInteger ; if ( VT . getScalarSizeInBits ( ) % 8 == 0 ) return TypeWidenVector ; return TargetLoweringBase :: getPreferredVectorAction ( VT ) ; } </s>

Customize the preferred legalization strategy for certain types .


<s> bool HexagonInstrInfo :: isAsCheapAsAMove ( const MachineInstr & MI ) const { if ( ! ( MI . getMF ( ) -> getFunction ( ) . hasOptSize ( ) ) ) return MI . isAsCheapAsAMove ( ) ; if ( MI . getOpcode ( ) == Hexagon :: A2_tfrsi ) { auto Op = MI . getOperand ( 1 ) ; if ( Op . getType ( ) == MachineOperand :: MO_GlobalAddress ) return false ; if ( Op . isImm ( ) ) { int64_t Imm = Op . getImm ( ) ; if ( ! isInt < 16 > ( Imm ) ) return false ; } } return MI . isAsCheapAsAMove ( ) ; } </s>

Return true if the instruction is as cheap as a move instruction .


<s> static int mips_fpr_return_fields ( const_tree valtype , tree * fields , bool * has_cxx_zero_width_bf , bool * has_cxx17_empty_base ) { tree field ; int i ; if ( ! TARGET_NEWABI ) return 0 ; if ( TREE_CODE ( valtype ) != RECORD_TYPE ) return 0 ; i = 0 ; for ( field = TYPE_FIELDS ( valtype ) ; field != 0 ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( cxx17_empty_base_field_p ( field ) ) { * has_cxx17_empty_base = true ; continue ; } if ( DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( field ) ) { * has_cxx_zero_width_bf = true ; continue ; } if ( ! SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( field ) ) ) return 0 ; if ( i == 2 ) return 0 ; fields [ i ++ ] = field ; } return i ; } </s>

See whether VALTYPE is a record whose fields should be returned in floating-point registers . If so , return the number of fields and list them in FIELDS ( which should have two elements ) . Return 0 otherwise . For n32 & n64 , a structure with one or two fields is returned in floating-point registers as long as every field has a floating-point type . The C++ FE used to remove zero-width bit-fields in GCC 11 and earlier . To make a proper diagnostic , this function will set HAS_CXX_ZERO_WIDTH_BF to true once a C++ zero-width bit-field shows up , and then ignore it . We had failed to ignore C++17 empty bases in GCC 7 , 8 , 9 , 10 , and 11 . This caused an ABI incompatibility between C++14 and C++17 . This is fixed now and to make a proper diagnostic , this function will set HAS_CXX17_EMPTY_BASE to true once a C++17 empty base shows up , and then ignore it . The caller should use the value of HAS_CXX17_EMPTY_BASE and/or HAS_CXX_ZERO_WIDTH_BF to emit a proper -Wpsabi inform .


<s> bool AArch64TargetLowering :: isDesirableToCommuteWithShift ( const SDNode * N ) const { EVT VT = N -> getValueType ( 0 ) ; if ( N -> getOpcode ( ) == ISD :: AND && ( VT == MVT :: i32 || VT == MVT :: i64 ) && isa < ConstantSDNode > ( N -> getOperand ( 1 ) ) ) { uint64_t TruncMask = N -> getConstantOperandVal ( 1 ) ; if ( isMask_64 ( TruncMask ) && N -> getOperand ( 0 ) . getOpcode ( ) == ISD :: SRL && isa < ConstantSDNode > ( N -> getOperand ( 0 ) -> getOperand ( 1 ) ) ) return false ; } return true ; } </s>

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


<s> int visium_initial_elimination_offset ( int from , int to ATTRIBUTE_UNUSED ) { const int save_fp = current_frame_info . save_fp ; const int save_lr = current_frame_info . save_lr ; const int lr_slot = current_frame_info . lr_slot ; int offset ; if ( from == FRAME_POINTER_REGNUM ) offset = ( save_fp + save_lr + lr_slot ) * UNITS_PER_WORD ; else if ( from == ARG_POINTER_REGNUM ) offset = visium_compute_frame_size ( get_frame_size ( ) ) ; else gcc_unreachable ( ) ; return offset ; } </s>

Helper function for INITIAL_ELIMINATION_OFFSET ( FROM , TO , OFFSET ) . Define the offset between two registers , one to be eliminated , and the other its replacement , at the start of a routine .


"PowerPC DAG->DAG Pattern Instruction Selection"

getPassName - Return a nice clean name for a pass .


<s> void emitValueImpl ( const MCExpr * Value , unsigned Size , SMLoc Loc ) override { emitDataMappingSymbol ( ) ; MCELFStreamer :: emitValueImpl ( Value , Size , Loc ) ; } </s>

Overriding these functions allows us to dismiss all labels that are candidates for marking as microMIPS when .word/.long/.4byte etc directives are emitted .


<s> int avr_hard_regno_mode_ok ( int regno , enum machine_mode mode ) { if ( regno == REG_Y && mode == Pmode ) return 1 ; if ( regno <= ( REG_Y + 1 ) && ( regno + GET_MODE_SIZE ( mode ) ) >= ( REG_Y + 1 ) ) return 0 ; if ( mode == QImode ) return 1 ; if ( regno + GET_MODE_SIZE ( mode ) > FIRST_PSEUDO_REGISTER ) return 0 ; return ! ( regno & 1 ) ; } </s>

Returns 1 if a value of mode MODE can be stored starting with hard register number REGNO . On the enhanced core , anything larger than 1 byte must start in even numbered register for `` movw '' to work ( this way we do n't have to check for odd registers everywhere ) .


"TOC save is not implemented on AIX yet."

getTOCSaveOffset - Return the previous frame offset to save the TOC register � ? 64-bit SVR4 ABI only .


<s> bool AMDGPUPrintfRuntimeBinding :: runOnModule ( Module & M ) { Triple TT ( M . getTargetTriple ( ) ) ; if ( TT . getArch ( ) == Triple :: r600 ) return false ; visit ( M ) ; if ( Printfs . empty ( ) ) return false ; TD = & M . getDataLayout ( ) ; auto DTWP = getAnalysisIfAvailable < DominatorTreeWrapperPass > ( ) ; DT = DTWP ? & DTWP -> getDomTree ( ) : nullptr ; TLI = & getAnalysis < TargetLibraryInfoWrapperPass > ( ) . getTLI ( ) ; return lowerPrintfForGpu ( M ) ; } </s>

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


"no identifier found in stanza header.\n"

Parse one stanza of the input overload file . linebuf already contains the first line to parse .


<s> bool ARMTargetLowering :: isLegalAddImmediate ( int64_t Imm ) const { int64_t AbsImm = std :: abs ( Imm ) ; if ( ! Subtarget -> isThumb ( ) ) return ARM_AM :: getSOImmVal ( AbsImm ) != - 1 ; if ( Subtarget -> isThumb2 ( ) ) return ARM_AM :: getT2SOImmVal ( AbsImm ) != - 1 ; return AbsImm >= 0 && AbsImm <= 255 ; } </s>

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


<s> static void avr_fix_operands ( rtx * op , rtx * hreg , unsigned opmask , unsigned rmask ) { for ( ; opmask ; opmask >>= 1 , op ++ ) { rtx reg = * op ; if ( hreg ) * hreg = NULL_RTX ; if ( ( opmask & 1 ) && REG_P ( reg ) && REGNO ( reg ) < FIRST_PSEUDO_REGISTER && ( rmask & regmask ( GET_MODE ( reg ) , REGNO ( reg ) ) ) ) { * op = gen_reg_rtx ( GET_MODE ( reg ) ) ; if ( hreg == NULL ) emit_move_insn ( * op , reg ) ; else * hreg = reg ; } if ( hreg ) hreg ++ ; } } </s>

PR63633 : The middle-end might come up with hard regs as input operands . RMASK is a bit mask representing a subset of hard registers R0 ... R31 : Rn is an element of that set iff bit n of RMASK is set . OPMASK describes a subset of OP [ ] : If bit n of OPMASK is 1 then OP [ n ] has to be fixed ; otherwise OP [ n ] is left alone . For each element of OPMASK which is a hard register overlapping RMASK , replace OP [ n ] with a newly created pseudo register HREG == 0 : Also emit a move insn that copies the contents of that hard register into the new pseudo . HREG ! = 0 : Also set HREG [ n ] to the hard register .


<s> bool X86TargetLowering :: canMergeStoresTo ( unsigned AddressSpace , EVT MemVT , const SelectionDAG & DAG ) const { bool NoFloat = DAG . getMachineFunction ( ) . getFunction ( ) . hasFnAttribute ( Attribute :: NoImplicitFloat ) ; if ( NoFloat ) { unsigned MaxIntSize = Subtarget . is64Bit ( ) ? 64 : 32 ; return ( MemVT . getSizeInBits ( ) <= MaxIntSize ) ; } if ( MemVT . getSizeInBits ( ) > Subtarget . getPreferVectorWidth ( ) ) return false ; if ( MemVT == MVT :: v256i32 ) return false ; return true ; } </s>

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


<s>
bool
PIC16AsmPrinter
::
doInitialization
(
Module
&
M
)
{
bool
Result
=
AsmPrinter
::
doInitialization
(
M
)
;
O
<<
"\n\t#include P16F1937.INC\n"
;
for
(
Module
::
global_iterator
I
=
M
.
global_begin
(
)
,
E
=
M
.
global_end
(
)
;
I
!=
E
;
++
I
)
if
(
!
I
->
isDeclaration
(
)
&&
!
I
->
hasAvailableExternallyLinkage
(
)
)
{
const
MCSection
*
S
=
getObjFileLowering
(
)
.
SectionForGlobal
(
I
,
Mang
,
TM
)
;
I
->
setSection
(
(
(
const
MCSectionPIC16
*
)
S
)
->
getName
(
)
)
;
}
DbgInfo
.
BeginModule
(
M
)
;
EmitFunctionDecls
(
M
)
;
EmitUndefinedVars
(
M
)
;
EmitDefinedVars
(
M
)
;
EmitIData
(
M
)
;
EmitUData
(
M
)
;
EmitRomData
(
M
)
;
return
Result
;
}
</s>

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


Emit : ( set TMP1 ( unspec : PRED_MODE [ PTRUE OP0 OP1 ] UNSPEC_COND_ < X1 > ) ) ( set TMP2 ( unspec : PRED_MODE [ PTRUE OP0 OP1 ] UNSPEC_COND_ < X2 > ) ) ( set TARGET ( and : PRED_MODE ( ior : PRED_MODE TMP1 TMP2 ) PTRUE ) ) where < Xi > is the operation associated with comparison CODEi .


<s> int long_immediate_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { switch ( GET_CODE ( op ) ) { case SYMBOL_REF : case LABEL_REF : case CONST : return 1 ; case CONST_INT : return ! SMALL_INT ( INTVAL ( op ) ) ; case CONST_DOUBLE : return 1 ; default : break ; } return 0 ; } </s>

Return true if OP will require a long immediate ( limm ) value . This is currently only used when calculating length attributes .


<s> unsigned getNumberOfRegisters ( bool Vector ) const override { if ( Vector ) { if ( ST -> hasNEON ( ) ) return 32 ; return 0 ; } return 31 ; } </s>


<s>
SDValue
XCoreTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
case
ISD
::
EH_RETURN
:
return
LowerEH_RETURN
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
LowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
ConstantPool
:
return
LowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
BR_JT
:
return
LowerBR_JT
(
Op
,
DAG
)
;
case
ISD
::
LOAD
:
return
LowerLOAD
(
Op
,
DAG
)
;
case
ISD
::
STORE
:
return
LowerSTORE
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
)
;
case
ISD
::
VAARG
:
return
LowerVAARG
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
)
;
case
ISD
::
SMUL_LOHI
:
return
LowerSMUL_LOHI
(
Op
,
DAG
)
;
case
ISD
::
UMUL_LOHI
:
return
LowerUMUL_LOHI
(
Op
,
DAG
)
;
case
ISD
::
ADD
:
case
ISD
::
SUB
:
return
ExpandADDSUB
(
Op
.
getNode
(
)
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
)
;
case
ISD
::
FRAME_TO_ARGS_OFFSET
:
return
LowerFRAME_TO_ARGS_OFFSET
(
Op
,
DAG
)
;
case
ISD
::
INIT_TRAMPOLINE
:
return
LowerINIT_TRAMPOLINE
(
Op
,
DAG
)
;
case
ISD
::
ADJUST_TRAMPOLINE
:
return
LowerADJUST_TRAMPOLINE
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_FENCE
:
return
LowerATOMIC_FENCE
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_LOAD
:
return
LowerATOMIC_LOAD
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_STORE
:
return
LowerATOMIC_STORE
(
Op
,
DAG
)
;
default
:
llvm_unreachable
(
"unimplemented operand"
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> static bool arm_tls_symbol_p ( rtx x ) { if ( ! TARGET_HAVE_TLS ) return false ; if ( GET_CODE ( x ) != SYMBOL_REF ) return false ; return SYMBOL_REF_TLS_MODEL ( x ) != 0 ; } </s>

Return TRUE if X is a thread-local symbol .


<s> const X86InstrInfo * getInstrInfo ( ) const { return Subtarget -> getInstrInfo ( ) ; } </s>


<s> bool X86AsmBackend :: writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { static const uint8_t TrueNops [ 10 ] [ 10 ] = { { 0x90 } , { 0x66 , 0x90 } , { 0x0f , 0x1f , 0x00 } , { 0x0f , 0x1f , 0x40 , 0x00 } , { 0x0f , 0x1f , 0x44 , 0x00 , 0x00 } , { 0x66 , 0x0f , 0x1f , 0x44 , 0x00 , 0x00 } , { 0x0f , 0x1f , 0x80 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x0f , 0x1f , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x66 , 0x0f , 0x1f , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x66 , 0x2e , 0x0f , 0x1f , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 } , } ; static const uint8_t AltNops [ 7 ] [ 10 ] = { { 0x90 } , { 0x66 , 0x90 } , { 0x8d , 0x76 , 0x00 } , { 0x8d , 0x74 , 0x26 , 0x00 } , { 0x90 , 0x8d , 0x74 , 0x26 , 0x00 } , { 0x8d , 0xb6 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x8d , 0xb4 , 0x26 , 0x00 , 0x00 , 0x00 , 0x00 } , } ; const uint8_t ( * Nops ) [ 10 ] = HasNopl ? TrueNops : AltNops ; assert ( HasNopl || MaxNopLength <= 7 ) ; do { const uint8_t ThisNopLength = ( uint8_t ) std :: min ( Count , MaxNopLength ) ; const uint8_t Prefixes = ThisNopLength <= 10 ? 0 : ThisNopLength - 10 ; for ( uint8_t i = 0 ; i < Prefixes ; i ++ ) OW -> write8 ( 0x66 ) ; const uint8_t Rest = ThisNopLength - Prefixes ; for ( uint8_t i = 0 ; i < Rest ; i ++ ) OW -> write8 ( Nops [ Rest - 1 ] [ i ] ) ; Count -= ThisNopLength ; } while ( Count != 0 ) ; return true ; } </s>

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


<s> const TargetRegisterClass * R600RegisterInfo :: getCFGStructurizerRegClass ( MVT VT ) const { switch ( VT . SimpleTy ) { default : case MVT :: i32 : return & AMDGPU :: R600_TReg32RegClass ; } } </s>

get the register class of the specified type to use in the CFGStructurizer


<s> bool CAHPPassConfig :: addInstSelector ( ) { addPass ( createCAHPISelDag ( getCAHPTargetMachine ( ) ) ) ; return false ; } </s>

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


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> EVT ARM64TargetLowering :: getSetCCResultType ( LLVMContext & , EVT VT ) const { if ( ! VT . isVector ( ) ) return MVT :: i32 ; return VT . changeVectorElementTypeToInteger ( ) ; } </s>

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


<s>
bool
ARMCallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
unsigned
VReg
)
const
{
assert
(
!
Val
==
!
VReg
&&
"Return value without a vreg"
)
;
auto
Ret
=
MIRBuilder
.
buildInstrNoInsert
(
ARM
::
BX_RET
)
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
if
(
!
lowerReturnVal
(
MIRBuilder
,
Val
,
VReg
,
Ret
)
)
return
false
;
MIRBuilder
.
insertInstr
(
Ret
)
;
return
true
;
}
</s>

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

ARM
ARM
"Return value without a vreg"
ARM::BX_RET
ARMCC::AL


<s> static inline bool is_virtual_register ( rtx r ) { return ( GET_CODE ( r ) == REG && REGNO ( r ) >= 8 && REGNO ( r ) < 32 ) ; } </s>

Returns TRUE if R is a virtual register .


<s> bool TLCS900TargetLowering :: isTruncateFree ( EVT VT1 , EVT VT2 ) const { if ( ! VT1 . isInteger ( ) || ! VT2 . isInteger ( ) ) return false ; return ( VT1 . getSizeInBits ( ) > VT2 . getSizeInBits ( ) ) ; } </s>

Return true if it 's free to truncate a value of type Ty1 to type Ty2 .


<s> rtx mn10300_function_value ( tree valtype , tree func , int outgoing ) { rtx rv ; enum machine_mode mode = TYPE_MODE ( valtype ) ; if ( ! POINTER_TYPE_P ( valtype ) ) return gen_rtx_REG ( mode , FIRST_DATA_REGNUM ) ; else if ( ! TARGET_PTR_A0D0 || ! outgoing || current_function_returns_struct ) return gen_rtx_REG ( mode , FIRST_ADDRESS_REGNUM ) ; rv = gen_rtx_PARALLEL ( mode , rtvec_alloc ( 2 ) ) ; XVECEXP ( rv , 0 , 0 ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode , FIRST_ADDRESS_REGNUM ) , GEN_INT ( 0 ) ) ; XVECEXP ( rv , 0 , 1 ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode , FIRST_DATA_REGNUM ) , GEN_INT ( 0 ) ) ; return rv ; } </s>

Return the location of the function 's value . This will be either $ d0 for integer functions , $ a0 for pointers , or a PARALLEL of both $ d0 and $ a0 if the -mreturn-pointer-on-do flag is set . Note that we only return the PARALLEL for outgoing values ; we do not want callers relying on this extra copy .


<s> bool allowsMisalignedMemoryAccesses ( LLT Ty , unsigned AddrSpace , Align Alignment , MachineMemOperand :: Flags Flags = MachineMemOperand :: MONone , bool * IsFast = nullptr ) const override { if ( IsFast ) * IsFast = false ; return allowsMisalignedMemoryAccessesImpl ( Ty . getSizeInBits ( ) , AddrSpace , Alignment , Flags , IsFast ) ; } </s>

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


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

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


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


"********** MI Converging Scheduling VLIW BB#"

"** VLIWMachineScheduler::schedule picking next node\n"

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


<s> bool isExtractVecEltCheap ( EVT VT , unsigned Index ) const override { EVT EltVT = VT . getScalarType ( ) ; return ( EltVT == MVT :: f32 || EltVT == MVT :: f64 ) && Index == 0 ; } </s>

Extract of a scalar FP value from index 0 of a vector is free .


<s>
void
RISCVFrameLowering
::
emitPrologue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
assert
(
&
MF
.
front
(
)
==
&
MBB
&&
"Shrink-wrapping not yet supported"
)
;
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
auto
*
RVFI
=
MF
.
getInfo
<
RISCVMachineFunctionInfo
>
(
)
;
const
RISCVRegisterInfo
*
RI
=
STI
.
getRegisterInfo
(
)
;
const
RISCVInstrInfo
*
TII
=
STI
.
getInstrInfo
(
)
;
MachineBasicBlock
::
iterator
MBBI
=
MBB
.
begin
(
)
;
unsigned
FPReg
=
getFPReg
(
STI
)
;
unsigned
SPReg
=
getSPReg
(
STI
)
;
DebugLoc
DL
;
determineFrameLayout
(
MF
)
;
uint64_t
StackSize
=
MFI
.
getStackSize
(
)
;
if
(
StackSize
==
0
&&
!
MFI
.
adjustsStack
(
)
)
return
;
adjustReg
(
MBB
,
MBBI
,
DL
,
SPReg
,
SPReg
,
StackSize
,
MachineInstr
::
FrameSetup
)
;
unsigned
CFIIndex
=
MF
.
addFrameInst
(
MCCFIInstruction
::
createDefCfaOffset
(
nullptr
,
StackSize
)
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
->
get
(
TargetOpcode
::
CFI_INSTRUCTION
)
)
.
addCFIIndex
(
CFIIndex
)
;
const
std
::
vector
<
CalleeSavedInfo
>
&
CSI
=
MFI
.
getCalleeSavedInfo
(
)
;
std
::
advance
(
MBBI
,
CSI
.
size
(
)
)
;
for
(
const
auto
&
Entry
:
CSI
)
{
int64_t
Offset
=
MFI
.
getObjectOffset
(
Entry
.
getFrameIdx
(
)
)
;
unsigned
Reg
=
Entry
.
getReg
(
)
;
unsigned
CFIIndex
=
MF
.
addFrameInst
(
MCCFIInstruction
::
createOffset
(
nullptr
,
RI
->
getDwarfRegNum
(
Reg
,
true
)
,
Offset
)
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
->
get
(
TargetOpcode
::
CFI_INSTRUCTION
)
)
.
addCFIIndex
(
CFIIndex
)
;
}
if
(
hasFP
(
MF
)
)
{
adjustReg
(
MBB
,
MBBI
,
DL
,
FPReg
,
SPReg
,
StackSize
RVFI
->
getVarArgsSaveSize
(
)
,
MachineInstr
::
FrameSetup
)
;
unsigned
CFIIndex
=
MF
.
addFrameInst
(
MCCFIInstruction
::
createDefCfa
(
nullptr
,
RI
->
getDwarfRegNum
(
FPReg
,
true
)
,
0
)
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
->
get
(
TargetOpcode
::
CFI_INSTRUCTION
)
)
.
addCFIIndex
(
CFIIndex
)
;
}
}
</s>

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

RISCV
RISCV
"Shrink-wrapping not yet supported"
RISCV
RISCV
RISCV
0
0


<s> unsigned PPCInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : break ; case PPC :: STD : case PPC :: STW : case PPC :: STFS : case PPC :: STFD : case PPC :: SPILL_CR : case PPC :: SPILL_CRBIT : case PPC :: STVX : case PPC :: STXVD2X : case PPC :: STXVX : case PPC :: QVSTFDX : case PPC :: QVSTFSXs : case PPC :: QVSTFDXb : case PPC :: SPILL_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>

isStoreToStackSlot - If the specified machine instruction is a direct store to a stack slot , return the virtual or physical register number of the source reg along with the FrameIndex of the loaded stack slot .


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

Enable the MachineScheduler pass for all X86 subtargets .


<s> void MCS51MCCodeEmitter :: emitInstruction ( uint64_t Val , unsigned Size , const MCSubtargetInfo & STI , raw_ostream & OS ) const { size_t WordCount = Size / 2 ; for ( int64_t i = WordCount - 1 ; i >= 0 ; -- i ) { uint16_t Word = ( Val >> ( i * 16 ) ) & 0xFFFF ; support :: endian :: write ( OS , Word , support :: endianness :: little ) ; } } </s>

Targets should implement this to emit instructions .


<s> inline tree function_instance :: memory_scalar_type ( ) const { return base -> memory_scalar_type ( * this ) ; } </s>

If the function addresses memory , return the type of a single scalar memory element .


<s> int getCost ( ) { return SUnits . size ( ) ; } </s>


<s> void notice_update_cc ( rtx exp ) { if ( GET_CODE ( exp ) == SET ) { if ( SET_DEST ( exp ) == pc_rtx ) return ; if ( REG_P ( SET_DEST ( exp ) ) && ( REG_P ( SET_SRC ( exp ) ) || GET_CODE ( SET_SRC ( exp ) ) == MEM ) ) { return ; } if ( GET_CODE ( SET_DEST ( exp ) ) == MEM && REG_P ( SET_SRC ( exp ) ) ) { return ; } } CC_STATUS_INIT ; return ; } </s>

On the 68000 , all the insns to store in an address register fail to set the cc 's . However , in some cases these instructions can make it possibly invalid to use the saved cc 's . In those cases we clear out some or all of the saved cc 's so they wo n't be used .


<s> bool SIInstrInfo :: isLegalRegOperand ( const MachineRegisterInfo & MRI , const MCOperandInfo & OpInfo , const MachineOperand & MO ) const { if ( ! MO . isReg ( ) ) return false ; Register Reg = MO . getReg ( ) ; const TargetRegisterClass * RC = Register :: isVirtualRegister ( Reg ) ? MRI . getRegClass ( Reg ) : RI . getPhysRegClass ( Reg ) ; const TargetRegisterClass * DRC = RI . getRegClass ( OpInfo . RegClass ) ; if ( MO . getSubReg ( ) ) { const MachineFunction * MF = MO . getParent ( ) -> getParent ( ) -> getParent ( ) ; const TargetRegisterClass * SuperRC = RI . getLargestLegalSuperClass ( RC , * MF ) ; if ( ! SuperRC ) return false ; DRC = RI . getMatchingSuperRegClass ( SuperRC , DRC , MO . getSubReg ( ) ) ; if ( ! DRC ) return false ; } return RC -> hasSuperClassEq ( DRC ) ; } </s>

Check if MO ( a register operand ) is a legal register for the given operand description .


<s> int moxie_initial_elimination_offset ( int from , int to ) { int ret ; if ( ( from ) == FRAME_POINTER_REGNUM && ( to ) == HARD_FRAME_POINTER_REGNUM ) { moxie_compute_frame ( ) ; ret = - cfun -> machine -> callee_saved_reg_size ; } else if ( ( from ) == ARG_POINTER_REGNUM && ( to ) == HARD_FRAME_POINTER_REGNUM ) ret = 0x00 ; else abort ( ) ; return ret ; } </s>

Implements the macro INITIAL_ELIMINATION_OFFSET , return the OFFSET .


<s> static rtx rs6000_emit_vector_compare_inner ( enum rtx_code code , rtx op0 , rtx op1 ) { rtx mask ; machine_mode mode = GET_MODE ( op0 ) ; switch ( code ) { default : break ; case GE : if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) return NULL_RTX ; case EQ : case GT : case GTU : case ORDERED : case UNORDERED : case UNEQ : case LTGT : mask = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , mask , gen_rtx_fmt_ee ( code , mode , op0 , op1 ) ) ) ; return mask ; } return NULL_RTX ; } </s>

Return insn for VSX or Altivec comparisons .


<s> void KudeyarFrameLowering :: emitPrologue ( MachineFunction & MF ) const { MachineBasicBlock & MBB = MF . front ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; KudeyarMachineFunctionInfo * KudeyarFI = MF . getInfo < KudeyarMachineFunctionInfo > ( ) ; const KudeyarInstrInfo & TII = * static_cast < const KudeyarInstrInfo * > ( MF . getTarget ( ) . 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 - 4 ; NumBytes = FrameSize - KudeyarFI -> getCalleeSavedFrameSize ( ) ; MFI -> setOffsetAdjustment ( - NumBytes ) ; BuildMI ( MBB , MBBI , DL , TII . get ( Kudeyar :: PUSH_R ) ) . addReg ( Kudeyar :: FP , RegState :: Kill ) ; BuildMI ( MBB , MBBI , DL , TII . get ( Kudeyar :: MOV_RR ) , Kudeyar :: FP ) . addReg ( Kudeyar :: SP ) ; for ( MachineFunction :: iterator I = llvm :: next ( MF . begin ( ) ) , E = MF . end ( ) ; I != E ; ++ I ) I -> addLiveIn ( Kudeyar :: FP ) ; } else NumBytes = StackSize - KudeyarFI -> getCalleeSavedFrameSize ( ) ; while ( MBBI != MBB . end ( ) && ( MBBI -> getOpcode ( ) == Kudeyar :: PUSH_R ) ) ++ MBBI ; if ( MBBI != MBB . end ( ) ) DL = MBBI -> getDebugLoc ( ) ; if ( NumBytes ) { if ( NumBytes ) { MachineInstr * MI = BuildMI ( MBB , MBBI , DL , TII . get ( Kudeyar :: SUB_RI32 ) , Kudeyar :: SP ) . addReg ( Kudeyar :: SP ) . addImm ( NumBytes ) ; } } } </s>

Kudeyar Kudeyar Kudeyar Kudeyar Kudeyar Kudeyar Kudeyar 0 4 Kudeyar Kudeyar::PUSH_R Kudeyar::FP Kudeyar::MOV_RR Kudeyar::FP Kudeyar::SP Kudeyar::FP Kudeyar Kudeyar::PUSH_R Kudeyar::SUB_RI32 Kudeyar::SP Kudeyar::SP


<s>
bool
HexagonPassConfig
::
addInstSelector
(
)
{
const
HexagonTargetMachine
&
TM
=
getHexagonTargetMachine
(
)
;
bool
NoOpt
=
(
getOptLevel
(
)
==
CodeGenOpt
::
)
;
if
(
!
NoOpt
)
addPass
(
createHexagonRemoveExtendArgs
(
TM
)
)
;
addPass
(
createHexagonISelDag
(
TM
,
getOptLevel
(
)
)
)
;
if
(
!
NoOpt
)
{
addPass
(
createHexagonPeephole
(
)
)
;
printAndVerify
(
"After hexagon peephole pass"
)
;
}
return
false
;
}
</s>

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

Hexagon
Hexagon
Hexagon
Hexagon
Hexagon
Hexagon
Hexagon
"After hexagon peephole pass"


<s> static bool abi_v4_pass_in_fpr ( machine_mode mode , bool named ) { if ( ! TARGET_HARD_FLOAT ) return false ; if ( TARGET_DOUBLE_FLOAT && mode == DFmode ) return true ; if ( TARGET_SINGLE_FLOAT && mode == SFmode && named ) return true ; if ( is_complex_IBM_long_double ( mode ) ) return false ; if ( FLOAT128_2REG_P ( mode ) ) return true ; if ( DECIMAL_FLOAT_MODE_P ( mode ) ) return true ; return false ; } </s>

Whether ABI_V4 passes MODE args to a function in floating point registers .


<s> unsigned AArch64TTIImpl :: getCacheLineSize ( ) { return ST -> getCacheLineSize ( ) ; } </s>

Return the target cache line size in bytes .


<s> bool PPCTargetLowering :: isFMAFasterThanFMulAndFAdd ( EVT VT ) const { VT = VT . getScalarType ( ) ; if ( ! VT . isSimple ( ) ) return false ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { case MVT :: f32 : case MVT :: f64 : return true ; default : break ; } return false ; } </s>

Return true if an FMA operation is faster than a pair of fmul and fadd instructions .


<s> bool csky_shifted_imm8_constant ( unsigned HOST_WIDE_INT val , unsigned int * base , unsigned int * shift ) { unsigned HOST_WIDE_INT mask = 0xff ; int i ; val = val & ( unsigned HOST_WIDE_INT ) 0xffffffffu ; if ( val == 0 ) return 0 ; for ( i = 0 ; i < 25 ; i ++ ) if ( ( val & ( mask << i ) ) == val ) { if ( base ) * base = ( unsigned int ) ( val >> i ) ; if ( shift ) * shift = ( unsigned int ) i ; return true ; } return false ; } </s>

Return true if the constant VAL can be expressed by an 8-bit constant with a shift value , filling in * BASE and * SHIFT .


<s> bool MandarinAsmPrinter :: PrintAsmMemoryOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode , raw_ostream & O ) { if ( ExtraCode && ExtraCode [ 0 ] ) return true ; O << '[' ; printMemOperand ( MI , OpNo , O ) ; O << ']' ; return false ; } </s>

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


<s> machreg_t inet_makeaddr ( machreg_t net , machreg_t lna ) { return _inet_makeaddr ( net , lna ) >> SHIFT_BITS ; } </s>

< arpa/inet.h > has struct in_addr inet_makeaddr ( int , int ) ; ( IRIX 6.2 ) struct in_addr inet_makeaddr ( in_addr_t , in_addr_t ) ; ( IRIX 6.5 )


<s> bool X86PassConfig :: addInstSelector ( ) { addPass ( createX86ISelDag ( getX86TargetMachine ( ) , getOptLevel ( ) ) ) ; if ( Triple ( TM -> getTargetTriple ( ) ) . isOSBinFormatELF ( ) && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createCleanupLocalDynamicTLSPass ( ) ) ; addPass ( createX86GlobalBaseRegPass ( ) ) ; return false ; } </s>


<s> static rtx_insn * apply_GEN_FCN ( enum insn_code icode , rtx * arg ) { switch ( insn_data [ icode ] . n_generator_args ) { case 0 : return GEN_FCN ( icode ) ( ) ; case 1 : return GEN_FCN ( icode ) ( arg [ 0 ] ) ; case 2 : return GEN_FCN ( icode ) ( arg [ 0 ] , arg [ 1 ] ) ; case 3 : return GEN_FCN ( icode ) ( arg [ 0 ] , arg [ 1 ] , arg [ 2 ] ) ; case 4 : return GEN_FCN ( icode ) ( arg [ 0 ] , arg [ 1 ] , arg [ 2 ] , arg [ 3 ] ) ; case 5 : return GEN_FCN ( icode ) ( arg [ 0 ] , arg [ 1 ] , arg [ 2 ] , arg [ 3 ] , arg [ 4 ] ) ; default : gcc_unreachable ( ) ; } } </s>

Helper arc_expand_builtin , generates a pattern for the given icode and arguments .


<s> void LC3InstPrinter :: printInst ( const MCInst * MI , raw_ostream & O , StringRef Annot , const MCSubtargetInfo & STI ) { printInstruction ( MI , O ) ; printAnnotation ( O , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


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


<s> static void rs6000_elf_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( first && TREE_CODE ( decl ) == FUNCTION_DECL && ! TARGET_AIX && DEFAULT_ABI == ABI_AIX ) { rtx sym_ref = XEXP ( rtl , 0 ) ; size_t len = strlen ( XSTR ( sym_ref , 0 ) ) ; char * str = XALLOCAVEC ( char , len + 2 ) ; str [ 0 ] = '.' ; memcpy ( str + 1 , XSTR ( sym_ref , 0 ) , len + 1 ) ; XSTR ( sym_ref , 0 ) = ggc_alloc_string ( str , len + 1 ) ; } } </s>

For a SYMBOL_REF , set generic flags and then perform some target-specific processing . When the AIX ABI is requested on a non-AIX system , replace the function name with the real name ( with a leading . ) rather than the function descriptor name . This saves a lot of overriding code to read the prefixes .


<s> static bool nvptx_unisimt_handle_set ( rtx set , rtx_insn * insn , rtx master ) { rtx reg ; if ( GET_CODE ( set ) == SET && REG_P ( reg = SET_DEST ( set ) ) && find_reg_note ( insn , REG_UNUSED , reg ) == NULL_RTX ) { emit_insn_after ( nvptx_gen_shuffle ( reg , reg , master , SHUFFLE_IDX ) , insn ) ; return true ; } return false ; } </s>

If SET subexpression of INSN sets a register , emit a shuffle instruction to propagate its value from lane MASTER to current lane .


<s> static bool arm_evpc_neon_vzip ( struct expand_vec_perm_d * d ) { unsigned int i , high , mask , nelt = d -> nelt ; rtx out0 , out1 , in0 , in1 ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; int first_elem ; bool is_swapped ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= 8 ) return false ; is_swapped = BYTES_BIG_ENDIAN ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , 0 ) ^ is_swapped ] ; high = nelt / 2 ; if ( first_elem == neon_endian_lane_map ( d -> vmode , high ) ) ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , 0 ) ) high = 0 ; else return false ; mask = ( d -> one_vector_p ? nelt - 1 : 2 * nelt - 1 ) ; for ( i = 0 ; i < nelt / 2 ; i ++ ) { unsigned elt = neon_pair_endian_lane_map ( d -> vmode , i + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , 2 * i + is_swapped ) ] != elt ) return false ; elt = neon_pair_endian_lane_map ( d -> vmode , i + nelt + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , 2 * i + ! is_swapped ) ] != elt ) return false ; } if ( d -> testing_p ) return true ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vzipv16qi_internal ; break ; case V8QImode : gen = gen_neon_vzipv8qi_internal ; break ; case V8HImode : gen = gen_neon_vzipv8hi_internal ; break ; case V4HImode : gen = gen_neon_vzipv4hi_internal ; break ; case V4SImode : gen = gen_neon_vzipv4si_internal ; break ; case V2SImode : gen = gen_neon_vzipv2si_internal ; break ; case V2SFmode : gen = gen_neon_vzipv2sf_internal ; break ; case V4SFmode : gen = gen_neon_vzipv4sf_internal ; break ; default : gcc_unreachable ( ) ; } in0 = d -> op0 ; in1 = d -> op1 ; if ( is_swapped ) std :: swap ( in0 , in1 ) ; out0 = d -> target ; out1 = gen_reg_rtx ( d -> vmode ) ; if ( high ) std :: swap ( out0 , out1 ) ; emit_insn ( gen ( out0 , in0 , in1 , out1 ) ) ; return true ; } </s>


<s> static bool sparc_print_operand_punct_valid_p ( unsigned char code ) { if ( code == '#' || code == '*' || code == '(' || code == ')' || code == '_' || code == '&' ) return true ; return false ; } </s>


<s> static void riscv_block_move_straight ( rtx dest , rtx src , unsigned HOST_WIDE_INT length ) { unsigned HOST_WIDE_INT offset , delta ; unsigned HOST_WIDE_INT bits ; int i ; enum machine_mode mode ; rtx * regs ; bits = MAX ( BITS_PER_UNIT , MIN ( BITS_PER_WORD , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) ) ) ; mode = mode_for_size ( bits , MODE_INT , 0 ) . require ( ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( rtx , length / delta ) ; for ( offset = 0 , i = 0 ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; riscv_emit_move ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; } for ( offset = 0 , i = 0 ; offset + delta <= length ; offset += delta , i ++ ) riscv_emit_move ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; if ( offset < length ) { src = adjust_address ( src , BLKmode , offset ) ; dest = adjust_address ( dest , BLKmode , offset ) ; move_by_pieces ( dest , src , length - offset , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) , RETURN_BEGIN ) ; } } </s>

Emit straight-line code to move LENGTH bytes from SRC to DEST . Assume that the areas do not overlap .


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

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


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

getPassName - Return a nice clean name for a pass .


<s> bool SIPeepholeSDWA :: runOnMachineFunction ( MachineFunction & MF ) { const SISubtarget & ST = MF . getSubtarget < SISubtarget > ( ) ; if ( ! ST . hasSDWA ( ) ) return false ; MRI = & MF . getRegInfo ( ) ; TRI = ST . getRegisterInfo ( ) ; TII = ST . getInstrInfo ( ) ; matchSDWAOperands ( MF ) ; for ( const auto & OperandPair : SDWAOperands ) { const auto & Operand = OperandPair . second ; MachineInstr * PotentialMI = Operand -> potentialToConvert ( TII ) ; if ( PotentialMI && isConvertibleToSDWA ( * PotentialMI , ST ) ) { PotentialMatches [ PotentialMI ] . push_back ( Operand . get ( ) ) ; } } for ( auto & PotentialPair : PotentialMatches ) { MachineInstr & PotentialMI = * PotentialPair . first ; convertToSDWA ( PotentialMI , PotentialPair . second ) ; } PotentialMatches . clear ( ) ; SDWAOperands . clear ( ) ; bool Ret = ! ConvertedInstructions . empty ( ) ; while ( ! ConvertedInstructions . empty ( ) ) legalizeScalarOperands ( * ConvertedInstructions . pop_back_val ( ) , ST ) ; return Ret ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool AMDGPUTargetLowering :: isLoadBitCastBeneficial ( EVT LoadTy , EVT CastTy , const SelectionDAG & DAG , const MachineMemOperand & MMO ) const { assert ( LoadTy . getSizeInBits ( ) == CastTy . getSizeInBits ( ) ) ; if ( LoadTy . getScalarType ( ) == MVT :: i32 ) return false ; unsigned LScalarSize = LoadTy . getScalarSizeInBits ( ) ; unsigned CastScalarSize = CastTy . getScalarSizeInBits ( ) ; if ( ( LScalarSize >= CastScalarSize ) && ( CastScalarSize < 32 ) ) return false ; bool Fast = false ; return allowsMemoryAccess ( * DAG . getContext ( ) , DAG . getDataLayout ( ) , CastTy , MMO , & Fast ) && Fast ; } </s>

Return true if the following transform is beneficial : fold ( conv ( load x ) ) - > ( load ( conv * ) x ) On architectures that do n't natively support some vector loads efficiently , casting the load to a smaller vector of larger types and loading is more efficient , however , this can be undone by optimizations in dag combiner .


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


<s>
void
encodeInstruction
(
const
MCInst
&
MI
,
raw_ostream
&
OS
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
const
override
{
verifyInstructionPredicates
(
MI
,
computeAvailableFeatures
(
STI
.
getFeatureBits
(
)
)
)
;
unsigned
Opcode
=
MI
.
getOpcode
(
)
;
const
MCInstrDesc
&
Desc
=
MCII
.
get
(
Opcode
)
;
uint64_t
Bits
=
getBinaryCodeForInstr
(
MI
,
Fixups
,
STI
)
;
unsigned
Size
=
Desc
.
getSize
(
)
;
support
::
endianness
E
=
IsLittleEndian
support
::
little
:
support
::
big
;
switch
(
Size
)
{
case
0
:
break
;
case
4
:
support
::
endian
::
write
<
uint32_t
>
(
OS
,
Bits
,
E
)
;
break
;
case
8
:
support
::
endian
::
write
<
uint32_t
>
(
OS
,
Bits
>>
32
,
E
)
;
support
::
endian
::
write
<
uint32_t
>
(
OS
,
Bits
,
E
)
;
break
;
default
:
llvm_unreachable
(
"Invalid instruction size"
)
;
}
++
MCNumEmitted
;
}
</s>

Encode the given Inst to bytes and append to CB .

PowerPC
support::endianness
support::little
support::big
0
4
support::endian
8
support::endian
32
support::endian
"Invalid instruction size"