<s> static void ix86_adjust_counter ( rtx countreg , HOST_WIDE_INT value ) { if ( GET_MODE ( countreg ) == DImode ) emit_insn ( gen_adddi3 ( countreg , countreg , GEN_INT ( - value ) ) ) ; else emit_insn ( gen_addsi3 ( countreg , countreg , GEN_INT ( - value ) ) ) ; } </s>


<s> unsigned PPCTTIImpl :: getPrefetchDistance ( ) { return PrefDist ; } </s>

Return the preferred prefetch distance in terms of instructions .


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

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


<s> Instruction * PPCTargetLowering :: emitLeadingFence ( IRBuilder < > & Builder , AtomicOrdering Ord , bool IsStore , bool IsLoad ) const { if ( Ord == SequentiallyConsistent ) return callIntrinsic ( Builder , Intrinsic :: ppc_sync ) ; if ( isAtLeastRelease ( Ord ) ) return callIntrinsic ( Builder , Intrinsic :: ppc_lwsync ) ; return nullptr ; } </s>


<s> MSP430Subtarget :: MSP430Subtarget ( const std :: string & TT , const std :: string & CPU , const std :: string & FS ) : MSP430GenSubtargetInfo ( TT , CPU , FS ) { std :: string CPUName = "generic" ; ParseSubtargetFeatures ( CPUName , FS ) ; } </s>

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


<s> bool MipsCallEntry :: isAliased ( const MachineFrameInfo * ) const { return false ; } </s>

Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Value .


<s> SMLoc Z80Operand :: getStartLoc ( ) const { return this -> StartLoc ; } </s>

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


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

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


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

getPassName - Return a nice clean name for a pass .


<s> bool AArch64RegisterInfo :: useFPForScavengingIndex ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; return MFI . hasVarSizedObjects ( ) && ! hasBasePointer ( MF ) ; } </s>

Returns true if the target wants to use frame pointer based accesses to spill to the scavenger emergency spill slot .


"Encountered a global variable kind that is "

Emit the specified global variable to the .s file .


<s> bool LanaiInstrInfo :: analyzeBranch ( MachineBasicBlock & MBB , MachineBasicBlock * & TrueBlock , MachineBasicBlock * & FalseBlock , SmallVectorImpl < MachineOperand > & Condition , bool AllowModify ) const { MachineBasicBlock :: iterator Instruction = MBB . end ( ) ; while ( Instruction != MBB . begin ( ) ) { -- Instruction ; if ( Instruction -> isDebugInstr ( ) ) continue ; if ( ! isUnpredicatedTerminator ( * Instruction ) ) break ; if ( ! Instruction -> isBranch ( ) ) return true ; if ( Instruction -> getOpcode ( ) == Lanai :: BT ) { if ( ! AllowModify ) { TrueBlock = Instruction -> getOperand ( 0 ) . getMBB ( ) ; continue ; } while ( std :: next ( Instruction ) != MBB . end ( ) ) { std :: next ( Instruction ) -> eraseFromParent ( ) ; } Condition . clear ( ) ; FalseBlock = nullptr ; if ( MBB . isLayoutSuccessor ( Instruction -> getOperand ( 0 ) . getMBB ( ) ) ) { TrueBlock = nullptr ; Instruction -> eraseFromParent ( ) ; Instruction = MBB . end ( ) ; continue ; } TrueBlock = Instruction -> getOperand ( 0 ) . getMBB ( ) ; continue ; } unsigned Opcode = Instruction -> getOpcode ( ) ; if ( Opcode != Lanai :: BRCC ) return true ; if ( Condition . empty ( ) ) { LPCC :: CondCode BranchCond = static_cast < LPCC :: CondCode > ( Instruction -> getOperand ( 1 ) . getImm ( ) ) ; FalseBlock = TrueBlock ; TrueBlock = Instruction -> getOperand ( 0 ) . getMBB ( ) ; Condition . push_back ( MachineOperand :: CreateImm ( BranchCond ) ) ; continue ; } return true ; } return false ; } </s>

analyzeBranch - Analyze the branching code at the end of MBB , returning true if it can not be understood ( e.g .


<s> int AArch64TTIImpl :: getIntImmCostInst ( unsigned Opcode , unsigned Idx , const APInt & Imm , Type * Ty ) { assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 ) return TTI :: TCC_Free ; unsigned ImmIdx = ~ 0U ; switch ( Opcode ) { default : return TTI :: TCC_Free ; case Instruction :: GetElementPtr : if ( Idx == 0 ) return 2 * TTI :: TCC_Basic ; return TTI :: TCC_Free ; case Instruction :: Store : ImmIdx = 0 ; break ; case Instruction :: Add : case Instruction :: Sub : case Instruction :: Mul : case Instruction :: UDiv : case Instruction :: SDiv : case Instruction :: URem : case Instruction :: SRem : case Instruction :: And : case Instruction :: Or : case Instruction :: Xor : case Instruction :: ICmp : ImmIdx = 1 ; break ; case Instruction :: Shl : case Instruction :: LShr : case Instruction :: AShr : if ( Idx == 1 ) return TTI :: TCC_Free ; break ; case Instruction :: Trunc : case Instruction :: ZExt : case Instruction :: SExt : case Instruction :: IntToPtr : case Instruction :: PtrToInt : case Instruction :: BitCast : case Instruction :: PHI : case Instruction :: Call : case Instruction :: Select : case Instruction :: Ret : case Instruction :: Load : break ; } if ( Idx == ImmIdx ) { int NumConstants = ( BitSize + 63 ) / 64 ; int Cost = AArch64TTIImpl :: getIntImmCost ( Imm , Ty ) ; return ( Cost <= NumConstants * TTI :: TCC_Basic ) ? static_cast < int > ( TTI :: TCC_Free ) : Cost ; } return AArch64TTIImpl :: getIntImmCost ( Imm , Ty ) ; } </s>

Return the expected cost of materialization for the given integer immediate of the specified type for a given instruction .


<s> static void ix86_init_pic_reg ( void ) { edge entry_edge ; rtx_insn * seq ; if ( ! ix86_use_pseudo_pic_reg ( ) ) return ; start_sequence ( ) ; if ( TARGET_64BIT ) { if ( ix86_cmodel == CM_LARGE_PIC ) ix86_init_large_pic_reg ( R11_REG ) ; else emit_insn ( gen_set_got_rex64 ( pic_offset_table_rtx ) ) ; } else { rtx reg = crtl -> profile ? gen_rtx_REG ( Pmode , REAL_PIC_OFFSET_TABLE_REGNUM ) : pic_offset_table_rtx ; rtx_insn * insn = emit_insn ( gen_set_got ( reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; if ( crtl -> profile ) emit_move_insn ( pic_offset_table_rtx , reg ) ; add_reg_note ( insn , REG_CFA_FLUSH_QUEUE , NULL_RTX ) ; } seq = get_insns ( ) ; end_sequence ( ) ; entry_edge = single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ; insert_insn_on_edge ( seq , entry_edge ) ; commit_one_edge_insertion ( entry_edge ) ; } </s>

Create and initialize PIC register if required .


<s> void arm_expand_compare_and_swap ( rtx operands [ ] ) { rtx bval , rval , mem , oldval , newval , is_weak , mod_s , mod_f , x ; machine_mode mode ; rtx ( * gen ) ( rtx , rtx , rtx , rtx , rtx , rtx , rtx ) ; bval = operands [ 0 ] ; rval = operands [ 1 ] ; mem = operands [ 2 ] ; oldval = operands [ 3 ] ; newval = operands [ 4 ] ; is_weak = operands [ 5 ] ; mod_s = operands [ 6 ] ; mod_f = operands [ 7 ] ; mode = GET_MODE ( mem ) ; if ( TARGET_HAVE_LDACQ && is_mm_acquire ( memmodel_from_int ( INTVAL ( mod_f ) ) ) && is_mm_release ( memmodel_from_int ( INTVAL ( mod_s ) ) ) ) mod_s = GEN_INT ( MEMMODEL_ACQ_REL ) ; switch ( mode ) { case QImode : case HImode : rval = gen_reg_rtx ( SImode ) ; oldval = convert_modes ( SImode , mode , oldval , true ) ; case SImode : if ( ! arm_add_operand ( oldval , SImode ) ) oldval = force_reg ( SImode , oldval ) ; break ; case DImode : if ( ! cmpdi_operand ( oldval , mode ) ) oldval = force_reg ( mode , oldval ) ; break ; default : gcc_unreachable ( ) ; } switch ( mode ) { case QImode : gen = gen_atomic_compare_and_swapqi_1 ; break ; case HImode : gen = gen_atomic_compare_and_swaphi_1 ; break ; case SImode : gen = gen_atomic_compare_and_swapsi_1 ; break ; case DImode : gen = gen_atomic_compare_and_swapdi_1 ; break ; default : gcc_unreachable ( ) ; } emit_insn ( gen ( rval , mem , oldval , newval , is_weak , mod_s , mod_f ) ) ; if ( mode == QImode || mode == HImode ) emit_move_insn ( operands [ 1 ] , gen_lowpart ( mode , rval ) ) ; x = gen_rtx_REG ( CCmode , CC_REGNUM ) ; x = gen_rtx_EQ ( SImode , x , const0_rtx ) ; emit_insn ( gen_rtx_SET ( bval , x ) ) ; } </s>


<s> bool fixupNeedsRelaxation ( const MCFixup & Fixup , uint64_t Value , const MCRelaxableFragment * DF , const MCAsmLayout & Layout ) const override { return false ; } </s>

Simple predicate for targets where ! Resolved implies requiring relaxation .


<s> void PIC16AsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { printInstruction ( MI ) ; OutStreamer . AddBlankLine ( ) ; } </s>

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


<s> BitVector RISCVRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { const RISCVFrameLowering * TFI = getFrameLowering ( MF ) ; const RISCVSubtarget & STI = MF . getSubtarget < RISCVSubtarget > ( ) ; BitVector Reserved ( getNumRegs ( ) ) ; for ( size_t Reg = 0 ; Reg < getNumRegs ( ) ; Reg ++ ) { if ( STI . isRegisterReservedByUser ( Reg ) ) markSuperRegs ( Reserved , Reg ) ; } markSuperRegs ( Reserved , RISCV :: X0 ) ; markSuperRegs ( Reserved , RISCV :: X2 ) ; markSuperRegs ( Reserved , RISCV :: X3 ) ; markSuperRegs ( Reserved , RISCV :: X4 ) ; if ( TFI -> hasFP ( MF ) ) markSuperRegs ( Reserved , RISCV :: X8 ) ; if ( TFI -> hasBP ( MF ) ) markSuperRegs ( Reserved , RISCV :: X9 ) ; markSuperRegs ( Reserved , RISCV :: C0 ) ; markSuperRegs ( Reserved , RISCV :: C2 ) ; markSuperRegs ( Reserved , RISCV :: C3 ) ; markSuperRegs ( Reserved , RISCV :: C4 ) ; if ( TFI -> hasFP ( MF ) ) markSuperRegs ( Reserved , RISCV :: C8 ) ; if ( TFI -> hasBP ( MF ) ) markSuperRegs ( Reserved , RISCV :: C9 ) ; markSuperRegs ( Reserved , RISCV :: DDC ) ; markSuperRegs ( Reserved , RISCV :: VL ) ; markSuperRegs ( Reserved , RISCV :: VTYPE ) ; markSuperRegs ( Reserved , RISCV :: VXSAT ) ; markSuperRegs ( Reserved , RISCV :: VXRM ) ; markSuperRegs ( Reserved , RISCV :: FRM ) ; markSuperRegs ( Reserved , RISCV :: FFLAGS ) ; markSuperRegs ( Reserved , RISCV :: FCSR ) ; assert ( checkAllSuperRegsMarked ( Reserved ) ) ; return Reserved ; } </s>

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


"Cannot store this register into a stack slot!"

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


<s> bool runOnModule ( Module & M ) override { SetVector < Function * > Functions ; AnalysisGetter AG ; for ( Function & F : M ) { if ( ! F . isIntrinsic ( ) ) Functions . insert ( & F ) ; } CallGraphUpdater CGUpdater ; BumpPtrAllocator Allocator ; AMDGPUInformationCache InfoCache ( M , AG , Allocator , nullptr , * TM ) ; DenseSet < const char * > Allowed ( { & AAAMDAttributes :: ID , & AAUniformWorkGroupSize :: ID , & AAAMDFlatWorkGroupSize :: ID , & AACallEdges :: ID , & AAPointerInfo :: ID } ) ; AttributorConfig AC ( CGUpdater ) ; AC . Allowed = & Allowed ; AC . IsModulePass = true ; AC . DefaultInitializeLiveInternals = false ; Attributor A ( Functions , InfoCache , AC ) ; for ( Function & F : M ) { if ( ! F . isIntrinsic ( ) ) { A . getOrCreateAAFor < AAAMDAttributes > ( IRPosition :: function ( F ) ) ; A . getOrCreateAAFor < AAUniformWorkGroupSize > ( IRPosition :: function ( F ) ) ; if ( ! AMDGPU :: isEntryFunctionCC ( F . getCallingConv ( ) ) ) { A . getOrCreateAAFor < AAAMDFlatWorkGroupSize > ( IRPosition :: function ( F ) ) ; } } } ChangeStatus Change = A . run ( ) ; return Change == ChangeStatus :: CHANGED ; } </s>

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


<s> gimple * gimple_folder :: redirect_call ( const function_instance & instance ) { registered_function * rfn = function_table -> find_with_hash ( instance , instance . hash ( ) ) ; if ( ! rfn ) return NULL ; gimple_call_set_fndecl ( call , rfn -> decl ) ; return call ; } </s>

Fold the call to a call to INSTANCE , with the same arguments .


<s> int thumb_far_jump_used_p ( int in_prologue ) { rtx insn ; if ( cfun -> machine -> far_jump_used ) return 1 ; if ( ! in_prologue ) { if ( regs_ever_live [ ARG_POINTER_REGNUM ] ) cfun -> machine -> arg_pointer_live = 1 ; else if ( ! cfun -> machine -> arg_pointer_live ) return 0 ; } for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) == JUMP_INSN && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && get_attr_far_jump ( insn ) == FAR_JUMP_YES ) { cfun -> machine -> far_jump_used = 1 ; return 1 ; } } return 0 ; } </s>

Returns non-zero if the current function contains , or might contain a far jump .


"You cannot use the same Regs with MOVX_RR"

"You cannot use the same Reg Classes with MOVX_RR"

Move across register classes without extension .


