<s> static rtx neon_vdup_constant ( rtx vals ) { machine_mode mode = GET_MODE ( vals ) ; machine_mode inner_mode = GET_MODE_INNER ( mode ) ; rtx x ; if ( GET_CODE ( vals ) != CONST_VECTOR || GET_MODE_SIZE ( inner_mode ) > 4 ) return NULL_RTX ; if ( ! const_vec_duplicate_p ( vals , & x ) ) return NULL_RTX ; x = copy_to_mode_reg ( inner_mode , x ) ; return gen_rtx_VEC_DUPLICATE ( mode , x ) ; } </s>

Return a non-NULL RTX iff VALS is a vector constant that can be loaded into a register using VDUP . If this is the case , and GENERATE is set , we also generate instructions to do this and return an RTX to assign to the register .


<s> bool isLiveIn ( int FI ) { for ( unsigned i = 0 , e = LiveInFI . size ( ) ; i < e ; ++ i ) if ( FI == LiveInFI [ i ] ) return true ; return false ; } </s>

Returns true if this VPValue is a live-in , i.e . defined outside the VPlan .


<s> bool spu_legitimate_constant_p ( machine_mode mode , rtx x ) { subrtx_iterator :: array_type array ; if ( GET_CODE ( x ) == HIGH ) x = XEXP ( x , 0 ) ; FOR_EACH_SUBRTX ( iter , array , x , ALL ) if ( ea_symbol_ref_p ( * iter ) ) return 0 ; if ( ! flag_pic && mode == V4SImode && ( GET_CODE ( CONST_VECTOR_ELT ( x , 0 ) ) == SYMBOL_REF || GET_CODE ( CONST_VECTOR_ELT ( x , 0 ) ) == LABEL_REF || GET_CODE ( CONST_VECTOR_ELT ( x , 0 ) ) == CONST ) ) return const_vec_duplicate_p ( x ) ; if ( GET_CODE ( x ) == CONST_VECTOR && ! const_vector_immediate_p ( x ) ) return 0 ; return 1 ; } </s>

We accept : - any 32-bit constant ( SImode , SFmode ) - any constant that can be generated with fsmbi ( any mode ) - a 64-bit constant where the high and low bits are identical ( DImode , DFmode ) - a 128-bit constant where the four 32-bit words match .


"Return from a call instruction in the loop."

NULL if INSN insn is valid within a low-overhead loop . Otherwise return why doloop can not be applied .


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { if ( skipFunction ( MF . getFunction ( ) ) ) return false ; TII = MF . getSubtarget ( ) . getInstrInfo ( ) ; bool Changed = false ; if ( MF . size ( ) < 2 ) return Changed ; for ( MachineBasicBlock & B : llvm :: make_early_inc_range ( MF ) ) Changed |= processBlock ( B ) ; return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool GBZ80TargetLowering :: CanLowerReturn ( CallingConv :: ID CallConv , MachineFunction & MF , bool isVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , LLVMContext & Context ) const { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , MF , RVLocs , Context ) ; auto CCFunction = CCAssignFnForReturn ( CallConv ) ; return CCInfo . CheckReturn ( Outs , CCFunction ) ; } </s>

This hook should be implemented to check whether the return values described by the Outs array can fit into the return registers .


<s> struct rtx_def * m88k_builtin_saveregs ( ) { rtx addr ; tree fntype = TREE_TYPE ( current_function_decl ) ; int argadj = ( ( ! ( TYPE_ARG_TYPES ( fntype ) != 0 && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) ) ? - UNITS_PER_WORD : 0 ) + UNITS_PER_WORD - 1 ; int fixed ; variable_args_p = 1 ; fixed = 0 ; if ( GET_CODE ( current_function_arg_offset_rtx ) == CONST_INT ) fixed = ( ( INTVAL ( current_function_arg_offset_rtx ) + argadj ) / UNITS_PER_WORD ) ; addr = assign_stack_local ( BLKmode , 8 * UNITS_PER_WORD , - 1 ) ; set_mem_alias_set ( addr , get_varargs_alias_set ( ) ) ; RTX_UNCHANGING_P ( addr ) = 1 ; RTX_UNCHANGING_P ( XEXP ( addr , 0 ) ) = 1 ; if ( fixed < 8 ) move_block_from_reg ( 2 + fixed , adjust_address ( addr , Pmode , fixed * UNITS_PER_WORD ) , 8 - fixed , UNITS_PER_WORD * ( 8 - fixed ) ) ; return XEXP ( addr , 0 ) ; } </s>

