<s> uint64_t R600MCCodeEmitter :: getMachineOpValue ( const MCInst & MI , const MCOperand & MO , SmallVectorImpl < MCFixup > & Fixup , const MCSubtargetInfo & STI ) const { if ( MO . isReg ( ) ) { if ( HAS_NATIVE_OPERANDS ( MCII . get ( MI . getOpcode ( ) ) . TSFlags ) ) return MRI . getEncodingValue ( MO . getReg ( ) ) ; return getHWReg ( MO . getReg ( ) ) ; } assert ( MO . isImm ( ) ) ; return MO . getImm ( ) ; } </s>

getMachineOpValue - Return binary encoding of operand .


<s> unsigned RISCVAsmParser :: validateTargetOperandClass ( MCParsedAsmOperand & AsmOp , unsigned Kind ) { RISCVOperand & Op = static_cast < RISCVOperand & > ( AsmOp ) ; if ( ! Op . isReg ( ) ) return Match_InvalidOperand ; Register Reg = Op . getReg ( ) ; bool IsRegFPR32 = RISCVMCRegisterClasses [ RISCV :: FPR32RegClassID ] . contains ( Reg ) ; bool IsRegFPR32C = RISCVMCRegisterClasses [ RISCV :: FPR32CRegClassID ] . contains ( Reg ) ; if ( ( IsRegFPR32 && Kind == MCK_FPR64 ) || ( IsRegFPR32C && Kind == MCK_FPR64C ) ) { Op . Reg . RegNum = convertFPR32ToFPR64 ( Reg ) ; return Match_Success ; } return Match_InvalidOperand ; } </s>

Allow a target to add special case operand matching for things that tblgen doesn't/ca n't handle effectively .

RISCV RISCV RISCV RISCV RISCV RISCV::FPR32RegClassID RISCV RISCV::FPR32CRegClassID


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


"\nrs6000_mode_dependent_address: ret = %s\n"

Debug version of rs6000_mode_dependent_address .


<s> static rtx_insn * rs6000_emit_savres_rtx ( rs6000_stack_t * info , rtx frame_reg_rtx , int save_area_offset , int lr_offset , machine_mode reg_mode , int sel ) { int i ; int offset , start_reg , end_reg , n_regs , use_reg ; int reg_size = GET_MODE_SIZE ( reg_mode ) ; rtx sym ; rtvec p ; rtx par ; rtx_insn * insn ; offset = 0 ; start_reg = ( ( sel & SAVRES_REG ) == SAVRES_GPR ? info -> first_gp_reg_save : ( sel & SAVRES_REG ) == SAVRES_FPR ? info -> first_fp_reg_save : ( sel & SAVRES_REG ) == SAVRES_VR ? info -> first_altivec_reg_save : - 1 ) ; end_reg = ( ( sel & SAVRES_REG ) == SAVRES_GPR ? 32 : ( sel & SAVRES_REG ) == SAVRES_FPR ? 64 : ( sel & SAVRES_REG ) == SAVRES_VR ? LAST_ALTIVEC_REGNO + 1 : - 1 ) ; n_regs = end_reg - start_reg ; p = rtvec_alloc ( 3 + ( ( sel & SAVRES_LR ) ? 1 : 0 ) + ( ( sel & SAVRES_REG ) == SAVRES_VR ? 1 : 0 ) + n_regs ) ; if ( ! ( sel & SAVRES_SAVE ) && ( sel & SAVRES_LR ) ) RTVEC_ELT ( p , offset ++ ) = ret_rtx ; RTVEC_ELT ( p , offset ++ ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( Pmode , LR_REGNO ) ) ; sym = rs6000_savres_routine_sym ( info , sel ) ; RTVEC_ELT ( p , offset ++ ) = gen_rtx_USE ( VOIDmode , sym ) ; use_reg = ptr_regno_for_savres ( sel ) ; if ( ( sel & SAVRES_REG ) == SAVRES_VR ) { RTVEC_ELT ( p , offset ++ ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( Pmode , use_reg ) ) ; RTVEC_ELT ( p , offset ++ ) = gen_rtx_USE ( VOIDmode , gen_rtx_REG ( Pmode , 0 ) ) ; } else RTVEC_ELT ( p , offset ++ ) = gen_rtx_USE ( VOIDmode , gen_rtx_REG ( Pmode , use_reg ) ) ; for ( i = 0 ; i < end_reg - start_reg ; i ++ ) RTVEC_ELT ( p , i + offset ) = gen_frame_set ( gen_rtx_REG ( reg_mode , start_reg + i ) , frame_reg_rtx , save_area_offset + reg_size * i , ( sel & SAVRES_SAVE ) != 0 ) ; if ( ( sel & SAVRES_SAVE ) && ( sel & SAVRES_LR ) ) RTVEC_ELT ( p , i + offset ) = gen_frame_store ( gen_rtx_REG ( Pmode , 0 ) , frame_reg_rtx , lr_offset ) ; par = gen_rtx_PARALLEL ( VOIDmode , p ) ; if ( ! ( sel & SAVRES_SAVE ) && ( sel & SAVRES_LR ) ) { insn = emit_jump_insn ( par ) ; JUMP_LABEL ( insn ) = ret_rtx ; } else insn = emit_insn ( par ) ; return insn ; } </s>

Construct a parallel rtx describing the effect of a call to an out-of-line register save/restore routine , and emit the insn or jump_insn as appropriate .


<s> const char * ix86_output_indirect_function_return ( rtx ret_op ) { if ( cfun -> machine -> function_return_type != indirect_branch_keep ) { char thunk_name [ 32 ] ; enum indirect_thunk_prefix need_prefix = indirect_thunk_need_prefix ( current_output_insn ) ; unsigned int regno = REGNO ( ret_op ) ; gcc_assert ( regno == CX_REG ) ; if ( cfun -> machine -> function_return_type != indirect_branch_thunk_inline ) { bool need_thunk = ( cfun -> machine -> function_return_type == indirect_branch_thunk ) ; indirect_thunk_name ( thunk_name , regno , need_prefix , true ) ; if ( need_thunk ) { indirect_return_via_cx = true ; indirect_thunks_used |= 1 << CX_REG ; } fprintf ( asm_out_file , "\tjmp\t%s\n" , thunk_name ) ; } else output_indirect_thunk ( regno ) ; return "" ; } else return "%!jmp\t%A0" ; } </s>

Output indirect function return . RET_OP is the function return target .


<s> static std :: string getNodeLabel ( const SUnit * SU , const ScheduleDAG * G ) { std :: string Str ; raw_string_ostream SS ( Str ) ; SS << "SU(" << SU -> NodeNum << ")[" << SU -> Latency << "]" ; return SS . str ( ) ; } </s>

Print a DDG node either in concise form ( -ddg-dot-only ) or verbose mode ( -ddg-dot ) .


<s> unsigned SIRegisterInfo :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { const SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; unsigned Occupancy = ST . getOccupancyWithLocalMemSize ( MFI -> getLDSSize ( ) , MF . getFunction ( ) ) ; switch ( RC -> getID ( ) ) { default : return AMDGPUGenRegisterInfo :: getRegPressureLimit ( RC , MF ) ; case AMDGPU :: VGPR_32RegClassID : case AMDGPU :: VGPR_LO16RegClassID : case AMDGPU :: VGPR_HI16RegClassID : return std :: min ( ST . getMaxNumVGPRs ( Occupancy ) , ST . getMaxNumVGPRs ( MF ) ) ; case AMDGPU :: SGPR_32RegClassID : return std :: min ( ST . getMaxNumSGPRs ( Occupancy , true ) , ST . getMaxNumSGPRs ( MF ) ) ; } } </s>

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


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

getSubExpr - Get the child of this expression .


<s> TargetFrameLowering :: DwarfFrameBase WebAssemblyFrameLowering :: getDwarfFrameBase ( const MachineFunction & MF ) const { DwarfFrameBase Loc ; Loc . Kind = DwarfFrameBase :: WasmFrameBase ; const WebAssemblyFunctionInfo & MFI = * MF . getInfo < WebAssemblyFunctionInfo > ( ) ; if ( needsSP ( MF ) ) { unsigned LocalNum = MFI . getFrameBaseLocal ( ) ; Loc . Location . WasmLoc = { WebAssembly :: TI_LOCAL_START , LocalNum } ; } else { Loc . Location . WasmLoc = { WebAssembly :: TI_GLOBAL_START , 0 } ; } return Loc ; } </s>

Return the frame base information to be encoded in the DWARF subprogram debug info .


<s>
bool
X86CallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
unsigned
VReg
)
const
{
assert
(
(
(
Val
&&
VReg
)
||
(
!
Val
&&
!
VReg
)
)
&&
"Return value without a vreg"
)
;
auto
MIB
=
MIRBuilder
.
buildInstrNoInsert
(
X86
::
RET
)
.
addImm
(
0
)
;
if
(
VReg
)
{
MachineFunction
&
MF
=
MIRBuilder
.
getMF
(
)
;
MachineRegisterInfo
&
MRI
=
MF
.
getRegInfo
(
)
;
auto
&
DL
=
MF
.
getDataLayout
(
)
;
const
Function
&
F
=
*
MF
.
getFunction
(
)
;
ArgInfo
OrigArg
{
VReg
,
Val
->
getType
(
)
}
;
setArgFlags
(
OrigArg
,
AttributeList
::
ReturnIndex
,
DL
,
F
)
;
SmallVector
<
ArgInfo
,
8
>
SplitArgs
;
splitToValueTypes
(
OrigArg
,
SplitArgs
,
DL
,
MRI
,
[
&
]
(
ArrayRef
<
unsigned
>
Regs
)
{
MIRBuilder
.
buildUnmerge
(
Regs
,
VReg
)
;
}
)
;
FuncReturnHandler
Handler
(
MIRBuilder
,
MRI
,
MIB
,
RetCC_X86
)
;
if
(
!
handleAssignments
(
MIRBuilder
,
SplitArgs
,
Handler
)
)
return
false
;
}
MIRBuilder
.
insertInstr
(
MIB
)
;
return
true
;
}
</s>

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


<s> SDValue X86TargetLowering :: getSqrtEstimate ( SDValue Op , SelectionDAG & DAG , int Enabled , int & RefinementSteps , bool & UseOneConstNR , bool Reciprocal ) const { SDLoc DL ( Op ) ; EVT VT = Op . getValueType ( ) ; if ( ( VT == MVT :: f32 && Subtarget . hasSSE1 ( ) ) || ( VT == MVT :: v4f32 && Subtarget . hasSSE1 ( ) && Reciprocal ) || ( VT == MVT :: v4f32 && Subtarget . hasSSE2 ( ) && ! Reciprocal ) || ( VT == MVT :: v8f32 && Subtarget . hasAVX ( ) ) || ( VT == MVT :: v16f32 && Subtarget . useAVX512Regs ( ) ) ) { if ( RefinementSteps == ReciprocalEstimate :: Unspecified ) RefinementSteps = 1 ; UseOneConstNR = false ; unsigned Opcode = VT == MVT :: v16f32 ? X86ISD :: RSQRT14 : X86ISD :: FRSQRT ; return DAG . getNode ( Opcode , DL , VT , Op ) ; } if ( VT . getScalarType ( ) == MVT :: f16 && isTypeLegal ( VT ) && Subtarget . hasFP16 ( ) ) { if ( RefinementSteps == ReciprocalEstimate :: Unspecified ) RefinementSteps = 0 ; if ( VT == MVT :: f16 ) { SDValue Zero = DAG . getIntPtrConstant ( 0 , DL ) ; SDValue Undef = DAG . getUNDEF ( MVT :: v8f16 ) ; Op = DAG . getNode ( ISD :: SCALAR_TO_VECTOR , DL , MVT :: v8f16 , Op ) ; Op = DAG . getNode ( X86ISD :: RSQRT14S , DL , MVT :: v8f16 , Undef , Op ) ; return DAG . getNode ( ISD :: EXTRACT_VECTOR_ELT , DL , MVT :: f16 , Op , Zero ) ; } return DAG . getNode ( X86ISD :: RSQRT14 , DL , VT , Op ) ; } return SDValue ( ) ; } </s>

Hooks for building estimates in place of slower divisions and square roots .


<s> unsigned MBlazeMCCodeEmitter :: getMachineOpValue ( const MCInst & MI , const MCOperand & MO ) const { if ( MO . isReg ( ) ) return MBlazeRegisterInfo :: getRegisterNumbering ( MO . getReg ( ) ) ; else if ( MO . isImm ( ) ) return static_cast < unsigned > ( MO . getImm ( ) ) ; else if ( MO . isExpr ( ) ) return 0 ; else { errs ( ) << MO ; llvm_unreachable ( 0 ) ; } return 0 ; } </s>


<s>
SDValue
MipsTargetLowering
::
LowerCallResult
(
SDValue
Chain
,
SDValue
InFlag
,
CallingConv
::
ID
CallConv
,
bool
IsVarArg
,
const
SmallVectorImpl
<
ISD
::
InputArg
>
&
Ins
,
const
SDLoc
&
DL
,
SelectionDAG
&
DAG
,
SmallVectorImpl
<
SDValue
>
&
InVals
,
TargetLowering
::
CallLoweringInfo
&
CLI
)
const
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
MipsCCState
CCInfo
(
CallConv
,
IsVarArg
,
DAG
.
getMachineFunction
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeCallResult
(
Ins
,
RetCC_Mips
,
CLI
)
;
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
SDValue
Val
=
DAG
.
getCopyFromReg
(
Chain
,
DL
,
RVLocs
[
i
]
.
getLocReg
(
)
,
RVLocs
[
i
]
.
getLocVT
(
)
,
InFlag
)
;
Chain
=
Val
.
getValue
(
1
)
;
InFlag
=
Val
.
getValue
(
2
)
;
if
(
VA
.
isUpperBitsInLoc
(
)
)
{
unsigned
ValSizeInBits
=
Ins
[
i
]
.
ArgVT
.
getSizeInBits
(
)
;
unsigned
LocSizeInBits
=
VA
.
getLocVT
(
)
.
getSizeInBits
(
)
;
unsigned
Shift
=
VA
.
getLocInfo
(
)
==
CCValAssign
::
ZExtUpper
ISD
::
SRL
:
ISD
::
SRA
;
Val
=
DAG
.
getNode
(
Shift
,
DL
,
VA
.
getLocVT
(
)
,
Val
,
DAG
.
getConstant
(
LocSizeInBits
ValSizeInBits
,
DL
,
VA
.
getLocVT
(
)
)
)
;
}
switch
(
VA
.
getLocInfo
(
)
)
{
default
:
llvm_unreachable
(
"Unknown loc info!"
)
;
case
CCValAssign
::
Full
:
break
;
case
CCValAssign
::
BCvt
:
Val
=
DAG
.
getNode
(
ISD
::
BITCAST
,
DL
,
VA
.
getValVT
(
)
,
Val
)
;
break
;
case
CCValAssign
::
AExt
:
case
CCValAssign
::
AExtUpper
:
Val
=
DAG
.
getNode
(
ISD
::
TRUNCATE
,
DL
,
VA
.
getValVT
(
)
,
Val
)
;
break
;
case
CCValAssign
::
ZExt
:
case
CCValAssign
::
ZExtUpper
:
Val
=
DAG
.
getNode
(
ISD
::
AssertZext
,
DL
,
VA
.
getLocVT
(
)
,
Val
,
DAG
.
getValueType
(
VA
.
getValVT
(
)
)
)
;
Val
=
DAG
.
getNode
(
ISD
::
TRUNCATE
,
DL
,
VA
.
getValVT
(
)
,
Val
)
;
break
;
case
CCValAssign
::
SExt
:
case
CCValAssign
::
SExtUpper
:
Val
=
DAG
.
getNode
(
ISD
::
AssertSext
,
DL
,
VA
.
getLocVT
(
)
,
Val
,
DAG
.
getValueType
(
VA
.
getValVT
(
)
)
)
;
Val
=
DAG
.
getNode
(
ISD
::
TRUNCATE
,
DL
,
VA
.
getValVT
(
)
,
Val
)
;
break
;
}
InVals
.
push_back
(
Val
)
;
}
return
Chain
;
}
</s>

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