<s> X86Subtarget :: X86Subtarget ( const Triple & TT , StringRef CPU , StringRef FS , const X86TargetMachine & TM , unsigned StackAlignOverride ) : X86GenSubtargetInfo ( TT , CPU , FS ) , X86ProcFamily ( Others ) , PICStyle ( PICStyles :: None ) , TM ( TM ) , TargetTriple ( TT ) , StackAlignOverride ( StackAlignOverride ) , In64BitMode ( TargetTriple . getArch ( ) == Triple :: x86_64 ) , In32BitMode ( TargetTriple . getArch ( ) == Triple :: x86 && TargetTriple . getEnvironment ( ) != Triple :: CODE16 ) , In16BitMode ( TargetTriple . getArch ( ) == Triple :: x86 && TargetTriple . getEnvironment ( ) == Triple :: CODE16 ) , InstrInfo ( initializeSubtargetDependencies ( CPU , FS ) ) , TLInfo ( TM , * this ) , FrameLowering ( * this , getStackAlignment ( ) ) { if ( ! isPositionIndependent ( ) ) setPICStyle ( PICStyles :: None ) ; else if ( is64Bit ( ) ) setPICStyle ( PICStyles :: RIPRel ) ; else if ( isTargetCOFF ( ) ) setPICStyle ( PICStyles :: None ) ; else if ( isTargetDarwin ( ) ) setPICStyle ( PICStyles :: StubPIC ) ; else if ( isTargetELF ( ) ) setPICStyle ( PICStyles :: GOT ) ; GISelAccessor * GISel = new GISelAccessor ( ) ; X86GISelActualAccessor * GISel = new X86GISelActualAccessor ( ) ; GISel -> CallLoweringInfo . reset ( new X86CallLowering ( * getTargetLowering ( ) ) ) ; GISel -> Legalizer . reset ( new X86LegalizerInfo ( * this , TM ) ) ; auto * RBI = new X86RegisterBankInfo ( * getRegisterInfo ( ) ) ; GISel -> RegBankInfo . reset ( RBI ) ; GISel -> InstSelector . reset ( createX86InstructionSelector ( TM , * this , * RBI ) ) ; setGISelAccessor ( * GISel ) ; } </s>

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


<s> int rs6000_loop_align ( rtx label ) { basic_block bb ; int ninsns ; if ( ! can_override_loop_align ) return align_loops_log ; bb = BLOCK_FOR_INSN ( label ) ; ninsns = num_loop_insns ( bb -> loop_father ) ; if ( ninsns > 4 && ninsns <= 8 && ( rs6000_cpu == PROCESSOR_POWER4 || rs6000_cpu == PROCESSOR_POWER5 || rs6000_cpu == PROCESSOR_POWER6 || rs6000_cpu == PROCESSOR_POWER7 || rs6000_cpu == PROCESSOR_POWER8 || rs6000_cpu == PROCESSOR_POWER9 ) ) return 5 ; else return align_loops_log ; } </s>


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

Return true if it is cheap to speculate a call to intrinsic ctlz .


<s>
void
setReg
(
unsigned
Reg
)
{
assert
(
isRegBase
(
)
&&
"Invalid base register access!"
)
;
Base
.
Reg
=
Reg
;
}
</s>

Assigns the associated register for this edge .


<s> SDValue ARMSelectionDAGInfo :: EmitTargetCodeForMemset ( SelectionDAG & DAG , SDLoc dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , unsigned Align , bool isVolatile , MachinePointerInfo DstPtrInfo ) const { const ARMSubtarget & Subtarget = DAG . getTarget ( ) . getSubtarget < ARMSubtarget > ( ) ; if ( ! Subtarget . isAAPCS_ABI ( ) || Subtarget . isTargetMachO ( ) || Subtarget . isTargetWindows ( ) ) return SDValue ( ) ; const ARMTargetLowering & TLI = * DAG . getTarget ( ) . getSubtarget < ARMSubtarget > ( ) . getTargetLowering ( ) ; TargetLowering :: ArgListTy Args ; TargetLowering :: ArgListEntry Entry ; Type * IntPtrTy = TLI . getDataLayout ( ) -> getIntPtrType ( * DAG . getContext ( ) ) ; Entry . Node = Dst ; Entry . Ty = IntPtrTy ; Args . push_back ( Entry ) ; Entry . Node = Size ; Entry . Ty = IntPtrTy ; Entry . isSExt = false ; Args . push_back ( Entry ) ; if ( Src . getValueType ( ) . bitsGT ( MVT :: i32 ) ) Src = DAG . getNode ( ISD :: TRUNCATE , dl , MVT :: i32 , Src ) ; else Src = DAG . getNode ( ISD :: ZERO_EXTEND , dl , MVT :: i32 , Src ) ; Entry . Node = Src ; Entry . Ty = Type :: getInt32Ty ( * DAG . getContext ( ) ) ; Entry . isSExt = true ; Args . push_back ( Entry ) ; TargetLowering :: CallLoweringInfo CLI ( DAG ) ; CLI . setDebugLoc ( dl ) . setChain ( Chain ) . setCallee ( TLI . getLibcallCallingConv ( RTLIB :: MEMSET ) , Type :: getVoidTy ( * DAG . getContext ( ) ) , DAG . getExternalSymbol ( TLI . getLibcallName ( RTLIB :: MEMSET ) , TLI . getPointerTy ( ) ) , std :: move ( Args ) , 0 ) . setDiscardResult ( ) ; std :: pair < SDValue , SDValue > CallResult = TLI . LowerCallTo ( CLI ) ; return CallResult . second ; } </s>

Emit target-specific code that performs a memset .


<s>
bool
WebAssemblyAsmTypeCheck
::
getGlobal
(
SMLoc
ErrorLoc
,
const
MCInst
&
Inst
,
wasm
::
ValType
&
Type
)
{
const
MCSymbolRefExpr
*
SymRef
;
if
(
getSymRef
(
ErrorLoc
,
Inst
,
SymRef
)
)
return
true
;
auto
WasmSym
=
cast
<
MCSymbolWasm
>
(
&
SymRef
->
getSymbol
(
)
)
;
switch
(
WasmSym
->
getType
(
)
.
getValueOr
(
wasm
::
WASM_SYMBOL_TYPE_DATA
)
)
{
case
wasm
::
WASM_SYMBOL_TYPE_GLOBAL
:
Type
=
static_cast
<
wasm
::
ValType
>
(
WasmSym
->
getGlobalType
(
)
.
Type
)
;
break
;
case
wasm
::
WASM_SYMBOL_TYPE_FUNCTION
:
case
wasm
::
WASM_SYMBOL_TYPE_DATA
:
switch
(
SymRef
->
getKind
(
)
)
{
case
MCSymbolRefExpr
::
VK_GOT
:
case
MCSymbolRefExpr
::
VK_WASM_GOT_TLS
:
Type
=
is64
wasm
::
ValType
::
I64
:
wasm
::
ValType
::
I32
;
return
false
;
default
:
break
;
}
LLVM_FALLTHROUGH
;
default
:
return
typeError
(
ErrorLoc
,
StringRef
(
"symbol "
)
+
WasmSym
->
getName
(
)
+
" missing .globaltype"
)
;
}
return
false
;
}
</s>

Get the Init value of the specified global variable .

WebAssembly
WebAssembly
wasm::ValType
wasm::WASM_SYMBOL_TYPE_DATA
wasm::WASM_SYMBOL_TYPE_GLOBAL
wasm::ValType
wasm::WASM_SYMBOL_TYPE_FUNCTION
wasm::WASM_SYMBOL_TYPE_DATA
wasm::ValType
wasm::ValType
"symbol "
" missing .globaltype"


<s> tree function_resolver :: get_vector_type ( type_suffix_index type ) { return acle_vector_types [ 0 ] [ type_suffixes [ type ] . vector_type ] ; } </s>

Return the vector type associated with type suffix TYPE .


<s>
void
WebAssemblyTargetELFStreamer
::
emitIndIdx
(
const
MCExpr
*
Value
)
{
llvm_unreachable
(
".indidx encoding not yet implemented"
)
;
}
</s>

WebAssembly
WebAssembly
".indidx encoding not yet implemented"


<s> const LegalizerInfo * RISCVSubtarget :: getLegalizerInfo ( ) const { return Legalizer . get ( ) ; } </s>

Expose LegalizerInfo so the clients can re-use .


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

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


"Expected a flag and a condition expression"

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


<s>
SDValue
SparcTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
bool
hasHardQuad
=
Subtarget
->
hasHardQuad
(
)
;
bool
is64Bit
=
Subtarget
->
is64Bit
(
)
;
bool
isV9
=
Subtarget
->
isV9
(
)
;
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Should not custom lower this!"
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
return
LowerGlobalTLSAddress
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
LowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
ConstantPool
:
return
LowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_SINT
:
return
LowerFP_TO_SINT
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
SINT_TO_FP
:
return
LowerSINT_TO_FP
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
BR_CC
:
return
LowerBR_CC
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
VAARG
:
return
LowerVAARG
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
case
ISD
::
LOAD
:
return
LowerF128Load
(
Op
,
DAG
)
;
case
ISD
::
STORE
:
return
LowerF128Store
(
Op
,
DAG
)
;
case
ISD
::
FADD
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
ADD_F128
)
,
2
)
;
case
ISD
::
FSUB
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
SUB_F128
)
,
2
)
;
case
ISD
::
FMUL
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
MUL_F128
)
,
2
)
;
case
ISD
::
FDIV
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
DIV_F128
)
,
2
)
;
case
ISD
::
FSQRT
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
SQRT_F128
)
,
1
)
;
case
ISD
::
FNEG
:
return
LowerFNEG
(
Op
,
DAG
,
*
this
,
is64Bit
)
;
case
ISD
::
FABS
:
return
LowerFABS
(
Op
,
DAG
,
isV9
)
;
case
ISD
::
FP_EXTEND
:
return
LowerF128_FPEXTEND
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
FP_ROUND
:
return
LowerF128_FPROUND
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
ADDC
:
case
ISD
::
ADDE
:
case
ISD
::
SUBC
:
case
ISD
::
SUBE
:
return
LowerADDC_ADDE_SUBC_SUBE
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .

Sparc
Sparc
"Should not custom lower this!"
ISD::RETURNADDR
ISD::FRAMEADDR
ISD::GlobalTLSAddress
ISD::GlobalAddress
ISD::BlockAddress
ISD::ConstantPool
ISD::FP_TO_SINT
ISD::SINT_TO_FP
ISD::BR_CC
ISD::SELECT_CC
ISD::VASTART
ISD::VAARG
ISD::DYNAMIC_STACKALLOC
ISD::LOAD
ISD::STORE
ISD::FADD
2
ISD::FSUB
2
ISD::FMUL
2
ISD::FDIV
2
ISD::FSQRT
1
ISD::FNEG
ISD::FABS
ISD::FP_EXTEND
ISD::FP_ROUND
ISD::ADDC
ISD::ADDE
ISD::SUBC
ISD::SUBE


"MIPS DAG->DAG Pattern Instruction Selection"

getPassName - Return a nice clean name for a pass .


ARCTargetMachine ctor - Create an ILP32 architecture model .


<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
=
(
Subtarget
.
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> bool isMem ( ) const { return Kind == k_Mem ; } </s>


<s> BitVector JVMRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector resRegs ( getNumRegs ( ) ) ; return resRegs . set ( ) ; } </s>

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


Return the string to output a compare and branch instruction to DEST . DEST is the destination insn ( i.e . the label ) , INSN is the source , and OP is the conditional expression .


<s> int SystemZTTIImpl :: getIntrinsicInstrCost ( const IntrinsicCostAttributes & ICA , TTI :: TargetCostKind CostKind ) { int Cost = getVectorIntrinsicInstrCost ( ICA . getID ( ) , ICA . getReturnType ( ) ) ; if ( Cost != - 1 ) return Cost ; return BaseT :: getIntrinsicInstrCost ( ICA , CostKind ) ; } </s>


<s> void MipsAsmPrinter :: emitBasicBlockEnd ( const MachineBasicBlock & MBB ) { AsmPrinter :: emitBasicBlockEnd ( MBB ) ; MipsTargetStreamer & TS = getTargetStreamer ( ) ; if ( MBB . empty ( ) ) TS . emitDirectiveInsn ( ) ; } </s>

Targets can override this to emit stuff at the end of a basic block .


Value should be nonzero if functions must have frame pointers . Zero means the frame pointer need not be set up ( and parms may be accessed via the stack pointer ) in functions that seem suitable .


<s> void set ( size_type Idx ) { V . set ( Idx ) ; } </s>

Set the generated scalar V for Def and the given Instance .


<s>
void
BTFDebug
::
beginFunctionImpl
(
const
MachineFunction
*
MF
)
{
auto
*
SP
=
MF
->
getFunction
(
)
.
getSubprogram
(
)
;
auto
*
Unit
=
SP
->
getUnit
(
)
;
if
(
Unit
->
getEmissionKind
(
)
==
DICompileUnit
::
NoDebug
)
{
SkipInstruction
=
true
;
return
;
}
SkipInstruction
=
false
;
if
(
MapDefNotCollected
)
{
processGlobals
(
true
)
;
MapDefNotCollected
=
false
;
}
std
::
unordered_map
<
uint32_t
,
StringRef
>
FuncArgNames
;
for
(
const
DINode
*
DN
:
SP
->
getRetainedNodes
(
)
)
{
if
(
const
auto
*
DV
=
dyn_cast
<
DILocalVariable
>
(
DN
)
)
{
uint32_t
Arg
=
DV
->
getArg
(
)
;
if
(
Arg
)
{
visitTypeEntry
(
DV
->
getType
(
)
)
;
FuncArgNames
[
Arg
]
=
DV
->
getName
(
)
;
}
}
}
uint32_t
ProtoTypeId
;
visitSubroutineType
(
SP
->
getType
(
)
,
true
,
FuncArgNames
,
ProtoTypeId
)
;
auto
FuncTypeEntry
=
llvm
::
make_unique
<
BTFTypeFunc
>
(
SP
->
getName
(
)
,
ProtoTypeId
)
;
uint32_t
FuncTypeId
=
addType
(
std
::
move
(
FuncTypeEntry
)
)
;
for
(
const
auto
&
TypeEntry
:
TypeEntries
)
TypeEntry
->
completeType
(
*
this
)
;
MCSymbol
*
FuncLabel
=
Asm
->
getFunctionBegin
(
)
;
BTFFuncInfo
FuncInfo
;
FuncInfo
.
Label
=
FuncLabel
;
FuncInfo
.
TypeId
=
FuncTypeId
;
if
(
FuncLabel
->
isInSection
(
)
)
{
MCSection
&
Section
=
FuncLabel
->
getSection
(
)
;
const
MCSectionELF
*
SectionELF
=
dyn_cast
<
MCSectionELF
>
(
&
Section
)
;
assert
(
SectionELF
&&
"Null section for Function Label"
)
;
SecNameOff
=
addString
(
SectionELF
->
getSectionName
(
)
)
;
}
else
{
SecNameOff
=
addString
(
".text"
)
;
}
FuncInfoTable
[
SecNameOff
]
.
push_back
(
FuncInfo
)
;
}
</s>

BPF
"Null section for Function Label"
".text"