Do what is necessary for ` va_start ' . We look at the current function to determine if stdargs or varargs is used and spill as necessary . We return a pointer to the spill area .


"Pseudo opcode found in EmitInstruction()"

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


<s> bool HexagonInstrInfo :: isPostIncrement ( const MachineInstr * MI ) const { return ( getAddrMode ( MI ) == HexagonII :: PostInc ) ; } </s>

Return true for post-incremented instructions .


<s> static rtx loongarch_got_load_tls_ld ( rtx dest , rtx sym ) { return gen_got_load_tls_ld ( Pmode , dest , sym ) ; } </s>

Load an entry from the GOT for a TLS LD access .


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


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

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


<s> static bool shadow_p ( rtx_insn * insn ) { if ( ! NONDEBUG_INSN_P ( insn ) || recog_memoized ( insn ) < 0 ) return false ; return shadow_type_p ( get_attr_type ( insn ) ) ; } </s>

Return true iff INSN is a shadow pattern .


<s> unsigned XtensaMCCodeEmitter :: getMachineOpValue ( const MCInst & MI , const MCOperand & MO , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { if ( MO . isReg ( ) ) return MRI . getEncodingValue ( MO . getReg ( ) ) ; if ( MO . isImm ( ) ) return static_cast < unsigned > ( MO . getImm ( ) ) ; assert ( MO . isExpr ( ) ) ; const MCExpr * Expr = MO . getExpr ( ) ; assert ( Expr -> getKind ( ) == MCExpr :: SymbolRef ) ; llvm :: errs ( ) << "Crap\n" ; return 0 ; } </s>

getMachineOpValue - Return binary encoding of operand .


<s> virtual bool check ( MachineBasicBlock & BB , const MachineInstr & MI ) const { return MI . getNumOperands ( ) >= 1 && MI . getOpcode ( ) == Opc1 ; } </s>

Check if the constraints are satisfiable .


<s> void EmitRaw ( const SmallVectorImpl < uint8_t > & Opcodes ) { Ops . insert ( Ops . end ( ) , Opcodes . begin ( ) , Opcodes . end ( ) ) ; OpBegins . push_back ( OpBegins . back ( ) + Opcodes . size ( ) ) ; } </s>


<s> void Cpu0MCInstLower :: Initialize ( Mangler * M , MCContext * C ) { Mang = M ; Ctx = C ; } </s>

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


<s> static const char * get_some_local_dynamic_name ( void ) { rtx insn ; if ( cfun -> machine -> some_ld_name ) return cfun -> machine -> some_ld_name ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && for_each_rtx ( & PATTERN ( insn ) , get_some_local_dynamic_name_1 , 0 ) ) return cfun -> machine -> some_ld_name ; gcc_unreachable ( ) ; } </s>

Locate some local-dynamic symbol still in use by this function so that we can print its name in local-dynamic base patterns .


<s> BitVector CAHPRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; markSuperRegs ( Reserved , CAHP :: X0 ) ; markSuperRegs ( Reserved , CAHP :: X1 ) ; markSuperRegs ( Reserved , CAHP :: X2 ) ; 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 .


<s> bool HexagonTargetLowering :: mayBeEmittedAsTailCall ( CallInst * CI ) const { if ( ! CI -> isTailCall ( ) || HTM . Options . DisableTailCalls ) return false ; return true ; } </s>

Return true if the target may be able emit the call instruction as a tail call .


<s>
const
RegisterBank
&
AArch64RegisterBankInfo
::
getRegBankFromRegClass
(
const
TargetRegisterClass
&
RC
)
const
{
switch
(
RC
.
getID
(
)
)
{
case
AArch64
::
FPR8RegClassID
:
case
AArch64
::
FPR16RegClassID
:
case
AArch64
::
FPR32RegClassID
:
case
AArch64
::
FPR64RegClassID
:
case
AArch64
::
FPR128RegClassID
:
case
AArch64
::
FPR128_loRegClassID
:
case
AArch64
::
DDRegClassID
:
case
AArch64
::
DDDRegClassID
:
case
AArch64
::
DDDDRegClassID
:
case
AArch64
::
QQRegClassID
:
case
AArch64
::
QQQRegClassID
:
case
AArch64
::
QQQQRegClassID
:
return
getRegBank
(
AArch64
::
FPRRegBankID
)
;
case
AArch64
::
GPR32commonRegClassID
:
case
AArch64
::
GPR32RegClassID
:
case
AArch64
::
GPR32spRegClassID
:
case
AArch64
::
GPR32sponlyRegClassID
:
case
AArch64
::
GPR32allRegClassID
:
case
AArch64
::
GPR64commonRegClassID
:
case
AArch64
::
GPR64RegClassID
:
case
AArch64
::
GPR64spRegClassID
:
case
AArch64
::
GPR64sponlyRegClassID
:
case
AArch64
::
GPR64allRegClassID
:
case
AArch64
::
tcGPR64RegClassID
:
case
AArch64
::
WSeqPairsClassRegClassID
:
case
AArch64
::
XSeqPairsClassRegClassID
:
return
getRegBank
(
AArch64
::
GPRRegBankID
)
;
case
AArch64
::
CCRRegClassID
:
return
getRegBank
(
AArch64
::
CCRRegBankID
)
;
default
:
llvm_unreachable
(
"Register class not supported"
)
;
}
}
</s>


<s> bool ARCRegisterInfo :: requiresRegisterScavenging ( const MachineFunction & MF ) const { return true ; } </s>

Returns true if the target requires ( and can make use of ) the register scavenger .


<s> static int mips_symbol_insns ( enum mips_symbol_type type , machine_mode mode ) { if ( mode != MAX_MACHINE_MODE && MSA_SUPPORTED_MODE_P ( mode ) ) return 0 ; return mips_symbol_insns_1 ( type , mode ) * ( TARGET_MIPS16 ? 2 : 1 ) ; } </s>

Return the number of instructions needed to load a symbol of the given type into a register . If valid in an address , the same number of instructions are needed for loads and stores . Treat extended mips16 instructions as two instructions .


<s> static unsigned int num_occurences_in_str ( char c , char * str ) { unsigned int res = 0 ; while ( * str != '\0' ) { if ( * str == c ) res ++ ; str ++ ; } return res ; } </s>

Count how many times the character C appears in NULL-terminated string STR .


<s> bool avr_popcount_each_byte ( rtx xval , int n_bytes , int pop_mask ) { machine_mode mode = GET_MODE ( xval ) ; if ( VOIDmode == mode ) mode = SImode ; for ( int i = 0 ; i < n_bytes ; i ++ ) { rtx xval8 = simplify_gen_subreg ( QImode , xval , mode , i ) ; unsigned int val8 = UINTVAL ( xval8 ) & GET_MODE_MASK ( QImode ) ; if ( ( pop_mask & ( 1 << popcount_hwi ( val8 ) ) ) == 0 ) return false ; } return true ; } </s>

Constraint helper function . XVAL is a CONST_INT or a CONST_DOUBLE . Return true if the least significant N_BYTES bytes of XVAL all have a popcount in POP_MASK and false , otherwise . POP_MASK represents a subset of integers which contains an integer N iff bit N of POP_MASK is set .


<s>
bool
HexagonExpandCondsets
::
split
(
MachineInstr
&
MI
,
std
::
set
<
unsigned
>
&
UpdRegs
)
{
if
(
TfrLimitActive
)
{
if
(
TfrCounter
>=
TfrLimit
)
return
false
;
TfrCounter
++
;
}
DEBUG
(
dbgs
(
)
<<
"\nsplitting BB#"
<<
MI
.
getParent
(
)
->
getNumber
(
)
<<
": "
<<
MI
)
;
MachineOperand
&
MD
=
MI
.
getOperand
(
0
)
;
MachineOperand
&
MP
=
MI
.
getOperand
(
1
)
;
assert
(
MD
.
isDef
(
)
)
;
unsigned
DR
=
MD
.
getReg
(
)
,
DSR
=
MD
.
getSubReg
(
)
;
bool
ReadUndef
=
MD
.
isUndef
(
)
;
MachineBasicBlock
::
iterator
At
=
MI
;
auto
updateRegs
=
[
&
UpdRegs
]
(
const
MachineInstr
&
MI
)
->
void
{
for
(
auto
&
Op
:
MI
.
operands
(
)
)
if
(
Op
.
isReg
(
)
)
UpdRegs
.
insert
(
Op
.
getReg
(
)
)
;
}
;
MachineOperand
&
ST
=
MI
.
getOperand
(
2
)
;
MachineOperand
&
SF
=
MI
.
getOperand
(
3
)
;
if
(
ST
.
isReg
(
)
&&
SF
.
isReg
(
)
)
{
RegisterRef
RT
(
ST
)
;
if
(
RT
==
RegisterRef
(
SF
)
)
{
updateRegs
(
MI
)
;
MI
.
setDesc
(
HII
->
get
(
TargetOpcode
::
COPY
)
)
;
unsigned
S
=
getRegState
(
ST
)
;
while
(
MI
.
getNumOperands
(
)
>
1
)
MI
.
RemoveOperand
(
MI
.
getNumOperands
(
)
1
)
;
MachineFunction
&
MF
=
*
MI
.
getParent
(
)
->
getParent
(
)
;
MachineInstrBuilder
(
MF
,
MI
)
.
addReg
(
RT
.
Reg
,
S
,
RT
.
Sub
)
;
return
true
;
}
}
MachineInstr
*
TfrT
=
genCondTfrFor
(
ST
,
At
,
DR
,
DSR
,
MP
,
true
,
ReadUndef
,
false
)
;
MachineInstr
*
TfrF
=
genCondTfrFor
(
SF
,
At
,
DR
,
DSR
,
MP
,
false
,
ReadUndef
,
true
)
;
LIS
->
InsertMachineInstrInMaps
(
*
TfrT
)
;
LIS
->
InsertMachineInstrInMaps
(
*
TfrF
)
;
updateRegs
(
MI
)
;
removeInstr
(
MI
)
;
return
true
;
}
</s>

Split into substrings around the occurrences of a separator character .


<s> bool SITargetLowering :: isFreeAddrSpaceCast ( unsigned SrcAS , unsigned DestAS ) const { if ( SrcAS == AMDGPUAS :: FLAT_ADDRESS ) return true ; const GCNTargetMachine & TM = static_cast < const GCNTargetMachine & > ( getTargetMachine ( ) ) ; return TM . isNoopAddrSpaceCast ( SrcAS , DestAS ) ; } </s>

Returns true if a cast from SrcAS to DestAS is `` cheap '' , such that e.g .


<s> bool AArch64AsmParser :: ParseDirective ( AsmToken DirectiveID ) { const MCObjectFileInfo :: Environment Format = getContext ( ) . getObjectFileInfo ( ) -> getObjectFileType ( ) ; bool IsMachO = Format == MCObjectFileInfo :: IsMachO ; bool IsCOFF = Format == MCObjectFileInfo :: IsCOFF ; StringRef IDVal = DirectiveID . getIdentifier ( ) ; SMLoc Loc = DirectiveID . getLoc ( ) ; if ( IDVal == ".cpu" ) return parseDirectiveCPU ( Loc ) ; if ( IDVal == ".hword" ) return parseDirectiveWord ( 2 , Loc ) ; if ( IDVal == ".word" ) return parseDirectiveWord ( 4 , Loc ) ; if ( IDVal == ".xword" ) return parseDirectiveWord ( 8 , Loc ) ; if ( IDVal == ".tlsdesccall" ) return parseDirectiveTLSDescCall ( Loc ) ; if ( IDVal == ".ltorg" || IDVal == ".pool" ) return parseDirectiveLtorg ( Loc ) ; if ( IDVal == ".unreq" ) return parseDirectiveUnreq ( Loc ) ; if ( ! IsMachO && ! IsCOFF ) { if ( IDVal == ".inst" ) return parseDirectiveInst ( Loc ) ; } return parseDirectiveLOH ( IDVal , Loc ) ; } </s>

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


<s> static void cris_conditional_register_usage ( void ) { if ( TARGET_HAS_MUL_INSNS ) fixed_regs [ CRIS_MOF_REGNUM ] = 0 ; if ( cris_cpu_version < 8 ) reg_names [ CRIS_CC0_REGNUM ] = "ccr" ; } </s>


<s> bool GBZ80PreEmit :: runOnMachineFunction ( MachineFunction & MF ) { bool Modified = false ; const GBZ80Subtarget & STI = MF . getSubtarget < GBZ80Subtarget > ( ) ; TRI = STI . getRegisterInfo ( ) ; TII = STI . getInstrInfo ( ) ; return Modified ; } </s>

runOnMachineFunction - Emit the function body .


<s> static int shiftr_zero ( HOST_WIDE_INT * v ) { unsigned HOST_WIDE_INT tmp = * v ; unsigned HOST_WIDE_INT sgn ; int n = 0 ; if ( tmp == 0 ) return 0 ; sgn = tmp & ( ( unsigned HOST_WIDE_INT ) 1 << ( HOST_BITS_PER_WIDE_INT - 1 ) ) ; while ( ( tmp & 0x1 ) == 0 && n <= 32 ) { tmp = ( tmp >> 1 ) | sgn ; n ++ ; } * v = tmp ; return n ; } </s>

Returns the number of consecutive least significant zeros in the binary representation of * V. We modify * V to contain the original value arithmetically shifted right by the number of zeroes .


<s> void SparcFrameLowering :: emitPrologue ( MachineFunction & MF ) const { } </s>

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


<s> void MipsPassConfig :: addPreEmitPass ( ) { addPass ( createMicroMipsSizeReductionPass ( ) ) ; addPass ( createMipsDelaySlotFillerPass ( ) ) ; addPass ( createMipsHazardSchedule ( ) ) ; addPass ( createMipsLongBranchPass ( ) ) ; addPass ( createMipsConstantIslandPass ( ) ) ; } </s>

This pass may be implemented by targets that want to run passes immediately before machine code is emitted .


<s> static unsigned int h8300_length_from_table ( rtx op1 , rtx op2 , const h8300_length_table * table ) { enum h8300_operand_class op1_class , op2_class ; unsigned int size , immediate_length ; size = GET_MODE_SIZE ( GET_MODE ( op1 ) ) ; immediate_length = ( h8300_classify_operand ( op1 , size , & op1_class ) + h8300_classify_operand ( op2 , size , & op2_class ) ) ; return immediate_length + ( * table ) [ op1_class - 1 ] [ op2_class ] ; } </s>

Return the length of the instruction described by TABLE given that its operands are OP1 and OP2 . OP1 must be an h8300_dst_operand and OP2 must be an h8300_src_operand .


<s> const MCExpr * M680x0TargetLowering :: getPICJumpTableRelocBaseExpr ( const MachineFunction * MF , unsigned JTI , MCContext & Ctx ) const { return MCSymbolRefExpr :: create ( MF -> getJTISymbol ( JTI , Ctx ) , Ctx ) ; } </s>

This returns the relocation base for the given PIC jumptable , the same as getPICJumpTableRelocBase , but as an MCExpr .


<s> bool GCNTTIImpl :: areInlineCompatible ( const Function * Caller , const Function * Callee ) const { const TargetMachine & TM = getTLI ( ) -> getTargetMachine ( ) ; const GCNSubtarget * CallerST = static_cast < const GCNSubtarget * > ( TM . getSubtargetImpl ( * Caller ) ) ; const GCNSubtarget * CalleeST = static_cast < const GCNSubtarget * > ( TM . getSubtargetImpl ( * Callee ) ) ; const FeatureBitset & CallerBits = CallerST -> getFeatureBits ( ) ; const FeatureBitset & CalleeBits = CalleeST -> getFeatureBits ( ) ; FeatureBitset RealCallerBits = CallerBits & ~ InlineFeatureIgnoreList ; FeatureBitset RealCalleeBits = CalleeBits & ~ InlineFeatureIgnoreList ; if ( ( RealCallerBits & RealCalleeBits ) != RealCalleeBits ) return false ; AMDGPU :: SIModeRegisterDefaults CallerMode ( * Caller , * CallerST ) ; AMDGPU :: SIModeRegisterDefaults CalleeMode ( * Callee , * CalleeST ) ; return CallerMode . isInlineCompatible ( CalleeMode ) ; } </s>

Determine whether a callee with the given TLI can be inlined into caller with this TLI , based on 'nobuiltin ' attributes .


<s> unsigned char ARM64Subtarget :: ClassifyGlobalReference ( const GlobalValue * GV , const TargetMachine & TM ) const { bool isDecl = GV -> hasAvailableExternallyLinkage ( ) ; if ( GV -> isDeclaration ( ) && ! GV -> isMaterializable ( ) ) isDecl = true ; if ( TM . getCodeModel ( ) == CodeModel :: Large && isTargetMachO ( ) ) return ARM64II :: MO_GOT ; if ( TM . getCodeModel ( ) == CodeModel :: Small && GV -> isWeakForLinker ( ) && isDecl ) return ARM64II :: MO_GOT ; if ( TM . getRelocationModel ( ) != Reloc :: Static && GV -> hasDefaultVisibility ( ) ) { if ( isTargetMachO ( ) ) return ( isDecl || GV -> isWeakForLinker ( ) ) ? ARM64II :: MO_GOT : ARM64II :: MO_NO_FLAG ; else return GV -> hasLocalLinkage ( ) ? ARM64II :: MO_NO_FLAG : ARM64II :: MO_GOT ; } return ARM64II :: MO_NO_FLAG ; } </s>

ClassifyGlobalReference - Find the target operand flags that describe how a global value should be referenced for the current subtarget .


<s> const DataLayout * getDataLayout ( ) const override { return & DL ; } </s>

Return the DataLayout associated with the module this SCEV instance is operating on .


<s> static bool aarch64_evpc_uzp ( struct expand_vec_perm_d * d ) { unsigned int i , odd , mask , nelt = d -> nelt ; rtx out , in0 , in1 , x ; rtx ( * gen ) ( rtx , rtx , rtx ) ; machine_mode vmode = d -> vmode ; if ( GET_MODE_UNIT_SIZE ( vmode ) > 8 ) return false ; if ( d -> perm [ 0 ] == 0 ) odd = 0 ; else if ( d -> perm [ 0 ] == 1 ) odd = 1 ; else return false ; mask = ( d -> one_vector_p ? nelt - 1 : 2 * nelt - 1 ) ; for ( i = 0 ; i < nelt ; i ++ ) { unsigned elt = ( i * 2 + odd ) & mask ; if ( d -> perm [ i ] != elt ) return false ; } if ( d -> testing_p ) return true ; in0 = d -> op0 ; in1 = d -> op1 ; if ( BYTES_BIG_ENDIAN ) { x = in0 , in0 = in1 , in1 = x ; odd = ! odd ; } out = d -> target ; if ( odd ) { switch ( vmode ) { case V16QImode : gen = gen_aarch64_uzp2v16qi ; break ; case V8QImode : gen = gen_aarch64_uzp2v8qi ; break ; case V8HImode : gen = gen_aarch64_uzp2v8hi ; break ; case V4HImode : gen = gen_aarch64_uzp2v4hi ; break ; case V4SImode : gen = gen_aarch64_uzp2v4si ; break ; case V2SImode : gen = gen_aarch64_uzp2v2si ; break ; case V2DImode : gen = gen_aarch64_uzp2v2di ; break ; case V4HFmode : gen = gen_aarch64_uzp2v4hf ; break ; case V8HFmode : gen = gen_aarch64_uzp2v8hf ; break ; case V4SFmode : gen = gen_aarch64_uzp2v4sf ; break ; case V2SFmode : gen = gen_aarch64_uzp2v2sf ; break ; case V2DFmode : gen = gen_aarch64_uzp2v2df ; break ; default : return false ; } } else { switch ( vmode ) { case V16QImode : gen = gen_aarch64_uzp1v16qi ; break ; case V8QImode : gen = gen_aarch64_uzp1v8qi ; break ; case V8HImode : gen = gen_aarch64_uzp1v8hi ; break ; case V4HImode : gen = gen_aarch64_uzp1v4hi ; break ; case V4SImode : gen = gen_aarch64_uzp1v4si ; break ; case V2SImode : gen = gen_aarch64_uzp1v2si ; break ; case V2DImode : gen = gen_aarch64_uzp1v2di ; break ; case V4HFmode : gen = gen_aarch64_uzp1v4hf ; break ; case V8HFmode : gen = gen_aarch64_uzp1v8hf ; break ; case V4SFmode : gen = gen_aarch64_uzp1v4sf ; break ; case V2SFmode : gen = gen_aarch64_uzp1v2sf ; break ; case V2DFmode : gen = gen_aarch64_uzp1v2df ; break ; default : return false ; } } emit_insn ( gen ( out , in0 , in1 ) ) ; return true ; } </s>

Recognize patterns suitable for the UZP instructions .


<s> static void ia64_emit_insn_before ( rtx insn , rtx_insn * before ) { emit_insn_before ( insn , before ) ; } </s>

Like emit_insn_before , but skip cycle_display insns . This makes the assembly output a bit prettier .


<s>
void
GCNUpwardRPTracker
::
recede
(
const
MachineInstr
&
MI
)
{
assert
(
MRI
&&
"call reset first"
)
;
LastTrackedMI
=
&
MI
;
if
(
MI
.
isDebugInstr
(
)
)
return
;
auto
const
RegUses
=
collectVirtualRegUses
(
MI
,
LIS
,
*
MRI
)
;
auto
AtMIPressure
=
CurPressure
;
for
(
const
auto
&
U
:
RegUses
)
{
auto
LiveMask
=
LiveRegs
[
U
.
RegUnit
]
;
AtMIPressure
.
inc
(
U
.
RegUnit
,
LiveMask
,
LiveMask
|
U
.
LaneMask
,
*
MRI
)
;
}
MaxPressure
=
max
(
AtMIPressure
,
MaxPressure
)
;
for
(
const
auto
&
MO
:
MI
.
defs
(
)
)
{
if
(
!
MO
.
isReg
(
)
||
!
TargetRegisterInfo
::
isVirtualRegister
(
MO
.
getReg
(
)
)
||
MO
.
isDead
(
)
)
continue
;
auto
Reg
=
MO
.
getReg
(
)
;
auto
I
=
LiveRegs
.
find
(
Reg
)
;
if
(
I
==
LiveRegs
.
end
(
)
)
continue
;
auto
&
LiveMask
=
I
->
second
;
auto
PrevMask
=
LiveMask
;
LiveMask
&=
~
getDefRegMask
(
MO
,
*
MRI
)
;
CurPressure
.
inc
(
Reg
,
PrevMask
,
LiveMask
,
*
MRI
)
;
if
(
LiveMask
.
(
)
)
LiveRegs
.
erase
(
I
)
;
}
for
(
const
auto
&
U
:
RegUses
)
{
auto
&
LiveMask
=
LiveRegs
[
U
.
RegUnit
]
;
auto
PrevMask
=
LiveMask
;
LiveMask
|=
U
.
LaneMask
;
CurPressure
.
inc
(
U
.
RegUnit
,
PrevMask
,
LiveMask
,
*
MRI
)
;
}
assert
(
CurPressure
==
getRegPressure
(
*
MRI
,
LiveRegs
)
)
;
}
</s>

Recede across the previous instruction .


<s> static rtx nvptx_libcall_value ( machine_mode mode , const_rtx ) { if ( ! cfun || ! cfun -> machine -> doing_call ) return gen_rtx_REG ( mode , NVPTX_RETURN_REGNUM ) ; return gen_reg_rtx ( mode ) ; } </s>


<s> const MCPhysReg * AArch64RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { return CSR_PCS_SaveList ; } </s>


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

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


"failed to spill SGPR to VGPR when allocated"

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


"LowerFormalArguments Unhandled argument type: "

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


"MMIX Internal: This is not a recognized address"


<s>
static
X86Operand
CreateMem
(
unsigned
SegReg
,
MCValue
Disp
,
unsigned
BaseReg
,
unsigned
IndexReg
,
unsigned
Scale
)
{
assert
(
(
SegReg
||
BaseReg
||
IndexReg
)
&&
"Invalid memory operand!"
)
;
assert
(
(
(
Scale
==
1
||
Scale
==
2
||
Scale
==
4
||
Scale
==
8
)
)
&&
"Invalid scale!"
)
;
X86Operand
Res
;
Res
.
Kind
=
Memory
;
Res
.
Mem
.
SegReg
=
SegReg
;
Res
.
Mem
.
Disp
=
Disp
;
Res
.
Mem
.
BaseReg
=
BaseReg
;
Res
.
Mem
.
IndexReg
=
IndexReg
;
Res
.
Mem
.
Scale
=
Scale
;
return
Res
;
}
</s>


<s> rtx mt_function_value ( tree valtype , enum machine_mode mode , tree func_decl ATTRIBUTE_UNUSED ) { if ( ( mode ) == DImode || ( mode ) == DFmode ) return gen_rtx_MEM ( mode , gen_rtx_REG ( mode , RETURN_VALUE_REGNUM ) ) ; if ( valtype ) mode = TYPE_MODE ( valtype ) ; return gen_rtx_REG ( mode , RETURN_VALUE_REGNUM ) ; } </s>

Handle FUNCTION_VALUE , FUNCTION_OUTGOING_VALUE , and LIBCALL_VALUE macros .


<s> M68kSubtarget :: M68kSubtarget ( const Triple & TT , StringRef CPU , StringRef FS , const M68kTargetMachine & TM ) : M68kGenSubtargetInfo ( TT , CPU , CPU , FS ) , UserReservedRegister ( M68k :: NUM_TARGET_REGS ) , TM ( TM ) , TSInfo ( ) , InstrInfo ( initializeSubtargetDependencies ( CPU , TT , FS , TM ) ) , FrameLowering ( * this , this -> getStackAlignment ( ) ) , TLInfo ( TM , * this ) , TargetTriple ( TT ) { } </s>

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


<s>
void
MSP430AsmBackend
::
applyFixup
(
const
MCAssembler
&
Asm
,
const
MCFixup
&
Fixup
,
const
MCValue
&
Target
,
MutableArrayRef
<
char
>
Data
,
uint64_t
Value
,
bool
IsResolved
,
const
MCSubtargetInfo
*
STI
)
const
{
Value
=
adjustFixupValue
(
Fixup
,
Value
,
Asm
.
getContext
(
)
)
;
MCFixupKindInfo
Info
=
getFixupKindInfo
(
Fixup
.
getKind
(
)
)
;
if
(
!
Value
)
return
;
Value
<<=
Info
.
TargetOffset
;
unsigned
Offset
=
Fixup
.
getOffset
(
)
;
unsigned
NumBytes
=
alignTo
(
Info
.
TargetSize
+
Info
.
TargetOffset
,
8
)
/
8
;
assert
(
Offset
+
NumBytes
<=
Data
.
size
(
)
&&
"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> static rtx ix86_erase_embedded_rounding ( rtx pat ) { if ( GET_CODE ( pat ) == INSN ) pat = PATTERN ( pat ) ; gcc_assert ( GET_CODE ( pat ) == SET ) ; rtx src = SET_SRC ( pat ) ; gcc_assert ( XVECLEN ( src , 0 ) == 2 ) ; rtx p0 = XVECEXP ( src , 0 , 0 ) ; gcc_assert ( GET_CODE ( src ) == UNSPEC && XINT ( src , 1 ) == UNSPEC_EMBEDDED_ROUNDING ) ; rtx res = gen_rtx_SET ( SET_DEST ( pat ) , p0 ) ; return res ; } </s>

Transform pattern of following layout : ( parallel [ set ( A B ) ( unspec [ C ] UNSPEC_EMBEDDED_ROUNDING ) ] ) ] ) into : ( set ( A B ) ) Or : ( parallel [ A B ... ( unspec [ C ] UNSPEC_EMBEDDED_ROUNDING ) ... ] ) into : ( parallel [ A B ... ] )


<s> void func_fma_steering :: analyze ( ) { int i , n_blocks , * bb_dfs_preorder ; basic_block bb ; rtx_insn * insn ; bb_dfs_preorder = XNEWVEC ( int , last_basic_block_for_fn ( cfun ) ) ; n_blocks = pre_and_rev_post_order_compute ( bb_dfs_preorder , NULL , false ) ; for ( i = 0 ; i < n_blocks ; i ++ ) { bb = BASIC_BLOCK_FOR_FN ( cfun , bb_dfs_preorder [ i ] ) ; FOR_BB_INSNS ( bb , insn ) { operand_rr_info * dest_op_info ; struct du_chain * chain = NULL ; unsigned dest_regno ; fma_forest * forest = NULL ; du_head_p head = NULL ; int i ; if ( ! is_fmul_fmac_insn ( insn , true ) ) continue ; dest_op_info = insn_rr [ INSN_UID ( insn ) ] . op_info ; dest_regno = REGNO ( SET_DEST ( PATTERN ( insn ) ) ) ; for ( i = 0 ; i < dest_op_info -> n_chains ; i ++ ) { if ( dest_op_info -> heads [ i ] -> regno != dest_regno ) continue ; head = dest_op_info -> heads [ i ] ; if ( ! head -> first ) head = regrename_chain_from_id ( head -> id ) ; forest = NULL ; for ( chain = head -> first ; chain ; chain = chain -> next_use ) { fma_node * * fma_slot ; if ( ! is_fmul_fmac_insn ( chain -> insn , true ) ) continue ; if ( chain -> loc != & SET_DEST ( PATTERN ( chain -> insn ) ) ) continue ; if ( chain -> insn == insn ) break ; fma_slot = this -> m_insn_fma_head_map -> get ( chain -> insn ) ; if ( fma_slot && ( * fma_slot ) -> get_children ( ) ) forest = ( * fma_slot ) -> get_forest ( ) ; } if ( chain ) break ; } if ( i < dest_op_info -> n_chains ) this -> analyze_fma_fmul_insn ( forest , chain , head ) ; } } free ( bb_dfs_preorder ) ; if ( dump_file ) this -> dfs ( dump_forest_info , dump_tree_root_info , dump_tree_node_info , false ) ; } </s>

Count how many times each regno is referenced as base address for a memory access .


<s>
unsigned
HexagonInstrInfo
::
createVR
(
MachineFunction
*
MF
,
MVT
VT
)
const
{
MachineRegisterInfo
&
MRI
=
MF
->
getRegInfo
(
)
;
const
TargetRegisterClass
*
TRC
;
if
(
VT
==
MVT
::
i1
)
{
TRC
=
&
Hexagon
::
PredRegsRegClass
;
}
else
if
(
VT
==
MVT
::
i32
||
VT
==
MVT
::
f32
)
{
TRC
=
&
Hexagon
::
IntRegsRegClass
;
}
else
if
(
VT
==
MVT
::
i64
||
VT
==
MVT
::
f64
)
{
TRC
=
&
Hexagon
::
DoubleRegsRegClass
;
}
else
{
llvm_unreachable
(
"Cannot handle this register class"
)
;
}
unsigned
NewReg
=
MRI
.
createVirtualRegister
(
TRC
)
;
return
NewReg
;
}
</s>


<s>
bool
SIInstrInfo
::
analyzeBranch
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
*
&
TBB
,
MachineBasicBlock
*
&
FBB
,
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
bool
AllowModify
)
const
{
MachineBasicBlock
::
iterator
I
=
MBB
.
getFirstTerminator
(
)
;
auto
E
=
MBB
.
end
(
)
;
if
(
I
==
E
)
return
false
;
while
(
I
!=
E
&&
!
I
->
isBranch
(
)
&&
!
I
->
isReturn
(
)
&&
I
->
getOpcode
(
)
!=
AMDGPU
::
SI_MASK_BRANCH
)
{
switch
(
I
->
getOpcode
(
)
)
{
case
AMDGPU
::
SI_MASK_BRANCH
:
case
AMDGPU
::
S_MOV_B64_term
:
case
AMDGPU
::
S_XOR_B64_term
:
case
AMDGPU
::
S_ANDN2_B64_term
:
case
AMDGPU
::
S_MOV_B32_term
:
case
AMDGPU
::
S_XOR_B32_term
:
case
AMDGPU
::
S_OR_B32_term
:
case
AMDGPU
::
S_ANDN2_B32_term
:
break
;
case
AMDGPU
::
SI_IF
:
case
AMDGPU
::
SI_ELSE
:
case
AMDGPU
::
SI_KILL_I1_TERMINATOR
:
case
AMDGPU
::
SI_KILL_F32_COND_IMM_TERMINATOR
:
return
true
;
default
:
llvm_unreachable
(
"unexpected non-branch terminator inst"
)
;
}
++
I
;
}
if
(
I
==
E
)
return
false
;
if
(
I
->
getOpcode
(
)
!=
AMDGPU
::
SI_MASK_BRANCH
)
return
analyzeBranchImpl
(
MBB
,
I
,
TBB
,
FBB
,
Cond
,
AllowModify
)
;
++
I
;
if
(
I
==
MBB
.
end
(
)
)
return
true
;
if
(
analyzeBranchImpl
(
MBB
,
I
,
TBB
,
FBB
,
Cond
,
AllowModify
)
)
return
true
;
MachineBasicBlock
*
MaskBrDest
=
I
->
getOperand
(
0
)
.
getMBB
(
)
;
if
(
TBB
!=
MaskBrDest
||
Cond
.
empty
(
)
)
return
true
;
auto
Pred
=
Cond
[
0
]
.
getImm
(
)
;
return
(
Pred
!=
EXECZ
&&
Pred
!=
EXECNZ
)
;
}
</s>

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


"constant argument out of range for %qs"

Return true if OPVAL can be used for operand OPNUM of instruction ICODE . The instruction should require a constant operand of some sort . The function prints an error if OPVAL is not valid .


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"X86 Intel-Style Assembly Printer"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> rtx gen_df_reg ( rtx reg , int low ) { int regno = REGNO ( reg ) ; if ( ( WORDS_BIG_ENDIAN == 0 ) ^ ( low != 0 ) ) regno += ( TARGET_ARCH64 && regno < 32 ) ? 1 : 2 ; return gen_rtx_REG ( DFmode , regno ) ; } </s>

Generate a DFmode part of a hard TFmode register . REG is the TFmode hard register , LOW is 1 for the low 64bit of the register and 0 otherwise .


<s>
bool
AMDGPUSimplifyLibCalls
::
runOnFunction
(
Function
&
F
)
{
if
(
skipFunction
(
F
)
)
return
false
;
bool
Changed
=
false
;
auto
AA
=
&
getAnalysis
<
AAResultsWrapperPass
>
(
)
.
getAAResults
(
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"AMDIC: process function "
;
F
.
printAsOperand
(
dbgs
(
)
,
false
,
F
.
getParent
(
)
)
;
dbgs
(
)
<<
'\n'
;
)
;
if
(
!
EnablePreLink
)
Changed
|=
setFastFlags
(
F
,
Options
)
;
for
(
auto
&
BB
:
F
)
{
for
(
BasicBlock
::
iterator
I
=
BB
.
begin
(
)
,
E
=
BB
.
end
(
)
;
I
!=
E
;
)
{
CallInst
*
CI
=
dyn_cast
<
CallInst
>
(
I
)
;
++
I
;
if
(
!
CI
)
continue
;
Function
*
Callee
=
CI
->
getCalledFunction
(
)
;
if
(
Callee
==
0
)
continue
;
LLVM_DEBUG
(
dbgs
(
)
<<
"AMDIC: try folding "
<<
*
CI
<<
"\n"
;
dbgs
(
)
.
flush
(
)
)
;
if
(
Simplifier
.
fold
(
CI
,
AA
)
)
Changed
=
true
;
}
}
return
Changed
;
}
</s>

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

AMDGPU
AMDGPU
"AMDIC: process function "
0
"AMDIC: try folding "
"\n"


<s> static rtx sched_get_operand ( rtx_insn * insn , bool opx_p ) { int i ; if ( recog_memoized ( insn ) < 0 ) gcc_unreachable ( ) ; extract_constrain_insn_cached ( insn ) ; if ( opx_p ) i = get_attr_opx ( insn ) ; else i = get_attr_opy ( insn ) ; if ( i >= recog_data . n_operands ) return NULL ; return recog_data . operand [ i ] ; } </s>

Return X or Y ( depending on OPX_P ) operand of INSN .


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

Implement TARGET_MD_ASM_ADJUST . All asm statements are considered to clobber the XER [ CA ] bit because clobbering that bit without telling the compiler worked just fine with versions of GCC before GCC 5 , and breaking a lot of older code in ways that are hard to track down is not such a great idea .


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


"movhi hi(%s), r0, r11\n\tmovea lo(%s), r11, r11\n\tjarl .+4, r10\n\tadd 4, r10\n\tjmp r11"

Construct a JARL instruction to a routine that will perform the equivalent of the RTL passed as a parameter . This RTL is a function prologue that saves some of the registers r20 - r31 onto the stack , and possibly acquires some stack space as well . The code has already verified that the RTL matches these requirements .


<s> bool HexagonTargetLowering :: isLegalICmpImmediate ( int64_t Imm ) const { return Imm >= - 512 && Imm <= 511 ; } </s>

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


<s>
void
X86InstrInfo
::
setExecutionDomain
(
MachineInstr
*
MI
,
unsigned
Domain
)
const
{
assert
(
Domain
>
0
&&
Domain
<
4
&&
"Invalid execution domain"
)
;
uint16_t
dom
=
(
MI
->
getDesc
(
)
.
TSFlags
>>
X86II
::
SSEDomainShift
)
&
3
;
assert
(
dom
&&
"Not an SSE instruction"
)
;
const
unsigned
*
table
=
lookup
(
MI
->
getOpcode
(
)
,
dom
)
;
assert
(
table
&&
"Cannot change domain"
)
;
MI
->
setDesc
(
get
(
table
[
Domain
1
]
)
)
;
}
</s>

Change the opcode of MI to execute in Domain .


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

Simple predicate for targets where ! Resolved implies requiring relaxation .


Emit target-specific code that performs a memcpy .


<s>
void
M680x0InstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
DebugLoc
&
DL
,
unsigned
DstReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
unsigned
Opc
=
0
;
if
(
M680x0
::
XR32RegClass
.
contains
(
DstReg
,
SrcReg
)
)
Opc
=
M680x0
::
MOV32rr
;
else
if
(
M680x0
::
XR16RegClass
.
contains
(
DstReg
,
SrcReg
)
)
Opc
=
M680x0
::
MOV16rr
;
else
if
(
M680x0
::
DR8RegClass
.
contains
(
DstReg
,
SrcReg
)
)
{
Opc
=
M680x0
::
MOV8dd
;
}
if
(
Opc
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
return
;
}
MachineInstrBuilder
MIB
(
*
MBB
.
getParent
(
)
,
MI
)
;
if
(
M680x0
::
DR8RegClass
.
contains
(
SrcReg
)
)
{
if
(
M680x0
::
XR16RegClass
.
contains
(
DstReg
)
)
{
Opc
=
M680x0
::
MOVXd16d8
;
}
else
if
(
M680x0
::
XR32RegClass
.
contains
(
DstReg
)
)
{
Opc
=
M680x0
::
MOVXd32d8
;
}
}
else
if
(
M680x0
::
XR16RegClass
.
contains
(
SrcReg
)
)
{
if
(
M680x0
::
XR32RegClass
.
contains
(
DstReg
)
)
{
Opc
=
M680x0
::
MOVXd32d16
;
}
}
if
(
Opc
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
return
;
}
bool
FromCCR
=
SrcReg
==
M680x0
::
CCR
;
bool
FromSR
=
SrcReg
==
M680x0
::
SR
;
bool
ToCCR
=
DstReg
==
M680x0
::
CCR
;
bool
ToSR
=
DstReg
==
M680x0
::
SR
;
if
(
FromCCR
)
{
assert
(
M680x0
::
DR8RegClass
.
contains
(
DstReg
)
&&
"Need DR8 register to copy CCR"
)
;
Opc
=
M680x0
::
MOV8dc
;
}
else
if
(
ToCCR
)
{
assert
(
M680x0
::
DR8RegClass
.
contains
(
SrcReg
)
&&
"Need DR8 register to copy CCR"
)
;
Opc
=
M680x0
::
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> Value * X86TargetLowering :: getIRStackGuard ( IRBuilder < > & IRB ) const { if ( hasStackGuardSlotTLS ( Subtarget . getTargetTriple ( ) ) ) { if ( Subtarget . isTargetFuchsia ( ) ) { return SegmentOffset ( IRB , 0x10 , getAddressSpace ( ) ) ; } else { unsigned AddressSpace = getAddressSpace ( ) ; unsigned Offset = getTargetMachine ( ) . Options . StackProtectorGuardOffset ; if ( Offset == ( unsigned ) - 1 ) Offset = ( Subtarget . is64Bit ( ) ) ? 0x28 : 0x14 ; const auto & GuardReg = getTargetMachine ( ) . Options . StackProtectorGuardReg ; if ( GuardReg == "fs" ) AddressSpace = X86AS :: FS ; else if ( GuardReg == "gs" ) AddressSpace = X86AS :: GS ; return SegmentOffset ( IRB , Offset , AddressSpace ) ; } } return TargetLowering :: getIRStackGuard ( IRB ) ; } </s>

If the target has a standard location for the stack protector cookie , returns the address of that location .


"Maximum call-frame size not sufficiently aligned"

lowerDynamicAlloc - Generate the code for allocating an object in the current frame .


<s> MVT getScalarShiftAmountTy ( const DataLayout & , EVT ) const override { return MVT :: i32 ; } </s>

Return the type to use for a scalar shift opcode , given the shifted amount type .


<s> bool TVMLowerIntrinsics :: runOnModule ( Module & M ) { bool Changed = false ; for ( Function & F : M ) { if ( ! F . isDeclaration ( ) ) continue ; switch ( F . getIntrinsicID ( ) ) { case Intrinsic :: memcpy : case Intrinsic :: memmove : case Intrinsic :: memset : if ( expandMemIntrinsicUses ( F ) ) Changed = true ; break ; default : break ; } } return Changed ; } </s>

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

TVM TVM Intrinsic::memcpy Intrinsic::memmove Intrinsic::memset


<s> DFAPacketizer * R600InstrInfo :: CreateTargetScheduleState ( const TargetSubtargetInfo & STI ) const { const InstrItineraryData * II = STI . getInstrItineraryData ( ) ; return static_cast < const R600Subtarget & > ( STI ) . createDFAPacketizer ( II ) ; } </s>

Create machine specific model for scheduling .


<s> AArch64TargetMachine :: AArch64TargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , Optional < CodeModel :: Model > CM , CodeGenOpt :: Level OL , bool JIT , bool LittleEndian ) : LLVMTargetMachine ( T , computeDataLayout ( TT , Options . MCOptions , LittleEndian ) , TT , computeDefaultCPU ( TT , CPU ) , FS , Options , getEffectiveRelocModel ( TT , RM ) , getEffectiveAArch64CodeModel ( TT , CM , JIT ) , OL ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) , isLittle ( LittleEndian ) { initAsmInfo ( ) ; if ( TT . isOSBinFormatMachO ( ) ) { this -> Options . TrapUnreachable = true ; this -> Options . NoTrapAfterNoreturn = true ; } if ( getMCAsmInfo ( ) -> usesWindowsCFI ( ) ) { this -> Options . TrapUnreachable = true ; } if ( getOptLevel ( ) <= EnableGlobalISelAtO && TT . getArch ( ) != Triple :: aarch64_32 && TT . getArchName ( ) != "arm64e" && ! ( getCodeModel ( ) == CodeModel :: Large && TT . isOSBinFormatMachO ( ) ) ) { setGlobalISel ( true ) ; setGlobalISelAbort ( GlobalISelAbortMode :: Disable ) ; } setMachineOutliner ( true ) ; setSupportsDefaultOutlining ( true ) ; setSupportsDebugEntryValues ( true ) ; } </s>


"large frame pointer change (%d) with -mtiny-stack"

Output to FILE the asm instructions to adjust the frame pointer by ADJ ( r29 : r28 -= ADJ ; ) which can be positive ( prologue ) or negative ( epilogue ) . Returns the number of instructions generated .


"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\n"

Worker function for TARGET_SETUP_INCOMING_VARARGS .


<s> const TVMImmStringMCExpr * TVMImmStringMCExpr :: create ( const StringRef & Data , MCContext & Ctx ) { return new ( Ctx ) TVMImmStringMCExpr ( Data ) ; } </s>


<s> MVT getFenceOperandTy ( const DataLayout & DL ) const override { return MVT :: i32 ; } </s>


<s> void RISCVPassConfig :: addPreRegAlloc ( ) { addPass ( createRISCVExpandSDMAPass ( ) ) ; addPass ( createRISCVExpandSSRPass ( ) ) ; addPass ( createSNITCHFrepLoopsPass ( ) ) ; if ( TM -> getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createRISCVMergeBaseOffsetOptPass ( ) ) ; addPass ( createRISCVCleanupVSETVLIPass ( ) ) ; addPass ( createPULPHardwareLoops ( ) ) ; } } </s>

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


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { Subtarget = & MF . getTarget ( ) . getSubtarget < ARMSubtarget > ( ) ; SelectionDAGISel :: runOnMachineFunction ( MF ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> static int mingw32_gt_pch_use_address ( void * & addr , size_t size , int fd , size_t offset ) { void * mmap_addr ; HANDLE mmap_handle ; char * object_name = NULL ; OSVERSIONINFO version_info ; int r ; version_info . dwOSVersionInfoSize = sizeof ( version_info ) ; if ( size == 0 ) return 0 ; if ( ( offset & ( va_granularity - 1 ) ) != 0 || size > pch_VA_max_size ) return - 1 ; GetVersionEx ( & version_info ) ; char local_object_name [ sizeof ( OBJECT_NAME_FMT ) + sizeof ( DWORD ) * 2 ] ; if ( version_info . dwMajorVersion > 4 ) { snprintf ( local_object_name , sizeof ( local_object_name ) , OBJECT_NAME_FMT "%lx" , GetCurrentProcessId ( ) ) ; object_name = local_object_name ; } mmap_handle = CreateFileMappingA ( ( HANDLE ) _get_osfhandle ( fd ) , NULL , PAGE_WRITECOPY | SEC_COMMIT , 0 , 0 , object_name ) ; if ( mmap_handle == NULL ) { w32_error ( __FUNCTION__ , __FILE__ , __LINE__ , "CreateFileMapping" ) ; return - 1 ; } for ( r = 0 ; r < 5 ; r ++ ) { mmap_addr = MapViewOfFileEx ( mmap_handle , FILE_MAP_COPY , 0 , offset , size , addr ) ; if ( mmap_addr == addr ) break ; if ( r != 4 ) Sleep ( 500 ) ; } if ( mmap_addr != addr ) { w32_error ( __FUNCTION__ , __FILE__ , __LINE__ , "MapViewOfFileEx" ) ; CloseHandle ( mmap_handle ) ; return - 1 ; } return 1 ; } </s>

ADDR is an address returned by gt_pch_get_address . Attempt to allocate SIZE bytes at the same address and load it with the data from FD at OFFSET . Return -1 if we could n't allocate memory at ADDR , return 0 if the memory is allocated but the data not loaded , return 1 if done .


<s> bool ARMBaseRegisterInfo :: getRegAllocationHints ( Register VirtReg , ArrayRef < MCPhysReg > Order , SmallVectorImpl < MCPhysReg > & Hints , const MachineFunction & MF , const VirtRegMap * VRM , const LiveRegMatrix * Matrix ) const { const MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; std :: pair < Register , Register > Hint = MRI . getRegAllocationHint ( VirtReg ) ; unsigned Odd ; switch ( Hint . first ) { case ARMRI :: RegPairEven : Odd = 0 ; break ; case ARMRI :: RegPairOdd : Odd = 1 ; break ; case ARMRI :: RegLR : TargetRegisterInfo :: getRegAllocationHints ( VirtReg , Order , Hints , MF , VRM ) ; if ( MRI . getRegClass ( VirtReg ) -> contains ( ARM :: LR ) ) Hints . push_back ( ARM :: LR ) ; return false ; default : return TargetRegisterInfo :: getRegAllocationHints ( VirtReg , Order , Hints , MF , VRM ) ; } Register Paired = Hint . second ; if ( ! Paired ) return false ; Register PairedPhys ; if ( Paired . isPhysical ( ) ) { PairedPhys = Paired ; } else if ( VRM && VRM -> hasPhys ( Paired ) ) { PairedPhys = getPairedGPR ( VRM -> getPhys ( Paired ) , Odd , this ) ; } if ( PairedPhys && is_contained ( Order , PairedPhys ) ) Hints . push_back ( PairedPhys ) ; for ( MCPhysReg Reg : Order ) { if ( Reg == PairedPhys || ( getEncodingValue ( Reg ) & 1 ) != Odd ) continue ; MCPhysReg Paired = getPairedGPR ( Reg , ! Odd , this ) ; if ( ! Paired || MRI . isReserved ( Paired ) ) continue ; Hints . push_back ( Reg ) ; } return false ; } </s>

Get a list of 'hint ' registers that the register allocator should try first when allocating a physical register for the virtual register VirtReg .

ARM ARM ARMRI::RegPairEven 0 ARMRI::RegPairOdd 1 ARMRI::RegLR ARM::LR ARM::LR 1


<s> ISD :: NodeType getExtendForAtomicCmpSwapArg ( ) const override { return ISD :: ZERO_EXTEND ; } </s>

Returns how the platform 's atomic compare and swap expects its comparison value to be extended ( ZERO_EXTEND , SIGN_EXTEND , or ANY_EXTEND ) .


<s>
void
mmix_asm_output_align
(
FILE
*
stream
,
int
power
)
{
fprintf
(
stream
,
"\t.p2align %d\n"
,
power
)
;
fprintf
(
stream
,
"\tLOC @+(%d-@)&%d\n"
,
1
<<
power
,
(
1
<<
power
)
1
)
;
}
</s>


<s> static rtx microblaze_function_value ( const_tree valtype , const_tree func ATTRIBUTE_UNUSED , bool outgoing ATTRIBUTE_UNUSED ) { return LIBCALL_VALUE ( TYPE_MODE ( valtype ) ) ; } </s>


"Instr doesn't have FrameIndex operand!"

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


<s>
void
LanaiInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
Position
,
const
DebugLoc
&
DL
,
unsigned
DestinationRegister
,
unsigned
SourceRegister
,
bool
KillSource
)
const
{
if
(
!
Lanai
::
GPRRegClass
.
contains
(
DestinationRegister
,
SourceRegister
)
)
{
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
BuildMI
(
MBB
,
Position
,
DL
,
get
(
Lanai
::
OR_I_LO
)
,
DestinationRegister
)
.
addReg
(
SourceRegister
,
getKillRegState
(
KillSource
)
)
.
addImm
(
0
)
;
}
</s>

Lanai
Lanai
Lanai::GPRRegClass
"Impossible reg-to-reg copy"
Lanai::OR_I_LO
0


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

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

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


<s> static void ix86_pad_returns ( void ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , EXIT_BLOCK_PTR_FOR_FN ( cfun ) -> preds ) { basic_block bb = e -> src ; rtx_insn * ret = BB_END ( bb ) ; rtx_insn * prev ; bool replace = false ; if ( ! JUMP_P ( ret ) || ! ANY_RETURN_P ( PATTERN ( ret ) ) || optimize_bb_for_size_p ( bb ) ) continue ; for ( prev = PREV_INSN ( ret ) ; prev ; prev = PREV_INSN ( prev ) ) if ( active_insn_p ( prev ) || LABEL_P ( prev ) ) break ; if ( prev && LABEL_P ( prev ) ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( EDGE_FREQUENCY ( e ) && e -> src -> index >= 0 && ! ( e -> flags & EDGE_FALLTHRU ) ) { replace = true ; break ; } } if ( ! replace ) { prev = prev_active_insn ( ret ) ; if ( prev && ( ( JUMP_P ( prev ) && any_condjump_p ( prev ) ) || CALL_P ( prev ) ) ) replace = true ; if ( ! prev && ! optimize_function_for_size_p ( cfun ) ) replace = true ; } if ( replace ) { emit_jump_insn_before ( gen_simple_return_internal_long ( ) , ret ) ; delete_insn ( ret ) ; } } } </s>

AMD Athlon works faster when RET is not destination of conditional jump or directly preceded by other jump instruction . We avoid the penalty by inserting NOP just before the RET instructions in such cases .


<s> void frv_final_prescan_insn ( rtx_insn * insn , rtx * opvec , int noperands ATTRIBUTE_UNUSED ) { if ( INSN_P ( insn ) ) { if ( frv_insn_packing_flag >= 0 ) { frv_insn_operands = opvec ; frv_insn_packing_flag = PACKING_FLAG_P ( insn ) ; } else if ( recog_memoized ( insn ) >= 0 && get_attr_acc_group ( insn ) == ACC_GROUP_ODD ) fprintf ( asm_out_file , "\tmnop.p\n" ) ; } } </s>

Set up the packing bit for the current output insn . Note that this function is not called for asm insns .


<s> bool MipsPassConfig :: addInstSelector ( ) { addPass ( createMipsModuleISelDagPass ( ) ) ; addPass ( createMips16ISelDag ( getMipsTargetMachine ( ) , getOptLevel ( ) ) ) ; addPass ( createMipsSEISelDag ( getMipsTargetMachine ( ) , getOptLevel ( ) ) ) ; return false ; } </s>

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


<s> static rtx aarch64_bit_representation ( rtx x ) { if ( CONST_DOUBLE_P ( x ) ) x = gen_lowpart ( int_mode_for_mode ( GET_MODE ( x ) ) . require ( ) , x ) ; return x ; } </s>

If X is a CONST_DOUBLE , return its bit representation as a constant integer , otherwise return X unmodified .


<s> const unsigned * SystemZRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const unsigned CalleeSavedRegs [ ] = { SystemZ :: R6D , SystemZ :: R7D , SystemZ :: R8D , SystemZ :: R9D , SystemZ :: R10D , SystemZ :: R11D , SystemZ :: R12D , SystemZ :: R13D , SystemZ :: R14D , SystemZ :: R15D , SystemZ :: F8L , SystemZ :: F9L , SystemZ :: F10L , SystemZ :: F11L , SystemZ :: F12L , SystemZ :: F13L , SystemZ :: F14L , SystemZ :: F15L , 0 } ; return CalleeSavedRegs ; } </s>


<s> static bool shadow_or_blockage_p ( rtx_insn * insn ) { enum attr_type type ; if ( ! NONDEBUG_INSN_P ( insn ) || recog_memoized ( insn ) < 0 ) return false ; type = get_attr_type ( insn ) ; return shadow_type_p ( type ) || type == TYPE_BLOCKAGE ; } </s>

Return true iff INSN is a shadow or blockage pattern .


<s> static inline bool is_naked_func ( void ) { return is_attr_func ( "naked" ) ; } </s>

Returns true if the provided function has the `` naked '' attribute .


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

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


<s> static bool pdp11_modes_tieable_p ( machine_mode , machine_mode ) { return false ; } </s>


<s> bool XCoreTargetLowering :: isLegalAddressingMode ( const DataLayout & DL , const AddrMode & AM , Type * Ty , unsigned AS , Instruction * I ) const { if ( Ty -> getTypeID ( ) == Type :: VoidTyID ) return AM . Scale == 0 && isImmUs ( AM . BaseOffs ) && isImmUs4 ( AM . BaseOffs ) ; unsigned Size = DL . getTypeAllocSize ( Ty ) ; if ( AM . BaseGV ) { return Size >= 4 && ! AM . HasBaseReg && AM . Scale == 0 && AM . BaseOffs % 4 == 0 ; } switch ( Size ) { case 1 : if ( AM . Scale == 0 ) { return isImmUs ( AM . BaseOffs ) ; } return AM . Scale == 1 && AM . BaseOffs == 0 ; case 2 : case 3 : if ( AM . Scale == 0 ) { return isImmUs2 ( AM . BaseOffs ) ; } return AM . Scale == 2 && AM . BaseOffs == 0 ; default : if ( AM . Scale == 0 ) { return isImmUs4 ( AM . BaseOffs ) ; } return AM . Scale == 4 && AM . BaseOffs == 0 ; } } </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> static struct machine_function * csky_init_machine_status ( void ) { struct machine_function * machine ; machine = ggc_cleared_alloc < machine_function > ( ) ; machine -> func_type = CSKY_FT_UNKNOWN ; return machine ; } </s>

Functions to save and restore machine-specific function data .


<s> bool ARM64TargetLowering :: isOffsetFoldingLegal ( const GlobalAddressSDNode * GA ) const { return false ; } </s>

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


Return the DataLayout associated with the module this SCEV instance is operating on .


<s> int attr_length_call ( rtx insn , int sibcall ) { int local_call ; rtx call_dest ; tree call_decl ; int length = 0 ; rtx pat = PATTERN ( insn ) ; unsigned long distance = - 1 ; if ( INSN_ADDRESSES_SET_P ( ) ) { unsigned long total ; total = IN_NAMED_SECTION_P ( cfun -> decl ) ? 0 : total_code_bytes ; distance = ( total + insn_current_reference_address ( insn ) ) ; if ( distance < total ) distance = - 1 ; } if ( GET_CODE ( XVECEXP ( pat , 0 , 0 ) ) == CALL ) call_dest = XEXP ( XEXP ( XVECEXP ( pat , 0 , 0 ) , 0 ) , 0 ) ; else call_dest = XEXP ( XEXP ( XEXP ( XVECEXP ( pat , 0 , 0 ) , 1 ) , 0 ) , 0 ) ; call_decl = SYMBOL_REF_DECL ( call_dest ) ; local_call = call_decl && ( * targetm . binds_local_p ) ( call_decl ) ; if ( ! TARGET_LONG_CALLS && ( ( TARGET_PA_20 && ! sibcall && distance < 7600000 ) || distance < 240000 ) ) length += 8 ; else if ( TARGET_64BIT && ! local_call ) length += sibcall ? 28 : 24 ; else if ( ( TARGET_LONG_ABS_CALL || local_call ) && ! flag_pic ) length += 12 ; else if ( ( TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL ) || ( TARGET_64BIT && ! TARGET_GAS ) || ( TARGET_GAS && ( TARGET_LONG_PIC_PCREL_CALL || local_call ) ) ) { length += 20 ; if ( ! TARGET_PA_20 && ! TARGET_NO_SPACE_REGS ) length += 8 ; } else { length += 32 ; if ( TARGET_SOM ) length += length_fp_args ( insn ) ; if ( flag_pic ) length += 4 ; if ( ! TARGET_PA_20 ) { if ( ! sibcall ) length += 8 ; if ( ! TARGET_NO_SPACE_REGS ) length += 8 ; } } return length ; } </s>

Return the attribute length of the call instruction INSN . The SIBCALL flag indicates whether INSN is a regular call or a sibling call . The length returned must be longer than the code actually generated by output_call . Since branch shortening is done before delay branch sequencing , there is no way to determine whether or not the delay slot will be filled during branch shortening . Even when the delay slot is filled , we may have to add a nop if the delay slot contains a branch that ca n't reach its target . Thus , we always have to include the delay slot in the length estimate . This used to be done in pa_adjust_insn_length but we do it here now as some sequences always fill the delay slot and we can save four bytes in the estimate for these sequences .


<s> static bool pru_can_use_doloop_p ( const widest_int & , const widest_int & iterations_max , unsigned int loop_depth , bool ) { if ( loop_depth > 1 ) return false ; if ( iterations_max == 0 || wi :: geu_p ( iterations_max , 0xffff ) ) return false ; return true ; } </s>


<s> int sh_media_register_for_return ( ) { int regno ; int tr0_used ; if ( ! current_function_is_leaf ) return - 1 ; tr0_used = flag_pic && regs_ever_live [ PIC_OFFSET_TABLE_REGNUM ] ; for ( regno = FIRST_TARGET_REG + tr0_used ; regno <= LAST_TARGET_REG ; regno ++ ) if ( call_used_regs [ regno ] && ! regs_ever_live [ regno ] ) return regno ; return - 1 ; } </s>

Choose a call-clobbered target-branch register that remains unchanged along the whole function . We set it up as the return value in the prologue .


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> bool WebAssemblyTargetMachine :: parseMachineFunctionInfo ( const yaml :: MachineFunctionInfo & MFI , PerFunctionMIParsingState & PFS , SMDiagnostic & Error , SMRange & SourceRange ) const { const auto & YamlMFI = reinterpret_cast < const yaml :: WebAssemblyFunctionInfo & > ( MFI ) ; MachineFunction & MF = PFS . MF ; MF . getInfo < WebAssemblyFunctionInfo > ( ) -> initializeBaseYamlFields ( YamlMFI ) ; return false ; } </s>

Parse out the target 's MachineFunctionInfo from the YAML reprsentation .

WebAssembly WebAssembly WebAssembly WebAssembly


<s> SDValue SystemZTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { default : break ; case ISD :: ZERO_EXTEND : return combineZERO_EXTEND ( N , DCI ) ; case ISD :: SIGN_EXTEND : return combineSIGN_EXTEND ( N , DCI ) ; case ISD :: SIGN_EXTEND_INREG : return combineSIGN_EXTEND_INREG ( N , DCI ) ; case SystemZISD :: MERGE_HIGH : case SystemZISD :: MERGE_LOW : return combineMERGE ( N , DCI ) ; case ISD :: STORE : return combineSTORE ( N , DCI ) ; case ISD :: EXTRACT_VECTOR_ELT : return combineEXTRACT_VECTOR_ELT ( N , DCI ) ; case SystemZISD :: JOIN_DWORDS : return combineJOIN_DWORDS ( N , DCI ) ; case ISD :: FP_ROUND : return combineFP_ROUND ( N , DCI ) ; case ISD :: BSWAP : return combineBSWAP ( N , DCI ) ; case ISD :: SHL : case ISD :: SRA : case ISD :: SRL : case ISD :: ROTL : return combineSHIFTROT ( N , DCI ) ; case SystemZISD :: BR_CCMASK : return combineBR_CCMASK ( N , DCI ) ; case SystemZISD :: SELECT_CCMASK : return combineSELECT_CCMASK ( N , DCI ) ; case SystemZISD :: GET_CCMASK : return combineGET_CCMASK ( N , DCI ) ; } return SDValue ( ) ; } </s>

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


"IRF registers are not spillable if -long-irf is specified"

"Unsupported register class in loadFromStack"

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


"%<__builtin_arc_aligned%> with non-constant alignment"

"invalid alignment value for %<__builtin_arc_aligned%>"

Helper to expand __builtin_arc_aligned ( void * val , int alignval ) .


<s> static void single_move_for_strmov ( rtx dst , rtx src , enum machine_mode mode , HOST_WIDE_INT offset ) { rtx scratch = gen_reg_rtx ( mode ) ; rtx srcmem , dstmem ; srcmem = adjust_address_nv ( src , mode , offset ) ; dstmem = adjust_address_nv ( dst , mode , offset ) ; emit_move_insn ( scratch , srcmem ) ; emit_move_insn ( dstmem , scratch ) ; } </s>

Adjust DST and SRC by OFFSET bytes , and generate one move in mode MODE .


<s>
unsigned
Mips16InstrInfo
::
getInlineAsmLength
(
const
char
*
Str
,
const
MCAsmInfo
&
MAI
)
const
{
bool
atInsnStart
=
true
;
unsigned
Length
=
0
;
for
(
;
*
Str
;
++
Str
)
{
if
(
*
Str
==
'\n'
||
strncmp
(
Str
,
MAI
.
getSeparatorString
(
)
,
strlen
(
MAI
.
getSeparatorString
(
)
)
)
==
0
)
atInsnStart
=
true
;
if
(
atInsnStart
&&
!
std
::
isspace
(
static_cast
<
unsigned
char
>
(
*
Str
)
)
)
{
if
(
strncmp
(
Str
,
".space"
,
6
)
==
0
)
{
char
*
EStr
;
int
Sz
;
Sz
=
strtol
(
Str
+
6
,
&
EStr
,
10
)
;
while
(
isspace
(
*
EStr
)
)
++
EStr
;
if
(
*
EStr
==
'\0'
)
{
DEBUG
(
dbgs
(
)
<<
"parsed .space "
<<
Sz
<<
'\n'
)
;
return
Sz
;
}
}
Length
+=
MAI
.
getMaxInstLength
(
)
;
atInsnStart
=
false
;
}
if
(
atInsnStart
&&
strncmp
(
Str
,
MAI
.
getCommentString
(
)
,
strlen
(
MAI
.
getCommentString
(
)
)
)
==
0
)
atInsnStart
=
false
;
}
return
Length
;
}
</s>

Measure the specified inline asm to determine an approximation of its length .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> static bool ia64_vectorize_vec_perm_const ( machine_mode vmode , rtx target , rtx op0 , rtx op1 , const vec_perm_indices & sel ) { struct expand_vec_perm_d d ; unsigned char perm [ MAX_VECT_LEN ] ; unsigned int i , nelt , which ; d . target = target ; if ( op0 ) { rtx nop0 = force_reg ( vmode , op0 ) ; if ( op0 == op1 ) op1 = nop0 ; op0 = nop0 ; } if ( op1 ) op1 = force_reg ( vmode , op1 ) ; d . op0 = op0 ; d . op1 = op1 ; d . vmode = vmode ; gcc_assert ( VECTOR_MODE_P ( d . vmode ) ) ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . testing_p = ! target ; gcc_assert ( sel . length ( ) == nelt ) ; gcc_checking_assert ( sizeof ( d . perm ) == sizeof ( perm ) ) ; for ( i = which = 0 ; i < nelt ; ++ i ) { unsigned int ei = sel [ i ] & ( 2 * nelt - 1 ) ; which |= ( ei < nelt ? 1 : 2 ) ; d . perm [ i ] = ei ; perm [ i ] = ei ; } switch ( which ) { default : gcc_unreachable ( ) ; case 3 : if ( d . testing_p || ! rtx_equal_p ( d . op0 , d . op1 ) ) { d . one_operand_p = false ; break ; } for ( i = 0 ; i < nelt ; ++ i ) if ( d . perm [ i ] >= nelt ) d . perm [ i ] -= nelt ; case 1 : d . op1 = d . op0 ; d . one_operand_p = true ; break ; case 2 : for ( i = 0 ; i < nelt ; ++ i ) d . perm [ i ] -= nelt ; d . op0 = d . op1 ; d . one_operand_p = true ; break ; } if ( d . testing_p ) { d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 1 ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 2 ) ; if ( ! d . one_operand_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 3 ) ; start_sequence ( ) ; bool ret = ia64_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ret ; } if ( ia64_expand_vec_perm_const_1 ( & d ) ) return true ; if ( which == 3 && d . one_operand_p ) { memcpy ( d . perm , perm , sizeof ( perm ) ) ; d . one_operand_p = false ; return ia64_expand_vec_perm_const_1 ( & d ) ; } return false ; } </s>


<s> bool TeakRegisterInfo :: trackLivenessAfterRegAlloc ( const MachineFunction & MF ) const { return true ; } </s>

Returns true if the live-ins should be tracked after register allocation .


<s> StackOffset SystemZFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { StackOffset Offset = TargetFrameLowering :: getFrameIndexReference ( MF , FI , FrameReg ) ; return Offset + StackOffset :: getFixed ( SystemZMC :: ELFCallFrameSize ) ; } </s>

getFrameIndexReference - This method should return the base register and offset used to reference a frame index location .


<s> const char * iq2000_fill_delay_slot ( const char * ret , enum delay_type type , rtx operands [ ] , rtx cur_insn ) { rtx set_reg ; enum machine_mode mode ; rtx next_insn = cur_insn ? NEXT_INSN ( cur_insn ) : NULL_RTX ; int num_nops ; if ( type == DELAY_LOAD || type == DELAY_FCMP ) num_nops = 1 ; else num_nops = 0 ; next_insn = NEXT_INSN ( cur_insn ) ; while ( next_insn != 0 && ( GET_CODE ( next_insn ) == NOTE || GET_CODE ( next_insn ) == CODE_LABEL ) ) next_insn = NEXT_INSN ( next_insn ) ; dslots_load_total += num_nops ; if ( TARGET_DEBUG_C_MODE || type == DELAY_NONE || operands == 0 || cur_insn == 0 || next_insn == 0 || GET_CODE ( next_insn ) == CODE_LABEL || ( set_reg = operands [ 0 ] ) == 0 ) { dslots_number_nops = 0 ; iq2000_load_reg = 0 ; iq2000_load_reg2 = 0 ; iq2000_load_reg3 = 0 ; iq2000_load_reg4 = 0 ; return ret ; } set_reg = operands [ 0 ] ; if ( set_reg == 0 ) return ret ; while ( GET_CODE ( set_reg ) == SUBREG ) set_reg = SUBREG_REG ( set_reg ) ; mode = GET_MODE ( set_reg ) ; dslots_number_nops = num_nops ; iq2000_load_reg = set_reg ; if ( GET_MODE_SIZE ( mode ) > ( unsigned ) ( UNITS_PER_WORD ) ) iq2000_load_reg2 = gen_rtx_REG ( SImode , REGNO ( set_reg ) + 1 ) ; else iq2000_load_reg2 = 0 ; return ret ; } </s>

Returns an operand string for the given instruction 's delay slot , after updating filled delay slot statistics . We assume that operands [ 0 ] is the target register that is set . In order to check the next insn , most of this functionality is moved to FINAL_PRESCAN_INSN , and we just set the global variables that it needs .


<s> MCExpr const * HexagonMCExpr :: getExpr ( ) const { return Expr ; } </s>

Implementation of the SCEVPredicate interface .


<s> SIAtomicScope getScope ( ) const { return Scope ; } </s>


<s> void GCNPassConfig :: addPreEmitPass ( ) { addPass ( createSIMemoryLegalizerPass ( ) ) ; addPass ( createSIInsertWaitcntsPass ( ) ) ; addPass ( createSIShrinkInstructionsPass ( ) ) ; addPass ( createSIModeRegisterPass ( ) ) ; addPass ( & PostRAHazardRecognizerID ) ; addPass ( & SIRemoveShortExecBranchesID ) ; addPass ( & SIInsertSkipsPassID ) ; addPass ( & BranchRelaxationPassID ) ; } </s>

This pass may be implemented by targets that want to run passes immediately before machine code is emitted .


<s> static const char * pru_asm_regname ( rtx op ) { static char canon_reg_names [ 3 ] [ LAST_GP_REGNUM ] [ 8 ] ; int speci , regi ; gcc_assert ( REG_P ( op ) ) ; if ( ! canon_reg_names [ 0 ] [ 0 ] [ 0 ] ) { for ( regi = 0 ; regi < LAST_GP_REGNUM ; regi ++ ) for ( speci = 0 ; speci < 3 ; speci ++ ) { const int sz = ( speci == 0 ) ? 1 : ( ( speci == 1 ) ? 2 : 4 ) ; if ( ( regi + sz ) > ( 32 * 4 ) ) continue ; const char * suffix = "" ; switch ( ( sz << 8 ) | ( regi % 4 ) ) { case ( 1 << 8 ) | 0 : suffix = ".b0" ; break ; case ( 1 << 8 ) | 1 : suffix = ".b1" ; break ; case ( 1 << 8 ) | 2 : suffix = ".b2" ; break ; case ( 1 << 8 ) | 3 : suffix = ".b3" ; break ; case ( 2 << 8 ) | 0 : suffix = ".w0" ; break ; case ( 2 << 8 ) | 1 : suffix = ".w1" ; break ; case ( 2 << 8 ) | 2 : suffix = ".w2" ; break ; case ( 4 << 8 ) | 0 : suffix = "" ; break ; default : continue ; } sprintf ( & canon_reg_names [ speci ] [ regi ] [ 0 ] , "r%d%s" , regi / 4 , suffix ) ; } } switch ( GET_MODE_SIZE ( GET_MODE ( op ) ) ) { case 1 : speci = 0 ; break ; case 2 : speci = 1 ; break ; case 4 : speci = 2 ; break ; case 8 : speci = 2 ; break ; default : gcc_unreachable ( ) ; } regi = REGNO ( op ) ; gcc_assert ( regi < LAST_GP_REGNUM ) ; gcc_assert ( canon_reg_names [ speci ] [ regi ] [ 0 ] ) ; return & canon_reg_names [ speci ] [ regi ] [ 0 ] ; } </s>

Translate between the MachineDescription notion of 8-bit consecutive registers , to the PRU assembler syntax of REGWORD [ .SUBREG ] .


<s> bool hasSMRDReadVALUDefHazard ( ) const { return getGeneration ( ) == SOUTHERN_ISLANDS ; } </s>

A read of an SGPR by SMRD instruction requires 4 wait states when the SGPR was written by a VALU instruction .


"' has frame pointer, incrementing stack frame size by ptr_size.\n"

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


<s>
void
SystemZHazardRecognizer
::
emitInstruction
(
MachineInstr
*
MI
,
bool
TakenBranch
)
{
SUnit
SU
(
MI
,
0
)
;
SU
.
isCall
=
MI
->
isCall
(
)
;
const
MCSchedClassDesc
*
SC
=
SchedModel
->
resolveSchedClass
(
MI
)
;
for
(
const
MCWriteProcResEntry
&
PRE
:
make_range
(
SchedModel
->
getWriteProcResBegin
(
SC
)
,
SchedModel
->
getWriteProcResEnd
(
SC
)
)
)
{
switch
(
SchedModel
->
getProcResource
(
PRE
.
ProcResourceIdx
)
->
BufferSize
)
{
case
0
:
SU
.
hasReservedResource
=
true
;
break
;
case
1
:
SU
.
isUnbuffered
=
true
;
break
;
default
:
break
;
}
}
unsigned
GroupSizeBeforeEmit
=
CurrGroupSize
;
EmitInstruction
(
&
SU
)
;
if
(
!
TakenBranch
&&
isBranchRetTrap
(
MI
)
)
{
if
(
GroupSizeBeforeEmit
==
1
)
nextGroup
(
)
;
}
if
(
TakenBranch
&&
CurrGroupSize
>
0
)
nextGroup
(
)
;
assert
(
(
!
MI
->
isTerminator
(
)
||
isBranchRetTrap
(
MI
)
)
&&
"Scheduler: unhandled terminator!"
)
;
}
</s>

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


<s> bool ARMBaseInstrInfo :: isProfitableToIfCvt ( MachineBasicBlock & MBB , unsigned NumCycles , unsigned ExtraPredCycles , BranchProbability Probability ) const { if ( ! NumCycles ) return false ; if ( MBB . getParent ( ) -> getFunction ( ) -> optForSize ( ) ) { MachineBasicBlock * Pred = * MBB . pred_begin ( ) ; if ( ! Pred -> empty ( ) ) { MachineInstr * LastMI = & * Pred -> rbegin ( ) ; if ( LastMI -> getOpcode ( ) == ARM :: t2Bcc ) { MachineBasicBlock :: iterator CmpMI = LastMI ; if ( CmpMI != Pred -> begin ( ) ) { -- CmpMI ; if ( CmpMI -> getOpcode ( ) == ARM :: tCMPi8 || CmpMI -> getOpcode ( ) == ARM :: t2CMPri ) { unsigned Reg = CmpMI -> getOperand ( 0 ) . getReg ( ) ; unsigned PredReg = 0 ; ARMCC :: CondCodes P = getInstrPredicate ( CmpMI , PredReg ) ; if ( P == ARMCC :: AL && CmpMI -> getOperand ( 1 ) . getImm ( ) == 0 && isARMLowRegister ( Reg ) ) return false ; } } } } } const unsigned ScalingUpFactor = 1024 ; unsigned UnpredCost = Probability . scale ( NumCycles * ScalingUpFactor ) ; UnpredCost += ScalingUpFactor ; UnpredCost += Subtarget . getMispredictionPenalty ( ) * ScalingUpFactor / 10 ; return ( NumCycles + ExtraPredCycles ) * ScalingUpFactor <= UnpredCost ; } </s>


<s> static void vr4130_true_reg_dependence_p_1 ( rtx x , rtx pat ATTRIBUTE_UNUSED , void * data ) { rtx * insn_ptr = data ; if ( REG_P ( x ) && * insn_ptr != 0 && reg_referenced_p ( x , PATTERN ( * insn_ptr ) ) ) * insn_ptr = 0 ; } </s>

A note_stores callback used by vr4130_true_reg_dependence_p . DATA points to an rtx that is initially an instruction . Nullify the rtx if the instruction uses the value of register X .


<s> bool ix86_bnd_prefixed_insn_p ( rtx insn ) { if ( insn && CALL_P ( insn ) ) { rtx call = get_call_rtx_from ( insn ) ; if ( call ) return CALL_EXPR_WITH_BOUNDS_P ( call ) ; } return chkp_function_instrumented_p ( current_function_decl ) ; } </s>

Return 1 if control tansfer instruction INSN should be encoded with bnd prefix . If insn is NULL then return 1 when control transfer instructions should be prefixed with bnd by default for current function .


<s> void mips_expand_conditional_move ( rtx * operands ) { rtx cond ; enum rtx_code code = GET_CODE ( operands [ 1 ] ) ; rtx op0 = XEXP ( operands [ 1 ] , 0 ) ; rtx op1 = XEXP ( operands [ 1 ] , 1 ) ; mips_emit_compare ( & code , & op0 , & op1 , true ) ; cond = gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) ; if ( ISA_HAS_SEL && INTEGRAL_MODE_P ( GET_MODE ( operands [ 2 ] ) ) && register_operand ( operands [ 2 ] , VOIDmode ) && register_operand ( operands [ 3 ] , VOIDmode ) ) { machine_mode mode = GET_MODE ( operands [ 0 ] ) ; rtx temp = gen_reg_rtx ( mode ) ; rtx temp2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( temp , gen_rtx_IF_THEN_ELSE ( mode , cond , operands [ 2 ] , const0_rtx ) ) ) ; cond = gen_rtx_fmt_ee ( ( code == EQ ) ? NE : EQ , GET_MODE ( op0 ) , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( temp2 , gen_rtx_IF_THEN_ELSE ( mode , cond , operands [ 3 ] , const0_rtx ) ) ) ; emit_insn ( gen_rtx_SET ( operands [ 0 ] , gen_rtx_IOR ( mode , temp , temp2 ) ) ) ; } else { if ( FLOAT_MODE_P ( GET_MODE ( operands [ 2 ] ) ) && ! ISA_HAS_SEL ) { operands [ 2 ] = force_reg ( GET_MODE ( operands [ 0 ] ) , operands [ 2 ] ) ; operands [ 3 ] = force_reg ( GET_MODE ( operands [ 0 ] ) , operands [ 3 ] ) ; } emit_insn ( gen_rtx_SET ( operands [ 0 ] , gen_rtx_IF_THEN_ELSE ( GET_MODE ( operands [ 0 ] ) , cond , operands [ 2 ] , operands [ 3 ] ) ) ) ; } } </s>

Perform the comparison in OPERANDS [ 1 ] . Move OPERANDS [ 2 ] into OPERANDS [ 0 ] if the condition holds , otherwise move OPERANDS [ 3 ] into OPERANDS [ 0 ] .


<s> virtual MVT getShiftAmountTy ( EVT LHSTy ) const { return MVT :: i32 ; } </s>

Returns the type for the shift amount of a shift opcode .


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

Return true if the target has a vector blend instruction .


<s> static rtx find_next_cycle_insn ( rtx insn , int clock ) { rtx t = insn ; if ( GET_MODE ( t ) == TImode ) t = next_real_insn ( t ) ; while ( t && GET_MODE ( t ) != TImode ) t = next_real_insn ( t ) ; if ( t && insn_get_clock ( t ) == clock ) return t ; return NULL_RTX ; } </s>

Scan forwards from INSN until we find the next insn that has mode TImode ( indicating it starts a new cycle ) , and occurs in cycle CLOCK . Return it if we find such an insn , NULL_RTX otherwise .


"Unhandled instruction encoding format!"

Targets should implement this to emit instructions .


<s> static int mips_issue_rate ( void ) { switch ( mips_tune ) { case PROCESSOR_74KC : case PROCESSOR_74KF2_1 : case PROCESSOR_74KF1_1 : case PROCESSOR_74KF3_2 : case PROCESSOR_R10000 : return 4 ; case PROCESSOR_20KC : case PROCESSOR_R4130 : case PROCESSOR_R5400 : case PROCESSOR_R5500 : case PROCESSOR_R5900 : case PROCESSOR_R7000 : case PROCESSOR_R9000 : case PROCESSOR_OCTEON : case PROCESSOR_OCTEON2 : case PROCESSOR_OCTEON3 : case PROCESSOR_I6400 : case PROCESSOR_GS264E : return 2 ; case PROCESSOR_SB1 : case PROCESSOR_SB1A : return 3 ; case PROCESSOR_LOONGSON_2E : case PROCESSOR_LOONGSON_2F : case PROCESSOR_GS464 : case PROCESSOR_GS464E : case PROCESSOR_P5600 : case PROCESSOR_P6600 : return 4 ; case PROCESSOR_XLP : return ( reload_completed ? 4 : 3 ) ; default : return 1 ; } } </s>

Return the number of instructions that can be issued per cycle .


<s> unsigned HexagonMCCodeEmitter :: getMachineOpValue ( MCInst const & MI , MCOperand const & MO , SmallVectorImpl < MCFixup > & Fixups , MCSubtargetInfo const & STI ) const { assert ( ! MO . isImm ( ) ) ; if ( MO . isReg ( ) ) { unsigned Reg = MO . getReg ( ) ; if ( HexagonMCInstrInfo :: isSubInstruction ( MI ) ) return HexagonMCInstrInfo :: getDuplexRegisterNumbering ( Reg ) ; switch ( MI . getOpcode ( ) ) { case Hexagon :: A2_tfrrcr : case Hexagon :: A2_tfrcrr : if ( Reg == Hexagon :: M0 ) Reg = Hexagon :: C6 ; if ( Reg == Hexagon :: M1 ) Reg = Hexagon :: C7 ; } return MCT . getRegisterInfo ( ) -> getEncodingValue ( Reg ) ; } return getExprOpValue ( MI , MO , MO . getExpr ( ) , Fixups , STI ) ; } </s>

getMachineOpValue - Return binary encoding of operand .


<s> rtx sh_find_equiv_gbr_addr ( rtx_insn * insn , rtx mem ) { if ( ! MEM_P ( mem ) || gbr_address_mem ( mem , GET_MODE ( mem ) ) ) return NULL_RTX ; if ( side_effects_p ( XEXP ( mem , 0 ) ) ) return NULL_RTX ; if ( df == NULL ) return NULL_RTX ; base_reg_disp gbr_disp = sh_find_base_reg_disp ( insn , XEXP ( mem , 0 ) ) ; if ( gbr_disp . is_reg ( ) && REGNO ( gbr_disp . reg ( ) ) == GBR_REG ) { for ( df_ref d = DF_REG_DEF_CHAIN ( GBR_REG ) ; d != NULL ; d = DF_REF_NEXT_REG ( d ) ) { if ( CALL_P ( DF_REF_INSN ( d ) ) ) { if ( REGNO_REG_SET_P ( regs_invalidated_by_call_regset , GBR_REG ) ) return NULL_RTX ; else continue ; } else return NULL_RTX ; } rtx disp = GEN_INT ( gbr_disp . disp ( ) ) ; if ( gbr_displacement ( disp , GET_MODE ( mem ) ) ) return gen_rtx_PLUS ( SImode , gen_rtx_REG ( SImode , GBR_REG ) , disp ) ; } return NULL_RTX ; } </s>

Given an insn and a memory operand , try to find an equivalent GBR based memory address and return the corresponding new memory address . Return NULL_RTX if not found .


<s> bool HexagonOptimizeSZextends :: runOnFunction ( Function & F ) { if ( skipFunction ( F ) ) return false ; unsigned Idx = 0 ; for ( auto & Arg : F . args ( ) ) { if ( F . getAttributes ( ) . hasParamAttr ( Idx , Attribute :: SExt ) ) { if ( ! isa < PointerType > ( Arg . getType ( ) ) ) { for ( Use & U : llvm :: make_early_inc_range ( Arg . uses ( ) ) ) { if ( isa < SExtInst > ( U ) ) { Instruction * Use = cast < Instruction > ( U ) ; SExtInst * SI = new SExtInst ( & Arg , Use -> getType ( ) ) ; assert ( EVT :: getEVT ( SI -> getType ( ) ) == ( EVT :: getEVT ( Use -> getType ( ) ) ) ) ; Use -> replaceAllUsesWith ( SI ) ; Instruction * First = & F . getEntryBlock ( ) . front ( ) ; SI -> insertBefore ( First ) ; Use -> eraseFromParent ( ) ; } } } } ++ Idx ; } for ( auto & B : F ) { for ( auto & I : B ) { BinaryOperator * Ashr = dyn_cast < BinaryOperator > ( & I ) ; if ( ! ( Ashr && Ashr -> getOpcode ( ) == Instruction :: AShr ) ) continue ; Value * AshrOp1 = Ashr -> getOperand ( 1 ) ; ConstantInt * C = dyn_cast < ConstantInt > ( AshrOp1 ) ; if ( ! ( C && C -> getSExtValue ( ) == 16 ) ) continue ; Instruction * Shl = dyn_cast < Instruction > ( Ashr -> getOperand ( 0 ) ) ; if ( ! ( Shl && Shl -> getOpcode ( ) == Instruction :: Shl ) ) continue ; Value * Intr = Shl -> getOperand ( 0 ) ; Value * ShlOp1 = Shl -> getOperand ( 1 ) ; C = dyn_cast < ConstantInt > ( ShlOp1 ) ; if ( ! ( C && C -> getSExtValue ( ) == 16 ) ) continue ; if ( IntrinsicInst * I = dyn_cast < IntrinsicInst > ( Intr ) ) { if ( ! intrinsicAlreadySextended ( I -> getIntrinsicID ( ) ) ) continue ; for ( auto UI = Ashr -> user_begin ( ) , UE = Ashr -> user_end ( ) ; UI != UE ; ++ UI ) { const Use & TheUse = UI . getUse ( ) ; if ( Instruction * J = dyn_cast < Instruction > ( TheUse . getUser ( ) ) ) { J -> replaceUsesOfWith ( Ashr , I ) ; } } } } } return true ; } </s>

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


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

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


<s>
const
char
*
R600ClauseMergePass
::
getPassName
(
)
const
{
return
"R600 Merge Clause Markers Pass"
;
}
</s>

getPassName - Return a nice clean name for a pass .

AMDGPU
R600
"R600 Merge Clause Markers Pass"


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


<s> unsigned int rs6000_data_alignment ( tree type , unsigned int align , enum data_align how ) { if ( how != align_opt ) { if ( TREE_CODE ( type ) == VECTOR_TYPE && align < 128 ) align = 128 ; } if ( how != align_abi ) { if ( TREE_CODE ( type ) == ARRAY_TYPE && TYPE_MODE ( TREE_TYPE ( type ) ) == QImode ) { if ( align < BITS_PER_WORD ) align = BITS_PER_WORD ; } } return align ; } </s>

Return alignment of TYPE . Existing alignment is ALIGN . HOW selects whether the alignment is abi mandated , optional , or both abi and optional alignment .


<s> AArch64TargetMachine :: AArch64TargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , CodeModel :: Model CM , CodeGenOpt :: Level OL , bool LittleEndian ) : LLVMTargetMachine ( T , computeDataLayout ( TT , Options . MCOptions , LittleEndian ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , RM ) , CM , OL ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) , isLittle ( LittleEndian ) { initAsmInfo ( ) ; } </s>


<s> rtx ix86_build_signbit_mask ( machine_mode mode , bool vect , bool invert ) { machine_mode vec_mode , imode ; wide_int w ; rtx mask , v ; switch ( mode ) { case E_V16SImode : case E_V16SFmode : case E_V8SImode : case E_V4SImode : case E_V8SFmode : case E_V4SFmode : case E_V2SFmode : vec_mode = mode ; imode = SImode ; break ; case E_V8DImode : case E_V4DImode : case E_V2DImode : case E_V8DFmode : case E_V4DFmode : case E_V2DFmode : vec_mode = mode ; imode = DImode ; break ; case E_TImode : case E_TFmode : vec_mode = VOIDmode ; imode = TImode ; break ; default : gcc_unreachable ( ) ; } machine_mode inner_mode = GET_MODE_INNER ( mode ) ; w = wi :: set_bit_in_zero ( GET_MODE_BITSIZE ( inner_mode ) - 1 , GET_MODE_BITSIZE ( inner_mode ) ) ; if ( invert ) w = wi :: bit_not ( w ) ; mask = immed_wide_int_const ( w , imode ) ; mask = gen_lowpart ( inner_mode , mask ) ; if ( vec_mode == VOIDmode ) return force_reg ( inner_mode , mask ) ; v = ix86_build_const_vector ( vec_mode , vect , mask ) ; return force_reg ( vec_mode , v ) ; } </s>

A subroutine of ix86_expand_fp_absneg_operator and copysign expanders . Create a mask for the sign bit in MODE for an SSE register . If VECT is true , then replicate the mask for all elements of the vector register . If INVERT is true , then create a mask excluding the sign bit .


<s> static rtx mips_unspec_call ( rtx reg , rtx symbol ) { rtvec vec ; vec = gen_rtvec ( 3 , reg , symbol , gen_rtx_REG ( SImode , GOT_VERSION_REGNUM ) ) ; return gen_rtx_UNSPEC ( Pmode , vec , UNSPEC_LOAD_CALL ) ; } </s>

Return the RHS of a load_call < mode > insn .


<s> bool sh_split_movrt_negc_to_movt_xor ( rtx_insn * curr_insn , rtx operands [ ] ) { if ( ! can_create_pseudo_p ( ) ) return false ; set_of_reg t_before_negc = sh_find_set_of_reg ( get_t_reg_rtx ( ) , curr_insn , prev_nonnote_insn_bb ) ; set_of_reg t_after_negc = sh_find_set_of_reg ( get_t_reg_rtx ( ) , curr_insn , next_nonnote_insn_bb ) ; if ( t_before_negc . set_rtx != NULL_RTX && t_after_negc . set_rtx != NULL_RTX && rtx_equal_p ( t_before_negc . set_rtx , t_after_negc . set_rtx ) && ! reg_used_between_p ( get_t_reg_rtx ( ) , curr_insn , t_after_negc . insn ) && ! sh_insn_operands_modified_between_p ( t_before_negc . insn , t_before_negc . insn , t_after_negc . insn ) && ! modified_between_p ( get_t_reg_rtx ( ) , curr_insn , t_after_negc . insn ) && ! sh_unspec_insn_p ( t_after_negc . insn ) && ! volatile_insn_p ( PATTERN ( t_after_negc . insn ) ) && ! side_effects_p ( PATTERN ( t_after_negc . insn ) ) && ! may_trap_or_fault_p ( PATTERN ( t_after_negc . insn ) ) ) { emit_insn ( gen_movrt_xor ( operands [ 0 ] , get_t_reg_rtx ( ) ) ) ; set_insn_deleted ( t_after_negc . insn ) ; return true ; } else return false ; } </s>

Given the current insn , which is assumed to be a movrt_negc insn , try to figure out whether it should be converted into a movt-xor sequence in the movrt_negc splitter . Returns true if insns have been modified and the splitter has succeeded .


<s> static void vector_init_bshuffle ( rtx target , rtx elt , machine_mode mode , machine_mode inner_mode ) { rtx t1 , final_insn , sel ; int bmask ; t1 = gen_reg_rtx ( mode ) ; elt = convert_modes ( SImode , inner_mode , elt , true ) ; emit_move_insn ( gen_lowpart ( SImode , t1 ) , elt ) ; switch ( mode ) { case V2SImode : final_insn = gen_bshufflev2si_vis ( target , t1 , t1 ) ; bmask = 0x45674567 ; break ; case V4HImode : final_insn = gen_bshufflev4hi_vis ( target , t1 , t1 ) ; bmask = 0x67676767 ; break ; case V8QImode : final_insn = gen_bshufflev8qi_vis ( target , t1 , t1 ) ; bmask = 0x77777777 ; break ; default : gcc_unreachable ( ) ; } sel = force_reg ( SImode , GEN_INT ( bmask ) ) ; emit_insn ( gen_bmasksi_vis ( gen_reg_rtx ( SImode ) , sel , const0_rtx ) ) ; emit_insn ( final_insn ) ; } </s>

Subroutine of sparc_expand_vector_init . Emit code to initialize all fields of TARGET to ELT by means of VIS2 BSHUFFLE insn . MODE and INNER_MODE are the modes describing TARGET .


<s> void BTFDebug :: beginInstruction ( const MachineInstr * MI ) { DebugHandlerBase :: beginInstruction ( MI ) ; if ( SkipInstruction || MI -> isMetaInstruction ( ) || MI -> getFlag ( MachineInstr :: FrameSetup ) ) return ; if ( MI -> isInlineAsm ( ) ) { unsigned NumDefs = 0 ; for ( ; MI -> getOperand ( NumDefs ) . isReg ( ) && MI -> getOperand ( NumDefs ) . isDef ( ) ; ++ NumDefs ) ; const char * AsmStr = MI -> getOperand ( NumDefs ) . getSymbolName ( ) ; if ( AsmStr [ 0 ] == 0 ) return ; } if ( MI -> getOpcode ( ) == BPF :: LD_imm64 ) { processGlobalValue ( MI -> getOperand ( 1 ) ) ; } else if ( MI -> getOpcode ( ) == BPF :: CORE_MEM || MI -> getOpcode ( ) == BPF :: CORE_ALU32_MEM || MI -> getOpcode ( ) == BPF :: CORE_SHIFT ) { processGlobalValue ( MI -> getOperand ( 3 ) ) ; } else if ( MI -> getOpcode ( ) == BPF :: JAL ) { const MachineOperand & MO = MI -> getOperand ( 0 ) ; if ( MO . isGlobal ( ) ) { processFuncPrototypes ( dyn_cast < Function > ( MO . getGlobal ( ) ) ) ; } } if ( ! CurMI ) return ; const DebugLoc & DL = MI -> getDebugLoc ( ) ; if ( ! DL || PrevInstLoc == DL ) { if ( LineInfoGenerated == false ) { auto * S = MI -> getMF ( ) -> getFunction ( ) . getSubprogram ( ) ; MCSymbol * FuncLabel = Asm -> getFunctionBegin ( ) ; constructLineInfo ( S , FuncLabel , S -> getLine ( ) , 0 ) ; LineInfoGenerated = true ; } return ; } MCSymbol * LineSym = OS . getContext ( ) . createTempSymbol ( ) ; OS . emitLabel ( LineSym ) ; auto SP = DL . get ( ) -> getScope ( ) -> getSubprogram ( ) ; constructLineInfo ( SP , LineSym , DL . getLine ( ) , DL . getCol ( ) ) ; LineInfoGenerated = true ; PrevInstLoc = DL ; } </s>


<s> bool shouldBuildLookupTablesForConstant ( Constant * C ) const { if ( ST -> isROPI ( ) || ST -> isRWPI ( ) ) return ! C -> needsRelocation ( ) ; return true ; } </s>

Return true if switches should be turned into lookup tables containing this constant value for the target .


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

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


<s> bool TLCS900FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getTarget ( ) . getInstrInfo ( ) ; TLCS900MachineFunctionInfo * MFI = MF . getInfo < TLCS900MachineFunctionInfo > ( ) ; MFI -> setCalleeSavedFrameSize ( CSI . size ( ) * 2 ) ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; MBB . addLiveIn ( Reg ) ; BuildMI ( MBB , MI , DL , TII . get ( TLCS900 :: PUSH16r ) ) . addReg ( Reg , RegState :: Kill ) ; } return true ; } </s>

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


<s> bool AArch64TargetLowering :: shouldExpandAtomicStoreInIR ( StoreInst * SI ) const { unsigned Size = SI -> getValueOperand ( ) -> getType ( ) -> getPrimitiveSizeInBits ( ) ; if ( Size != 128 ) return false ; return ! isOpSuitableForLDPSTP ( SI ) ; } </s>

Returns how the given ( atomic ) store should be expanded by the IR-level AtomicExpand pass into .


<s> std :: pair < unsigned , const TargetRegisterClass * > MOSTargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'r' : if ( VT == MVT :: i16 ) return std :: make_pair ( 0U , & MOS :: Imag16RegClass ) ; return std :: make_pair ( 0U , & MOS :: Imag8RegClass ) ; case 'R' : return std :: make_pair ( 0U , & MOS :: GPRRegClass ) ; case 'a' : return std :: make_pair ( MOS :: A , & MOS :: GPRRegClass ) ; case 'x' : return std :: make_pair ( MOS :: X , & MOS :: GPRRegClass ) ; case 'y' : return std :: make_pair ( MOS :: Y , & MOS :: GPRRegClass ) ; case 'd' : return std :: make_pair ( 0U , & MOS :: XYRegClass ) ; } } if ( Constraint == "{cc}" ) return std :: make_pair ( MOS :: P , & MOS :: PcRegClass ) ; return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> unsigned PPCTargetLowering :: getByValTypeAlignment ( const Type * Ty ) const { TargetMachine & TM = getTargetMachine ( ) ; if ( TM . getSubtarget < PPCSubtarget > ( ) . isDarwin ( ) ) return 4 ; return 4 ; } </s>

Return the desired alignment for ByVal aggregate function arguments in the caller parameter area .


<s>
void
dump
(
)
{
errs
(
)
<<
"XNCMISelAddressMode "
<<
this
<<
'\n'
;
if
(
BaseType
==
RegBase
&&
Base
.
Reg
.
getNode
(
)
!=
0
)
{
errs
(
)
<<
"Base.Reg "
;
Base
.
Reg
.
getNode
(
)
->
dump
(
)
;
}
else
if
(
BaseType
==
FrameIndexBase
)
{
errs
(
)
<<
" Base.FrameIndex "
<<
Base
.
FrameIndex
<<
'\n'
;
}
errs
(
)
<<
" Disp "
<<
Disp
<<
'\n'
;
if
(
GV
)
{
errs
(
)
<<
"GV "
;
GV
->
dump
(
)
;
}
else
if
(
CP
)
{
errs
(
)
<<
" CP "
;
CP
->
dump
(
)
;
errs
(
)
<<
" Align"
<<
Align
<<
'\n'
;
}
else
if
(
ES
)
{
errs
(
)
<<
"ES "
;
errs
(
)
<<
ES
<<
'\n'
;
}
else
if
(
JT
!=
1
)
errs
(
)
<<
" JT"
<<
JT
<<
" Align"
<<
Align
<<
'\n'
;
}
</s>

Dump the plan to stderr ( for debugging ) .

XNCM
"XNCMISelAddressMode "
0
"Base.Reg "
" Base.FrameIndex "
" Disp "
"GV "
" CP "
" Align"
"ES "
1
" JT"
" Align"


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

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


<s> void s390_expand_atomic ( machine_mode mode , enum rtx_code code , rtx target , rtx mem , rtx val , bool after ) { struct alignment_context ac ; rtx cmp ; rtx new_rtx = gen_reg_rtx ( SImode ) ; rtx orig = gen_reg_rtx ( SImode ) ; rtx_code_label * csloop = gen_label_rtx ( ) ; gcc_assert ( ! target || register_operand ( target , VOIDmode ) ) ; gcc_assert ( MEM_P ( mem ) ) ; init_alignment_context ( & ac , mem , mode ) ; if ( ! ( ac . aligned && code == SET && MEM_P ( val ) ) ) val = s390_expand_mask_and_shift ( val , mode , ac . shift ) ; if ( code == PLUS || code == MINUS ) emit_move_insn ( orig , val ) ; else if ( code == MULT || code == AND ) val = expand_simple_binop ( SImode , XOR , val , ac . modemaski , NULL_RTX , 1 , OPTAB_DIRECT ) ; cmp = force_reg ( SImode , ac . memsi ) ; emit_label ( csloop ) ; emit_move_insn ( new_rtx , cmp ) ; switch ( code ) { case PLUS : case MINUS : val = expand_simple_binop ( SImode , code , new_rtx , orig , NULL_RTX , 1 , OPTAB_DIRECT ) ; val = expand_simple_binop ( SImode , AND , val , ac . modemask , NULL_RTX , 1 , OPTAB_DIRECT ) ; case SET : if ( ac . aligned && MEM_P ( val ) ) store_bit_field ( new_rtx , GET_MODE_BITSIZE ( mode ) , 0 , 0 , 0 , SImode , val , false ) ; else { new_rtx = expand_simple_binop ( SImode , AND , new_rtx , ac . modemaski , NULL_RTX , 1 , OPTAB_DIRECT ) ; new_rtx = expand_simple_binop ( SImode , IOR , new_rtx , val , NULL_RTX , 1 , OPTAB_DIRECT ) ; } break ; case AND : case IOR : case XOR : new_rtx = expand_simple_binop ( SImode , code , new_rtx , val , NULL_RTX , 1 , OPTAB_DIRECT ) ; break ; case MULT : new_rtx = expand_simple_binop ( SImode , AND , new_rtx , val , NULL_RTX , 1 , OPTAB_DIRECT ) ; new_rtx = expand_simple_binop ( SImode , XOR , new_rtx , ac . modemask , NULL_RTX , 1 , OPTAB_DIRECT ) ; break ; default : gcc_unreachable ( ) ; } s390_emit_jump ( csloop , s390_emit_compare_and_swap ( NE , cmp , ac . memsi , cmp , new_rtx ) ) ; if ( target ) convert_move ( target , expand_simple_binop ( SImode , LSHIFTRT , after ? new_rtx : cmp , ac . shift , NULL_RTX , 1 , OPTAB_DIRECT ) , 1 ) ; } </s>

Expand an atomic operation CODE of mode MODE . MEM is the memory location and VAL the value to play with . If AFTER is true then store the the value MEM holds after the operation , if AFTER is false then store the value MEM holds before the operation . If TARGET is zero then discard that value , else store it to TARGET .


<s>
const
ArrayRef
<
MCPhysReg
>
MipsABIInfo
::
GetByValArgRegs
(
)
const
{
if
(
IsO32
(
)
)
return
makeArrayRef
(
O32IntRegs
)
;
if
(
IsN32
(
)
||
IsN64
(
)
)
return
makeArrayRef
(
Mips64IntRegs
)
;
llvm_unreachable
(
"Unhandled ABI"
)
;
}
</s>

The registers to use for byval arguments .


<s> uint32_t getArrayIndexTypeId ( ) { assert ( ArrayIndexTypeId ) ; return ArrayIndexTypeId ; } </s>


<s> PreservedAnalyses BPFIRPeepholePass :: run ( Function & F , FunctionAnalysisManager & AM ) { return BPFIRPeepholeImpl ( F ) ? PreservedAnalyses :: none ( ) : PreservedAnalyses :: all ( ) ; } </s>

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


<s>
bool
GenericToNVVM
::
runOnModule
(
Module
&
M
)
{
for
(
GlobalVariable
&
GV
:
llvm
::
make_early_inc_range
(
M
.
globals
(
)
)
)
{
if
(
GV
.
getType
(
)
->
getAddressSpace
(
)
==
llvm
::
ADDRESS_SPACE_GENERIC
&&
!
llvm
::
isTexture
(
GV
)
&&
!
llvm
::
isSurface
(
GV
)
&&
!
llvm
::
isSampler
(
GV
)
&&
!
GV
.
getName
(
)
.
startswith
(
"llvm."
)
)
{
GlobalVariable
*
NewGV
=
new
GlobalVariable
(
M
,
GV
.
getValueType
(
)
,
GV
.
isConstant
(
)
,
GV
.
getLinkage
(
)
,
GV
.
hasInitializer
(
)
GV
.
getInitializer
(
)
:
nullptr
,
""
,
&
GV
,
GV
.
getThreadLocalMode
(
)
,
llvm
::
ADDRESS_SPACE_GLOBAL
)
;
NewGV
->
copyAttributesFrom
(
&
GV
)
;
GVMap
[
&
GV
]
=
NewGV
;
}
}
if
(
GVMap
.
empty
(
)
)
{
return
false
;
}
for
(
Function
&
F
:
M
)
{
if
(
F
.
isDeclaration
(
)
)
{
continue
;
}
IRBuilder
<
>
Builder
(
F
.
getEntryBlock
(
)
.
getFirstNonPHIOrDbg
(
)
)
;
for
(
BasicBlock
&
BB
:
F
)
{
for
(
Instruction
&
II
:
BB
)
{
for
(
unsigned
i
=
0
,
e
=
II
.
getNumOperands
(
)
;
i
<
e
;
++
i
)
{
Value
*
Operand
=
II
.
getOperand
(
i
)
;
if
(
isa
<
Constant
>
(
Operand
)
)
{
II
.
setOperand
(
i
,
remapConstant
(
&
M
,
&
F
,
cast
<
Constant
>
(
Operand
)
,
Builder
)
)
;
}
}
}
}
ConstantToValueMap
.
clear
(
)
;
}
ValueToValueMapTy
VM
;
for
(
auto
I
=
GVMap
.
begin
(
)
,
E
=
GVMap
.
end
(
)
;
I
!=
E
;
++
I
)
VM
[
I
->
first
]
=
I
->
second
;
for
(
GVMapTy
::
iterator
I
=
GVMap
.
begin
(
)
,
E
=
GVMap
.
end
(
)
;
I
!=
E
;
)
{
GlobalVariable
*
GV
=
I
->
first
;
GlobalVariable
*
NewGV
=
I
->
second
;
auto
Next
=
std
::
next
(
I
)
;
GVMap
.
erase
(
I
)
;
I
=
Next
;
Constant
*
BitCastNewGV
=
ConstantExpr
::
getPointerCast
(
NewGV
,
GV
->
getType
(
)
)
;
GV
->
replaceAllUsesWith
(
BitCastNewGV
)
;
std
::
string
Name
=
std
::
string
(
GV
->
getName
(
)
)
;
GV
->
eraseFromParent
(
)
;
NewGV
->
setName
(
Name
)
;
}
assert
(
GVMap
.
empty
(
)
&&
"Expected it to be empty by now"
)
;
return
true
;
}
</s>

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


<s> static rtx tilepro_got_rtx ( void ) { return cfun -> machine -> got_rtx ; } </s>

Return the register storing the value of the global offset table .


<s> BT :: RegisterCell BT :: get ( RegisterRef RR ) const { return ME . getCell ( RR , Map ) ; } </s>

Get the generated Value for a given VPValue and given Part and Lane .


<s> void emitFunctionEntryLabel ( ) override { } </s>

EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function .


<s> bool MipsSEInstrInfo :: expandPostRAPseudo ( MachineBasicBlock :: iterator MI ) const { MachineBasicBlock & MBB = * MI -> getParent ( ) ; switch ( MI -> getDesc ( ) . getOpcode ( ) ) { default : return false ; case Mips :: RetRA : ExpandRetRA ( MBB , MI , Mips :: RET ) ; break ; case Mips :: BuildPairF64 : ExpandBuildPairF64 ( MBB , MI ) ; break ; case Mips :: ExtractElementF64 : ExpandExtractElementF64 ( MBB , MI ) ; break ; case Mips :: MIPSeh_return32 : case Mips :: MIPSeh_return64 : ExpandEhReturn ( MBB , MI ) ; break ; } MBB . erase ( MI ) ; return true ; } </s>

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


<s> ScheduleDAGInstrs * createPostMachineScheduler ( MachineSchedContext * C ) const override { ScheduleDAGMI * DAG = createGenericSchedPostRA ( C ) ; return DAG ; } </s>

Similar to createMachineScheduler but used when postRA machine scheduling is enabled .


<s> PredicateOp getPredicate ( ) const { assert ( isPredicate ( ) ) ; return Pred ; } </s>

Returns the comparison predicate underlying the intrinsic .


<s> bool X86FrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; if ( MI != MBB . end ( ) && isFuncletReturnInstr ( * MI ) && STI . isOSWindows ( ) ) { if ( STI . is32Bit ( ) ) return true ; if ( MI -> getOpcode ( ) == X86 :: CATCHRET ) { const Function * Func = MBB . getParent ( ) -> getFunction ( ) ; bool IsSEH = isAsynchronousEHPersonality ( classifyEHPersonality ( Func -> getPersonalityFn ( ) ) ) ; if ( IsSEH ) return true ; } } DebugLoc DL = MBB . findDebugLoc ( MI ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( X86 :: GR64RegClass . contains ( Reg ) || X86 :: GR32RegClass . contains ( Reg ) ) continue ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . loadRegFromStackSlot ( MBB , MI , Reg , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; } unsigned Opc = STI . is64Bit ( ) ? X86 :: POP64r : X86 :: POP32r ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( ! X86 :: GR64RegClass . contains ( Reg ) && ! X86 :: GR32RegClass . contains ( Reg ) ) continue ; BuildMI ( MBB , MI , DL , TII . get ( Opc ) , Reg ) . setMIFlag ( MachineInstr :: FrameDestroy ) ; } return true ; } </s>

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


<s> bool aarch_rev16_p ( rtx x ) { rtx left_sub_rtx , right_sub_rtx ; bool is_rev = false ; if ( GET_CODE ( x ) != IOR ) return false ; left_sub_rtx = XEXP ( x , 0 ) ; right_sub_rtx = XEXP ( x , 1 ) ; is_rev = aarch_rev16_p_1 ( left_sub_rtx , right_sub_rtx , GET_MODE ( x ) ) ; if ( ! is_rev ) is_rev = aarch_rev16_p_1 ( right_sub_rtx , left_sub_rtx , GET_MODE ( x ) ) ; return is_rev ; } </s>

Recognise a sequence of bitwise operations corresponding to a rev16 operation . These will be of the form : ( ( x > > 8 ) & 0x00ff00ff ) | ( ( x < < 8 ) & 0xff00ff00 ) for SImode and with similar but wider bitmasks for DImode . The two sub-expressions of the IOR can appear on either side so check both permutations with the help of aarch_rev16_p_1 above .


<s> unsigned WebAssemblyTTIImpl :: getNumberOfRegisters ( bool Vector ) { unsigned Result = BaseT :: getNumberOfRegisters ( Vector ) ; if ( Vector ) Result = std :: max ( Result , 16u ) ; return Result ; } </s>


<s> void RISCVPassConfig :: addPostRegAlloc ( ) { if ( TM -> getOptLevel ( ) != CodeGenOpt :: None && EnableRedundantCopyElimination ) addPass ( createRISCVRedundantCopyEliminationPass ( ) ) ; } </s>

This method may be implemented by targets that want to run passes after register allocation pass pipeline but before prolog-epilog insertion .


<s> bool isRegister ( ) const { return type == RAInfo :: LocType :: Register ; } </s>

isRegister - Returns true if this is a normal register use/def slot .


<s> BitVector getReservedRegs ( const MachineFunction & MF ) const override { assert ( ! "Unimplemented" ) ; return BitVector ( ) ; } </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 .