Mips
Mips
ISD::InputArg
16
Mips
Mips
0
"Can only return in registers!"
1
2
ISD::SRL
ISD::SRA
"Unknown loc info!"
ISD::BITCAST
ISD::TRUNCATE
ISD::AssertZext
ISD::TRUNCATE
ISD::AssertSext
ISD::TRUNCATE


"all ColorKinds should be handled by the switch above"

Dump the plan to stderr ( for debugging ) .


<s> llvm :: FastISel * X86 :: createFastISel ( MachineFunction & mf , MachineModuleInfo * mmi , DwarfWriter * dw , DenseMap < const Value * , unsigned > & vm , DenseMap < const BasicBlock * , MachineBasicBlock * > & bm , DenseMap < const AllocaInst * , int > & am , SmallSet < Instruction * , 8 > & cil ) { return new X86FastISel ( mf , mmi , dw , vm , bm , am , cil ) ; } </s>

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


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

Return true if a select of constants ( select Cond , C1 , C2 ) should be transformed into simple math ops with the condition value .


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

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


<s> void LEGFrameLowering :: emitPrologue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; DebugLoc dl = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; uint64_t StackSize = computeStackSize ( MF ) ; if ( ! StackSize ) { return ; } unsigned StackReg = LEG :: SP ; unsigned OffsetReg = materializeOffset ( MF , MBB , MBBI , ( unsigned ) StackSize ) ; if ( OffsetReg ) { BuildMI ( MBB , MBBI , dl , TII . get ( LEG :: SUBrr ) , StackReg ) . addReg ( StackReg ) . addReg ( OffsetReg ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } else { BuildMI ( MBB , MBBI , dl , TII . get ( LEG :: SUBri ) , StackReg ) . addReg ( StackReg ) . addImm ( StackSize ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } } </s>

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


<s> MCInstrDesc const & HexagonMCInstrInfo :: getDesc ( MCInstrInfo const & MCII , MCInst const & MCI ) { return ( MCII . get ( MCI . getOpcode ( ) ) ) ; } </s>

Returns the target instruction descriptor of this MachineInstr .


<s>
void
SystemZInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
unsigned
Opc
;
if
(
SystemZ
::
GR64RegClass
.
contains
(
DestReg
,
SrcReg
)
)
Opc
=
SystemZ
::
MOV64rr
;
else
if
(
SystemZ
::
GR32RegClass
.
contains
(
DestReg
,
SrcReg
)
)
Opc
=
SystemZ
::
MOV32rr
;
else
if
(
SystemZ
::
GR64PRegClass
.
contains
(
DestReg
,
SrcReg
)
)
Opc
=
SystemZ
::
MOV64rrP
;
else
if
(
SystemZ
::
GR128RegClass
.
contains
(
DestReg
,
SrcReg
)
)
Opc
=
SystemZ
::
MOV128rr
;
else
if
(
SystemZ
::
FP32RegClass
.
contains
(
DestReg
,
SrcReg
)
)
Opc
=
SystemZ
::
FMOV32rr
;
else
if
(
SystemZ
::
FP64RegClass
.
contains
(
DestReg
,
SrcReg
)
)
Opc
=
SystemZ
::
FMOV64rr
;
else
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
</s>


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

Mips
Intrinsic::ID
Intrinsic::cheri_cap_bounds_set
Intrinsic::getDeclaration
0
"Replacing "
"  with "


<s> static inline unsigned getFormat ( uint64_t TSFlags ) { return ( TSFlags & InstFormatMask ) >> InstFormatShift ; } </s>


<s> ARMBaseTargetMachine :: ARMBaseTargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) : LLVMTargetMachine ( T , TT , CPU , FS , Options , RM , CM , OL ) , Subtarget ( TT , CPU , FS , Options ) , JITInfo ( ) , InstrItins ( Subtarget . getInstrItineraryData ( ) ) { if ( Options . FloatABIType == FloatABI :: Default ) this -> Options . FloatABIType = FloatABI :: Soft ; } </s>


<s> bool loongarch_expand_block_move ( rtx dest , rtx src , rtx length ) { int max_move_bytes = LARCH_MAX_MOVE_BYTES_STRAIGHT ; if ( CONST_INT_P ( length ) && INTVAL ( length ) <= loongarch_max_inline_memcpy_size ) { if ( INTVAL ( length ) <= max_move_bytes ) { loongarch_block_move_straight ( dest , src , INTVAL ( length ) ) ; return true ; } else if ( optimize ) { loongarch_block_move_loop ( dest , src , INTVAL ( length ) , LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER ) ; return true ; } } return false ; } </s>

Expand a cpymemsi instruction , which copies LENGTH bytes from memory reference SRC to memory reference DEST .


<s> static void sparc_output_dwarf_dtprel ( FILE * file , int size , rtx x ) { switch ( size ) { case 4 : fputs ( "\t.word\t%r_tls_dtpoff32(" , file ) ; break ; case 8 : fputs ( "\t.xword\t%r_tls_dtpoff64(" , file ) ; break ; default : gcc_unreachable ( ) ; } output_addr_const ( file , x ) ; fputs ( ")" , file ) ; } </s>

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


<s> PreservedAnalyses AMDGPULowerModuleLDSPass :: run ( Module & M , ModuleAnalysisManager & ) { return AMDGPULowerModuleLDS ( ) . runOnModule ( M ) ? PreservedAnalyses :: none ( ) : PreservedAnalyses :: all ( ) ; } </s>

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


<s>
void
Z80RegisterInfo
::
resolveFrameIndex
(
MachineInstr
&
MI
,
unsigned
BaseReg
,
int64_t
Offset
)
const
{
unsigned
FIOperandNum
=
0
;
while
(
!
MI
.
getOperand
(
FIOperandNum
)
.
isFI
(
)
)
{
FIOperandNum
++
;
assert
(
FIOperandNum
<
MI
.
getNumOperands
(
)
&&
"Expected a frame index"
)
;
}
MI
.
getOperand
(
FIOperandNum
)
.
ChangeToRegister
(
BaseReg
,
false
)
;
MI
.
getOperand
(
FIOperandNum
+
1
)
.
ChangeToImmediate
(
MI
.
getOperand
(
FIOperandNum
+
1
)
.
getImm
(
)
+
Offset
)
;
}
</s>

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


<s> const WebAssemblyTargetLowering * getTLI ( ) const { return TLI ; } </s>

Getter for generic TargetLowering class .


<s> static void predicate_insn ( rtx_insn * insn , rtx pred ) { rtx pat = PATTERN ( insn ) ; pred = gen_rtx_NE ( BImode , pred , const0_rtx ) ; pat = gen_rtx_COND_EXEC ( VOIDmode , pred , pat ) ; bool changed_p = validate_change ( insn , & PATTERN ( insn ) , pat , false ) ; gcc_assert ( changed_p ) ; } </s>

Return true if we can add a predicate COND to INSN , or if INSN already has that predicate . If DOIT is true , also perform the modification .


<s> bool WebAssembly :: mayThrow ( const MachineInstr & MI ) { switch ( MI . getOpcode ( ) ) { case WebAssembly :: THROW_I32 : case WebAssembly :: THROW_I32_S : case WebAssembly :: THROW_I64 : case WebAssembly :: THROW_I64_S : case WebAssembly :: RETHROW : case WebAssembly :: RETHROW_S : return true ; } if ( isCallIndirect ( MI ) ) return true ; if ( ! MI . isCall ( ) ) return false ; const MachineOperand & MO = MI . getOperand ( getCalleeOpNo ( MI ) ) ; assert ( MO . isGlobal ( ) ) ; const auto * F = dyn_cast < Function > ( MO . getGlobal ( ) ) ; if ( ! F ) return true ; if ( F -> doesNotThrow ( ) ) return false ; if ( F -> getName ( ) == CxaBeginCatchFn || F -> getName ( ) == PersonalityWrapperFn || F -> getName ( ) == ClangCallTerminateFn || F -> getName ( ) == StdTerminateFn ) return false ; return true ; } </s>

Return true if this instruction may throw an exception .


<s> void visium_expand_epilogue ( void ) { const int save_area_size = current_frame_info . save_area_size ; const int reg_size1 = current_frame_info . reg_size1 ; const int max_reg1 = current_frame_info . max_reg1 ; const int reg_size2 = current_frame_info . reg_size2 ; const int var_size = current_frame_info . var_size ; const int restore_fp = current_frame_info . save_fp ; const int restore_lr = current_frame_info . save_lr ; const int lr_slot = current_frame_info . lr_slot ; const int local_frame_offset = ( restore_fp + restore_lr + lr_slot ) * UNITS_PER_WORD ; const int combine = current_frame_info . combine ; int reg_size ; int last_reg ; int fsize ; if ( ! crtl -> sp_is_unchanging ) emit_insn ( gen_stack_restore ( ) ) ; if ( restore_fp ) { rtx src ; if ( TARGET_MCM && ! crtl -> sp_is_unchanging ) src = gen_frame_mem ( SImode , hard_frame_pointer_rtx ) ; else src = gen_frame_mem ( SImode , stack_pointer_rtx ) ; rtx insn = emit_frame_insn ( gen_movsi ( hard_frame_pointer_rtx , src ) ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; visium_add_cfa_restore_note ( hard_frame_pointer_rtx ) ; } if ( restore_lr ) { rtx mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , restore_fp * UNITS_PER_WORD ) ) ; rtx reg = gen_rtx_REG ( SImode , LINK_REGNUM ) ; emit_insn ( gen_movsi ( reg , mem ) ) ; visium_add_cfa_restore_note ( reg ) ; } if ( reg_size2 ) { reg_size = reg_size2 ; last_reg = max_reg1 + 1 ; fsize = local_frame_offset + var_size + reg_size2 ; } else { reg_size = reg_size1 ; last_reg = 0 ; fsize = local_frame_offset + var_size + reg_size1 + save_area_size ; } if ( reg_size && combine ) visium_restore_regs ( fsize , local_frame_offset + var_size , FIRST_PSEUDO_REGISTER - 1 , last_reg ) ; else if ( fsize ) { const int pop_size = reg_size ? local_frame_offset + var_size : fsize ; rtx insn ; if ( pop_size > 65535 ) { rtx tmp = gen_rtx_REG ( SImode , PROLOGUE_TMP_REGNUM ) ; emit_move_insn ( tmp , GEN_INT ( pop_size ) ) ; insn = emit_frame_insn ( gen_stack_pop ( tmp ) ) ; } else insn = emit_frame_insn ( gen_stack_pop ( GEN_INT ( pop_size ) ) ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( pop_size ) ) ) ) ; visium_add_queued_cfa_restore_notes ( insn ) ; } if ( reg_size && ! combine ) visium_restore_regs ( fsize - local_frame_offset - var_size , 0 , FIRST_PSEUDO_REGISTER - 1 , last_reg ) ; if ( reg_size2 ) visium_restore_regs ( reg_size1 + save_area_size , 0 , max_reg1 , 0 ) ; if ( crtl -> calls_eh_return ) emit_insn ( gen_stack_pop ( EH_RETURN_STACKADJ_RTX ) ) ; } </s>

This function generates the code for function exit .


<s> DecodeStatus AArch64Disassembler :: getInstruction ( MCInst & MI , uint64_t & Size , const MemoryObject & Region , uint64_t Address , raw_ostream & os , raw_ostream & cs ) const { CommentStream = & cs ; uint8_t bytes [ 4 ] ; Size = 0 ; if ( Region . readBytes ( Address , 4 , ( uint8_t * ) bytes ) == - 1 ) return Fail ; Size = 4 ; uint32_t insn = ( bytes [ 3 ] << 24 ) | ( bytes [ 2 ] << 16 ) | ( bytes [ 1 ] << 8 ) | ( bytes [ 0 ] << 0 ) ; return decodeInstruction ( DecoderTable32 , MI , insn , Address , this , STI ) ; } </s>

Returns the disassembly of a single instruction .


<s> bool AMDGPUPerfHintAnalysis :: runOnFunction ( Function & F ) { auto * TPC = getAnalysisIfAvailable < TargetPassConfig > ( ) ; if ( ! TPC ) return false ; const TargetMachine & TM = TPC -> getTM < TargetMachine > ( ) ; const TargetSubtargetInfo * ST = TM . getSubtargetImpl ( F ) ; AMDGPUPerfHint Analyzer ( FIM , ST -> getTargetLowering ( ) ) ; Analyzer . runOnFunction ( F ) ; return false ; } </s>


"LR & FP are always handled in emitEpilogue"

"loadRegFromStackSlot didn't insert any code!"

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


"Instr doesn't have FrameIndex operand!"

"Unconditionally using R28 for evil purposes Offset: "

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


"sret virtual register not created in the entry block"

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