<s> void X86FrameLowering :: emitSPUpdate ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , int64_t NumBytes , bool InEpilogue ) const { bool isSub = NumBytes < 0 ; uint64_t Offset = isSub ? - NumBytes : NumBytes ; uint64_t Chunk = ( 1LL << 31 ) - 1 ; DebugLoc DL = MBB . findDebugLoc ( MBBI ) ; while ( Offset ) { if ( Offset > Chunk ) { unsigned Reg = 0 ; if ( isSub && ! isEAXLiveIn ( * MBB . getParent ( ) ) ) Reg = ( unsigned ) ( Is64Bit ? X86 :: RAX : X86 :: EAX ) ; else Reg = findDeadCallerSavedReg ( MBB , MBBI , TRI , Is64Bit ) ; if ( Reg ) { unsigned Opc = Is64Bit ? X86 :: MOV64ri : X86 :: MOV32ri ; BuildMI ( MBB , MBBI , DL , TII . get ( Opc ) , Reg ) . addImm ( Offset ) ; Opc = isSub ? getSUBrrOpcode ( Is64Bit ) : getADDrrOpcode ( Is64Bit ) ; MachineInstr * MI = BuildMI ( MBB , MBBI , DL , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addReg ( Reg ) ; MI -> getOperand ( 3 ) . setIsDead ( ) ; Offset = 0 ; continue ; } } uint64_t ThisVal = std :: min ( Offset , Chunk ) ; if ( ThisVal == ( Is64Bit ? 8 : 4 ) ) { unsigned Reg = isSub ? ( unsigned ) ( Is64Bit ? X86 :: RAX : X86 :: EAX ) : findDeadCallerSavedReg ( MBB , MBBI , TRI , Is64Bit ) ; if ( Reg ) { unsigned Opc = isSub ? ( Is64Bit ? X86 :: PUSH64r : X86 :: PUSH32r ) : ( Is64Bit ? X86 :: POP64r : X86 :: POP32r ) ; MachineInstr * MI = BuildMI ( MBB , MBBI , DL , TII . get ( Opc ) ) . addReg ( Reg , getDefRegState ( ! isSub ) | getUndefRegState ( isSub ) ) ; if ( isSub ) MI -> setFlag ( MachineInstr :: FrameSetup ) ; Offset -= ThisVal ; continue ; } } MachineInstrBuilder MI = BuildStackAdjustment ( MBB , MBBI , DL , isSub ? - ThisVal : ThisVal , InEpilogue ) ; if ( isSub ) MI . setMIFlag ( MachineInstr :: FrameSetup ) ; Offset -= ThisVal ; } } </s>

Emit a series of instructions to increment / decrement the stack pointer by a constant value .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


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

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


<s> static int rs6000_hard_regno_mode_ok_uncached ( int regno , machine_mode mode ) { int last_regno = regno + rs6000_hard_regno_nregs [ mode ] [ regno ] - 1 ; if ( COMPLEX_MODE_P ( mode ) ) mode = GET_MODE_INNER ( mode ) ; if ( mode == PTImode ) return ( IN_RANGE ( regno , FIRST_GPR_REGNO , LAST_GPR_REGNO ) && IN_RANGE ( last_regno , FIRST_GPR_REGNO , LAST_GPR_REGNO ) && ( ( regno & 1 ) == 0 ) ) ; if ( TARGET_VSX && VSX_REGNO_P ( regno ) && ( VECTOR_MEM_VSX_P ( mode ) || FLOAT128_VECTOR_P ( mode ) || reg_addr [ mode ] . scalar_in_vmx_p || mode == TImode || ( TARGET_VADDUQM && mode == V1TImode ) ) ) { if ( FP_REGNO_P ( regno ) ) return FP_REGNO_P ( last_regno ) ; if ( ALTIVEC_REGNO_P ( regno ) ) { if ( GET_MODE_SIZE ( mode ) != 16 && ! reg_addr [ mode ] . scalar_in_vmx_p ) return 0 ; return ALTIVEC_REGNO_P ( last_regno ) ; } } if ( INT_REGNO_P ( regno ) ) return INT_REGNO_P ( last_regno ) ; if ( FP_REGNO_P ( regno ) ) { if ( FLOAT128_VECTOR_P ( mode ) ) return false ; if ( SCALAR_FLOAT_MODE_P ( mode ) && ( mode != TDmode || ( regno % 2 ) == 0 ) && FP_REGNO_P ( last_regno ) ) return 1 ; if ( GET_MODE_CLASS ( mode ) == MODE_INT ) { if ( GET_MODE_SIZE ( mode ) == UNITS_PER_FP_WORD ) return 1 ; if ( TARGET_P8_VECTOR && ( mode == SImode ) ) return 1 ; if ( TARGET_P9_VECTOR && ( mode == QImode || mode == HImode ) ) return 1 ; } if ( PAIRED_SIMD_REGNO_P ( regno ) && TARGET_PAIRED_FLOAT && PAIRED_VECTOR_MODE ( mode ) ) return 1 ; return 0 ; } if ( CR_REGNO_P ( regno ) ) return GET_MODE_CLASS ( mode ) == MODE_CC ; if ( CA_REGNO_P ( regno ) ) return mode == Pmode || mode == SImode ; if ( ALTIVEC_REGNO_P ( regno ) ) return ( VECTOR_MEM_ALTIVEC_OR_VSX_P ( mode ) || mode == V1TImode ) ; return GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ; } </s>

Value is 1 if hard register REGNO can hold a value of machine-mode MODE .


<s> unsigned X86FastISel :: fastMaterializeFloatZero ( const ConstantFP * CF ) { MVT VT ; if ( ! isTypeLegal ( CF -> getType ( ) , VT ) ) return 0 ; bool HasAVX512 = Subtarget -> hasAVX512 ( ) ; unsigned Opc = 0 ; switch ( VT . SimpleTy ) { default : return 0 ; case MVT :: f32 : if ( X86ScalarSSEf32 ) Opc = HasAVX512 ? X86 :: AVX512_FsFLD0SS : X86 :: FsFLD0SS ; else Opc = X86 :: LD_Fp032 ; break ; case MVT :: f64 : if ( X86ScalarSSEf64 ) Opc = HasAVX512 ? X86 :: AVX512_FsFLD0SD : X86 :: FsFLD0SD ; else Opc = X86 :: LD_Fp064 ; break ; case MVT :: f80 : return 0 ; } unsigned ResultReg = createResultReg ( TLI . getRegClassFor ( VT ) ) ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( Opc ) , ResultReg ) ; return ResultReg ; } </s>

Emit the floating-point constant +0.0 in a register using target- specific logic .


<s> void tilegx_compute_pcrel_plt_address ( rtx result , rtx addr ) { rtx text_label_symbol = tilegx_text_label_symbol ( ) ; rtx text_label_rtx = tilegx_text_label_rtx ( ) ; rtx temp , temp2 , temp3 ; temp = create_temp_reg_if_possible ( Pmode , result ) ; temp2 = create_temp_reg_if_possible ( Pmode , result ) ; if ( TARGET_32BIT ) { emit_insn ( gen_mov_plt_pcrel_step1_32bit ( temp , addr , text_label_symbol ) ) ; emit_insn ( gen_mov_plt_pcrel_step2_32bit ( temp2 , temp , addr , text_label_symbol ) ) ; emit_move_insn ( result , gen_rtx_PLUS ( Pmode , temp2 , text_label_rtx ) ) ; } else { temp3 = create_temp_reg_if_possible ( Pmode , result ) ; emit_insn ( gen_mov_plt_pcrel_step1 ( temp , addr , text_label_symbol ) ) ; emit_insn ( gen_mov_plt_pcrel_step2 ( temp2 , temp , addr , text_label_symbol ) ) ; emit_insn ( gen_mov_plt_pcrel_step3 ( temp3 , temp2 , addr , text_label_symbol ) ) ; emit_move_insn ( result , gen_rtx_PLUS ( Pmode , temp3 , text_label_rtx ) ) ; } } </s>

Returns a register that points to the plt entry of ADDR , a symbolic address , by computing its address relative to tilegx_text_label_symbol .


<s> bool SITargetLowering :: isKnownNeverNaNForTargetNode ( SDValue Op , const SelectionDAG & DAG , bool SNaN , unsigned Depth ) const { if ( Op . getOpcode ( ) == AMDGPUISD :: CLAMP ) { if ( Subtarget -> enableDX10Clamp ( ) ) return true ; return DAG . isKnownNeverNaN ( Op . getOperand ( 0 ) , SNaN , Depth + 1 ) ; } return AMDGPUTargetLowering :: isKnownNeverNaNForTargetNode ( Op , DAG , SNaN , Depth ) ; } </s>


<s> DecodeStatus PatmosDisassembler :: getInstruction ( MCInst & instr , uint64_t & Size , const MemoryObject & Region , uint64_t Address , raw_ostream & vStream , raw_ostream & cStream ) const { uint32_t Insn ; Size = 0 ; DecodeStatus Result = readInstruction32 ( Region , Address , Size , Insn ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; bool isBundled = ( Insn >> 31 ) ; Insn &= ~ ( 1 << 31 ) ; Result = decodeInstruction ( DecoderTablePatmos32 , instr , Insn , Address , this , STI ) ; if ( Result == MCDisassembler :: Fail ) { if ( ! isBundled ) return MCDisassembler :: Fail ; uint32_t InsnL ; Result = readInstruction32 ( Region , Address + 4 , Size , InsnL ) ; if ( Result == MCDisassembler :: Fail ) { return MCDisassembler :: Fail ; } uint64_t Insn64 = ( 1ULL << 63 ) | ( ( uint64_t ) Insn << 32 ) | InsnL ; Result = decodeInstruction ( DecoderTablePatmos64 , instr , Insn64 , Address , this , STI ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; isBundled = false ; } instr . addOperand ( MCOperand :: CreateImm ( isBundled ) ) ; adjustSignedImm ( instr ) ; return Result ; } </s>

Returns the disassembly of a single instruction .


<s> unsigned RISCVTargetLowering :: ComputeNumSignBitsForTargetNode ( SDValue Op , const APInt & DemandedElts , const SelectionDAG & DAG , unsigned Depth ) const { switch ( Op . getOpcode ( ) ) { default : break ; case RISCVISD :: SLLW : case RISCVISD :: SRAW : case RISCVISD :: SRLW : case RISCVISD :: DIVW : case RISCVISD :: DIVUW : case RISCVISD :: REMUW : case RISCVISD :: ROLW : case RISCVISD :: RORW : case RISCVISD :: GREVIW : case RISCVISD :: GORCIW : case RISCVISD :: FSLW : case RISCVISD :: FSRW : return 33 ; case RISCVISD :: VMV_X_S : if ( Op . getOperand ( 0 ) . getScalarValueSizeInBits ( ) > Subtarget . getXLen ( ) ) return 1 ; return Subtarget . getXLen ( ) - Op . getOperand ( 0 ) . getScalarValueSizeInBits ( ) + 1 ; } return 1 ; } </s>

Determine the number of bits in the operation that are sign bits .


<s>
void
M68kInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
DebugLoc
&
DL
,
MCRegister
DstReg
,
MCRegister
SrcReg
,
bool
KillSrc
)
const
{
unsigned
Opc
=
0
;
if
(
M68k
::
XR32RegClass
.
contains
(
DstReg
,
SrcReg
)
)
Opc
=
M68k
::
MOV32rr
;
else
if
(
M68k
::
XR16RegClass
.
contains
(
DstReg
,
SrcReg
)
)
Opc
=
M68k
::
MOV16rr
;
else
if
(
M68k
::
DR8RegClass
.
contains
(
DstReg
,
SrcReg
)
)
Opc
=
M68k
::
MOV8dd
;
if
(
Opc
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
return
;
}
MachineInstrBuilder
MIB
(
*
MBB
.
getParent
(
)
,
MI
)
;
if
(
M68k
::
DR8RegClass
.
contains
(
SrcReg
)
)
{
if
(
M68k
::
XR16RegClass
.
contains
(
DstReg
)
)
Opc
=
M68k
::
MOVXd16d8
;
else
if
(
M68k
::
XR32RegClass
.
contains
(
DstReg
)
)
Opc
=
M68k
::
MOVXd32d8
;
}
else
if
(
M68k
::
XR16RegClass
.
contains
(
SrcReg
)
&&
M68k
::
XR32RegClass
.
contains
(
DstReg
)
)
Opc
=
M68k
::
MOVXd32d16
;
if
(
Opc
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
return
;
}
bool
FromCCR
=
SrcReg
==
M68k
::
CCR
;
bool
FromSR
=
SrcReg
==
M68k
::
SR
;
bool
ToCCR
=
DstReg
==
M68k
::
CCR
;
bool
ToSR
=
DstReg
==
M68k
::
SR
;
if
(
FromCCR
)
{
assert
(
M68k
::
DR8RegClass
.
contains
(
DstReg
)
&&
"Need DR8 register to copy CCR"
)
;
Opc
=
M68k
::
MOV8dc
;
}
else
if
(
ToCCR
)
{
assert
(
M68k
::
DR8RegClass
.
contains
(
SrcReg
)
&&
"Need DR8 register to copy CCR"
)
;
Opc
=
M68k
::
MOV8cd
;
}
else
if
(
FromSR
||
ToSR
)
llvm_unreachable
(
"Cannot emit SR copy instruction"
)
;
if
(
Opc
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
return
;
}
LLVM_DEBUG
(
dbgs
(
)
<<
"Cannot copy "
<<
RI
.
getName
(
SrcReg
)
<<
" to "
<<
RI
.
getName
(
DstReg
)
<<
'\n'
)
;
llvm_unreachable
(
"Cannot emit physreg copy instruction"
)
;
}
</s>


<s> static bool operands_ok_ldd_std ( rtx rt , rtx rt2 , HOST_WIDE_INT offset ) { unsigned int t , t2 ; if ( ! reload_completed ) return true ; if ( ! ( SMALL_INT_RANGE ( offset , ( GET_MODE_SIZE ( DImode ) - 1 ) & ( ~ 0x03 ) , ( offset & ( GET_MODE_SIZE ( DImode ) - 1 ) & 3 ? 0 : - ( - GET_MODE_SIZE ( DImode ) | ( ~ 0x03 ) ) >> 1 ) ) ) ) return false ; t = REGNO ( rt ) ; t2 = REGNO ( rt2 ) ; if ( ( t2 == PCL_REG ) || ( t % 2 != 0 ) || ( t2 != t + 1 ) ) return false ; return true ; } </s>

Checks whether the operands are valid for use in an LDD/STD instruction . Assumes that RT , and RT2 are REG . This is guaranteed by the patterns . Assumes that the address in the base register RN is word aligned . Pattern guarantees that both memory accesses use the same base register , the offsets are constants within the range , and the gap between the offsets is 4 . If reload complete then check that registers are legal .


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

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


<s> const TargetFrameLowering :: SpillSlot * AMDGPUFrameLowering :: getCalleeSavedSpillSlots ( unsigned & NumEntries ) const { NumEntries = 0 ; return nullptr ; } </s>

getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs , that contains an entry for each callee saved register that must be spilled to a particular stack location if it is spilled .


<s> static bool rs6000_legitimate_constant_p ( machine_mode mode , rtx x ) { if ( TARGET_ELF && tls_referenced_p ( x ) ) return false ; return ( ( GET_CODE ( x ) != CONST_DOUBLE && GET_CODE ( x ) != CONST_VECTOR ) || GET_MODE ( x ) == VOIDmode || ( TARGET_POWERPC64 && mode == DImode ) || easy_fp_constant ( x , mode ) || easy_vector_constant ( x , mode ) ) ; } </s>

Implement TARGET_LEGITIMATE_CONSTANT_P . On the RS/6000 , all integer constants are acceptable , most wo n't be valid for particular insns , though . Only easy FP constants are acceptable .


<s> static rtx_insn * s390_md_asm_adjust ( vec < rtx > & outputs , vec < rtx > & inputs , vec < machine_mode > & input_modes , vec < const char * > & constraints , vec < rtx > & , HARD_REG_SET & ) { if ( ! TARGET_VXE ) return NULL ; rtx_insn * after_md_seq = NULL , * after_md_end = NULL ; unsigned ninputs = inputs . length ( ) ; unsigned noutputs = outputs . length ( ) ; for ( unsigned i = 0 ; i < noutputs ; i ++ ) { if ( GET_MODE ( outputs [ i ] ) != TFmode ) continue ; const char * constraint = constraints [ i ] ; bool allows_mem , allows_reg , is_inout ; bool ok = parse_output_constraint ( & constraint , i , ninputs , noutputs , & allows_mem , & allows_reg , & is_inout ) ; gcc_assert ( ok ) ; if ( ! f_constraint_p ( constraint ) ) continue ; gcc_assert ( allows_reg ) ; gcc_assert ( ! is_inout ) ; rtx fprx2 = gen_reg_rtx ( FPRX2mode ) ; push_to_sequence2 ( after_md_seq , after_md_end ) ; emit_insn ( gen_fprx2_to_tf ( outputs [ i ] , fprx2 ) ) ; after_md_seq = get_insns ( ) ; after_md_end = get_last_insn ( ) ; end_sequence ( ) ; outputs [ i ] = fprx2 ; } for ( unsigned i = 0 ; i < ninputs ; i ++ ) { if ( GET_MODE ( inputs [ i ] ) != TFmode ) continue ; const char * constraint = constraints [ noutputs + i ] ; bool allows_mem , allows_reg ; bool ok = parse_input_constraint ( & constraint , i , ninputs , noutputs , 0 , constraints . address ( ) , & allows_mem , & allows_reg ) ; gcc_assert ( ok ) ; if ( ! f_constraint_p ( constraint ) ) continue ; gcc_assert ( allows_reg ) ; rtx fprx2 = gen_reg_rtx ( FPRX2mode ) ; emit_insn ( gen_tf_to_fprx2 ( fprx2 , inputs [ i ] ) ) ; inputs [ i ] = fprx2 ; input_modes [ i ] = FPRX2mode ; } return after_md_seq ; } </s>

Implement TARGET_MD_ASM_ADJUST hook in order to fix up `` f '' constraints when long doubles are stored in vector registers .


"Unexpected register class in CSRsViaCopy!"

"Function should be nounwind in insertCopiesSplitCSR!"

Insert explicit copies in entry and exit blocks .


<s>
void
print
(
raw_ostream
&
OS
,
const
TargetRegisterInfo
*
TRI
=
nullptr
)
const
{
if
(
isReg
(
)
)
{
OS
<<
"register: "
<<
printReg
(
Contents
.
R
.
Reg
,
TRI
,
Contents
.
R
.
Sub
)
<<
'\n'
;
}
if
(
isImm
(
)
)
{
OS
<<
"immediate: "
<<
Contents
.
ImmVal
<<
'\n'
;
}
}
</s>

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


<s> bool prepare_move_operands ( rtx * operands , machine_mode mode ) { if ( 1 ) { if ( ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ 0 ] , Pmode ) ) operands [ 0 ] = arc_rewrite_small_data ( operands [ 0 ] ) ; else if ( mode == SImode && flag_pic && SYMBOLIC_CONST ( operands [ 1 ] ) ) { emit_pic_move ( operands , SImode ) ; } else if ( GET_CODE ( operands [ 0 ] ) != MEM && ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ 1 ] , Pmode ) ) { operands [ 1 ] = arc_rewrite_small_data ( operands [ 1 ] ) ; emit_insn ( gen_rtx_SET ( mode , operands [ 0 ] , operands [ 1 ] ) ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , operands [ 1 ] ) ; emit_move_insn ( operands [ 0 ] , operands [ 0 ] ) ; return true ; } } if ( MEM_P ( operands [ 0 ] ) && ! ( reload_in_progress || reload_completed ) ) { operands [ 1 ] = force_reg ( mode , operands [ 1 ] ) ; if ( ! move_dest_operand ( operands [ 0 ] , mode ) ) { rtx addr = copy_to_mode_reg ( Pmode , XEXP ( operands [ 0 ] , 0 ) ) ; rtx pat = change_address ( operands [ 0 ] , mode , addr ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ 0 ] ) ; operands [ 0 ] = pat ; } if ( ! cse_not_expected ) { rtx pat = XEXP ( operands [ 0 ] , 0 ) ; pat = arc_legitimize_address_0 ( pat , pat , mode ) ; if ( pat ) { pat = change_address ( operands [ 0 ] , mode , pat ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ 0 ] ) ; operands [ 0 ] = pat ; } } } if ( MEM_P ( operands [ 1 ] ) && ! cse_not_expected ) { rtx pat = XEXP ( operands [ 1 ] , 0 ) ; pat = arc_legitimize_address_0 ( pat , pat , mode ) ; if ( pat ) { pat = change_address ( operands [ 1 ] , mode , pat ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ 1 ] ) ; operands [ 1 ] = pat ; } } return false ; } </s>