<s> int X86InstrInfo :: getSPAdjust ( const MachineInstr * MI ) const { const MachineFunction * MF = MI -> getParent ( ) -> getParent ( ) ; const TargetFrameLowering * TFI = MF -> getSubtarget ( ) . getFrameLowering ( ) ; if ( MI -> getOpcode ( ) == getCallFrameSetupOpcode ( ) || MI -> getOpcode ( ) == getCallFrameDestroyOpcode ( ) ) { unsigned StackAlign = TFI -> getStackAlignment ( ) ; int SPAdj = ( MI -> getOperand ( 0 ) . getImm ( ) + StackAlign - 1 ) / StackAlign * StackAlign ; SPAdj -= MI -> getOperand ( 1 ) . getImm ( ) ; if ( MI -> getOpcode ( ) == getCallFrameSetupOpcode ( ) ) return SPAdj ; else return - SPAdj ; } if ( MI -> isCall ( ) ) { const MachineBasicBlock * MBB = MI -> getParent ( ) ; auto I = ++ MachineBasicBlock :: const_iterator ( MI ) ; for ( auto E = MBB -> end ( ) ; I != E ; ++ I ) { if ( I -> getOpcode ( ) == getCallFrameDestroyOpcode ( ) || I -> isCall ( ) ) break ; } if ( I -> getOpcode ( ) != getCallFrameDestroyOpcode ( ) ) return 0 ; return - ( I -> getOperand ( 1 ) . getImm ( ) ) ; } switch ( MI -> getOpcode ( ) ) { default : return 0 ; case X86 :: PUSH32i8 : case X86 :: PUSH32r : case X86 :: PUSH32rmm : case X86 :: PUSH32rmr : case X86 :: PUSHi32 : return 4 ; case X86 :: PUSH64i8 : case X86 :: PUSH64r : case X86 :: PUSH64rmm : case X86 :: PUSH64rmr : case X86 :: PUSH64i32 : return 8 ; } } </s>

getSPAdjust - This returns the stack pointer adjustment made by this instruction .


<s> LLVM_DUMP_METHOD void dump ( ) const { print ( dbgs ( ) ) ; dbgs ( ) << "\n" ; } </s>

Dump the plan to stderr ( for debugging ) .


<s> unsigned R600TTIImpl :: getNumberOfRegisters ( bool Vec ) const { return getHardwareNumberOfRegisters ( Vec ) ; } </s>


<s> static void aarch64_emit_load_exclusive ( machine_mode mode , rtx rval , rtx mem , rtx model_rtx ) { emit_insn ( gen_aarch64_load_exclusive ( mode , rval , mem , model_rtx ) ) ; } </s>


<s> int AArch64TTIImpl :: getArithmeticInstrCost ( unsigned Opcode , Type * Ty , TTI :: OperandValueKind Opd1Info , TTI :: OperandValueKind Opd2Info , TTI :: OperandValueProperties Opd1PropInfo , TTI :: OperandValueProperties Opd2PropInfo , ArrayRef < const Value * > Args ) { std :: pair < int , MVT > LT = TLI -> getTypeLegalizationCost ( DL , Ty ) ; int Cost = 0 ; if ( isWideningInstruction ( Ty , Opcode , Args ) ) Cost += ST -> getWideningBaseCost ( ) ; int ISD = TLI -> InstructionOpcodeToISD ( Opcode ) ; switch ( ISD ) { default : return Cost + BaseT :: getArithmeticInstrCost ( Opcode , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; case ISD :: SDIV : if ( Opd2Info == TargetTransformInfo :: OK_UniformConstantValue && Opd2PropInfo == TargetTransformInfo :: OP_PowerOf2 ) { Cost += getArithmeticInstrCost ( Instruction :: Add , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; Cost += getArithmeticInstrCost ( Instruction :: Sub , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; Cost += getArithmeticInstrCost ( Instruction :: Select , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; Cost += getArithmeticInstrCost ( Instruction :: AShr , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; return Cost ; } LLVM_FALLTHROUGH ; case ISD :: UDIV : if ( Opd2Info == TargetTransformInfo :: OK_UniformConstantValue ) { auto VT = TLI -> getValueType ( DL , Ty ) ; if ( TLI -> isOperationLegalOrCustom ( ISD :: MULHU , VT ) ) { int MulCost = getArithmeticInstrCost ( Instruction :: Mul , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; int AddCost = getArithmeticInstrCost ( Instruction :: Add , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; int ShrCost = getArithmeticInstrCost ( Instruction :: AShr , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; return MulCost * 2 + AddCost * 2 + ShrCost * 2 + 1 ; } } Cost += BaseT :: getArithmeticInstrCost ( Opcode , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; if ( Ty -> isVectorTy ( ) ) { Cost += getArithmeticInstrCost ( Instruction :: ExtractElement , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; Cost += getArithmeticInstrCost ( Instruction :: InsertElement , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; Cost += Cost ; } return Cost ; case ISD :: ADD : case ISD :: MUL : case ISD :: XOR : case ISD :: OR : case ISD :: AND : return ( Cost + 1 ) * LT . first ; } } </s>

This is an approximation of reciprocal throughput of a math/logic op .


Pass or return a composite value in the FPR pair REGNO and REGNO + 1 . MODE is the mode of the composite . MODE1 and OFFSET1 are the mode and byte offset for the first value , likewise MODE2 and OFFSET2 for the second value .


<s> void rs6000_emit_le_vsx_store ( rtx dest , rtx source , machine_mode mode ) { rtx tmp , permute_src , permute_tmp ; if ( mode == TImode || mode == V1TImode ) { mode = V2DImode ; dest = adjust_address ( dest , V2DImode , 0 ) ; source = gen_lowpart ( V2DImode , source ) ; } tmp = can_create_pseudo_p ( ) ? gen_reg_rtx_and_attrs ( source ) : source ; permute_src = rs6000_gen_le_vsx_permute ( source , mode ) ; permute_tmp = rs6000_gen_le_vsx_permute ( tmp , mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp , permute_src ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , permute_tmp ) ) ; } </s>

Emit a little-endian store to vector memory location DEST from VSX register SOURCE in mode MODE . The store is done with two permuting insn 's that represent an xxpermdi and an stxvd2x .


<s> bool MipsSEFrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; MachineBasicBlock * EntryBlock = MF -> begin ( ) ; const TargetInstrInfo & TII = * MF -> getSubtarget ( ) . getInstrInfo ( ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; bool IsRAAndRetAddrIsTaken = ( Reg == Mips :: RA || Reg == Mips :: RA_64 ) && MF -> getFrameInfo ( ) -> isReturnAddressTaken ( ) ; if ( ! IsRAAndRetAddrIsTaken ) EntryBlock -> addLiveIn ( Reg ) ; bool IsKill = ! IsRAAndRetAddrIsTaken ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . storeRegToStackSlot ( * EntryBlock , MI , Reg , IsKill , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; } return true ; } </s>

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


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

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


<s> EVT getSetCCResultType ( LLVMContext & C , EVT VT ) const override { if ( ! VT . isVector ( ) ) return MVT :: i1 ; else return EVT :: getVectorVT ( C , MVT :: i1 , VT . getVectorNumElements ( ) ) ; } </s>

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


<s>
bool
HCE
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
if
(
skipFunction
(
*
MF
.
getFunction
(
)
)
)
return
false
;
DEBUG
(
MF
.
print
(
dbgs
(
)
<<
"Before "
<<
getPassName
(
)
<<
'\n'
,
nullptr
)
)
;
HII
=
MF
.
getSubtarget
<
HexagonSubtarget
>
(
)
.
getInstrInfo
(
)
;
HRI
=
MF
.
getSubtarget
<
HexagonSubtarget
>
(
)
.
getRegisterInfo
(
)
;
MDT
=
&
getAnalysis
<
MachineDominatorTree
>
(
)
;
MRI
=
&
MF
.
getRegInfo
(
)
;
AssignmentMap
IMap
;
collect
(
MF
)
;
std
::
sort
(
Extenders
.
begin
(
)
,
Extenders
.
end
(
)
,
[
]
(
const
ExtDesc
&
A
,
const
ExtDesc
&
B
)
{
return
ExtValue
(
A
)
<
ExtValue
(
B
)
;
}
)
;
bool
Changed
=
false
;
DEBUG
(
dbgs
(
)
<<
"Collected "
<<
Extenders
.
size
(
)
<<
" extenders\n"
)
;
for
(
unsigned
I
=
0
,
E
=
Extenders
.
size
(
)
;
I
!=
E
;
)
{
unsigned
B
=
I
;
const
ExtRoot
&
T
=
Extenders
[
B
]
.
getOp
(
)
;
while
(
I
!=
E
&&
ExtRoot
(
Extenders
[
I
]
.
getOp
(
)
)
==
T
)
++
I
;
IMap
.
clear
(
)
;
assignInits
(
T
,
B
,
I
,
IMap
)
;
Changed
|=
replaceExtenders
(
IMap
)
;
}
DEBUG
(
{
if
(
Changed
)
MF
.
print
(
dbgs
(
)
<<
"After "
<<
getPassName
(
)
<<
'\n'
,
nullptr
)
;
else
dbgs
(
)
<<
"No changes\n"
;
}
)
;
return
Changed
;
}
</s>

runOnMachineFunction - Emit the function body .

Hexagon
"Before "
Hexagon
Hexagon
"Collected "
" extenders\n"
0
"After "
"No changes\n"


<s> static rtx_insn * riscv_call_tls_get_addr ( rtx sym , rtx result ) { rtx a0 = gen_rtx_REG ( Pmode , GP_ARG_FIRST ) , func ; rtx_insn * insn ; if ( ! riscv_tls_symbol ) riscv_tls_symbol = init_one_libfunc ( "__tls_get_addr" ) ; func = gen_rtx_MEM ( FUNCTION_MODE , riscv_tls_symbol ) ; start_sequence ( ) ; emit_insn ( riscv_got_load_tls_gd ( a0 , sym ) ) ; insn = emit_call_insn ( gen_call_value ( result , func , const0_rtx , NULL ) ) ; RTL_CONST_CALL_P ( insn ) = 1 ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , a0 ) ; insn = get_insns ( ) ; end_sequence ( ) ; return insn ; } </s>

Return an instruction sequence that calls __tls_get_addr . SYM is the TLS symbol we are referencing and TYPE is the symbol type to use ( either global dynamic or local dynamic ) . RESULT is an RTX for the return value location .


<s>
bool
SystemZAsmParser
::
MatchAndEmitInstruction
(
SMLoc
IDLoc
,
unsigned
&
Opcode
,
OperandVector
&
Operands
,
MCStreamer
&
Out
,
uint64_t
&
ErrorInfo
,
bool
MatchingInlineAsm
)
{
MCInst
Inst
;
unsigned
MatchResult
;
MatchResult
=
MatchInstructionImpl
(
Operands
,
Inst
,
ErrorInfo
,
MatchingInlineAsm
)
;
switch
(
MatchResult
)
{
case
Match_Success
:
Inst
.
setLoc
(
IDLoc
)
;
Out
.
EmitInstruction
(
Inst
,
getSTI
(
)
)
;
return
false
;
case
Match_MissingFeature
:
{
assert
(
ErrorInfo
&&
"Unknown missing feature!"
)
;
std
::
string
Msg
=
"instruction requires:"
;
uint64_t
Mask
=
1
;
for
(
unsigned
I
=
0
;
I
<
sizeof
(
ErrorInfo
)
*
8
1
;
++
I
)
{
if
(
ErrorInfo
&
Mask
)
{
Msg
+=
" "
;
Msg
+=
getSubtargetFeatureName
(
ErrorInfo
&
Mask
)
;
}
Mask
<<=
1
;
}
return
Error
(
IDLoc
,
Msg
)
;
}
case
Match_InvalidOperand
:
{
SMLoc
ErrorLoc
=
IDLoc
;
if
(
ErrorInfo
!=
~
0ULL
)
{
if
(
ErrorInfo
>=
Operands
.
size
(
)
)
return
Error
(
IDLoc
,
"too few operands for instruction"
)
;
ErrorLoc
=
(
(
SystemZOperand
&
)
*
Operands
[
ErrorInfo
]
)
.
getStartLoc
(
)
;
if
(
ErrorLoc
==
SMLoc
(
)
)
ErrorLoc
=
IDLoc
;
}
return
Error
(
ErrorLoc
,
"invalid operand for instruction"
)
;
}
case
Match_MnemonicFail
:
return
Error
(
IDLoc
,
"invalid instruction"
)
;
}
llvm_unreachable
(
"Unexpected match type"
)
;
}
</s>

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


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

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


<s>
NVPTXSubtarget
::
NVPTXSubtarget
(
const
std
::
string
&
TT
,
const
std
::
string
&
CPU
,
const
std
::
string
&
FS
,
bool
is64Bit
)
:
NVPTXGenSubtargetInfo
(
TT
,
""
,
FS
)
,
Is64Bit
(
is64Bit
)
{
drvInterface
=
DriverInterface
;
std
::
string
defCPU
=
"sm_10"
;
if
(
FS
.
empty
(
)
&&
CPU
.
empty
(
)
)
TargetName
=
defCPU
;
else
if
(
!
CPU
.
empty
(
)
)
TargetName
=
CPU
;
else
llvm_unreachable
(
"we are not using FeatureStr"
)
;
SmVersion
=
atoi
(
TargetName
.
c_str
(
)
+
3
)
;
}
</s>

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

NVPTX
NVPTX
NVPTX
NVPTX
""
"sm_10"
"we are not using FeatureStr"
3


<s> void rs6000_emit_le_vsx_load ( rtx dest , rtx source , machine_mode mode ) { rtx tmp , permute_mem , permute_reg ; if ( mode == TImode || mode == V1TImode ) { mode = V2DImode ; dest = gen_lowpart ( V2DImode , dest ) ; source = adjust_address ( source , V2DImode , 0 ) ; } tmp = can_create_pseudo_p ( ) ? gen_reg_rtx_and_attrs ( dest ) : dest ; permute_mem = rs6000_gen_le_vsx_permute ( source , mode ) ; permute_reg = rs6000_gen_le_vsx_permute ( tmp , mode ) ; emit_insn ( gen_rtx_SET ( tmp , permute_mem ) ) ; emit_insn ( gen_rtx_SET ( dest , permute_reg ) ) ; } </s>

Emit a little-endian load from vector memory location SOURCE to VSX register DEST in mode MODE . The load is done with two permuting insn 's that represent an lxvd2x and xxpermdi .


<s> rtx_insn * cris_emit_insn ( rtx x ) { rtvec vec = rtvec_alloc ( 2 ) ; RTVEC_ELT ( vec , 0 ) = x ; RTVEC_ELT ( vec , 1 ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , CRIS_CC0_REGNUM ) ) ; return emit_insn ( gen_rtx_PARALLEL ( VOIDmode , vec ) ) ; } </s>

Convenience function for CRIS-local use of emit_insn , wrapping the argument in a parallel with a clobber of CRIS_CC0_REGNUM before passing on to emit_insn .


<s>
bool
AArch64InstrInfo
::
isGPRCopy
(
const
MachineInstr
*
MI
)
const
{
switch
(
MI
->
getOpcode
(
)
)
{
default
:
break
;
case
TargetOpcode
::
COPY
:
{
unsigned
DstReg
=
MI
->
getOperand
(
0
)
.
getReg
(
)
;
return
(
AArch64
::
GPR32RegClass
.
contains
(
DstReg
)
||
AArch64
::
GPR64RegClass
.
contains
(
DstReg
)
)
;
}
case
AArch64
::
ORRXrs
:
if
(
MI
->
getOperand
(
1
)
.
getReg
(
)
==
AArch64
::
XZR
)
{
assert
(
MI
->
getDesc
(
)
.
getNumOperands
(
)
==
4
&&
MI
->
getOperand
(
3
)
.
getImm
(
)
==
0
&&
"invalid ORRrs operands"
)
;
return
true
;
}
break
;
case
AArch64
::
ADDXri
:
if
(
MI
->
getOperand
(
2
)
.
getImm
(
)
==
0
)
{
assert
(
MI
->
getDesc
(
)
.
getNumOperands
(
)
==
4
&&
MI
->
getOperand
(
3
)
.
getImm
(
)
==
0
&&
"invalid ADDXri operands"
)
;
return
true
;
}
break
;
}
return
false
;
}
</s>

Does this instruction rename a GPR without modifying bits ?


<s> enum reg_class cr16_regno_reg_class ( int regno ) { if ( ( regno >= 0 ) && ( regno < CR16_FIRST_DWORD_REGISTER ) ) return SHORT_REGS ; if ( ( regno >= CR16_FIRST_DWORD_REGISTER ) && ( regno < FIRST_PSEUDO_REGISTER ) ) return LONG_REGS ; return NO_REGS ; } </s>

Return the class number of the smallest class containing reg number REGNO . This could be a conditional expression or could index an array .


<s>
bool
BPFAsmPrinter
::
doInitialization
(
Module
&
M
)
{
AsmPrinter
::
doInitialization
(
M
)
;
if
(
MAI
->
doesSupportDebugInformation
(
)
)
{
Handlers
.
push_back
(
HandlerInfo
(
new
BTFDebug
(
this
)
,
"emit"
,
"Debug Info Emission"
,
"BTF"
,
"BTF Emission"
)
)
;
}
return
false
;
}
</s>

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

BPF
BPF
"emit"
"Debug Info Emission"
"BTF"
"BTF Emission"


<s> void i386_pe_seh_end_prologue ( FILE * f ) { struct seh_frame_state * seh ; if ( ! TARGET_SEH ) return ; if ( cfun -> is_thunk ) return ; seh = cfun -> machine -> seh ; XDELETE ( seh ) ; cfun -> machine -> seh = NULL ; fputs ( "\t.seh_endprologue\n" , f ) ; } </s>

Emit an assembler directive for the end of the prologue .


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { const R600Subtarget & ST = MF . getSubtarget < R600Subtarget > ( ) ; TII = ST . getInstrInfo ( ) ; for ( MachineFunction :: iterator BB = MF . begin ( ) , BB_E = MF . end ( ) ; BB != BB_E ; ++ BB ) { MachineBasicBlock & MBB = * BB ; MachineBasicBlock :: iterator I = MBB . begin ( ) ; if ( I -> getOpcode ( ) == AMDGPU :: CF_ALU ) continue ; for ( MachineBasicBlock :: iterator E = MBB . end ( ) ; I != E ; ) { if ( isALU ( * I ) ) I = MakeALUClause ( MBB , I ) ; else ++ I ; } } return false ; } </s>


<s> int h8300_tiny_data_p ( tree decl ) { tree a ; if ( TREE_CODE ( decl ) != VAR_DECL ) return 0 ; a = lookup_attribute ( "tiny_data" , DECL_ATTRIBUTES ( decl ) ) ; return a != NULL_TREE ; } </s>

Return nonzero if DECL is a variable that 's in the tiny data area .


<s> static int avr_map ( unsigned int f , int x ) { return x < 8 ? ( f >> ( 4 * x ) ) & 0xf : 0 ; } </s>

Compute the image of x under f , i.e . perform x -- > f ( x )


<s> void h8300_expand_prologue ( void ) { int regno ; int saved_regs ; int n_regs ; if ( h8300_os_task_function_p ( current_function_decl ) ) return ; if ( h8300_monitor_function_p ( current_function_decl ) ) emit_insn ( gen_monitor_prologue ( ) ) ; if ( frame_pointer_needed ) { push ( HARD_FRAME_POINTER_REGNUM ) ; F ( emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) , 0 ) ; } saved_regs = compute_saved_regs ( ) ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno += n_regs ) { n_regs = 1 ; if ( saved_regs & ( 1 << regno ) ) { if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & 3 ) == 0 ) && ( ( saved_regs >> regno ) & 0x0f ) == 0x0f ) n_regs = 4 ; else if ( ( TARGET_H8300SX || ( regno & 3 ) == 0 ) && ( ( saved_regs >> regno ) & 0x07 ) == 0x07 ) n_regs = 3 ; else if ( ( TARGET_H8300SX || ( regno & 1 ) == 0 ) && ( ( saved_regs >> regno ) & 0x03 ) == 0x03 ) n_regs = 2 ; } h8300_push_pop ( regno , n_regs , false , false ) ; } } h8300_emit_stack_adjustment ( - 1 , round_frame_size ( get_frame_size ( ) ) ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = round_frame_size ( get_frame_size ( ) ) + ( __builtin_popcount ( saved_regs ) * UNITS_PER_WORD ) + ( frame_pointer_needed ? UNITS_PER_WORD : 0 ) ; } </s>

Generate RTL code for the function prologue .


<s> bool X86TTIImpl :: supportsEfficientVectorElementLoadStore ( ) const { return false ; } </s>

If target has efficient vector element load/store instructions , it can return true here so that insertion/extraction costs are not added to the scalarization cost of a load/store .


<s> unsigned WebAssemblyFastISel :: zeroExtend ( unsigned Reg , const Value * V , MVT :: SimpleValueType From , MVT :: SimpleValueType To ) { if ( To == MVT :: i64 ) { if ( From == MVT :: i64 ) return copyValue ( Reg ) ; Reg = zeroExtendToI32 ( Reg , V , From ) ; unsigned Result = createResultReg ( & WebAssembly :: I64RegClass ) ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( WebAssembly :: I64_EXTEND_U_I32 ) , Result ) . addReg ( Reg ) ; return Result ; } return zeroExtendToI32 ( Reg , V , From ) ; } </s>

Return a new range in the specified integer type , which must be strictly larger than the current type .


"%qE attribute only applies to functions"

"attribute interrupt_handler is not compatible with -m5-compact"

Handle an `` interrupt_handler '' attribute ; arguments as in struct attribute_spec.handler .


<s> RegisterBankInfo :: InstructionMappings X86RegisterBankInfo :: getInstrAlternativeMappings ( const MachineInstr & MI ) const { const MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; const TargetSubtargetInfo & STI = MF . getSubtarget ( ) ; const TargetRegisterInfo & TRI = * STI . getRegisterInfo ( ) ; const MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; switch ( MI . getOpcode ( ) ) { case TargetOpcode :: G_LOAD : case TargetOpcode :: G_STORE : { unsigned Size = getSizeInBits ( MI . getOperand ( 0 ) . getReg ( ) , MRI , TRI ) ; if ( Size != 32 && Size != 64 ) break ; unsigned NumOperands = MI . getNumOperands ( ) ; SmallVector < PartialMappingIdx , 4 > OpRegBankIdx ( NumOperands ) ; getInstrPartialMappingIdxs ( MI , MRI , true , OpRegBankIdx ) ; SmallVector < const ValueMapping * , 8 > OpdsMapping ( NumOperands ) ; if ( ! getInstrValueMapping ( MI , OpRegBankIdx , OpdsMapping ) ) break ; const RegisterBankInfo :: InstructionMapping & Mapping = getInstructionMapping ( 1 , 1 , getOperandsMapping ( OpdsMapping ) , NumOperands ) ; InstructionMappings AltMappings ; AltMappings . push_back ( & Mapping ) ; return AltMappings ; } default : break ; } return RegisterBankInfo :: getInstrAlternativeMappings ( MI ) ; } </s>


<s>
void
SICInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
const
DebugLoc
&
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
unsigned
Opc
=
0
;
if
(
SIC
::
GPROutRegClass
.
contains
(
DestReg
)
&&
SIC
::
GPROutRegClass
.
contains
(
SrcReg
)
)
{
Opc
=
SIC
::
RMO
;
}
else
if
(
SIC
::
GPROutRegClass
.
contains
(
DestReg
)
&&
SIC
::
SW
==
SrcReg
)
{
Opc
=
SIC
::
MVSW
;
}
assert
(
Opc
&&
"Cannot copy registers"
)
;
MachineInstrBuilder
MIB
=
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
)
;
if
(
DestReg
)
MIB
.
addReg
(
DestReg
,
RegState
::
Define
)
;
if
(
SrcReg
)
MIB
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
</s>

SIC
SIC
0
SIC::GPROutRegClass
SIC::GPROutRegClass
SIC::RMO
SIC::GPROutRegClass
SIC::SW
SIC::MVSW
"Cannot copy registers"


<s>
char
*
output_call
(
rtx_insn
*
insn
,
rtx
*
operands
,
int
dest_operand_number
,
int
cookie_operand_number
)
{
static
char
buf
[
256
]
;
if
(
darwin_emit_branch_islands
&&
GET_CODE
(
operands
[
dest_operand_number
]
)
==
SYMBOL_REF
&&
(
INTVAL
(
operands
[
cookie_operand_number
]
)
&
CALL_LONG
)
)
{
tree
labelname
;
tree
funname
=
get_identifier
(
XSTR
(
operands
[
dest_operand_number
]
,
0
)
)
;
if
(
no_previous_def
(
funname
)
)
{
rtx
label_rtx
=
gen_label_rtx
(
)
;
char
*
label_buf
,
temp_buf
[
256
]
;
ASM_GENERATE_INTERNAL_LABEL
(
temp_buf
,
"L"
,
CODE_LABEL_NUMBER
(
label_rtx
)
)
;
label_buf
=
temp_buf
[
0
]
==
'*'
temp_buf
+
1
:
temp_buf
;
labelname
=
get_identifier
(
label_buf
)
;
add_compiler_branch_island
(
labelname
,
funname
,
insn_line
(
insn
)
)
;
}
else
labelname
=
get_prev_label
(
funname
)
;
sprintf
(
buf
,
"jbsr %%z%d,%.246s"
,
dest_operand_number
,
IDENTIFIER_POINTER
(
labelname
)
)
;
}
else
sprintf
(
buf
,
"bl %%z%d"
,
dest_operand_number
)
;
return
buf
;
}
</s>

INSN is either a function call or a millicode call . It may have an unconditional jump in its delay slot . CALL_DEST is the routine we are calling .


<s> static rtx expand_set_or_movmem_constant_prologue ( rtx dst , rtx * srcp , rtx destreg , rtx srcreg , rtx value , rtx vec_value , int desired_align , int align_bytes , bool issetmem ) { rtx src = NULL ; rtx orig_dst = dst ; rtx orig_src = NULL ; int piece_size = 1 ; int copied_bytes = 0 ; if ( ! issetmem ) { gcc_assert ( srcp != NULL ) ; src = * srcp ; orig_src = src ; } for ( piece_size = 1 ; piece_size <= desired_align && copied_bytes < align_bytes ; piece_size <<= 1 ) { if ( align_bytes & piece_size ) { if ( issetmem ) { if ( vec_value && piece_size > GET_MODE_SIZE ( GET_MODE ( value ) ) ) dst = emit_memset ( dst , destreg , vec_value , piece_size ) ; else dst = emit_memset ( dst , destreg , value , piece_size ) ; } else dst = emit_memmov ( dst , & src , destreg , srcreg , piece_size ) ; copied_bytes += piece_size ; } } if ( MEM_ALIGN ( dst ) < ( unsigned int ) desired_align * BITS_PER_UNIT ) set_mem_align ( dst , desired_align * BITS_PER_UNIT ) ; if ( MEM_SIZE_KNOWN_P ( orig_dst ) ) set_mem_size ( dst , MEM_SIZE ( orig_dst ) - align_bytes ) ; if ( ! issetmem ) { int src_align_bytes = get_mem_align_offset ( src , desired_align * BITS_PER_UNIT ) ; if ( src_align_bytes >= 0 ) src_align_bytes = desired_align - src_align_bytes ; if ( src_align_bytes >= 0 ) { unsigned int src_align ; for ( src_align = desired_align ; src_align >= 2 ; src_align >>= 1 ) { if ( ( src_align_bytes & ( src_align - 1 ) ) == ( align_bytes & ( src_align - 1 ) ) ) break ; } if ( src_align > ( unsigned int ) desired_align ) src_align = desired_align ; if ( MEM_ALIGN ( src ) < src_align * BITS_PER_UNIT ) set_mem_align ( src , src_align * BITS_PER_UNIT ) ; } if ( MEM_SIZE_KNOWN_P ( orig_src ) ) set_mem_size ( src , MEM_SIZE ( orig_src ) - align_bytes ) ; * srcp = src ; } return dst ; } </s>

This function is like the previous one , except here we know how many bytes need to be copied . That allows us to update alignment not only of DST , which is returned , but also of SRC , which is passed as a pointer for that reason .


<s> static bool aarch64_advsimd_valid_immediate_hs ( unsigned int val32 , simd_immediate_info * info , enum simd_immediate_check which , simd_immediate_info :: insn_type insn ) { for ( unsigned int shift = 0 ; shift < 32 ; shift += 8 ) if ( ( val32 & ( 0xff << shift ) ) == val32 ) { if ( info ) * info = simd_immediate_info ( SImode , val32 >> shift , insn , simd_immediate_info :: LSL , shift ) ; return true ; } unsigned int imm16 = val32 & 0xffff ; if ( imm16 == ( val32 >> 16 ) ) for ( unsigned int shift = 0 ; shift < 16 ; shift += 8 ) if ( ( imm16 & ( 0xff << shift ) ) == imm16 ) { if ( info ) * info = simd_immediate_info ( HImode , imm16 >> shift , insn , simd_immediate_info :: LSL , shift ) ; return true ; } if ( which == AARCH64_CHECK_MOV ) for ( unsigned int shift = 8 ; shift < 24 ; shift += 8 ) { unsigned int low = ( 1 << shift ) - 1 ; if ( ( ( val32 & ( 0xff << shift ) ) | low ) == val32 ) { if ( info ) * info = simd_immediate_info ( SImode , val32 >> shift , insn , simd_immediate_info :: MSL , shift ) ; return true ; } } return false ; } </s>