Prepare operands for a move define_expand in MODE .


<s>
scalar_chain
::
scalar_chain
(
enum
machine_mode
smode_
,
enum
machine_mode
vmode_
)
{
smode
=
smode_
;
vmode
=
vmode_
;
chain_id
=
++
max_id
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Created a new instruction chain #%d\n"
,
chain_id
)
;
bitmap_obstack_initialize
(
)
;
insns
=
BITMAP_ALLOC
(
)
;
defs
=
BITMAP_ALLOC
(
)
;
defs_conv
=
BITMAP_ALLOC
(
)
;
insns_conv
=
BITMAP_ALLOC
(
)
;
queue
=
;
n_sse_to_integer
=
0
;
n_integer_to_sse
=
0
;
max_visits
=
x86_stv_max_visits
;
}
</s>


<s> bool cris_bdap_index_p ( const_rtx x , bool strict ) { return ( ( MEM_P ( x ) && GET_MODE ( x ) == SImode && cris_base_or_autoincr_p ( XEXP ( x , 0 ) , strict ) ) || ( GET_CODE ( x ) == SIGN_EXTEND && MEM_P ( XEXP ( x , 0 ) ) && ( GET_MODE ( XEXP ( x , 0 ) ) == HImode || GET_MODE ( XEXP ( x , 0 ) ) == QImode ) && cris_base_or_autoincr_p ( XEXP ( XEXP ( x , 0 ) , 0 ) , strict ) ) ) ; } </s>

True if X is a valid ( register ) index for BDAP , i.e . [ Rs ] .S or [ Rs+ ] .S .


<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 ) ) ; } return false ; } </s>

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


<s> bool X86AsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode ) { if ( ExtraCode && ExtraCode [ 0 ] ) { if ( ExtraCode [ 1 ] != 0 ) return true ; const MachineOperand & MO = MI -> getOperand ( OpNo ) ; switch ( ExtraCode [ 0 ] ) { default : return true ; case 'a' : if ( MO . isImm ( ) ) { O << MO . getImm ( ) ; return false ; } if ( MO . isGlobal ( ) || MO . isCPI ( ) || MO . isJTI ( ) || MO . isSymbol ( ) ) { printSymbolOperand ( MO ) ; return false ; } if ( MO . isReg ( ) ) { O << '(' ; printOperand ( MI , OpNo ) ; O << ')' ; return false ; } return true ; case 'c' : if ( MO . isImm ( ) ) O << MO . getImm ( ) ; else if ( MO . isGlobal ( ) || MO . isCPI ( ) || MO . isJTI ( ) || MO . isSymbol ( ) ) printSymbolOperand ( MO ) ; else printOperand ( MI , OpNo ) ; return false ; case 'A' : if ( MO . isReg ( ) ) { O << '*' ; printOperand ( MI , OpNo ) ; return false ; } return true ; case 'b' : case 'h' : case 'w' : case 'k' : case 'q' : if ( MO . isReg ( ) ) return printAsmMRegister ( MO , ExtraCode [ 0 ] ) ; printOperand ( MI , OpNo ) ; return false ; case 'P' : print_pcrel_imm ( MI , OpNo ) ; return false ; case 'n' : if ( MO . isImm ( ) ) { O << - MO . getImm ( ) ; return false ; } O << '-' ; } } printOperand ( MI , OpNo ) ; return false ; } </s>

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


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

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


<s> void Z80oldFrameLowering :: processFunctionBeforeFrameFinalized ( MachineFunction & MF , RegScavenger * RS ) const { MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MFI . setMaxCallFrameSize ( 0 ) ; if ( MFI . estimateStackSize ( MF ) > 0x80 ) { RS -> addScavengingFrameIndex ( MFI . CreateStackObject ( SlotSize , 1 , false ) ) ; } } </s>

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


<s>
static
void
cris_asm_output_mi_thunk
(
FILE
*
stream
,
tree
thunkdecl
ATTRIBUTE_UNUSED
,
HOST_WIDE_INT
delta
,
HOST_WIDE_INT
vcall_offset
ATTRIBUTE_UNUSED
,
tree
funcdecl
)
{
const
char
*
fnname
=
IDENTIFIER_POINTER
(
DECL_ASSEMBLER_NAME
(
thunkdecl
)
)
;
assemble_start_function
(
thunkdecl
,
fnname
)
;
final_start_function
(
emit_barrier
(
)
,
stream
,
1
)
;
if
(
delta
>
0
)
fprintf
(
stream
,
"\tadd%s "
HOST_WIDE_INT_PRINT_DEC
",$%s\n"
,
ADDITIVE_SIZE_MODIFIER
(
delta
)
,
delta
,
reg_names
[
CRIS_FIRST_ARG_REG
]
)
;
else
if
(
delta
<
0
)
fprintf
(
stream
,
"\tsub%s "
HOST_WIDE_INT_PRINT_DEC
",$%s\n"
,
ADDITIVE_SIZE_MODIFIER
(
delta
)
,
delta
,
reg_names
[
CRIS_FIRST_ARG_REG
]
)
;
fprintf
(
stream
,
"\tjump "
)
;
assemble_name
(
stream
,
XSTR
(
XEXP
(
DECL_RTL
(
funcdecl
)
,
0
)
,
0
)
)
;
fprintf
(
stream
,
"\n"
)
;
final_end_function
(
)
;
assemble_end_function
(
thunkdecl
,
fnname
)
;
}
</s>


<s> bool MipsTargetObjectFile :: IsGlobalInSmallSection ( const GlobalValue * GV , const TargetMachine & TM , SectionKind Kind ) const { return ( IsGlobalInSmallSectionImpl ( GV , TM ) && ( Kind . isDataRel ( ) || Kind . isBSS ( ) || Kind . isCommon ( ) ) ) ; } </s>

Return true if this global address should be placed into small data/bss section .


<s> void ia64_split_tmode_move ( rtx operands [ ] ) { rtx in [ 2 ] , out [ 2 ] , insn ; rtx fixup [ 2 ] ; bool dead = false ; bool reversed = false ; if ( GET_CODE ( operands [ 1 ] ) == MEM && reg_overlap_mentioned_p ( operands [ 0 ] , operands [ 1 ] ) ) { rtx base = XEXP ( operands [ 1 ] , 0 ) ; while ( GET_CODE ( base ) != REG ) base = XEXP ( base , 0 ) ; if ( REGNO ( base ) == REGNO ( operands [ 0 ] ) ) reversed = true ; if ( refers_to_regno_p ( REGNO ( operands [ 0 ] ) , REGNO ( operands [ 0 ] ) + 2 , base , 0 ) ) dead = true ; } if ( GET_CODE ( operands [ 0 ] ) == REG && GET_CODE ( operands [ 1 ] ) == REG && REGNO ( operands [ 0 ] ) == REGNO ( operands [ 1 ] ) + 1 ) reversed = true ; fixup [ 0 ] = ia64_split_tmode ( in , operands [ 1 ] , reversed , dead ) ; fixup [ 1 ] = ia64_split_tmode ( out , operands [ 0 ] , reversed , dead ) ; if ( GET_CODE ( EXP ) == MEM \ && ( GET_CODE ( XEXP ( EXP , 0 ) ) == POST_MODIFY \ || GET_CODE ( XEXP ( EXP , 0 ) ) == POST_INC \ || GET_CODE ( XEXP ( EXP , 0 ) ) == POST_DEC ) ) \ add_reg_note ( insn , REG_INC , XEXP ( XEXP ( EXP , 0 ) , 0 ) ) insn = emit_insn ( gen_rtx_SET ( out [ 0 ] , in [ 0 ] ) ) ; MAYBE_ADD_REG_INC_NOTE ( insn , in [ 0 ] ) ; MAYBE_ADD_REG_INC_NOTE ( insn , out [ 0 ] ) ; insn = emit_insn ( gen_rtx_SET ( out [ 1 ] , in [ 1 ] ) ) ; MAYBE_ADD_REG_INC_NOTE ( insn , in [ 1 ] ) ; MAYBE_ADD_REG_INC_NOTE ( insn , out [ 1 ] ) ; if ( fixup [ 0 ] ) emit_insn ( fixup [ 0 ] ) ; if ( fixup [ 1 ] ) emit_insn ( fixup [ 1 ] ) ; } </s>

Split a TImode or TFmode move instruction after reload . This is used by * movtf_internal and * movti_internal .


<s> const MCFixup * RISCVMCExpr :: getPCRelHiFixup ( const MCFragment * * DFOut ) const { MCValue AUIPCLoc ; if ( ! getSubExpr ( ) -> evaluateAsRelocatable ( AUIPCLoc , nullptr , nullptr ) ) return nullptr ; const MCSymbolRefExpr * AUIPCSRE = AUIPCLoc . getSymA ( ) ; if ( ! AUIPCSRE ) return nullptr ; const MCSymbol * AUIPCSymbol = & AUIPCSRE -> getSymbol ( ) ; const auto * DF = dyn_cast_or_null < MCDataFragment > ( AUIPCSymbol -> getFragment ( ) ) ; if ( ! DF ) return nullptr ; uint64_t Offset = AUIPCSymbol -> getOffset ( ) ; if ( DF -> getContents ( ) . size ( ) == Offset ) { DF = dyn_cast_or_null < MCDataFragment > ( DF -> getNextNode ( ) ) ; if ( ! DF ) return nullptr ; Offset = 0 ; } for ( const MCFixup & F : DF -> getFixups ( ) ) { if ( F . getOffset ( ) != Offset ) continue ; switch ( ( unsigned ) F . getKind ( ) ) { default : continue ; case RISCV :: fixup_riscv_got_hi20 : case RISCV :: fixup_riscv_tls_got_hi20 : case RISCV :: fixup_riscv_tls_gd_hi20 : case RISCV :: fixup_riscv_pcrel_hi20 : if ( DFOut ) * DFOut = DF ; return & F ; } } return nullptr ; } </s>