Return true if replicating VAL32 is a valid 2-byte or 4-byte immediate for the Advanced SIMD operation described by WHICH and INSN . If INFO is nonnull , use it to describe valid immediates .


<s> ARMBaseTargetMachine :: ARMBaseTargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL , bool isLittle ) : LLVMTargetMachine ( T , TT , CPU , FS , Options , RM , CM , OL ) , Subtarget ( TT , CPU , FS , isLittle , Options ) , JITInfo ( ) , InstrItins ( Subtarget . getInstrItineraryData ( ) ) { if ( Options . FloatABIType == FloatABI :: Default ) this -> Options . FloatABIType = Subtarget . isTargetHardFloat ( ) ? FloatABI :: Hard : FloatABI :: Soft ; } </s>


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addPreserved < DominatorTreeWrapperPass > ( ) ; AU . addPreserved < LoopInfoWrapperPass > ( ) ; AU . addRequired < TargetPassConfig > ( ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s>
void
X86IntelInstPrinter
::
printPCRelImm
(
const
MCInst
*
MI
,
unsigned
OpNo
,
raw_ostream
&
O
)
{
const
MCOperand
&
Op
=
MI
->
getOperand
(
OpNo
)
;
if
(
Op
.
isImm
(
)
)
O
<<
formatImm
(
Op
.
getImm
(
)
)
;
else
{
assert
(
Op
.
isExpr
(
)
&&
"unknown pcrel immediate operand"
)
;
const
MCConstantExpr
*
BranchTarget
=
dyn_cast
<
MCConstantExpr
>
(
Op
.
getExpr
(
)
)
;
int64_t
Address
;
if
(
BranchTarget
&&
BranchTarget
->
evaluateAsAbsolute
(
Address
)
)
{
O
<<
formatHex
(
(
uint64_t
)
Address
)
;
}
else
{
Op
.
getExpr
(
)
->
print
(
O
,
&
MAI
)
;
}
}
}
</s>


<s> static void rs6000_elf_asm_init_sections ( void ) { toc_section = get_unnamed_section ( 0 , rs6000_elf_output_toc_section_asm_op , NULL ) ; sdata2_section = get_unnamed_section ( SECTION_WRITE , output_section_asm_op , SDATA2_SECTION_ASM_OP ) ; } </s>


<s> bool mn10300_wide_const_load_uses_clr ( rtx operands [ 2 ] ) { long val [ 2 ] ; if ( GET_CODE ( operands [ 0 ] ) != REG || REGNO_REG_CLASS ( REGNO ( operands [ 0 ] ) ) != DATA_REGS ) return false ; switch ( GET_CODE ( operands [ 1 ] ) ) { case CONST_INT : { rtx low , high ; split_double ( operands [ 1 ] , & low , & high ) ; val [ 0 ] = INTVAL ( low ) ; val [ 1 ] = INTVAL ( high ) ; } break ; case CONST_DOUBLE : if ( GET_MODE ( operands [ 1 ] ) == DFmode ) { REAL_VALUE_TYPE rv ; REAL_VALUE_FROM_CONST_DOUBLE ( rv , operands [ 1 ] ) ; REAL_VALUE_TO_TARGET_DOUBLE ( rv , val ) ; } else if ( GET_MODE ( operands [ 1 ] ) == VOIDmode || GET_MODE ( operands [ 1 ] ) == DImode ) { val [ 0 ] = CONST_DOUBLE_LOW ( operands [ 1 ] ) ; val [ 1 ] = CONST_DOUBLE_HIGH ( operands [ 1 ] ) ; } break ; default : return false ; } return val [ 0 ] == 0 || val [ 1 ] == 0 ; } </s>

Check whether a constant used to initialize a DImode or DFmode can use a clr instruction . The code here must be kept in sync with movdf and movdi .


<s> SMLoc AMDGPUAsmParser :: getLoc ( ) const { return getToken ( ) . getLoc ( ) ; } </s>

Get the source location of the point where the field was defined .


<s> DecodeStatus LanaiDisassembler :: getInstruction ( MCInst & Instr , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & , raw_ostream & ) const { uint32_t Insn ; DecodeStatus Result = readInstruction32 ( Bytes , Size , Insn ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; Result = decodeInstruction ( DecoderTableLanai32 , Instr , Insn , Address , this , STI ) ; if ( Result != MCDisassembler :: Fail ) { PostOperandDecodeAdjust ( Instr , Insn ) ; Size = 4 ; return Result ; } return MCDisassembler :: Fail ; } </s>

Returns the disassembly of a single instruction .


<s> void BRIGDwarfStreamer :: Finish ( ) { MCELFStreamer :: Finish ( ) ; dwarfStream -> flush ( ) ; dwarfStream -> releaseStream ( ) ; } </s>

Finish - Do final processing and write the object to the output stream .


<s> static rtx pa_struct_value_rtx ( tree fntype ATTRIBUTE_UNUSED , int incoming ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( Pmode , PA_STRUCT_VALUE_REGNUM ) ; } </s>

Worker function for TARGET_STRUCT_VALUE_RTX .


"Instr doesn't have FrameIndex operand!"

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


<s>
void
print
(
raw_ostream
&
OS
)
const
override
{
switch
(
Kind
)
{
case
k_Token
:
OS
<<
"Token: "
<<
getToken
(
)
<<
"\n"
;
break
;
case
k_Register
:
OS
<<
"Reg: #"
<<
getReg
(
)
<<
"\n"
;
break
;
case
k_Immediate
:
OS
<<
"Imm: "
<<
getImm
(
)
<<
"\n"
;
break
;
case
k_MemoryReg
:
OS
<<
"Mem: "
<<
getMemBase
(
)
<<
"+"
<<
getMemOffsetReg
(
)
<<
"\n"
;
break
;
case
k_MemoryImm
:
assert
(
getMemOff
(
)
!=
nullptr
)
;
OS
<<
"Mem: "
<<
getMemBase
(
)
<<
"+"
<<
*
getMemOff
(
)
<<
"\n"
;
break
;
}
}
</s>

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


<s> static int tilepro_issue_rate ( void ) { return 3 ; } </s>


<s> static void mips_start_function_definition ( const char * name , bool mips16_p ) { if ( mips16_p ) fprintf ( asm_out_file , "\t.set\tmips16\n" ) ; else fprintf ( asm_out_file , "\t.set\tnomips16\n" ) ; if ( TARGET_MICROMIPS ) fprintf ( asm_out_file , "\t.set\tmicromips\n" ) ; else fprintf ( asm_out_file , "\t.set\tnomicromips\n" ) ; if ( ! flag_inhibit_size_directive ) { fputs ( "\t.ent\t" , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; fputs ( "\n" , asm_out_file ) ; } ASM_OUTPUT_TYPE_DIRECTIVE ( asm_out_file , name , "function" ) ; assemble_name ( asm_out_file , name ) ; fputs ( ":\n" , asm_out_file ) ; } </s>

Start a definition of function NAME . MIPS16_P indicates whether the function contains MIPS16 code .


<s> X86Subtarget :: X86Subtarget ( const Triple & TT , StringRef CPU , StringRef FS , const X86TargetMachine & TM , MaybeAlign StackAlignOverride , unsigned PreferVectorWidthOverride , unsigned RequiredVectorWidth ) : X86GenSubtargetInfo ( TT , CPU , FS ) , PICStyle ( PICStyles :: Style :: None ) , TM ( TM ) , TargetTriple ( TT ) , StackAlignOverride ( StackAlignOverride ) , PreferVectorWidthOverride ( PreferVectorWidthOverride ) , RequiredVectorWidth ( RequiredVectorWidth ) , InstrInfo ( initializeSubtargetDependencies ( CPU , FS ) ) , TLInfo ( TM , * this ) , FrameLowering ( * this , getStackAlignment ( ) ) { if ( ! isPositionIndependent ( ) ) setPICStyle ( PICStyles :: Style :: None ) ; else if ( is64Bit ( ) ) setPICStyle ( PICStyles :: Style :: RIPRel ) ; else if ( isTargetCOFF ( ) ) setPICStyle ( PICStyles :: Style :: None ) ; else if ( isTargetDarwin ( ) ) setPICStyle ( PICStyles :: Style :: StubPIC ) ; else if ( isTargetELF ( ) ) setPICStyle ( PICStyles :: Style :: GOT ) ; CallLoweringInfo . reset ( new X86CallLowering ( * getTargetLowering ( ) ) ) ; Legalizer . reset ( new X86LegalizerInfo ( * this , TM ) ) ; auto * RBI = new X86RegisterBankInfo ( * getRegisterInfo ( ) ) ; RegBankInfo . reset ( RBI ) ; InstSelector . reset ( createX86InstructionSelector ( TM , * this , * RBI ) ) ; } </s>

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


<s> rtx expand_builtin ( unsigned int code , tree exp , rtx target ) { registered_function & rfn = * ( * registered_functions ) [ code ] ; if ( ! check_required_extensions ( EXPR_LOCATION ( exp ) , rfn . decl , rfn . required_extensions ) ) return target ; return function_expander ( rfn . instance , rfn . decl , exp , target ) . expand ( ) ; } </s>

Expand a call to the RVV function with subcode CODE . EXP is the call expression and TARGET is the preferred location for the result . Return the value of the lhs .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Hexagon Gather Packetize Code"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> void pdp11_output_def ( FILE * file , const char * label1 , const char * label2 ) { if ( TARGET_DEC_ASM ) { assemble_name ( file , label1 ) ; putc ( '=' , file ) ; assemble_name ( file , label2 ) ; } else { fputs ( "\t.set\t" , file ) ; assemble_name ( file , label1 ) ; putc ( ',' , file ) ; assemble_name ( file , label2 ) ; } putc ( '\n' , file ) ; } </s>


<s> bool ix86_binary_operator_ok ( enum rtx_code code , machine_mode mode , rtx operands [ 3 ] ) { rtx dst = operands [ 0 ] ; rtx src1 = operands [ 1 ] ; rtx src2 = operands [ 2 ] ; if ( ( MEM_P ( src1 ) || bcst_mem_operand ( src1 , mode ) ) && ( MEM_P ( src2 ) || bcst_mem_operand ( src2 , mode ) ) ) return false ; if ( ix86_swap_binary_operands_p ( code , mode , operands ) ) std :: swap ( src1 , src2 ) ; if ( MEM_P ( dst ) && ! rtx_equal_p ( dst , src1 ) ) return false ; if ( CONSTANT_P ( src1 ) ) return false ; if ( MEM_P ( src1 ) && ! rtx_equal_p ( dst , src1 ) ) return ( code == AND && ( mode == HImode || mode == SImode || ( TARGET_64BIT && mode == DImode ) ) && satisfies_constraint_L ( src2 ) ) ; return true ; } </s>

Return TRUE or FALSE depending on whether the binary operator meets the appropriate constraints .


<s> rtx arm_load_function_descriptor ( rtx funcdesc ) { rtx fnaddr_reg = gen_reg_rtx ( Pmode ) ; rtx pic_reg = gen_rtx_REG ( Pmode , FDPIC_REGNUM ) ; rtx fnaddr = gen_rtx_MEM ( Pmode , funcdesc ) ; rtx gotaddr = gen_rtx_MEM ( Pmode , plus_constant ( Pmode , funcdesc , 4 ) ) ; emit_move_insn ( fnaddr_reg , fnaddr ) ; emit_insn ( gen_restore_pic_register_after_call ( pic_reg , gotaddr ) ) ; return fnaddr_reg ; } </s>

Emit insns to load the function address from FUNCDESC ( an FDPIC function descriptor ) into a register and the GOT address into the FDPIC register , returning an rtx for the register holding the function address .


<s> bool AMDGPUPassConfig :: addPreRegAlloc ( ) { addPass ( createAMDGPUConvertToISAPass ( * TM ) ) ; const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . getGeneration ( ) <= AMDGPUSubtarget :: NORTHERN_ISLANDS ) { addPass ( createR600VectorRegMerger ( * TM ) ) ; } else { addPass ( createSIFixSGPRCopiesPass ( * TM ) ) ; addPass ( & MachineCSEID ) ; } return false ; } </s>

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


<s> bool WinEHStatePass :: doInitialization ( Module & M ) { TheModule = & M ; FrameEscape = Intrinsic :: getDeclaration ( TheModule , Intrinsic :: localescape ) ; FrameRecover = Intrinsic :: getDeclaration ( TheModule , Intrinsic :: localrecover ) ; FrameAddress = Intrinsic :: getDeclaration ( TheModule , Intrinsic :: frameaddress ) ; return false ; } </s>

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

X86 Intrinsic::getDeclaration Intrinsic::localescape Intrinsic::getDeclaration Intrinsic::localrecover Intrinsic::getDeclaration Intrinsic::frameaddress


<s> bool R600DAGToDAGISel :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & MF . getSubtarget < R600Subtarget > ( ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool GCNPassConfig :: addPreISel ( ) { AMDGPUPassConfig :: addPreISel ( ) ; addPass ( & AMDGPUAnnotateKernelFeaturesID ) ; addPass ( createSinkingPass ( ) ) ; addPass ( createSITypeRewriter ( ) ) ; addPass ( createSIAnnotateControlFlowPass ( ) ) ; return false ; } </s>


<s> static unsigned int frv_hard_regno_nregs ( unsigned int regno , machine_mode mode ) { if ( ACCG_P ( regno ) ) return GET_MODE_SIZE ( mode ) ; else return ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; } </s>

On the FRV , make the CC_FP mode take 3 words in the integer registers , so that we can build the appropriate instructions to properly reload the values . Also , make the byte-sized accumulator guards use one guard for each byte .


<s> static unsigned bit_count ( unsigned long value ) { unsigned long count = 0 ; while ( value ) { count ++ ; value &= value - 1 ; } return count ; } </s>

Typical stack layout should looks like this after the function 's prologue : | | -- ^ | | \ | | | arguments saved | Increasing | | on the stack | addresses PARENT arg pointer - > | | / -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - CHILD |ret | return address -- | | \ | | call saved | | registers | | / -- | | \ | | local | | variables frame pointer - > | | / -- | | \ | | outgoing | Decreasing | | arguments | addresses current stack pointer - > | | / | -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- V | |


<s> bool loongarch_epilogue_uses ( unsigned int regno ) { if ( regno == RETURN_ADDR_REGNUM ) return true ; return false ; } </s>


<s> bool Thumb1InstrInfo :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL = DebugLoc :: getUnknownLoc ( ) ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineInstrBuilder MIB = BuildMI ( MBB , MI , DL , get ( ARM :: tPUSH ) ) ; AddDefaultPred ( MIB ) ; MIB . addReg ( 0 ) ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; MBB . addLiveIn ( Reg ) ; MIB . addReg ( Reg , RegState :: Kill ) ; } return true ; } </s>

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


<s> Value * ARMTargetLowering :: emitLoadLinked ( IRBuilderBase & Builder , Type * ValueTy , Value * Addr , AtomicOrdering Ord ) const { Module * M = Builder . GetInsertBlock ( ) -> getParent ( ) -> getParent ( ) ; bool IsAcquire = isAcquireOrStronger ( Ord ) ; if ( ValueTy -> getPrimitiveSizeInBits ( ) == 64 ) { Intrinsic :: ID Int = IsAcquire ? Intrinsic :: arm_ldaexd : Intrinsic :: arm_ldrexd ; Function * Ldrex = Intrinsic :: getDeclaration ( M , Int ) ; Addr = Builder . CreateBitCast ( Addr , Type :: getInt8PtrTy ( M -> getContext ( ) ) ) ; Value * LoHi = Builder . CreateCall ( Ldrex , Addr , "lohi" ) ; Value * Lo = Builder . CreateExtractValue ( LoHi , 0 , "lo" ) ; Value * Hi = Builder . CreateExtractValue ( LoHi , 1 , "hi" ) ; if ( ! Subtarget -> isLittle ( ) ) std :: swap ( Lo , Hi ) ; Lo = Builder . CreateZExt ( Lo , ValueTy , "lo64" ) ; Hi = Builder . CreateZExt ( Hi , ValueTy , "hi64" ) ; return Builder . CreateOr ( Lo , Builder . CreateShl ( Hi , ConstantInt :: get ( ValueTy , 32 ) ) , "val64" ) ; } Type * Tys [ ] = { Addr -> getType ( ) } ; Intrinsic :: ID Int = IsAcquire ? Intrinsic :: arm_ldaex : Intrinsic :: arm_ldrex ; Function * Ldrex = Intrinsic :: getDeclaration ( M , Int , Tys ) ; return Builder . CreateTruncOrBitCast ( Builder . CreateCall ( Ldrex , Addr ) , ValueTy ) ; } </s>

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


<s> std :: unique_ptr < CSEConfigBase > ARMPassConfig :: getCSEConfig ( ) const { return getStandardCSEConfigForOpt ( TM -> getOptLevel ( ) ) ; } </s>

Returns the CSEConfig object to use for the current optimization level .


<s> static void mips_promote_ready ( rtx_insn * * ready , int lower , int higher ) { rtx_insn * new_head ; int i ; new_head = ready [ lower ] ; for ( i = lower ; i < higher ; i ++ ) ready [ i ] = ready [ i + 1 ] ; ready [ i ] = new_head ; } </s>

Remove the instruction at index LOWER from ready queue READY and reinsert it in front of the instruction at index HIGHER . LOWER must be < = HIGHER .


<s> X86_64GOTEntry * X86_64GOT :: create ( ) { return new X86_64GOTEntry ( 0 , m_SectionData ) ; } </s>


<s> bool X86InstrInfo :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL = MBB . findDebugLoc ( MI ) ; bool is64Bit = TM . getSubtarget < X86Subtarget > ( ) . is64Bit ( ) ; bool isWin64 = TM . getSubtarget < X86Subtarget > ( ) . isTargetWin64 ( ) ; unsigned SlotSize = is64Bit ? 8 : 4 ; MachineFunction & MF = * MBB . getParent ( ) ; unsigned FPReg = RI . getFrameRegister ( MF ) ; X86MachineFunctionInfo * X86FI = MF . getInfo < X86MachineFunctionInfo > ( ) ; unsigned CalleeFrameSize = 0 ; unsigned Opc = is64Bit ? X86 :: PUSH64r : X86 :: PUSH32r ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; MBB . addLiveIn ( Reg ) ; if ( Reg == FPReg ) continue ; if ( ! X86 :: VR128RegClass . contains ( Reg ) && ! isWin64 ) { CalleeFrameSize += SlotSize ; BuildMI ( MBB , MI , DL , get ( Opc ) ) . addReg ( Reg , RegState :: Kill ) ; } else { const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; storeRegToStackSlot ( MBB , MI , Reg , true , CSI [ i - 1 ] . getFrameIdx ( ) , RC , & RI ) ; } } X86FI -> setCalleeSavedFrameSize ( CalleeFrameSize ) ; return true ; } </s>


"rs6000_can_change_mode_class, return %s, from = %s, "

Debug version of rs6000_can_change_mode_class .


<s> SDValue SystemZTargetLowering :: prepareVolatileOrAtomicLoad ( SDValue Chain , SDLoc DL , SelectionDAG & DAG ) const { return DAG . getNode ( SystemZISD :: SERIALIZE , DL , MVT :: Other , Chain ) ; } </s>

This callback is used to prepare for a volatile or atomic load .

SystemZ SystemZ SystemZISD::SERIALIZE MVT::Other


<s> static rtx_insn * mn10300_md_asm_adjust ( vec < rtx > & , vec < rtx > & , vec < machine_mode > & , vec < const char * > & , vec < rtx > & clobbers , HARD_REG_SET & clobbered_regs , location_t ) { clobbers . safe_push ( gen_rtx_REG ( CCmode , CC_REG ) ) ; SET_HARD_REG_BIT ( clobbered_regs , CC_REG ) ; return NULL ; } </s>

Worker function for TARGET_MD_ASM_ADJUST . We do this in the mn10300 backend to maintain source compatibility with the old cc0-based compiler .


<s> static int mips16_insn_length ( rtx insn ) { if ( JUMP_P ( insn ) ) { rtx body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == ADDR_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , 0 ) ; if ( GET_CODE ( body ) == ADDR_DIFF_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , 1 ) ; } return get_attr_length ( insn ) ; } </s>


<s> machine_mode cris_select_cc_mode ( enum rtx_code op , rtx x , rtx y ) { gcc_assert ( reload_completed ) ; if ( GET_MODE_CLASS ( GET_MODE ( x ) ) != MODE_INT || y != const0_rtx ) return CCmode ; if ( op == EQ || op == NE || op == GTU || op == LEU || op == LT || op == GE ) return CC_NZmode ; gcc_assert ( op == GEU || op == LTU || op == GT || op == LE ) ; return CC_NZVCmode ; } </s>


"Instr doesn't have FrameIndex operand!"

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


<s> void HexagonCallMutation :: apply ( ScheduleDAGInstrs * DAG ) { SUnit * LastSequentialCall = nullptr ; unsigned VRegHoldingRet = 0 ; unsigned RetRegister ; SUnit * LastUseOfRet = nullptr ; auto & TRI = * DAG -> MF . getSubtarget ( ) . getRegisterInfo ( ) ; auto & HII = * DAG -> MF . getSubtarget < HexagonSubtarget > ( ) . getInstrInfo ( ) ; for ( unsigned su = 0 , e = DAG -> SUnits . size ( ) ; su != e ; ++ su ) { if ( DAG -> SUnits [ su ] . getInstr ( ) -> isCall ( ) ) LastSequentialCall = & DAG -> SUnits [ su ] ; else if ( DAG -> SUnits [ su ] . getInstr ( ) -> isCompare ( ) && LastSequentialCall ) DAG -> SUnits [ su ] . addPred ( SDep ( LastSequentialCall , SDep :: Barrier ) ) ; else if ( SchedPredsCloser && LastSequentialCall && su > 1 && su < e - 1 && shouldTFRICallBind ( HII , DAG -> SUnits [ su ] , DAG -> SUnits [ su + 1 ] ) ) DAG -> SUnits [ su ] . addPred ( SDep ( & DAG -> SUnits [ su - 1 ] , SDep :: Barrier ) ) ; else if ( SchedRetvalOptimization ) { const MachineInstr * MI = DAG -> SUnits [ su ] . getInstr ( ) ; if ( MI -> isCopy ( ) && ( MI -> readsRegister ( Hexagon :: R0 , & TRI ) || MI -> readsRegister ( Hexagon :: V0 , & TRI ) ) ) { VRegHoldingRet = MI -> getOperand ( 0 ) . getReg ( ) ; RetRegister = MI -> getOperand ( 1 ) . getReg ( ) ; LastUseOfRet = nullptr ; } else if ( VRegHoldingRet && MI -> readsVirtualRegister ( VRegHoldingRet ) ) LastUseOfRet = & DAG -> SUnits [ su ] ; else if ( LastUseOfRet && MI -> definesRegister ( RetRegister , & TRI ) ) DAG -> SUnits [ su ] . addPred ( SDep ( LastUseOfRet , SDep :: Barrier ) ) ; } } } </s>

Apply the profile inference algorithm for a given function .


<s> void MipsRegisterBankInfo :: applyMappingImpl ( const OperandsMapper & OpdMapper ) const { MachineInstr & MI = OpdMapper . getMI ( ) ; InstListTy NewInstrs ; MachineIRBuilder B ( MI ) ; MachineFunction * MF = MI . getMF ( ) ; MachineRegisterInfo & MRI = OpdMapper . getMRI ( ) ; const LegalizerInfo & LegInfo = * MF -> getSubtarget ( ) . getLegalizerInfo ( ) ; InstManager NewInstrObserver ( NewInstrs ) ; GISelObserverWrapper WrapperObserver ( & NewInstrObserver ) ; LegalizerHelper Helper ( * MF , WrapperObserver , B ) ; LegalizationArtifactCombiner ArtCombiner ( B , MF -> getRegInfo ( ) , LegInfo ) ; switch ( MI . getOpcode ( ) ) { case TargetOpcode :: G_LOAD : case TargetOpcode :: G_STORE : case TargetOpcode :: G_PHI : case TargetOpcode :: G_SELECT : case TargetOpcode :: G_IMPLICIT_DEF : { Helper . narrowScalar ( MI , 0 , LLT :: scalar ( 32 ) ) ; while ( ! NewInstrs . empty ( ) ) { MachineInstr * NewMI = NewInstrs . pop_back_val ( ) ; if ( NewMI -> getOpcode ( ) == TargetOpcode :: G_UNMERGE_VALUES ) combineAwayG_UNMERGE_VALUES ( ArtCombiner , * NewMI , WrapperObserver ) ; else if ( NewMI -> getOpcode ( ) == TargetOpcode :: G_MERGE_VALUES ) continue ; else setRegBank ( * NewMI , MRI ) ; } return ; } case TargetOpcode :: G_UNMERGE_VALUES : combineAwayG_UNMERGE_VALUES ( ArtCombiner , MI , WrapperObserver ) ; return ; default : break ; } return applyDefaultMapping ( OpdMapper ) ; } </s>


<s> void AMDGPUAsmPrinter :: emitFunctionBodyEnd ( ) { const SIMachineFunctionInfo & MFI = * MF -> getInfo < SIMachineFunctionInfo > ( ) ; if ( ! MFI . isEntryFunction ( ) ) return ; if ( TM . getTargetTriple ( ) . getOS ( ) != Triple :: AMDHSA || isHsaAbiVersion2 ( getGlobalSTI ( ) ) ) return ; auto & Streamer = getTargetStreamer ( ) -> getStreamer ( ) ; auto & Context = Streamer . getContext ( ) ; auto & ObjectFileInfo = * Context . getObjectFileInfo ( ) ; auto & ReadOnlySection = * ObjectFileInfo . getReadOnlySection ( ) ; Streamer . PushSection ( ) ; Streamer . SwitchSection ( & ReadOnlySection ) ; Streamer . emitValueToAlignment ( 64 , 0 , 1 , 0 ) ; if ( ReadOnlySection . getAlignment ( ) < 64 ) ReadOnlySection . setAlignment ( Align ( 64 ) ) ; const MCSubtargetInfo & STI = MF -> getSubtarget ( ) ; SmallString < 128 > KernelName ; getNameWithPrefix ( KernelName , & MF -> getFunction ( ) ) ; getTargetStreamer ( ) -> EmitAmdhsaKernelDescriptor ( STI , KernelName , getAmdhsaKernelDescriptor ( * MF , CurrentProgramInfo ) , CurrentProgramInfo . NumVGPRsForWavesPerEU , CurrentProgramInfo . NumSGPRsForWavesPerEU - IsaInfo :: getNumExtraSGPRs ( & STI , CurrentProgramInfo . VCCUsed , CurrentProgramInfo . FlatUsed ) , CurrentProgramInfo . VCCUsed , CurrentProgramInfo . FlatUsed , hasXNACK ( STI ) ) ; Streamer . PopSection ( ) ; } </s>

Targets can override this to emit stuff after the last basic block in the function .


<s> bool Thumb1RegisterInfo :: hasReservedCallFrame ( MachineFunction & MF ) const { const MachineFrameInfo * FFI = MF . getFrameInfo ( ) ; unsigned CFSize = FFI -> getMaxCallFrameSize ( ) ; if ( CFSize >= ( ( 1 << 8 ) - 1 ) * 4 / 2 ) return false ; return ! MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ; } </s>

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


<s> HOST_WIDE_INT const_vector_elt_as_int ( rtx op , unsigned int elt ) { rtx tmp ; gcc_assert ( GET_MODE ( op ) != V2DImode && GET_MODE ( op ) != V2DFmode ) ; tmp = CONST_VECTOR_ELT ( op , elt ) ; if ( GET_MODE ( op ) == V4SFmode || GET_MODE ( op ) == V2SFmode ) tmp = gen_lowpart ( SImode , tmp ) ; return INTVAL ( tmp ) ; } </s>

Interpret element ELT of the CONST_VECTOR OP as an integer value . If the mode of OP is MODE_VECTOR_INT , this simply returns the corresponding element of the vector , but for V4SFmode , the corresponding `` float '' is interpreted as an SImode integer .