Get the corresponding PC-relative HI fixup that a VK_RISCV_PCREL_LO points to , and optionally the fragment containing it .


<s> bool GCNSubtarget :: zeroesHigh16BitsOfDest ( unsigned Opcode ) const { switch ( Opcode ) { case AMDGPU :: V_CVT_F16_F32_e32 : case AMDGPU :: V_CVT_F16_F32_e64 : case AMDGPU :: V_CVT_F16_U16_e32 : case AMDGPU :: V_CVT_F16_U16_e64 : case AMDGPU :: V_CVT_F16_I16_e32 : case AMDGPU :: V_CVT_F16_I16_e64 : case AMDGPU :: V_RCP_F16_e64 : case AMDGPU :: V_RCP_F16_e32 : case AMDGPU :: V_RSQ_F16_e64 : case AMDGPU :: V_RSQ_F16_e32 : case AMDGPU :: V_SQRT_F16_e64 : case AMDGPU :: V_SQRT_F16_e32 : case AMDGPU :: V_LOG_F16_e64 : case AMDGPU :: V_LOG_F16_e32 : case AMDGPU :: V_EXP_F16_e64 : case AMDGPU :: V_EXP_F16_e32 : case AMDGPU :: V_SIN_F16_e64 : case AMDGPU :: V_SIN_F16_e32 : case AMDGPU :: V_COS_F16_e64 : case AMDGPU :: V_COS_F16_e32 : case AMDGPU :: V_FLOOR_F16_e64 : case AMDGPU :: V_FLOOR_F16_e32 : case AMDGPU :: V_CEIL_F16_e64 : case AMDGPU :: V_CEIL_F16_e32 : case AMDGPU :: V_TRUNC_F16_e64 : case AMDGPU :: V_TRUNC_F16_e32 : case AMDGPU :: V_RNDNE_F16_e64 : case AMDGPU :: V_RNDNE_F16_e32 : case AMDGPU :: V_FRACT_F16_e64 : case AMDGPU :: V_FRACT_F16_e32 : case AMDGPU :: V_FREXP_MANT_F16_e64 : case AMDGPU :: V_FREXP_MANT_F16_e32 : case AMDGPU :: V_FREXP_EXP_I16_F16_e64 : case AMDGPU :: V_FREXP_EXP_I16_F16_e32 : case AMDGPU :: V_LDEXP_F16_e64 : case AMDGPU :: V_LDEXP_F16_e32 : case AMDGPU :: V_LSHLREV_B16_e64 : case AMDGPU :: V_LSHLREV_B16_e32 : case AMDGPU :: V_LSHRREV_B16_e64 : case AMDGPU :: V_LSHRREV_B16_e32 : case AMDGPU :: V_ASHRREV_I16_e64 : case AMDGPU :: V_ASHRREV_I16_e32 : case AMDGPU :: V_ADD_U16_e64 : case AMDGPU :: V_ADD_U16_e32 : case AMDGPU :: V_SUB_U16_e64 : case AMDGPU :: V_SUB_U16_e32 : case AMDGPU :: V_SUBREV_U16_e64 : case AMDGPU :: V_SUBREV_U16_e32 : case AMDGPU :: V_MUL_LO_U16_e64 : case AMDGPU :: V_MUL_LO_U16_e32 : case AMDGPU :: V_ADD_F16_e64 : case AMDGPU :: V_ADD_F16_e32 : case AMDGPU :: V_SUB_F16_e64 : case AMDGPU :: V_SUB_F16_e32 : case AMDGPU :: V_SUBREV_F16_e64 : case AMDGPU :: V_SUBREV_F16_e32 : case AMDGPU :: V_MUL_F16_e64 : case AMDGPU :: V_MUL_F16_e32 : case AMDGPU :: V_MAX_F16_e64 : case AMDGPU :: V_MAX_F16_e32 : case AMDGPU :: V_MIN_F16_e64 : case AMDGPU :: V_MIN_F16_e32 : case AMDGPU :: V_MAX_U16_e64 : case AMDGPU :: V_MAX_U16_e32 : case AMDGPU :: V_MIN_U16_e64 : case AMDGPU :: V_MIN_U16_e32 : case AMDGPU :: V_MAX_I16_e64 : case AMDGPU :: V_MAX_I16_e32 : case AMDGPU :: V_MIN_I16_e64 : case AMDGPU :: V_MIN_I16_e32 : case AMDGPU :: V_MAD_F16_e64 : case AMDGPU :: V_MAD_U16_e64 : case AMDGPU :: V_MAD_I16_e64 : case AMDGPU :: V_FMA_F16_e64 : case AMDGPU :: V_DIV_FIXUP_F16_e64 : return getGeneration ( ) <= AMDGPUSubtarget :: GFX9 ; case AMDGPU :: V_MADAK_F16 : case AMDGPU :: V_MADMK_F16 : case AMDGPU :: V_MAC_F16_e64 : case AMDGPU :: V_MAC_F16_e32 : case AMDGPU :: V_FMAMK_F16 : case AMDGPU :: V_FMAAK_F16 : case AMDGPU :: V_FMAC_F16_e64 : case AMDGPU :: V_FMAC_F16_e32 : return getGeneration ( ) == AMDGPUSubtarget :: VOLCANIC_ISLANDS ; case AMDGPU :: V_MAD_MIXLO_F16 : case AMDGPU :: V_MAD_MIXHI_F16 : default : return false ; } } </s>

Returns if the result of this instruction with a 16-bit result returned in a 32-bit register implicitly zeroes the high 16-bits , rather than preserve the original value .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Global Variable Resolver"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool SIDebuggerInsertNops :: runOnMachineFunction ( MachineFunction & MF ) { const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; if ( ! ST . debuggerInsertNops ( ) ) return false ; if ( ! MF . getMMI ( ) . hasDebugInfo ( ) ) return false ; const SIInstrInfo * TII = ST . getInstrInfo ( ) ; DenseSet < unsigned > NopInserted ; for ( auto & MBB : MF ) { for ( auto MI = MBB . begin ( ) ; MI != MBB . end ( ) ; ++ MI ) { if ( MI -> isDebugInstr ( ) || ! MI -> getDebugLoc ( ) ) continue ; auto DL = MI -> getDebugLoc ( ) ; if ( NopInserted . find ( DL . getLine ( ) ) == NopInserted . end ( ) ) { BuildMI ( MBB , * MI , DL , TII -> get ( AMDGPU :: S_NOP ) ) . addImm ( 0 ) ; NopInserted . insert ( DL . getLine ( ) ) ; } } } return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> void BPFAsmPrinter :: emitInstruction ( const MachineInstr * MI ) { MCInst TmpInst ; if ( ! BTF || ! BTF -> InstLower ( MI , TmpInst ) ) { BPFMCInstLower MCInstLowering ( OutContext , * this ) ; MCInstLowering . Lower ( MI , TmpInst ) ; } EmitToStreamer ( * OutStreamer , TmpInst ) ; } </s>

Targets should implement this to emit instructions .


<s> const MCFixup * RISCVMCExpr :: getPCRelHiFixup ( ) const { MCValue AUIPCLoc ; if ( ! getSubExpr ( ) -> evaluateAsRelocatable ( AUIPCLoc , nullptr , nullptr ) ) return nullptr ; const MCSymbolRefExpr * AUIPCSRE = AUIPCLoc . getSymA ( ) ; if ( ! AUIPCSRE ) return nullptr ; const MCSymbol * AUIPCSymbol = & AUIPCSRE -> getSymbol ( ) ; const auto * DF = dyn_cast_or_null < MCDataFragment > ( AUIPCSymbol -> getFragment ( ) ) ; if ( ! DF ) return nullptr ; uint64_t Offset = AUIPCSymbol -> getOffset ( ) ; if ( DF -> getContents ( ) . size ( ) == Offset ) { DF = dyn_cast_or_null < MCDataFragment > ( DF -> getNextNode ( ) ) ; if ( ! DF ) return nullptr ; Offset = 0 ; } for ( const MCFixup & F : DF -> getFixups ( ) ) { if ( F . getOffset ( ) != Offset ) continue ; switch ( ( unsigned ) F . getKind ( ) ) { default : continue ; case RISCV :: fixup_riscv_got_hi20 : case RISCV :: fixup_riscv_pcrel_hi20 : return & F ; } } return nullptr ; } </s>


<s> int short_memory_operand ( rtx x , machine_mode mode ) { if ( ! memory_operand ( x , mode ) ) return 0 ; return ( GET_CODE ( XEXP ( x , 0 ) ) != PLUS ) ; } </s>