<s> bool AMDGPUAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getString ( ) ; if ( AMDGPU :: IsaInfo :: hasCodeObjectV3 ( & getSTI ( ) ) ) { if ( IDVal == ".amdgcn_target" ) return ParseDirectiveAMDGCNTarget ( ) ; if ( IDVal == ".amdhsa_kernel" ) return ParseDirectiveAMDHSAKernel ( ) ; if ( IDVal == AMDGPU :: HSAMD :: V3 :: AssemblerDirectiveBegin ) return ParseDirectiveHSAMetadata ( ) ; } else { if ( IDVal == ".hsa_code_object_version" ) return ParseDirectiveHSACodeObjectVersion ( ) ; if ( IDVal == ".hsa_code_object_isa" ) return ParseDirectiveHSACodeObjectISA ( ) ; if ( IDVal == ".amd_kernel_code_t" ) return ParseDirectiveAMDKernelCodeT ( ) ; if ( IDVal == ".amdgpu_hsa_kernel" ) return ParseDirectiveAMDGPUHsaKernel ( ) ; if ( IDVal == ".amd_amdgpu_isa" ) return ParseDirectiveISAVersion ( ) ; if ( IDVal == AMDGPU :: HSAMD :: AssemblerDirectiveBegin ) return ParseDirectiveHSAMetadata ( ) ; } if ( IDVal == PALMD :: AssemblerDirective ) return ParseDirectivePALMetadata ( ) ; return true ; } </s>

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


<s> static int csky_arg_partial_bytes ( cumulative_args_t pcum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * pcum = get_cumulative_args ( pcum_v ) ; int param_size = csky_num_arg_regs ( arg . mode , arg . type , pcum -> is_stdarg ) ; int reg = pcum -> reg ; if ( FUNCTION_VARG_MODE_P ( arg . mode ) && ! pcum -> is_stdarg ) return 0 ; if ( reg < CSKY_NPARM_REGS && reg + param_size > CSKY_NPARM_REGS ) return ( CSKY_NPARM_REGS - reg ) * UNITS_PER_WORD ; return 0 ; } </s>

Implement TARGET_ARG_PARTIAL_BYTES . Return the number of bytes at the beginning of an argument that must be put in registers . The value must be zero for arguments that are passed entirely in registers or that are entirely pushed on the stack .


<s>
TargetIRAnalysis
MipsTargetMachine
::
getTargetIRAnalysis
(
)
{
return
TargetIRAnalysis
(
[
this
]
(
const
Function
&
F
)
{
if
(
Subtarget
->
allowMixed16_32
(
)
)
{
DEBUG
(
errs
(
)
<<
"No Target Transform Info Pass Added\n"
)
;
return
TargetTransformInfo
(
F
.
getParent
(
)
->
getDataLayout
(
)
)
;
}
DEBUG
(
errs
(
)
<<
"Target Transform Info Pass Added\n"
)
;
return
TargetTransformInfo
(
BasicTTIImpl
(
this
,
F
)
)
;
}
)
;
}
</s>

Get a TargetIRAnalysis appropriate for the target .

Mips
Mips
"No Target Transform Info Pass Added\n"
"Target Transform Info Pass Added\n"


<s> bool isTarget64BitLP64 ( ) const { return In64BitMode && ( TargetTriple . getEnvironment ( ) != Triple :: GNUX32 ) ; } </s>

Is this x86_64 with the LP64 programming model ( standard AMD64 , no x32 ) ?


<s> void riscv_expand_conditional_move ( rtx dest , rtx cons , rtx alt , rtx_code code , rtx op0 , rtx op1 ) { riscv_emit_int_compare ( & code , & op0 , & op1 ) ; rtx cond = gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_IF_THEN_ELSE ( GET_MODE ( dest ) , cond , cons , alt ) ) ) ; } </s>

Emit a cond move : If OP holds , move CONS to DEST ; else move ALT to DEST . Return 0 if expansion failed .


<s> static int riscv_address_cost ( rtx addr , machine_mode mode , addr_space_t as ATTRIBUTE_UNUSED , bool speed ATTRIBUTE_UNUSED ) { if ( TARGET_RVC && ! speed && riscv_mshorten_memrefs && mode == SImode && ! riscv_compressed_lw_address_p ( addr ) ) return riscv_address_insns ( addr , mode , false ) + 1 ; return riscv_address_insns ( addr , mode , false ) ; } </s>


<s> void altivec_expand_stvex_be ( rtx op0 , rtx op1 , machine_mode mode , unsigned unspec ) { machine_mode inner_mode = GET_MODE_INNER ( mode ) ; rtx tmp = gen_reg_rtx ( mode ) ; rtx stvx = gen_rtx_UNSPEC ( inner_mode , gen_rtvec ( 1 , tmp ) , unspec ) ; rtx sel = swap_selector_for_mode ( mode ) ; rtx vperm ; gcc_assert ( REG_P ( op1 ) ) ; vperm = gen_rtx_UNSPEC ( mode , gen_rtvec ( 3 , op1 , op1 , sel ) , UNSPEC_VPERM ) ; emit_insn ( gen_rtx_SET ( tmp , vperm ) ) ; emit_insn ( gen_rtx_SET ( op0 , stvx ) ) ; } </s>

Generate code for a `` stve * x '' built-in for a little endian target with -maltivec=be specified . Issue the store preceded by an element-reversing permute .


<s>
void
X86InstrInfo
::
insertSelect
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DstReg
,
const
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
unsigned
TrueReg
,
unsigned
FalseReg
)
const
{
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
assert
(
Cond
.
size
(
)
==
1
&&
"Invalid Cond array"
)
;
unsigned
Opc
=
getCMovFromCond
(
(
X86
::
CondCode
)
Cond
[
0
]
.
getImm
(
)
,
MRI
.
getRegClass
(
DstReg
)
->
getSize
(
)
,
false
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
FalseReg
)
.
addReg
(
TrueReg
)
;
}
</s>

Insert a select instruction into MBB before I that will copy TrueReg to DstReg when Cond is true , and FalseReg to DstReg when Cond is false .


<s> const char * output_cbranch ( rtx label , enum rtx_code code , enum machine_mode cc_mode , int reversed , rtx_insn * insn ) { const char * cond ; if ( reversed ) { if ( cc_mode == CCFPmode || cc_mode == CCFPEmode ) code = reverse_condition_maybe_unordered ( code ) ; else code = reverse_condition ( code ) ; } switch ( code ) { case NE : if ( cc_mode == CC_BTSTmode ) cond = "cs" ; else cond = "ne" ; break ; case EQ : if ( cc_mode == CC_BTSTmode ) cond = "cc" ; else cond = "eq" ; break ; case GE : if ( cc_mode == CC_NOOVmode ) cond = "nc" ; else cond = "ge" ; break ; case GT : cond = "gt" ; break ; case LE : if ( cc_mode == CCFPmode || cc_mode == CCFPEmode ) cond = "ls" ; else cond = "le" ; break ; case LT : if ( cc_mode == CCFPmode || cc_mode == CCFPEmode ) cond = "ns" ; else if ( cc_mode == CC_NOOVmode ) cond = "ns" ; else cond = "lt" ; break ; case GEU : cond = "cc" ; break ; case GTU : cond = "hi" ; break ; case LEU : cond = "ls" ; break ; case LTU : cond = "cs" ; break ; case UNORDERED : cond = "os" ; break ; case ORDERED : cond = "oc" ; break ; case UNGE : cond = "nc" ; break ; case UNGT : cond = "hi" ; break ; case UNLE : cond = "le" ; break ; case UNLT : cond = "lt" ; break ; case UNEQ : case LTGT : default : gcc_unreachable ( ) ; } return output_branch ( label , cond , insn ) ; } </s>

Output a conditional branch to LABEL . CODE is the comparison code . CC_MODE is the mode of the CC register . REVERSED is non-zero if we should reverse the sense of the comparison . INSN is the instruction .

visium "cs" "ne" "cc" "eq" "nc" "ge" "gt" "ls" "le" "ns" "ns" "lt" "cc" "hi" "ls" "cs" "os" "oc" "nc" "hi" "le" "lt"


<s> bool tilegx_expand_mov ( machine_mode mode , rtx * operands ) { if ( MEM_P ( operands [ 0 ] ) ) { if ( can_create_pseudo_p ( ) ) operands [ 0 ] = validize_mem ( operands [ 0 ] ) ; if ( reg_or_0_operand ( operands [ 1 ] , mode ) ) return false ; if ( ! reload_in_progress ) operands [ 1 ] = force_reg ( mode , operands [ 1 ] ) ; } if ( CONSTANT_P ( operands [ 1 ] ) && tilegx_tls_referenced_p ( operands [ 1 ] ) ) { operands [ 1 ] = tilegx_legitimize_tls_address ( operands [ 1 ] ) ; return false ; } if ( flag_pic && CONSTANT_P ( operands [ 1 ] ) ) { if ( tilegx_pic_address_needs_scratch ( operands [ 1 ] ) ) operands [ 1 ] = tilegx_legitimize_pic_address ( operands [ 1 ] , mode , 0 ) ; if ( symbolic_operand ( operands [ 1 ] , mode ) ) { operands [ 1 ] = tilegx_legitimize_pic_address ( operands [ 1 ] , mode , ( reload_in_progress ? operands [ 0 ] : NULL_RTX ) ) ; return false ; } } if ( ! CONSTANT_P ( operands [ 1 ] ) || move_operand ( operands [ 1 ] , mode ) ) return false ; tilegx_expand_set_const64 ( operands [ 0 ] , operands [ 1 ] ) ; return true ; } </s>

Expand a move instruction . Return true if all work is done .


"Unknown regclass in loadRegFromStackSlot!"

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


"%qE attribute only applies to functions"

"%qE attribute requires a string constant argument"

Check syntax of function decl attributes having a string type value .


<s>
void
VEInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
const
DebugLoc
&
DL
,
MCRegister
DestReg
,
MCRegister
SrcReg
,
bool
KillSrc
)
const
{
if
(
IsAliasOfSX
(
SrcReg
)
&&
IsAliasOfSX
(
DestReg
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
VE
::
ORri
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
.
addImm
(
0
)
;
}
else
if
(
VE
::
F128RegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
const
unsigned
SubRegIdx
[
]
=
{
VE
::
sub_even
,
VE
::
sub_odd
}
;
unsigned
int
NumSubRegs
=
2
;
copyPhysSubRegs
(
MBB
,
I
,
DL
,
DestReg
,
SrcReg
,
KillSrc
,
get
(
VE
::
ORri
)
,
NumSubRegs
,
SubRegIdx
,
&
getRegisterInfo
(
)
)
;
}
else
{
const
TargetRegisterInfo
*
TRI
=
&
getRegisterInfo
(
)
;
dbgs
(
)
<<
"Impossible reg-to-reg copy from "
<<
printReg
(
SrcReg
,
TRI
)
<<
" to "
<<
printReg
(
DestReg
,
TRI
)
<<
"\n"
;
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
}
</s>


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


<s> static void frv_output_dwarf_dtprel ( FILE * file , int size , rtx x ) { gcc_assert ( size == 4 ) ; fputs ( "\t.picptr\ttlsmoff(" , file ) ; output_addr_const ( file , plus_constant ( Pmode , x , TLS_BIAS ) ) ; fputs ( ")" , file ) ; } </s>

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


<s> int move_src_operand ( rtx op , enum machine_mode mode ) { switch ( GET_CODE ( op ) ) { case SYMBOL_REF : case LABEL_REF : case CONST : return 1 ; case CONST_INT : return ( LARGE_INT ( INTVAL ( op ) ) ) ; case CONST_DOUBLE : if ( mode == SImode ) return arc_double_limm_p ( op ) ; if ( mode == SFmode ) return GET_MODE ( op ) == SFmode ; return 0 ; case REG : return register_operand ( op , mode ) ; case SUBREG : if ( GET_CODE ( SUBREG_REG ( op ) ) == MEM ) return address_operand ( XEXP ( SUBREG_REG ( op ) , 0 ) , mode ) ; else return register_operand ( op , mode ) ; case MEM : return address_operand ( XEXP ( op , 0 ) , mode ) ; default : return 0 ; } } </s>

Return true if OP is an acceptable argument for a single word move source .


<s> tree function_builder :: get_attributes ( const function_instance & instance ) { tree attrs = NULL_TREE ; if ( ! instance . modifies_global_state_p ( ) ) { if ( instance . reads_global_state_p ( ) ) attrs = add_attribute ( "pure" , attrs ) ; else attrs = add_attribute ( "const" , attrs ) ; } if ( ! flag_non_call_exceptions || ! instance . could_trap_p ( ) ) attrs = add_attribute ( "nothrow" , attrs ) ; return add_attribute ( "leaf" , attrs ) ; } </s>

Return the appropriate function attributes for INSTANCE .


<s> bool BranchDelayBase :: runOnMachineFunction ( MachineFunction & F ) { bool Changed = false ; for ( MachineFunction :: iterator FI = F . begin ( ) , FE = F . end ( ) ; FI != FE ; ++ FI ) Changed |= runOnMachineBasicBlock ( * FI ) ; return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> rtx function_expander :: use_compare_insn ( rtx_code rcode , insn_code icode ) { machine_mode mode = TYPE_MODE ( builtin_types [ type . index ] . vector ) ; machine_mode mask_mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; int arg_offset = 0 ; if ( use_real_mask_p ( pred ) ) add_input_operand ( arg_offset ++ ) ; else add_all_one_mask_operand ( mask_mode ) ; if ( use_real_merge_p ( pred ) ) add_input_operand ( arg_offset ++ ) ; else add_vundef_operand ( mask_mode ) ; rtx op1 = expand_normal ( CALL_EXPR_ARG ( exp , arg_offset ++ ) ) ; rtx op2 = expand_normal ( CALL_EXPR_ARG ( exp , arg_offset ++ ) ) ; if ( ! insn_operand_matches ( icode , opno + 1 , op1 ) ) op1 = force_reg ( mode , op1 ) ; if ( ! insn_operand_matches ( icode , opno + 2 , op2 ) ) { if ( VECTOR_MODE_P ( GET_MODE ( op2 ) ) ) op2 = force_reg ( mode , op2 ) ; else op2 = force_reg ( GET_MODE_INNER ( mode ) , op2 ) ; } rtx comparison = gen_rtx_fmt_ee ( rcode , mask_mode , op1 , op2 ) ; if ( ! VECTOR_MODE_P ( GET_MODE ( op2 ) ) ) comparison = gen_rtx_fmt_ee ( rcode , mask_mode , op1 , gen_rtx_VEC_DUPLICATE ( mode , op2 ) ) ; add_fixed_operand ( comparison ) ; add_fixed_operand ( op1 ) ; if ( CONST_INT_P ( op2 ) ) add_integer_operand ( op2 ) ; else add_fixed_operand ( op2 ) ; for ( int argno = arg_offset ; argno < call_expr_nargs ( exp ) ; argno ++ ) add_input_operand ( argno ) ; add_input_operand ( Pmode , get_mask_policy_for_pred ( pred ) ) ; add_input_operand ( Pmode , get_avl_type_rtx ( avl_type :: NONVLMAX ) ) ; return generate_insn ( icode ) ; } </s>

Implement the call using instruction ICODE , with a 1:1 mapping between arguments and input operands .


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

Customize the preferred legalization strategy for certain types .


<s>
bool
X86ATTAsmParser
::
ParseInstruction
(
const
StringRef
&
Name
,
MCInst
&
Inst
)
{
SmallVector
<
X86Operand
,
8
>
Operands
;
Operands
.
push_back
(
X86Operand
::
CreateToken
(
Name
)
)
;
SMLoc
Loc
=
getLexer
(
)
.
getTok
(
)
.
getLoc
(
)
;
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
if
(
getLexer
(
)
.
is
(
AsmToken
::
Star
)
)
{
getLexer
(
)
.
Lex
(
)
;
Operands
.
push_back
(
X86Operand
::
CreateToken
(
"*"
)
)
;
}
Operands
.
push_back
(
X86Operand
(
)
)
;
if
(
ParseOperand
(
Operands
.
back
(
)
)
)
return
true
;
while
(
getLexer
(
)
.
is
(
AsmToken
::
Comma
)
)
{
getLexer
(
)
.
Lex
(
)
;
Operands
.
push_back
(
X86Operand
(
)
)
;
if
(
ParseOperand
(
Operands
.
back
(
)
)
)
return
true
;
}
}
if
(
!
MatchInstruction
(
Operands
,
Inst
)
)
return
false
;
Error
(
Loc
,
"unrecognized instruction"
)
;
return
true
;
}
</s>

ParseInstruction - Parse one assembly instruction .


<s> static void mcore_encode_section_info ( tree decl , rtx rtl ATTRIBUTE_UNUSED , int first ATTRIBUTE_UNUSED ) { if ( mcore_dllexport_p ( decl ) ) mcore_mark_dllexport ( decl ) ; else if ( mcore_dllimport_p ( decl ) ) mcore_mark_dllimport ( decl ) ; else if ( ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CODE ( decl ) == VAR_DECL ) && DECL_RTL ( decl ) != NULL_RTX && GET_CODE ( DECL_RTL ( decl ) ) == MEM && GET_CODE ( XEXP ( DECL_RTL ( decl ) , 0 ) ) == MEM && GET_CODE ( XEXP ( XEXP ( DECL_RTL ( decl ) , 0 ) , 0 ) ) == SYMBOL_REF && mcore_dllimport_name_p ( XSTR ( XEXP ( XEXP ( DECL_RTL ( decl ) , 0 ) , 0 ) , 0 ) ) ) { const char * oldname = XSTR ( XEXP ( XEXP ( DECL_RTL ( decl ) , 0 ) , 0 ) , 0 ) ; tree idp = get_identifier ( oldname + 9 ) ; rtx newrtl = gen_rtx_SYMBOL_REF ( Pmode , IDENTIFIER_POINTER ( idp ) ) ; XEXP ( DECL_RTL ( decl ) , 0 ) = newrtl ; } } </s>

Cover function to implement ENCODE_SECTION_INFO .


<s>
static
int
class_can_hold_mode
(
int
class
,
enum
machine_mode
mode
)
{
static
char
results
[
LIM_REG_CLASSES
]
[
MAX_MACHINE_MODE
]
;
if
(
results
[
class
]
[
mode
]
==
0
)
{
int
r
,
n
,
i
;
results
[
class
]
[
mode
]
=
1
;
for
(
r
=
0
;
r
<
FIRST_PSEUDO_REGISTER
;
r
++
)
if
(
class_contents
[
class
]
[
0
]
&
(
1
<<
r
)
&&
HARD_REGNO_MODE_OK
(
r
,
mode
)
)
{
int
ok
=
1
;
n
=
HARD_REGNO_NREGS
(
r
,
mode
)
;
for
(
i
=
1
;
i
<
n
;
i
++
)
if
(
!
(
class_contents
[
class
]
[
0
]
&
(
1
<<
(
r
+
i
)
)
)
)
ok
=
0
;
if
(
ok
)
{
results
[
class
]
[
mode
]
=
2
;
break
;
}
}
}
fprintf
(
stderr
,
"class %s can hold %s? %s\n"
,
class_names
[
class
]
,
mode_name
[
mode
]
,
(
results
[
class
]
[
mode
]
==
2
)
"yes"
:
"no"
)
;
return
results
[
class
]
[
mode
]
==
2
;
}
</s>

Used by m32c_register_move_cost to determine if a move is impossibly expensive .


<s> MachineMemOperand :: Flags XCoreTargetLowering :: getTargetMMOFlags ( const Instruction & I ) const { if ( auto * SI = dyn_cast < StoreInst > ( & I ) ) if ( SI -> isAtomic ( ) ) return MachineMemOperand :: MOVolatile ; if ( auto * LI = dyn_cast < LoadInst > ( & I ) ) if ( LI -> isAtomic ( ) ) return MachineMemOperand :: MOVolatile ; if ( auto * AI = dyn_cast < AtomicRMWInst > ( & I ) ) if ( AI -> isAtomic ( ) ) return MachineMemOperand :: MOVolatile ; if ( auto * AI = dyn_cast < AtomicCmpXchgInst > ( & I ) ) if ( AI -> isAtomic ( ) ) return MachineMemOperand :: MOVolatile ; return MachineMemOperand :: MONone ; } </s>

This callback is used to inspect load/store instructions and add target-specific MachineMemOperand flags to them .


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

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

ARM ARM::GPRRegisterClass ARM::tGPRRegisterClass ARM::tcGPRRegisterClass ARM::rGPRRegisterClass 0 ARM::t2STRi12 0 ARM


<s> static void ix86_reorg ( void ) { compute_bb_for_insn ( ) ; if ( flag_mitigate_rop ) ix86_mitigate_rop ( ) ; if ( TARGET_SEH && current_function_has_exception_handlers ( ) ) ix86_seh_fixup_eh_fallthru ( ) ; if ( optimize && optimize_function_for_speed_p ( cfun ) ) { if ( TARGET_PAD_SHORT_FUNCTION ) ix86_pad_short_function ( ) ; else if ( TARGET_PAD_RETURNS ) ix86_pad_returns ( ) ; if ( TARGET_FOUR_JUMP_LIMIT ) ix86_avoid_jump_mispredicts ( ) ; } } </s>

Implement machine specific optimizations . We implement padding of returns for K8 CPUs and pass to avoid 4 jumps in the single 16 byte window .


<s> const unsigned * TMS320C64XRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const unsigned nonvolatileRegs [ ] = { TMS320C64X :: A10 , TMS320C64X :: A11 , TMS320C64X :: A12 , TMS320C64X :: A13 , TMS320C64X :: B10 , TMS320C64X :: B11 , TMS320C64X :: B12 , TMS320C64X :: B13 , 0 } ; return nonvolatileRegs ; } </s>


<s> MachineBasicBlock * MipsSETargetLowering :: EmitInstrWithCustomInserter ( MachineInstr * MI , MachineBasicBlock * BB ) const { switch ( MI -> getOpcode ( ) ) { default : return MipsTargetLowering :: EmitInstrWithCustomInserter ( MI , BB ) ; case Mips :: BPOSGE32_PSEUDO : return emitBPOSGE32 ( MI , BB ) ; case Mips :: SNZ_B_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_B ) ; case Mips :: SNZ_H_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_H ) ; case Mips :: SNZ_W_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_W ) ; case Mips :: SNZ_D_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_D ) ; case Mips :: SNZ_V_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_V ) ; case Mips :: SZ_B_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_B ) ; case Mips :: SZ_H_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_H ) ; case Mips :: SZ_W_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_W ) ; case Mips :: SZ_D_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_D ) ; case Mips :: SZ_V_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_V ) ; } } </s>

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


<s> rtx tilegx_simd_int ( rtx num , machine_mode mode ) { HOST_WIDE_INT n = 0 ; gcc_assert ( CONST_INT_P ( num ) ) ; n = INTVAL ( num ) ; switch ( mode ) { case E_QImode : n = 0x0101010101010101LL * ( n & 0x000000FF ) ; break ; case E_HImode : n = 0x0001000100010001LL * ( n & 0x0000FFFF ) ; break ; case E_SImode : n = 0x0000000100000001LL * ( n & 0xFFFFFFFF ) ; break ; case E_DImode : break ; default : gcc_unreachable ( ) ; } return GEN_INT ( n ) ; } </s>

Return the simd variant of the constant NUM of mode MODE , by replicating it to fill an interger of mode DImode . NUM is first truncated to fit in MODE .


<s> void WebAssemblyPassConfig :: addIRPasses ( ) { addPass ( new CoalesceFeaturesAndStripAtomics ( & getWebAssemblyTargetMachine ( ) ) ) ; addPass ( createAtomicExpandPass ( ) ) ; addPass ( createWebAssemblyAddMissingPrototypes ( ) ) ; addPass ( createWebAssemblyLowerGlobalDtors ( ) ) ; addPass ( createWebAssemblyFixFunctionBitcasts ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createWebAssemblyOptimizeReturned ( ) ) ; if ( ! WasmEnableEmException && TM -> Options . ExceptionModel == ExceptionHandling :: None ) { addPass ( createLowerInvokePass ( ) ) ; addPass ( createUnreachableBlockEliminationPass ( ) ) ; } if ( WasmEnableEmException || WasmEnableEmSjLj ) addPass ( createWebAssemblyLowerEmscriptenEHSjLj ( WasmEnableEmException , WasmEnableEmSjLj ) ) ; addPass ( createIndirectBrExpandPass ( ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>

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

WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly


<s> rtx alpha_use_linkage ( rtx func ATTRIBUTE_UNUSED , bool lflag ATTRIBUTE_UNUSED , bool rflag ATTRIBUTE_UNUSED ) { return NULL_RTX ; } </s>

Return a SYMBOL_REF representing the reference to the .linkage entry of function FUNC built for calls made from CFUNDECL . LFLAG is 1 if this is the reference to the linkage pointer value , 0 if this is the reference to the function entry value . RFLAG is 1 if this a reduced reference ( code address only ) , 0 if this is a full reference .


<s>
MachineInstr
*
TPCInstrInfo
::
foldMemoryOperandImpl
(
MachineFunction
&
MF
,
MachineInstr
&
MI
,
ArrayRef
<
unsigned
>
Ops
,
MachineBasicBlock
::
iterator
InsertPt
,
int
FrameIndex
,
LiveIntervals
*
LIS
,
VirtRegMap
*
VRM
)
const
{
const
TargetRegisterInfo
&
TRI
=
*
MF
.
getSubtarget
(
)
.
getRegisterInfo
(
)
;
const
MachineRegisterInfo
&
MRI
=
MF
.
getRegInfo
(
)
;
MachineBasicBlock
&
MBB
=
*
MI
.
getParent
(
)
;
if
(
MI
.
isCopy
(
)
)
{
if
(
Ops
.
size
(
)
==
1
&&
(
Ops
[
0
]
==
0
||
Ops
[
0
]
==
1
)
)
{
bool
IsSpill
=
Ops
[
0
]
==
0
;
const
MachineOperand
&
DstMO
=
MI
.
getOperand
(
0
)
;
const
MachineOperand
&
SrcMO
=
MI
.
getOperand
(
1
)
;
Register
DstReg
=
DstMO
.
getReg
(
)
;
Register
SrcReg
=
SrcMO
.
getReg
(
)
;
Register
FoldReg
=
IsSpill
DstReg
:
SrcReg
;
Register
LiveReg
=
IsSpill
SrcReg
:
DstReg
;
assert
(
FoldReg
.
isVirtual
(
)
&&
"Cannot fold physregs"
)
;
const
TargetRegisterClass
*
RC
=
MRI
.
getRegClass
(
FoldReg
)
;
if
(
LiveReg
.
isPhysical
(
)
)
if
(
!
RC
->
contains
(
LiveReg
)
)
{
llvm_unreachable
(
"Unrelated regclasses"
)
;
}
MachineInstr
*
SpillMI
=
nullptr
;
if
(
IsSpill
)
{
storeRegToStackSlot
(
MBB
,
InsertPt
,
SrcReg
,
DstMO
.
isKill
(
)
,
FrameIndex
,
RC
,
&
TRI
)
;
SpillMI
=
&
*
InsertPt
;
if
(
SrcMO
.
getSubReg
(
)
!=
0
)
{
SpillMI
->
getOperand
(
1
)
.
setSubReg
(
SrcMO
.
getSubReg
(
)
)
;
}
}
else
{
loadRegFromStackSlot
(
MBB
,
InsertPt
,
DstReg
,
FrameIndex
,
RC
,
&
TRI
)
;
SpillMI
=
&
*
InsertPt
;
if
(
DstMO
.
getSubReg
(
)
!=
0
)
{
SpillMI
->
getOperand
(
0
)
.
setSubReg
(
DstMO
.
getSubReg
(
)
)
;
}
}
return
SpillMI
;
}
}
return
nullptr
;
}
</s>

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


"flag setting instruction only valid outside IT block"

"instruction only valid inside IT block"

"instruction variant requires ARMv6 or later"

"immediate operand must be in the range [0,15]"

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


<s> rtx nvptx_maybe_convert_symbolic_operand ( rtx orig_op ) { if ( GET_MODE ( orig_op ) != Pmode ) return orig_op ; rtx op = orig_op ; while ( GET_CODE ( op ) == PLUS || GET_CODE ( op ) == CONST ) op = XEXP ( op , 0 ) ; if ( GET_CODE ( op ) != SYMBOL_REF ) return orig_op ; tree decl = SYMBOL_REF_DECL ( op ) ; if ( decl && TREE_CODE ( decl ) == FUNCTION_DECL ) { nvptx_record_needed_fndecl ( decl ) ; return orig_op ; } addr_space_t as = nvptx_addr_space_from_address ( op ) ; if ( as == ADDR_SPACE_GENERIC ) return orig_op ; enum unspec code ; code = ( as == ADDR_SPACE_GLOBAL ? UNSPEC_FROM_GLOBAL : as == ADDR_SPACE_LOCAL ? UNSPEC_FROM_LOCAL : as == ADDR_SPACE_SHARED ? UNSPEC_FROM_SHARED : as == ADDR_SPACE_CONST ? UNSPEC_FROM_CONST : UNSPEC_FROM_PARAM ) ; rtx dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , orig_op ) , code ) ) ) ; return dest ; } </s>

When loading an operand ORIG_OP , verify whether an address space conversion to generic is required , and if so , perform it . Also check for SYMBOL_REFs for function decls and call nvptx_record_needed_fndecl as needed . Return either the original operand , or the converted one .


<s>
unsigned
getReg
(
)
const
{
assert
(
isReg
(
)
&&
"Wrong CountValue accessor"
)
;
return
Contents
.
RegNum
;
}
</s>

Returns the register associated with this edge .