Return 1 if OP is a valid operand for a ` short ' memory reference insn .


<s> unsigned SITargetLowering :: getVectorTypeBreakdownForCallingConv ( LLVMContext & Context , CallingConv :: ID CC , EVT VT , EVT & IntermediateVT , unsigned & NumIntermediates , MVT & RegisterVT ) const { if ( CC != CallingConv :: AMDGPU_KERNEL && VT . isVector ( ) ) { unsigned NumElts = VT . getVectorNumElements ( ) ; EVT ScalarVT = VT . getScalarType ( ) ; unsigned Size = ScalarVT . getSizeInBits ( ) ; if ( Size == 16 && Subtarget -> has16BitInsts ( ) ) { RegisterVT = VT . isInteger ( ) ? MVT :: v2i16 : MVT :: v2f16 ; IntermediateVT = RegisterVT ; NumIntermediates = ( NumElts + 1 ) / 2 ; return NumIntermediates ; } if ( Size == 32 ) { RegisterVT = ScalarVT . getSimpleVT ( ) ; IntermediateVT = RegisterVT ; NumIntermediates = NumElts ; return NumIntermediates ; } if ( Size < 16 && Subtarget -> has16BitInsts ( ) ) { RegisterVT = MVT :: i16 ; IntermediateVT = ScalarVT ; NumIntermediates = NumElts ; return NumIntermediates ; } if ( Size != 16 && Size <= 32 ) { RegisterVT = MVT :: i32 ; IntermediateVT = ScalarVT ; NumIntermediates = NumElts ; return NumIntermediates ; } if ( Size > 32 ) { RegisterVT = MVT :: i32 ; IntermediateVT = RegisterVT ; NumIntermediates = NumElts * ( ( Size + 31 ) / 32 ) ; return NumIntermediates ; } } return TargetLowering :: getVectorTypeBreakdownForCallingConv ( Context , CC , VT , IntermediateVT , NumIntermediates , RegisterVT ) ; } </s>

Certain targets such as MIPS require that some types such as vectors are always broken down into scalars in some contexts .


<s> SDValue MipsTargetLowering :: getTargetNode ( ConstantPoolSDNode * N , EVT Ty , SelectionDAG & DAG , unsigned Flag ) const { return DAG . getTargetConstantPool ( N -> getConstVal ( ) , Ty , N -> getAlign ( ) , N -> getOffset ( ) , Flag ) ; } </s>

Retrieve the target node this edge connects to .


<s> static void cirrus_reorg ( rtx first ) { enum attr_cirrus attr ; rtx body = PATTERN ( first ) ; rtx t ; int nops ; if ( GET_CODE ( first ) == JUMP_INSN && GET_CODE ( body ) != RETURN ) { nops = 0 ; t = next_nonnote_insn ( first ) ; if ( arm_cirrus_insn_p ( t ) ) ++ nops ; if ( arm_cirrus_insn_p ( next_nonnote_insn ( t ) ) ) ++ nops ; while ( nops -- ) emit_insn_after ( gen_nop ( ) , first ) ; return ; } if ( GET_CODE ( body ) == PARALLEL && XVECLEN ( body , 0 ) > 0 ) body = XVECEXP ( body , 0 , 0 ) ; if ( GET_CODE ( body ) == SET ) { rtx lhs = XEXP ( body , 0 ) , rhs = XEXP ( body , 1 ) ; if ( get_attr_cirrus ( first ) == CIRRUS_DOUBLE ) { if ( arm_cirrus_insn_p ( next_nonnote_insn ( first ) ) ) emit_insn_after ( gen_nop ( ) , first ) ; return ; } else if ( arm_memory_load_p ( first ) ) { unsigned int arm_regno ; if ( GET_CODE ( lhs ) == REG ) arm_regno = REGNO ( lhs ) ; else { gcc_assert ( GET_CODE ( rhs ) == REG ) ; arm_regno = REGNO ( rhs ) ; } first = next_nonnote_insn ( first ) ; if ( ! arm_cirrus_insn_p ( first ) ) return ; body = PATTERN ( first ) ; if ( GET_CODE ( body ) == PARALLEL && XVECLEN ( body , 0 ) ) body = XVECEXP ( body , 0 , 0 ) ; if ( GET_CODE ( body ) == FLOAT ) body = XEXP ( body , 0 ) ; if ( get_attr_cirrus ( first ) == CIRRUS_MOVE && GET_CODE ( XEXP ( body , 1 ) ) == REG && arm_regno == REGNO ( XEXP ( body , 1 ) ) ) emit_insn_after ( gen_nop ( ) , first ) ; return ; } } if ( ! first || GET_CODE ( first ) != INSN || GET_CODE ( PATTERN ( first ) ) == USE || GET_CODE ( PATTERN ( first ) ) == CLOBBER ) return ; attr = get_attr_cirrus ( first ) ; if ( attr == CIRRUS_COMPARE ) { nops = 0 ; t = next_nonnote_insn ( first ) ; if ( arm_cirrus_insn_p ( t ) ) ++ nops ; if ( arm_cirrus_insn_p ( next_nonnote_insn ( t ) ) ) ++ nops ; while ( nops -- ) emit_insn_after ( gen_nop ( ) , first ) ; return ; } } </s>

Cirrus reorg for invalid instruction combinations .


<s> bool pdp11_secondary_memory_needed ( reg_class_t c1 , reg_class_t c2 , machine_mode mode ATTRIBUTE_UNUSED ) { int fromfloat = ( c1 == LOAD_FPU_REGS || c1 == NO_LOAD_FPU_REGS || c1 == FPU_REGS ) ; int tofloat = ( c2 == LOAD_FPU_REGS || c2 == NO_LOAD_FPU_REGS || c2 == FPU_REGS ) ; return ( fromfloat != tofloat ) ; } </s>

Implement TARGET_SECONDARY_MEMORY_NEEDED . The answer is yes if we 're going between general register and FPU registers . The mode does n't matter in making this check .


<s> MCSection * LanaiTargetObjectFile :: getSectionForConstant ( const DataLayout & DL , SectionKind Kind , const Constant * C , unsigned & Align , const GlobalObject * GO ) const { if ( isConstantInSmallSection ( DL , C ) ) return SmallDataSection ; return TargetLoweringObjectFileELF :: getSectionForConstant ( DL , Kind , C , Align , GO ) ; } </s>

Given a constant with the SectionKind , return a section that it should be placed in .


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

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


<s>
void
BPFMIPreEmitChecking
::
initialize
(
MachineFunction
&
MFParm
)
{
MF
=
&
MFParm
;
TRI
=
MF
->
getSubtarget
<
BPFSubtarget
>
(
)
.
getRegisterInfo
(
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"*** BPF PreEmit checking pass ***\n\n"
)
;
}
</s>

Initialize the strategy after building the DAG for a new region .

BPF
BPF
BPF
"*** BPF PreEmit checking pass ***\n\n"


<s>
StringRef
getPassName
(
)
const
override
{
return
"2003f Assembly Printer"
;
}
</s>


<s> bool HexagonTargetLowering :: isLegalAddressingMode ( const AddrMode & AM , Type * Ty , unsigned AS ) const { if ( AM . BaseOffs <= - ( 1LL << 13 ) || AM . BaseOffs >= ( 1LL << 13 ) - 1 ) return false ; if ( AM . BaseGV ) return false ; int Scale = AM . Scale ; if ( Scale < 0 ) Scale = - Scale ; switch ( Scale ) { case 0 : break ; default : return false ; } return true ; } </s>

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


<s> bool shouldInsertFencesForAtomic ( const Instruction * I ) const override { return true ; } </s>

Helper functions for atomic operations .


<s> static unsigned nvptx_process_pars ( parallel * par ) { if ( nvptx_optimize ) nvptx_optimize_inner ( par ) ; unsigned inner_mask = par -> mask ; if ( par -> inner ) { par -> inner_mask = nvptx_process_pars ( par -> inner ) ; inner_mask |= par -> inner_mask ; } bool is_call = ( par -> mask & GOMP_DIM_MASK ( GOMP_DIM_MAX ) ) != 0 ; bool worker = ( par -> mask & GOMP_DIM_MASK ( GOMP_DIM_WORKER ) ) ; bool large_vector = ( ( par -> mask & GOMP_DIM_MASK ( GOMP_DIM_VECTOR ) ) && nvptx_mach_vector_length ( ) > PTX_WARP_SIZE ) ; if ( worker || large_vector ) { nvptx_shared_propagate ( false , is_call , par -> forked_block , par -> forked_insn , ! worker ) ; bool no_prop_p = nvptx_shared_propagate ( true , is_call , par -> forked_block , par -> fork_insn , ! worker ) ; bool empty_loop_p = ! is_call && ( NEXT_INSN ( par -> forked_insn ) && NEXT_INSN ( par -> forked_insn ) == par -> joining_insn ) ; rtx barrier = GEN_INT ( 0 ) ; int threads = 0 ; if ( ! worker && cfun -> machine -> sync_bar ) { barrier = cfun -> machine -> sync_bar ; threads = nvptx_mach_vector_length ( ) ; } if ( no_prop_p && empty_loop_p ) ; else if ( no_prop_p && is_call ) ; else { emit_insn_before ( nvptx_cta_sync ( barrier , threads ) , par -> forked_insn ) ; emit_insn_before ( nvptx_cta_sync ( barrier , threads ) , par -> join_insn ) ; } } else if ( par -> mask & GOMP_DIM_MASK ( GOMP_DIM_VECTOR ) ) nvptx_warp_propagate ( is_call , par -> forked_block , par -> forked_insn ) ; if ( par -> next ) inner_mask |= nvptx_process_pars ( par -> next ) ; return inner_mask ; } </s>

Process the parallel PAR and all its contained parallels . We do everything but the neutering . Return mask of partitioned modes used within this parallel .


<s> static int s390_issue_rate ( void ) { if ( s390_tune == PROCESSOR_2084_Z990 || s390_tune == PROCESSOR_2094_Z9_109 ) return 3 ; return 1 ; } </s>

The number of instructions that can be issued per cycle .


<s> const char * AAPTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return nullptr ; case AAPISD :: RET_FLAG : return "AAPISD::RET_FLAG" ; case AAPISD :: CALL : return "AAPISD::CALL" ; case AAPISD :: Wrapper : return "AAPISD::Wrapper" ; case AAPISD :: SELECT_CC : return "AAPISD::SELECT_CC" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


<s>
void
ScheduleDAGPostRA
::
dumpSchedule
(
)
const
{
for
(
MachineBasicBlock
::
iterator
MI
=
begin
(
)
,
ME
=
end
(
)
;
MI
!=
ME
;
++
MI
)
{
if
(
SUnit
*
SU
=
getSUnit
(
&
(
*
MI
)
)
)
SU
->
dumpAttributes
(
)
;
else
if
(
MI
->
isDebugValue
(
)
)
dbgs
(
)
<<
"Debug Value\n"
;
else
dbgs
(
)
<<
"Missing SUnit\n"
;
}
}
</s>

Patmos
"Debug Value\n"
"Missing SUnit\n"


<s> static rtx nds32_gen_dup_4_byte_to_word_value_aux ( rtx value , rtx value4word ) { gcc_assert ( GET_MODE ( value ) == QImode || CONST_INT_P ( value ) ) ; if ( CONST_INT_P ( value ) ) { unsigned HOST_WIDE_INT val = UINTVAL ( value ) & GET_MODE_MASK ( QImode ) ; rtx new_val = gen_int_mode ( val | ( val << 8 ) | ( val << 16 ) | ( val << 24 ) , SImode ) ; emit_move_insn ( value4word , new_val ) ; } else { if ( NDS32_EXT_DSP_P ( ) ) { rtx tmp = gen_reg_rtx ( SImode ) ; convert_move ( tmp , value , true ) ; emit_insn ( gen_insvsi_internal ( tmp , gen_int_mode ( 0x8 , SImode ) , tmp ) ) ; emit_insn ( gen_pkbbsi_1 ( value4word , tmp , tmp ) ) ; } else { rtx tmp1 , tmp2 , tmp3 , tmp4 ; tmp1 = expand_binop ( SImode , and_optab , value , gen_int_mode ( 0xff , SImode ) , NULL_RTX , 0 , OPTAB_WIDEN ) ; tmp2 = expand_binop ( SImode , ashl_optab , tmp1 , gen_int_mode ( 8 , SImode ) , NULL_RTX , 0 , OPTAB_WIDEN ) ; tmp3 = expand_binop ( SImode , ior_optab , tmp1 , tmp2 , NULL_RTX , 0 , OPTAB_WIDEN ) ; tmp4 = expand_binop ( SImode , ashl_optab , tmp3 , gen_int_mode ( 16 , SImode ) , NULL_RTX , 0 , OPTAB_WIDEN ) ; emit_insn ( gen_iorsi3 ( value4word , tmp3 , tmp4 ) ) ; } } return value4word ; } </s>

Auxiliary function for expand setmem pattern .


<s> static void arc_initialize_trampoline ( rtx tramp , tree fndecl , rtx cxt ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; emit_block_move ( tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ; emit_move_insn ( adjust_address ( tramp , SImode , 8 ) , fnaddr ) ; emit_move_insn ( adjust_address ( tramp , SImode , 12 ) , cxt ) ; maybe_emit_call_builtin___clear_cache ( XEXP ( tramp , 0 ) , plus_constant ( Pmode , XEXP ( tramp , 0 ) , TRAMPOLINE_SIZE ) ) ; } </s>

With potentially multiple shared objects loaded , and multiple stacks present for multiple thereds where trampolines might reside , a simple range check will likely not suffice for the profiler to tell if a callee is a trampoline . We a speedier check by making the trampoline start at an address that is not 4-byte aligned . A trampoline looks like this : nop_s 0x78e0entry : ld_s r12 , [ pcl,12 ] 0xd403 ld r11 , [ pcl,12 ] 0x170c 700b j_s [ r12 ] 0x7c00 nop_s 0x78e0 The fastest trampoline to execute for trampolines within +-8KB of CTX would be : add2 r11 , pcl , s12 j [ limm ] 0x20200f80 limm and that would also be faster to write to the stack by computing the offset from CTX to TRAMP at compile time . However , it would really be better to get rid of the high cost of cache invalidation when generating trampolines , which requires that the code part of trampolines stays constant , and additionally either - making sure that no executable code but trampolines is on the stack , no icache entries linger for the area of the stack from when before the stack was allocated , and allocating trampolines in trampoline-only cache lines or - allocate trampolines fram a special pool of pre-allocated trampolines .


<s> MachineBasicBlock * getBlock ( ) const { return Block ; } </s>

getBlock - Return the current basic block .


<s> BitVector SIRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( AMDGPU :: INDIRECT_BASE_ADDR ) ; reserveRegisterTuples ( Reserved , AMDGPU :: EXEC ) ; reserveRegisterTuples ( Reserved , AMDGPU :: FLAT_SCR ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TBA ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TMA ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP0_TTMP1 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP2_TTMP3 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP4_TTMP5 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP6_TTMP7 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP8_TTMP9 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP10_TTMP11 ) ; unsigned MaxWorkGroupSGPRCount = getMaxWorkGroupSGPRCount ( MF ) ; unsigned MaxWorkGroupVGPRCount = getMaxWorkGroupVGPRCount ( MF ) ; unsigned NumSGPRs = AMDGPU :: SGPR_32RegClass . getNumRegs ( ) ; unsigned NumVGPRs = AMDGPU :: VGPR_32RegClass . getNumRegs ( ) ; for ( unsigned i = MaxWorkGroupSGPRCount ; i < NumSGPRs ; ++ i ) { unsigned Reg = AMDGPU :: SGPR_32RegClass . getRegister ( i ) ; reserveRegisterTuples ( Reserved , Reg ) ; } for ( unsigned i = MaxWorkGroupVGPRCount ; i < NumVGPRs ; ++ i ) { unsigned Reg = AMDGPU :: VGPR_32RegClass . getRegister ( i ) ; reserveRegisterTuples ( Reserved , Reg ) ; } const SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; unsigned ScratchWaveOffsetReg = MFI -> getScratchWaveOffsetReg ( ) ; if ( ScratchWaveOffsetReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , ScratchWaveOffsetReg ) ; } unsigned ScratchRSrcReg = MFI -> getScratchRSrcReg ( ) ; if ( ScratchRSrcReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , ScratchRSrcReg ) ; assert ( ! isSubRegister ( ScratchRSrcReg , ScratchWaveOffsetReg ) ) ; } const AMDGPUSubtarget & ST = MF . getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . debuggerReserveRegs ( ) ) { unsigned ReservedVGPRFirst = MaxWorkGroupVGPRCount - MFI -> getDebuggerReservedVGPRCount ( ) ; for ( unsigned i = ReservedVGPRFirst ; i < MaxWorkGroupVGPRCount ; ++ i ) { unsigned Reg = AMDGPU :: VGPR_32RegClass . getRegister ( i ) ; reserveRegisterTuples ( Reserved , Reg ) ; } } return Reserved ; } </s>

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


<s> ScheduleDAGInstrs * createMachineScheduler ( MachineSchedContext * C ) const override { const PPCSubtarget & ST = C -> MF -> getSubtarget < PPCSubtarget > ( ) ; if ( ST . usePPCPreRASchedStrategy ( ) ) return createPPCMachineScheduler ( C ) ; return nullptr ; } </s>

Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this function and target at the current optimization level .


"After expanding ARM pseudo instructions."

runOnMachineFunction - Emit the function body .


This is the top of the devritualization pass .


<s> static int gen_v9_scc ( rtx dest , enum rtx_code compare_code , rtx x , rtx y ) { if ( ! TARGET_ARCH64 && ( GET_MODE ( x ) == DImode || GET_MODE ( dest ) == DImode ) ) return 0 ; if ( TARGET_ARCH64 && GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_INT && y == const0_rtx && v9_regcmp_p ( compare_code ) ) { rtx op0 = x ; rtx temp ; if ( compare_code == NE && GET_MODE ( dest ) == DImode && rtx_equal_p ( op0 , dest ) ) { emit_insn ( gen_rtx_SET ( dest , gen_rtx_IF_THEN_ELSE ( DImode , gen_rtx_fmt_ee ( compare_code , DImode , op0 , const0_rtx ) , const1_rtx , dest ) ) ) ; return 1 ; } if ( reg_overlap_mentioned_p ( dest , op0 ) ) { op0 = gen_reg_rtx ( GET_MODE ( x ) ) ; emit_move_insn ( op0 , x ) ; } emit_insn ( gen_rtx_SET ( dest , const0_rtx ) ) ; if ( GET_MODE ( op0 ) != DImode ) { temp = gen_reg_rtx ( DImode ) ; convert_move ( temp , op0 , 0 ) ; } else temp = op0 ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_IF_THEN_ELSE ( GET_MODE ( dest ) , gen_rtx_fmt_ee ( compare_code , DImode , temp , const0_rtx ) , const1_rtx , dest ) ) ) ; return 1 ; } else { x = gen_compare_reg_1 ( compare_code , x , y ) ; y = const0_rtx ; emit_insn ( gen_rtx_SET ( dest , const0_rtx ) ) ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_IF_THEN_ELSE ( GET_MODE ( dest ) , gen_rtx_fmt_ee ( compare_code , GET_MODE ( x ) , x , y ) , const1_rtx , dest ) ) ) ; return 1 ; } } </s>

This function is used for v9 only . CODE is the code for an Scc 's comparison . OPERANDS [ 0 ] is the target of the Scc insn . OPERANDS [ 1 ] is the value we compare against const0_rtx ( which has n't been generated yet ) . This function is needed to turn ( set ( reg : SI 110 ) ( gt ( reg : CCX 100 % icc ) ( const_int 0 ) ) ) into ( set ( reg : SI 110 ) ( gt : DI ( reg : CCX 100 % icc ) ( const_int 0 ) ) ) IE : The instruction recognizer needs to see the mode of the comparison to find the right instruction . We could use `` gt : DI '' right in the define_expand , but leaving it out allows us to handle DI , SI , etc . We refer to the global sparc compare operands sparc_compare_op0 and sparc_compare_op1 .


<s> FunctionType * getFunctionType ( Module & M ) const override { return FuncTy ; } </s>

getFunctionType - InlineAsm 's are always pointers to functions .


<s>
void
X86InstrInfo
::
insertSelect
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
const
DebugLoc
&
DL
,
unsigned
DstReg
,
ArrayRef
<
MachineOperand
>
Cond
,
unsigned
TrueReg
,
unsigned
FalseReg
)
const
{
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
const
TargetRegisterInfo
&
TRI
=
*
MRI
.
getTargetRegisterInfo
(
)
;
const
TargetRegisterClass
&
RC
=
*
MRI
.
getRegClass
(
DstReg
)
;
assert
(
Cond
.
size
(
)
==
1
&&
"Invalid Cond array"
)
;
unsigned
Opc
=
getCMovFromCond
(
(
X86
::
CondCode
)
Cond
[
0
]
.
getImm
(
)
,
TRI
.
getRegSizeInBits
(
RC
)
/
8
,
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> static void addarg ( const char * str ) { int i ; if ( ++ comp_arg_index >= comp_arg_max ) { const char * * new_comp_args = ( const char * * ) xcalloc ( comp_arg_max + 1000 , sizeof ( char * ) ) ; for ( i = 0 ; i <= comp_arg_max ; i ++ ) new_comp_args [ i ] = comp_args [ i ] ; if ( comp_args ) free ( comp_args ) ; comp_arg_max += 1000 ; comp_args = new_comp_args ; } comp_args [ comp_arg_index ] = str ; } </s>

Append STR to the command line to invoke the linker . Expand the line as necessary to accommodate .


<s> void dump ( ) { print ( dbgs ( ) ) ; } </s>

Dump the plan to stderr ( for debugging ) .


<s> void printCustom ( raw_ostream & OS ) const override { OS << "MisalignedCrash" ; } </s>

Implement printing for PseudoSourceValue .


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

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


<s> const RegisterBankInfo * getRegBankInfo ( ) const override { return RegBankInfo . get ( ) ; } </s>

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


<s> static int tilegx_mode_rep_extended ( scalar_int_mode mode , scalar_int_mode mode_rep ) { if ( mode == SImode && mode_rep == DImode ) return SIGN_EXTEND ; return UNKNOWN ; } </s>


<s> bool arc_lra_p ( void ) { return arc_lra_flag ; } </s>

Return true if we use LRA instead of reload pass .


<s> static int compute_clrmem_length ( rtx_insn * insn ) { rtx pat = PATTERN ( insn ) ; unsigned int align = INTVAL ( XEXP ( XVECEXP ( pat , 0 , 4 ) , 0 ) ) ; unsigned long n_bytes = INTVAL ( XEXP ( XVECEXP ( pat , 0 , 3 ) , 0 ) ) ; unsigned int n_insns = 0 ; if ( align > ( TARGET_64BIT ? 8 : 4 ) ) align = ( TARGET_64BIT ? 8 : 4 ) ; n_insns = 4 ; if ( n_bytes % ( 2 * align ) != 0 ) { if ( ( n_bytes % ( 2 * align ) ) >= align ) n_insns ++ ; if ( ( n_bytes % align ) != 0 ) n_insns ++ ; } return n_insns * 4 ; } </s>

Count the number of insns necessary to handle this block move . Basic structure is the same as emit_block_move , except that we count insns rather than emit them .


Implement the TARGET_CPU_CPP_BUILTINS macro


<s>
StringRef
RISCVMCExpr
::
getVariantKindName
(
VariantKind
Kind
)
{
switch
(
Kind
)
{
default
:
llvm_unreachable
(
"Invalid ELF symbol kind"
)
;
case
VK_RISCV_LO
:
return
"lo"
;
case
VK_RISCV_HI
:
return
"hi"
;
case
VK_RISCV_PCREL_LO
:
return
"pcrel_lo"
;
case
VK_RISCV_PCREL_HI
:
return
"pcrel_hi"
;
case
VK_RISCV_GOT_HI
:
return
"got_pcrel_hi"
;
}
}
</s>

Convert the variant kind into an ELF-appropriate modifier ( e.g .

RISCV
RISCV
"Invalid ELF symbol kind"
RISCV
"lo"
RISCV
"hi"
RISCV
"pcrel_lo"
RISCV
"pcrel_hi"
RISCV
"got_pcrel_hi"


<s>
void
LEGAsmBackend
::
applyFixup
(
const
MCFixup
&
Fixup
,
char
*
Data
,
unsigned
DataSize
,
uint64_t
Value
,
bool
isPCRel
)
const
{
unsigned
NumBytes
=
4
;
Value
=
adjustFixupValue
(
Fixup
,
Value
)
;
if
(
!
Value
)
{
return
;
}
unsigned
Offset
=
Fixup
.
getOffset
(
)
;
assert
(
Offset
+
NumBytes
<=
DataSize
&&
"Invalid fixup offset!"
)
;
for
(
unsigned
i
=
0
;
i
!=
NumBytes
;
++
i
)
{
Data
[
Offset
+
i
]
|=
uint8_t
(
(
Value
>>
(
i
*
8
)
)
&
0xff
)
;
}
}
</s>

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


<s> bool ARMBaseInstrInfo :: areLoadsFromSameBasePtr ( SDNode * Load1 , SDNode * Load2 , int64_t & Offset1 , int64_t & Offset2 ) const { if ( Subtarget . isThumb1Only ( ) ) return false ; if ( ! Load1 -> isMachineOpcode ( ) || ! Load2 -> isMachineOpcode ( ) ) return false ; switch ( Load1 -> getMachineOpcode ( ) ) { default : return false ; case ARM :: LDRi12 : case ARM :: LDRBi12 : case ARM :: LDRD : case ARM :: LDRH : case ARM :: LDRSB : case ARM :: LDRSH : case ARM :: VLDRD : case ARM :: VLDRS : case ARM :: t2LDRi8 : case ARM :: t2LDRDi8 : case ARM :: t2LDRSHi8 : case ARM :: t2LDRi12 : case ARM :: t2LDRSHi12 : break ; } switch ( Load2 -> getMachineOpcode ( ) ) { default : return false ; case ARM :: LDRi12 : case ARM :: LDRBi12 : case ARM :: LDRD : case ARM :: LDRH : case ARM :: LDRSB : case ARM :: LDRSH : case ARM :: VLDRD : case ARM :: VLDRS : case ARM :: t2LDRi8 : case ARM :: t2LDRSHi8 : case ARM :: t2LDRi12 : case ARM :: t2LDRSHi12 : break ; } if ( Load1 -> getOperand ( 0 ) != Load2 -> getOperand ( 0 ) || Load1 -> getOperand ( 4 ) != Load2 -> getOperand ( 4 ) ) return false ; if ( Load1 -> getOperand ( 3 ) != Load2 -> getOperand ( 3 ) ) return false ; if ( isa < ConstantSDNode > ( Load1 -> getOperand ( 1 ) ) && isa < ConstantSDNode > ( Load2 -> getOperand ( 1 ) ) ) { Offset1 = cast < ConstantSDNode > ( Load1 -> getOperand ( 1 ) ) -> getSExtValue ( ) ; Offset2 = cast < ConstantSDNode > ( Load2 -> getOperand ( 1 ) ) -> getSExtValue ( ) ; return true ; } return false ; } </s>

areLoadsFromSameBasePtr - This is used by the pre-regalloc scheduler to determine if two loads are loading from the same base address .


<s> bool ARMPassConfig :: addPreISel ( ) { if ( TM -> getOptLevel ( ) != CodeGenOpt :: None && EnableGlobalMerge ) addPass ( createGlobalMergePass ( TM -> getTargetLowering ( ) ) ) ; return false ; } </s>


<s> void erase ( SDNode * N ) { auto F = Refs . find ( N ) ; if ( F != Refs . end ( ) ) * F -> second = nullptr ; } </s>

erase - Erases an element identified by Key , if it exists .


<s> bool AMDGPUInstrInfo :: isSafeToMoveRegClassDefs ( const TargetRegisterClass * RC ) const { return true ; } </s>

isSafeToMoveRegClassDefs - Return true if it 's safe to move a machine instruction that defines the specified register class .


<s> static bool const_load_sequence_p ( swap_web_entry * insn_entry , rtx insn ) { unsigned uid = INSN_UID ( insn ) ; if ( ! insn_entry [ uid ] . is_swap || insn_entry [ uid ] . is_load ) return false ; const_rtx tocrel_base ; struct df_insn_info * insn_info = DF_INSN_INFO_GET ( insn ) ; df_ref use ; FOR_EACH_INSN_INFO_USE ( use , insn_info ) { struct df_link * def_link = DF_REF_CHAIN ( use ) ; if ( ! def_link || ! def_link -> ref || DF_REF_IS_ARTIFICIAL ( def_link -> ref ) || def_link -> next ) return false ; rtx def_insn = DF_REF_INSN ( def_link -> ref ) ; unsigned uid2 = INSN_UID ( def_insn ) ; if ( ! insn_entry [ uid2 ] . is_load || ! insn_entry [ uid2 ] . is_swap ) return false ; rtx body = PATTERN ( def_insn ) ; if ( GET_CODE ( body ) != SET || GET_CODE ( SET_SRC ( body ) ) != VEC_SELECT || GET_CODE ( XEXP ( SET_SRC ( body ) , 0 ) ) != MEM ) return false ; rtx mem = XEXP ( SET_SRC ( body ) , 0 ) ; rtx base_reg = XEXP ( mem , 0 ) ; if ( ! REG_P ( base_reg ) ) return false ; df_ref base_use ; insn_info = DF_INSN_INFO_GET ( def_insn ) ; FOR_EACH_INSN_INFO_USE ( base_use , insn_info ) { if ( ! rtx_equal_p ( DF_REF_REG ( base_use ) , base_reg ) ) continue ; struct df_link * base_def_link = DF_REF_CHAIN ( base_use ) ; if ( ! base_def_link || base_def_link -> next ) return false ; if ( DF_REF_IS_ARTIFICIAL ( base_def_link -> ref ) ) return false ; rtx tocrel_insn = DF_REF_INSN ( base_def_link -> ref ) ; rtx tocrel_body = PATTERN ( tocrel_insn ) ; rtx base , offset ; if ( GET_CODE ( tocrel_body ) != SET ) return false ; rtx tocrel_expr = SET_SRC ( tocrel_body ) ; if ( GET_CODE ( tocrel_expr ) == MEM ) tocrel_expr = XEXP ( tocrel_expr , 0 ) ; if ( ! toc_relative_expr_p ( tocrel_expr , false , & tocrel_base , NULL ) ) return false ; split_const ( XVECEXP ( tocrel_base , 0 , 0 ) , & base , & offset ) ; if ( GET_CODE ( base ) != SYMBOL_REF || ! CONSTANT_POOL_ADDRESS_P ( base ) ) return false ; else { rtx const_vector = get_pool_constant ( base ) ; if ( GET_CODE ( const_vector ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( const_vector ) ) const_vector = get_pool_constant ( const_vector ) ; if ( GET_CODE ( const_vector ) != CONST_VECTOR ) return false ; } } } return true ; } </s>

Return TRUE if insn is a swap fed by a load from the constant pool .


<s> unsigned LanaiInstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { if ( MI -> getOpcode ( ) == Lanai :: SW_RI ) if ( MI -> getOperand ( 0 ) . isFI ( ) && MI -> getOperand ( 1 ) . isImm ( ) && MI -> getOperand ( 1 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 0 ) . getIndex ( ) ; return MI -> getOperand ( 2 ) . getReg ( ) ; } return 0 ; } </s>

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


<s>
bool
TVMContinuationsHoist
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
LLVM_DEBUG
(
MF
.
print
(
dbgs
(
)
<<
"Before "
<<
getPassName
(
)
<<
'\n'
,
nullptr
)
)
;
TII
=
MF
.
getSubtarget
<
TVMSubtarget
>
(
)
.
getInstrInfo
(
)
;
MDT
=
&
getAnalysis
<
MachineDominatorTree
>
(
)
;
MRI
=
&
MF
.
getRegInfo
(
)
;
collect
(
MF
)
;
bool
Changed
=
optimize
(
)
;
LLVM_DEBUG
(
{
if
(
Changed
)
MF
.
print
(
dbgs
(
)
<<
"After "
<<
getPassName
(
)
<<
'\n'
,
nullptr
)
;
else
dbgs
(
)
<<
"No changes\n"
;
}
)
;
return
Changed
;
}
</s>

runOnMachineFunction - Emit the function body .

TVM
TVM
"Before "
TVM
"After "
"No changes\n"


<s>
bool
AArch64LegalizerInfo
::
legalizeCustom
(
LegalizerHelper
&
Helper
,
MachineInstr
&
MI
)
const
{
MachineIRBuilder
&
MIRBuilder
=
Helper
.
MIRBuilder
;
MachineRegisterInfo
&
MRI
=
*
MIRBuilder
.
getMRI
(
)
;
GISelChangeObserver
&
Observer
=
Helper
.
Observer
;
switch
(
MI
.
getOpcode
(
)
)
{
default
:
return
false
;
case
TargetOpcode
::
G_VAARG
:
return
legalizeVaArg
(
MI
,
MRI
,
MIRBuilder
)
;
case
TargetOpcode
::
G_LOAD
:
case
TargetOpcode
::
G_STORE
:
return
legalizeLoadStore
(
MI
,
MRI
,
MIRBuilder
,
Observer
)
;
case
TargetOpcode
::
G_BSWAP
:
return
legalizeBSwap
(
MI
,
MRI
,
MIRBuilder
)
;
case
TargetOpcode
::
G_SHL
:
case
TargetOpcode
::
G_ASHR
:
case
TargetOpcode
::
G_LSHR
:
return
legalizeShlAshrLshr
(
MI
,
MRI
,
MIRBuilder
,
Observer
)
;
case
TargetOpcode
::
G_GLOBAL_VALUE
:
return
legalizeSmallCMGlobalValue
(
MI
,
MRI
,
MIRBuilder
,
Observer
)
;
case
TargetOpcode
::
G_TRUNC
:
return
legalizeVectorTrunc
(
MI
,
Helper
)
;
case
TargetOpcode
::
G_SBFX
:
case
TargetOpcode
::
G_UBFX
:
return
legalizeBitfieldExtract
(
MI
,
MRI
,
Helper
)
;
case
TargetOpcode
::
G_ROTR
:
return
legalizeRotate
(
MI
,
MRI
,
Helper
)
;
case
TargetOpcode
::
G_CTPOP
:
return
legalizeCTPOP
(
MI
,
MRI
,
Helper
)
;
case
TargetOpcode
::
G_ATOMIC_CMPXCHG
:
return
legalizeAtomicCmpxchg128
(
MI
,
MRI
,
Helper
)
;
case
TargetOpcode
::
G_CTTZ
:
return
legalizeCTTZ
(
MI
,
Helper
)
;
}
llvm_unreachable
(
"expected switch to return"
)
;
}
</s>

Called for instructions with the Custom LegalizationAction .


<s> const RegisterBankInfo :: InstructionMapping & MipsRegisterBankInfo :: getInstrMapping ( const MachineInstr & MI ) const { unsigned Opc = MI . getOpcode ( ) ; const RegisterBankInfo :: InstructionMapping & Mapping = getInstrMappingImpl ( MI ) ; if ( Mapping . isValid ( ) ) return Mapping ; using namespace TargetOpcode ; unsigned NumOperands = MI . getNumOperands ( ) ; const ValueMapping * OperandsMapping = & Mips :: ValueMappings [ Mips :: GPRIdx ] ; switch ( Opc ) { case G_ADD : OperandsMapping = & Mips :: ValueMappings [ Mips :: GPRIdx ] ; break ; default : return getInvalidInstructionMapping ( ) ; } return getInstructionMapping ( DefaultMappingID , 1 , OperandsMapping , NumOperands ) ; } </s>

Get the mapping of the different operands of MI on the register bank .

Mips Mips Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx 1


<s> bool NVPTXImageOptimizer :: runOnFunction ( Function & F ) { if ( skipFunction ( F ) ) return false ; bool Changed = false ; InstrToDelete . clear ( ) ; for ( Function :: iterator BI = F . begin ( ) , BE = F . end ( ) ; BI != BE ; ++ BI ) { for ( BasicBlock :: iterator I = ( * BI ) . begin ( ) , E = ( * BI ) . end ( ) ; I != E ; ++ I ) { Instruction & Instr = * I ; if ( CallInst * CI = dyn_cast < CallInst > ( I ) ) { Function * CalledF = CI -> getCalledFunction ( ) ; if ( CalledF && CalledF -> isIntrinsic ( ) ) { switch ( CalledF -> getIntrinsicID ( ) ) { default : break ; case Intrinsic :: nvvm_istypep_sampler : Changed |= replaceIsTypePSampler ( Instr ) ; break ; case Intrinsic :: nvvm_istypep_surface : Changed |= replaceIsTypePSurface ( Instr ) ; break ; case Intrinsic :: nvvm_istypep_texture : Changed |= replaceIsTypePTexture ( Instr ) ; break ; } } } } } for ( unsigned i = 0 , e = InstrToDelete . size ( ) ; i != e ; ++ i ) InstrToDelete [ i ] -> eraseFromParent ( ) ; return Changed ; } </s>

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


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


<s>
StringRef
RISCVMCExpr
::
getVariantKindName
(
VariantKind
Kind
)
{
switch
(
Kind
)
{
default
:
llvm_unreachable
(
"Invalid ELF symbol kind"
)
;
case
VK_RISCV_LO
:
return
"lo"
;
case
VK_RISCV_HI
:
return
"hi"
;
case
VK_RISCV_PCREL_LO
:
return
"pcrel_lo"
;
case
VK_RISCV_PCREL_HI
:
return
"pcrel_hi"
;
}
}
</s>

RISCV
RISCV
"Invalid ELF symbol kind"
RISCV
"lo"
RISCV
"hi"
RISCV
"pcrel_lo"
RISCV
"pcrel_hi"


<s> void addIRPasses ( ) override { addPass ( createTGSIAlwaysInlinePass ( ) ) ; addPass ( createAlwaysInlinerLegacyPass ( ) ) ; addPass ( createBarrierNoopPass ( ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>

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


<s> bool isToken ( ) const override { return Kind == Token ; } </s>


"passing %qT to argument %d of %qE, but its"

Finish resolving a function whose final argument can be a vector or a scalar , with the function having an implicit `` _n '' suffix in the latter case . This `` _n '' form might only exist for certain type suffixes . ARGNO is the index of the final argument . The inferred type suffix was obtained from argument FIRST_ARGNO , which has type FIRST_TYPE . EXPECTED_TCLASS and EXPECTED_BITS describe the expected properties of the final vector or scalar argument , in the same way as for require_derived_vector_type . INFERRED_TYPE is the inferred type suffix itself , or NUM_TYPE_SUFFIXES if it 's the same as FIRST_TYPE . Return the function decl of the resolved function on success , otherwise report a suitable error and return error_mark_node .


<s> static void aarch64_init_bf16_types ( void ) { aarch64_bf16_type_node = make_node ( REAL_TYPE ) ; TYPE_PRECISION ( aarch64_bf16_type_node ) = 16 ; SET_TYPE_MODE ( aarch64_bf16_type_node , BFmode ) ; layout_type ( aarch64_bf16_type_node ) ; lang_hooks . types . register_builtin_type ( aarch64_bf16_type_node , "__bf16" ) ; aarch64_bf16_ptr_type_node = build_pointer_type ( aarch64_bf16_type_node ) ; } </s>

Initialize the backend REAL_TYPE type supporting bfloat types .


<s>
const
char
*
getPassName
(
)
const
override
{
return
"AMDGPU Always Inline Pass"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> void cris_expand_return ( bool on_stack ) { emit_jump_insn ( ret_rtx ) ; CRIS_ASSERT ( cfun -> machine -> return_type != CRIS_RETINSN_RET || ! on_stack ) ; CRIS_ASSERT ( cfun -> machine -> return_type != CRIS_RETINSN_JUMP || on_stack ) ; cfun -> machine -> return_type = on_stack ? CRIS_RETINSN_JUMP : CRIS_RETINSN_RET ; } </s>

Expand a return insn ( just one insn ) marked as using SRP or stack slot depending on parameter ON_STACK .


<s> bool ix86_memtag_can_tag_addresses ( ) { return ix86_lam_type != lam_none && TARGET_LP64 ; } </s>


<s> void aarch64_asm_output_alias ( FILE * stream , const tree decl , const tree target ) { const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , 0 ) , 0 ) ; const char * value = IDENTIFIER_POINTER ( target ) ; aarch64_asm_output_variant_pcs ( stream , decl , name ) ; ASM_OUTPUT_DEF ( stream , name , value ) ; } </s>

Implement ASM_OUTPUT_DEF_FROM_DECLS . Output .variant_pcs for aliases .


<s> static bool classof ( const MCExpr * E ) { return E -> getKind ( ) == MCExpr :: Target ; } </s>

Methods for support type inquiry through isa , cast , and dyn_cast :


<s> bool c6x_valid_mask_p ( HOST_WIDE_INT val ) { int i ; for ( i = 0 ; i < 32 ; i ++ ) if ( ! ( val & ( ( unsigned HOST_WIDE_INT ) 1 << i ) ) ) break ; for ( ; i < 32 ; i ++ ) if ( val & ( ( unsigned HOST_WIDE_INT ) 1 << i ) ) break ; for ( ; i < 32 ; i ++ ) if ( ! ( val & ( ( unsigned HOST_WIDE_INT ) 1 << i ) ) ) return false ; return true ; } </s>

Return true if VAL is a mask valid for a clr instruction .


<s> static int sparc_arg_partial_bytes ( cumulative_args_t cum , machine_mode mode , tree type , bool named ) { int slotno , regno , padding ; slotno = function_arg_slotno ( get_cumulative_args ( cum ) , mode , type , named , false , & regno , & padding ) ; if ( slotno == - 1 ) return 0 ; if ( TARGET_ARCH32 ) { const int size = GET_MODE_SIZE ( mode ) ; if ( size > UNITS_PER_WORD && slotno == SPARC_INT_ARG_MAX - 1 ) return UNITS_PER_WORD ; } else { if ( type && AGGREGATE_TYPE_P ( type ) ) { const int size = int_size_in_bytes ( type ) ; if ( size > UNITS_PER_WORD && ( slotno == SPARC_INT_ARG_MAX - 1 || slotno == SPARC_FP_ARG_MAX - 1 ) ) return UNITS_PER_WORD ; } else if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT || ( ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT || ( type && VECTOR_TYPE_P ( type ) ) ) && ! ( TARGET_FPU && named ) ) ) { const int size = ( type && VECTOR_FLOAT_TYPE_P ( type ) ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; if ( size > UNITS_PER_WORD && slotno == SPARC_INT_ARG_MAX - 1 ) return UNITS_PER_WORD ; } else if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT || ( type && VECTOR_TYPE_P ( type ) ) ) { const int size = ( type && VECTOR_FLOAT_TYPE_P ( type ) ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; if ( size > UNITS_PER_WORD && slotno == SPARC_FP_ARG_MAX - 1 ) return UNITS_PER_WORD ; } } return 0 ; } </s>

For an arg passed partly in registers and partly in memory , this is the number of bytes of registers used . For args passed entirely in registers or entirely in memory , zero . Any arg that starts in the first 6 regs but wo n't entirely fit in them needs partial registers on v8 . On v9 , structures with integer values in arg slots 5,6 will be passed in % o5 and SP+176 , and complex fp values that begin in the last fp reg [ where `` last fp reg '' varies with the mode ] will be split between that reg and memory .


<s> rtx legitimize_tls_address ( rtx x , rtx reg ) { rtx dest , tp , label , labelno , sum , ret , eqv , addend ; rtx_insn * insns ; unsigned int model = SYMBOL_REF_TLS_MODEL ( x ) ; switch ( model ) { case TLS_MODEL_GLOBAL_DYNAMIC : if ( TARGET_GNU2_TLS ) { reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_GD32 ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , x ) ; } return dest ; case TLS_MODEL_LOCAL_DYNAMIC : if ( TARGET_GNU2_TLS ) { reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_LDM32 ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , eqv ) ; addend = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 2 , x , GEN_INT ( TLS_LDO32 ) ) , UNSPEC_TLS ) ; addend = force_reg ( SImode , gen_rtx_CONST ( SImode , addend ) ) ; dest = gen_rtx_PLUS ( Pmode , dest , addend ) ; } return dest ; case TLS_MODEL_INITIAL_EXEC : labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 4 , x , GEN_INT ( TLS_IE32 ) , label , GEN_INT ( TARGET_ARM ? 8 : 4 ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ; if ( TARGET_ARM ) emit_insn ( gen_tls_load_dot_plus_eight ( reg , reg , labelno ) ) ; else if ( TARGET_THUMB2 ) emit_insn ( gen_tls_load_dot_plus_four ( reg , NULL , reg , labelno ) ) ; else { emit_insn ( gen_pic_add_dot_plus_four ( reg , reg , labelno ) ) ; emit_move_insn ( reg , gen_const_mem ( SImode , reg ) ) ; } tp = arm_load_tp ( NULL_RTX ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; case TLS_MODEL_LOCAL_EXEC : tp = arm_load_tp ( NULL_RTX ) ; reg = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 2 , x , GEN_INT ( TLS_LE32 ) ) , UNSPEC_TLS ) ; reg = force_reg ( SImode , gen_rtx_CONST ( SImode , reg ) ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; default : abort ( ) ; } } </s>

ADDR contains a thread-local SYMBOL_REF . Generate code to compute this ( thread-local ) address .


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


<s> void TPCPassConfig :: addMachineSSAOptimization ( ) { if ( getOptLevel ( ) > CodeGenOpt :: None ) addPass ( createTPCHWWAGeneral ( ) ) ; TargetPassConfig :: addMachineSSAOptimization ( ) ; if ( getOptLevel ( ) > CodeGenOpt :: None ) { addPass ( createTPCPredicateOptimizer ( ) ) ; addPass ( createTPCSetIndxCoalescer ( ) ) ; addPass ( & DeadMachineInstructionElimID ) ; } } </s>

Methods with trivial inline returns are convenient points in the common codegen pass pipeline where targets may insert passes .


<s> void Note ( SMLoc L , const Twine & Msg , ArrayRef < SMRange > Ranges = None ) { return getParser ( ) . Note ( L , Msg , Ranges ) ; } </s>

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


"instruction use requires an option to be enabled"

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


<s> MachineInstr * WebAssemblyInstrInfo :: commuteInstructionImpl ( MachineInstr * MI , bool NewMI , unsigned OpIdx1 , unsigned OpIdx2 ) const { WebAssemblyFunctionInfo & MFI = * MI -> getParent ( ) -> getParent ( ) -> getInfo < WebAssemblyFunctionInfo > ( ) ; if ( MFI . isVRegStackified ( MI -> getOperand ( OpIdx1 ) . getReg ( ) ) || MFI . isVRegStackified ( MI -> getOperand ( OpIdx2 ) . getReg ( ) ) ) return nullptr ; return TargetInstrInfo :: commuteInstructionImpl ( MI , NewMI , OpIdx1 , OpIdx2 ) ; } </s>

Commutes the operands in the given instruction by changing the operands order and/or changing the instruction 's opcode and/or the immediate value operand .

WebAssembly WebAssembly WebAssembly WebAssembly


"WebAssembly non-variable_ops don't use TSFlags"

"Unexpected floating-point immediate as a non-fixed operand"

"WebAssembly variable_ops floating point ops don't use TSFlags"

Encode the given Inst to bytes and append to CB .


<s>
MachineBasicBlock
::
iterator
AVRFrameLowering
::
eliminateCallFramePseudoInstr
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
)
const
{
const
AVRSubtarget
&
STI
=
MF
.
getSubtarget
<
AVRSubtarget
>
(
)
;
const
AVRInstrInfo
&
TII
=
*
STI
.
getInstrInfo
(
)
;
if
(
hasReservedCallFrame
(
MF
)
)
{
fixStackStores
(
MBB
,
MI
,
TII
,
AVR
::
R29R28
)
;
return
MBB
.
erase
(
MI
)
;
}
DebugLoc
DL
=
MI
->
getDebugLoc
(
)
;
unsigned
int
Opcode
=
MI
->
getOpcode
(
)
;
int
Amount
=
TII
.
getFrameSize
(
*
MI
)
;
if
(
Amount
!=
0
)
{
assert
(
getStackAlign
(
)
==
Align
(
1
)
&&
"Unsupported stack alignment"
)
;
if
(
Opcode
==
TII
.
getCallFrameSetupOpcode
(
)
)
{
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
AVR
::
SPREAD
)
,
AVR
::
R31R30
)
.
addReg
(
AVR
::
SP
)
;
MachineInstr
*
New
=
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
AVR
::
SUBIWRdK
)
,
AVR
::
R31R30
)
.
addReg
(
AVR
::
R31R30
,
RegState
::
Kill
)
.
addImm
(
Amount
)
;
New
->
getOperand
(
3
)
.
setIsDead
(
)
;
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
AVR
::
SPWRITE
)
,
AVR
::
SP
)
.
addReg
(
AVR
::
R31R30
,
RegState
::
Kill
)
;
fixStackStores
(
MBB
,
MI
,
TII
,
AVR
::
R31R30
)
;
}
else
{
assert
(
Opcode
==
TII
.
getCallFrameDestroyOpcode
(
)
)
;
unsigned
addOpcode
;
if
(
isUInt
<
6
>
(
Amount
)
)
{
addOpcode
=
AVR
::
ADIWRdK
;
}
else
{
addOpcode
=
AVR
::
SUBIWRdK
;
Amount
=
Amount
;
}
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
AVR
::
SPREAD
)
,
AVR
::
R31R30
)
.
addReg
(
AVR
::
SP
)
;
MachineInstr
*
New
=
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
addOpcode
)
,
AVR
::
R31R30
)
.
addReg
(
AVR
::
R31R30
,
RegState
::
Kill
)
.
addImm
(
Amount
)
;
New
->
getOperand
(
3
)
.
setIsDead
(
)
;
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
AVR
::
SPWRITE
)
,
AVR
::
SP
)
.
addReg
(
AVR
::
R31R30
,
RegState
::
Kill
)
;
}
}
return
MBB
.
erase
(
MI
)
;
}
</s>

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