<s> void ix86_expand_clear ( rtx dest ) { rtx tmp ; gcc_assert ( reload_completed ) ; if ( GET_MODE_SIZE ( GET_MODE ( dest ) ) < 4 ) dest = gen_rtx_REG ( SImode , REGNO ( dest ) ) ; tmp = gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ; if ( reload_completed && ( ! TARGET_USE_MOV0 || optimize_size ) ) { rtx clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , 17 ) ) ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , tmp , clob ) ) ; } emit_insn ( tmp ) ; } </s>

Generate either `` mov $ 0 , reg '' or `` xor reg , reg '' , as appropriate for the target .


<s> unsigned Z80oldInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { if ( isFrameStoreOpcode ( MI . getOpcode ( ) ) && ! MI . getOperand ( 2 ) . getSubReg ( ) && isFrameOperand ( MI , 0 , FrameIndex ) ) { return MI . getOperand ( 2 ) . getReg ( ) ; } return 0 ; } </s>

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


<s> static rtx_insn * gen_and2_insn ( rtx x , rtx y ) { enum insn_code icode = optab_handler ( and_optab , GET_MODE ( x ) ) ; gcc_assert ( insn_operand_matches ( icode , 0 , x ) ) ; gcc_assert ( insn_operand_matches ( icode , 1 , x ) ) ; gcc_assert ( insn_operand_matches ( icode , 2 , y ) ) ; return GEN_FCN ( icode ) ( x , x , y ) ; } </s>

Generate and return an insn body to AND X with Y .


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

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


<s> static bool sh_function_ok_for_sibcall ( tree decl , tree exp ATTRIBUTE_UNUSED ) { return ( 1 && ( ! TARGET_SHCOMPACT || crtl -> args . info . stack_regs == 0 ) && ! sh_cfun_interrupt_handler_p ( ) && ( ! flag_pic || TARGET_FDPIC || ( decl && ! ( TREE_PUBLIC ( decl ) || DECL_WEAK ( decl ) ) ) || ( decl && DECL_VISIBILITY ( decl ) != VISIBILITY_DEFAULT ) ) ) ; } </s>

If PIC , we can not make sibling calls to global functions because the PLT requires r12 to be live .


<s> unsigned getNumFixupKinds ( ) const override { return MSP430 :: NumTargetFixupKinds ; } </s>

Get the number of target specific fixup kinds .


<s> bool isRegister ( ) const { return ! IsStack ; } </s>

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


<s> static rtx avr_compare_pattern ( rtx_insn * insn ) { rtx pattern = single_set ( insn ) ; if ( pattern && NONJUMP_INSN_P ( insn ) && REG_P ( SET_DEST ( pattern ) ) && REGNO ( SET_DEST ( pattern ) ) == REG_CC && GET_CODE ( SET_SRC ( pattern ) ) == COMPARE ) { machine_mode mode0 = GET_MODE ( XEXP ( SET_SRC ( pattern ) , 0 ) ) ; machine_mode mode1 = GET_MODE ( XEXP ( SET_SRC ( pattern ) , 1 ) ) ; if ( ( mode0 == VOIDmode || GET_MODE_SIZE ( mode0 ) <= 4 ) && ( mode1 == VOIDmode || GET_MODE_SIZE ( mode1 ) <= 4 ) ) return pattern ; } return NULL_RTX ; } </s>


<s> bool SVEIntrinsicOpts :: runOnModule ( Module & M ) { bool Changed = false ; SmallSetVector < Function * , 4 > Functions ; for ( auto & F : M . getFunctionList ( ) ) { if ( ! F . isDeclaration ( ) ) continue ; switch ( F . getIntrinsicID ( ) ) { case Intrinsic :: aarch64_sve_ptest_any : case Intrinsic :: aarch64_sve_ptest_first : case Intrinsic :: aarch64_sve_ptest_last : case Intrinsic :: aarch64_sve_ptrue : case Intrinsic :: aarch64_sve_mul : case Intrinsic :: aarch64_sve_fmul : case Intrinsic :: aarch64_sve_tbl : for ( User * U : F . users ( ) ) Functions . insert ( cast < Instruction > ( U ) -> getFunction ( ) ) ; break ; default : break ; } } if ( ! Functions . empty ( ) ) Changed |= optimizeFunctions ( Functions ) ; return Changed ; } </s>

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


<s> unsigned AMDGPUCFGStructurizer :: getLoopDepth ( MachineLoop * LoopRep ) { return LoopRep ? LoopRep -> getLoopDepth ( ) : 0 ; } </s>

Return the loop nesting level of the specified block .


<s>
static
void
visium_output_address
(
FILE
*
file
,
enum
machine_mode
mode
,
rtx
addr
)
{
switch
(
GET_CODE
(
addr
)
)
{
case
REG
:
case
SUBREG
:
fprintf
(
file
,
"(%s)"
,
reg_names
[
true_regnum
(
addr
)
]
)
;
break
;
case
PLUS
:
{
rtx
x
=
XEXP
(
addr
,
0
)
,
y
=
XEXP
(
addr
,
1
)
;
switch
(
GET_CODE
(
x
)
)
{
case
REG
:
case
SUBREG
:
if
(
CONST_INT_P
(
y
)
)
{
unsigned
int
regno
=
true_regnum
(
x
)
;
HOST_WIDE_INT
val
=
INTVAL
(
y
)
;
switch
(
mode
)
{
case
SImode
:
case
DImode
:
case
SFmode
:
case
DFmode
:
val
>>=
2
;
break
;
case
HImode
:
val
>>=
1
;
break
;
case
QImode
:
default
:
break
;
}
fprintf
(
file
,
HOST_WIDE_INT_PRINT_DEC
"(%s)"
,
val
,
reg_names
[
regno
]
)
;
}
else
fatal_insn
(
"illegal operand address (1)"
,
addr
)
;
break
;
default
:
if
(
CONSTANT_P
(
x
)
&&
CONSTANT_P
(
y
)
)
output_addr_const
(
file
,
addr
)
;
else
fatal_insn
(
"illegal operand address (2)"
,
addr
)
;
break
;
}
}
break
;
case
LABEL_REF
:
case
SYMBOL_REF
:
case
CONST_INT
:
case
CONST
:
output_addr_const
(
file
,
addr
)
;
break
;
case
NOTE
:
if
(
NOTE_KIND
(
addr
)
!=
NOTE_INSN_DELETED_LABEL
)
fatal_insn
(
"illegal operand address (3)"
,
addr
)
;
break
;
case
CODE_LABEL
:
asm_fprintf
(
file
,
"%LL%d"
,
CODE_LABEL_NUMBER
(
addr
)
)
;
break
;
default
:
fatal_insn
(
"illegal operand address (4)"
,
addr
)
;
break
;
}
}
</s>

Output to stdio stream FILE the assembler syntax for an instruction operand that is a memory reference in MODE and whose address is ADDR .

visium
"(%s)"
0
1
2
1
"(%s)"
"illegal operand address (1)"
"illegal operand address (2)"
"illegal operand address (3)"
"%LL%d"
"illegal operand address (4)"


"unimplemented opcode in encodeInstruction()"

Encode the given Inst to bytes and append to CB .


<s> void aarch64_cpu_cpp_builtins ( cpp_reader * pfile ) { aarch64_define_unconditional_macros ( pfile ) ; aarch64_update_cpp_builtins ( pfile ) ; } </s>


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

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


<s> static tree ia64_gimplify_va_arg ( tree valist , tree type , gimple_seq * pre_p , gimple_seq * post_p ) { if ( pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ) { tree ptrtype = build_pointer_type ( type ) ; tree addr = std_gimplify_va_arg_expr ( valist , ptrtype , pre_p , post_p ) ; return build_va_arg_indirect_ref ( addr ) ; } if ( ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) ? int_size_in_bytes ( type ) > 8 : TYPE_ALIGN ( type ) > 8 * BITS_PER_UNIT ) { tree t = fold_build_pointer_plus_hwi ( valist , 2 * UNITS_PER_WORD - 1 ) ; t = build2 ( BIT_AND_EXPR , TREE_TYPE ( t ) , t , build_int_cst ( TREE_TYPE ( t ) , - 2 * UNITS_PER_WORD ) ) ; gimplify_assign ( unshare_expr ( valist ) , t , pre_p ) ; } return std_gimplify_va_arg_expr ( valist , type , pre_p , post_p ) ; } </s>


<s> static int mips16_constant_cost ( int code , HOST_WIDE_INT x ) { switch ( code ) { case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( IN_RANGE ( x , 1 , 8 ) ) return 0 ; return COSTS_N_INSNS ( 1 ) ; case PLUS : if ( IN_RANGE ( x , - 128 , 127 ) ) return 0 ; if ( SMALL_OPERAND ( x ) ) return COSTS_N_INSNS ( 1 ) ; return - 1 ; case LEU : if ( x == - 1 ) return - 1 ; case LE : x += 1 ; case XOR : case LT : case LTU : if ( IN_RANGE ( x , 0 , 255 ) ) return 0 ; if ( SMALL_OPERAND_UNSIGNED ( x ) ) return COSTS_N_INSNS ( 1 ) ; return - 1 ; case EQ : case NE : if ( x == 0 ) return 0 ; return - 1 ; default : return - 1 ; } } </s>

Return the cost of X when used as an operand to the MIPS16 instruction that implements CODE . Return -1 if there is no such instruction , or if X is not a valid immediate operand for it .


<s> static bool epiphany_pass_by_reference ( cumulative_args_t ca ATTRIBUTE_UNUSED , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { if ( type ) { if ( AGGREGATE_TYPE_P ( type ) && ( mode == BLKmode || TYPE_NEEDS_CONSTRUCTING ( type ) ) ) return true ; } return false ; } </s>

For EPIPHANY , All aggregates and arguments greater than 8 bytes are passed by reference .


<s> bool mergeStoresAfterLegalization ( EVT MemVT ) const override { return ! MemVT . isVector ( ) ; } </s>

Do not merge vector stores after legalization because that may conflict with x86-specific store splitting optimizations .


<s>
const
char
*
nds32_output_casesi
(
rtx
*
operands
)
{
if
(
flag_pic
)
{
output_asm_insn
(
"sethi\t$ta, hi20(%l1@GOTOFF)"
,
operands
)
;
output_asm_insn
(
"ori\t$ta, $ta, lo12(%l1@GOTOFF)"
,
operands
)
;
output_asm_insn
(
"add\t$ta, $ta, $gp"
,
operands
)
;
}
else
output_asm_insn
(
"la\t$ta, %l1"
,
operands
)
;
output_asm_insn
(
"lw\t%2, [$ta + %0 << 2]"
,
operands
)
;
if
(
TARGET_16_BIT
)
return
"jr5\t%2"
;
else
return
"jr\t%2"
;
}
</s>

Function to generate normal jump table .


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

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


"SHUXI DAG->DAG Pattern Instruction Selection"

getPassName - Return a nice clean name for a pass .


"Should be handled target independently"

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


<s> unsigned char X86Subtarget :: classifyGlobalFunctionReference ( const GlobalValue * GV , const Module & M ) const { if ( shouldAssumeDSOLocal ( TM . getRelocationModel ( ) , TargetTriple , M , GV ) ) return X86II :: MO_NO_FLAG ; assert ( ! isTargetCOFF ( ) ) ; if ( isTargetELF ( ) ) return X86II :: MO_PLT ; if ( is64Bit ( ) ) { auto * F = dyn_cast_or_null < Function > ( GV ) ; if ( F && F -> hasFnAttribute ( Attribute :: NonLazyBind ) ) return X86II :: MO_GOTPCREL ; return X86II :: MO_NO_FLAG ; } if ( ! getTargetTriple ( ) . isMacOSX ( ) || getTargetTriple ( ) . isMacOSXVersionLT ( 10 , 5 ) ) return X86II :: MO_DARWIN_STUB ; return X86II :: MO_NO_FLAG ; } </s>

Classify a global function reference for the current subtarget .


<s> static bool ix86_can_inline_p ( tree caller , tree callee ) { tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET ( caller ) ; tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET ( callee ) ; unsigned HOST_WIDE_INT always_inline_safe_mask = ( MASK_USE_8BIT_IDIV | MASK_ACCUMULATE_OUTGOING_ARGS | MASK_NO_ALIGN_STRINGOPS | MASK_AVX256_SPLIT_UNALIGNED_LOAD | MASK_AVX256_SPLIT_UNALIGNED_STORE | MASK_CLD | MASK_NO_FANCY_MATH_387 | MASK_IEEE_FP | MASK_INLINE_ALL_STRINGOPS | MASK_INLINE_STRINGOPS_DYNAMICALLY | MASK_RECIP | MASK_STACK_PROBE | MASK_STV | MASK_TLS_DIRECT_SEG_REFS | MASK_VZEROUPPER | MASK_NO_PUSH_ARGS | MASK_OMIT_LEAF_FRAME_POINTER ) ; if ( ! callee_tree ) callee_tree = target_option_default_node ; if ( ! caller_tree ) caller_tree = target_option_default_node ; if ( callee_tree == caller_tree ) return true ; struct cl_target_option * caller_opts = TREE_TARGET_OPTION ( caller_tree ) ; struct cl_target_option * callee_opts = TREE_TARGET_OPTION ( callee_tree ) ; bool ret = false ; bool always_inline = ( DECL_DISREGARD_INLINE_LIMITS ( callee ) && lookup_attribute ( "always_inline" , DECL_ATTRIBUTES ( callee ) ) ) ; if ( TARGET_GENERAL_REGS_ONLY_P ( callee_opts -> x_ix86_target_flags ) ) always_inline_safe_mask |= MASK_80387 ; cgraph_node * callee_node = cgraph_node :: get ( callee ) ; if ( ( ( caller_opts -> x_ix86_isa_flags & callee_opts -> x_ix86_isa_flags ) != callee_opts -> x_ix86_isa_flags ) || ( ( caller_opts -> x_ix86_isa_flags2 & callee_opts -> x_ix86_isa_flags2 ) != callee_opts -> x_ix86_isa_flags2 ) ) ret = false ; else if ( ( ! always_inline && caller_opts -> x_target_flags != callee_opts -> x_target_flags ) || ( caller_opts -> x_target_flags & ~ always_inline_safe_mask ) != ( callee_opts -> x_target_flags & ~ always_inline_safe_mask ) ) ret = false ; else if ( caller_opts -> arch != callee_opts -> arch ) ret = false ; else if ( ! always_inline && caller_opts -> tune != callee_opts -> tune ) ret = false ; else if ( caller_opts -> x_ix86_fpmath != callee_opts -> x_ix86_fpmath && ( ! ipa_fn_summaries || ipa_fn_summaries -> get ( callee_node ) == NULL || ipa_fn_summaries -> get ( callee_node ) -> fp_expressions ) ) ret = false ; else if ( ! always_inline && caller_opts -> branch_cost != callee_opts -> branch_cost ) ret = false ; else ret = true ; return ret ; } </s>

Hook to determine if one function can safely inline another .


<s> int empty_delay_slot ( rtx insn ) { rtx seq ; if ( PREV_INSN ( insn ) == NULL ) return 1 ; seq = NEXT_INSN ( PREV_INSN ( insn ) ) ; if ( GET_CODE ( PATTERN ( seq ) ) == SEQUENCE ) return 0 ; return 1 ; } </s>

Return non-zero if a branch or call instruction will be emitting a nop into its delay slot .


<s> static bool tilegx_pass_by_reference ( cumulative_args_t cum ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED , const_tree type , bool named ATTRIBUTE_UNUSED ) { return ( type && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) ; } </s>

Implement TARGET_PASS_BY_REFERENCE . Variable sized types are passed by reference .


"Disassembly not yet supported for subtarget"

Returns the disassembly of a single instruction .


<s> unsigned SparcRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { return SP :: I6 ; } </s>


<s> static rtx aarch64_function_value ( const_tree type , const_tree func , bool outgoing ATTRIBUTE_UNUSED ) { machine_mode mode ; int unsignedp ; int count ; machine_mode ag_mode ; mode = TYPE_MODE ( type ) ; if ( INTEGRAL_TYPE_P ( type ) ) mode = promote_function_mode ( type , mode , & unsignedp , func , 1 ) ; if ( aarch64_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( size % UNITS_PER_WORD != 0 ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , 0 ) ; } } if ( aarch64_vfp_is_call_or_return_candidate ( mode , type , & ag_mode , & count , NULL ) ) { if ( ! aarch64_composite_type_p ( type , mode ) ) { gcc_assert ( count == 1 && mode == ag_mode ) ; return gen_rtx_REG ( mode , V0_REGNUM ) ; } else { int i ; rtx par ; par = gen_rtx_PARALLEL ( mode , rtvec_alloc ( count ) ) ; for ( i = 0 ; i < count ; i ++ ) { rtx tmp = gen_rtx_REG ( ag_mode , V0_REGNUM + i ) ; tmp = gen_rtx_EXPR_LIST ( VOIDmode , tmp , GEN_INT ( i * GET_MODE_SIZE ( ag_mode ) ) ) ; XVECEXP ( par , 0 , i ) = tmp ; } return par ; } } else return gen_rtx_REG ( mode , R0_REGNUM ) ; } </s>

Implement TARGET_FUNCTION_VALUE . Define how to find the value returned by a function .


<s> static int arc_sched_issue_rate ( void ) { switch ( arc_tune ) { case TUNE_ARCHS4X : case TUNE_ARCHS4XD : return 3 ; default : break ; } return 1 ; } </s>

Implements target hook TARGET_SCHED_ISSUE_RATE .


<s>
const
char
*
getPassName
(
)
const
{
return
"R600 Expand special instructions pass"
;
}
</s>


<s> unsigned getStackAddress ( uint64_t Size , int64_t Offset , MachinePointerInfo & MPO ) override { auto & MFI = MIRBuilder . getMF ( ) . getFrameInfo ( ) ; int FI = MFI . CreateFixedObject ( Size , Offset , true ) ; MPO = MachinePointerInfo :: getFixedStack ( MIRBuilder . getMF ( ) , FI ) ; unsigned AddrReg = MRI . createGenericVirtualRegister ( LLT :: pointer ( 0 , 64 ) ) ; MIRBuilder . buildFrameIndex ( AddrReg , FI ) ; return AddrReg ; } </s>

Materialize a VReg containing the address of the specified stack-based object .


<s> std :: pair < unsigned , const TargetRegisterClass * > RISCVTargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'd' : case 'r' : if ( Subtarget . isRV64 ( ) ) return std :: make_pair ( 0U , & RISCV :: GR64BitRegClass ) ; return std :: make_pair ( 0U , & RISCV :: GR32BitRegClass ) ; case 'f' : if ( Subtarget . hasD ( ) ) return std :: make_pair ( 0U , & RISCV :: FP64BitRegClass ) ; else if ( Subtarget . hasF ( ) ) return std :: make_pair ( 0U , & RISCV :: FP32BitRegClass ) ; else if ( Subtarget . isRV64 ( ) ) return std :: make_pair ( 0U , & RISCV :: GR64BitRegClass ) ; return std :: make_pair ( 0U , & RISCV :: GR32BitRegClass ) ; } } std :: pair < unsigned , const TargetRegisterClass * > R ; R = TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; if ( ! R . second ) { R = parseRegForInlineAsmConstraint ( Constraint , VT ) ; } return R ; } </s>

Given a physical register constraint ( e.g .


<s> bool SystemZInstrInfo :: isPredicable ( MachineInstr & MI ) const { unsigned Opcode = MI . getOpcode ( ) ; if ( STI . hasLoadStoreOnCond ( ) && getConditionalMove ( Opcode ) ) return true ; if ( STI . hasLoadStoreOnCond2 ( ) && getConditionalLoadImmediate ( Opcode ) ) return true ; if ( Opcode == SystemZ :: Return || Opcode == SystemZ :: Trap || Opcode == SystemZ :: CallJG || Opcode == SystemZ :: CallBR ) return true ; return false ; } </s>

Return true if the specified instruction can be predicated .

SystemZ SystemZ SystemZ::Return SystemZ::Trap SystemZ::CallJG SystemZ::CallBR


<s> ARMBaseTargetMachine :: ARMBaseTargetMachine ( const Target & T , const std :: string & TT , const std :: string & FS , bool isThumb ) : LLVMTargetMachine ( T , TT ) , Subtarget ( TT , FS , isThumb ) , FrameInfo ( Subtarget ) , JITInfo ( ) , InstrItins ( Subtarget . getInstrItineraryData ( ) ) { DefRelocModel = getRelocationModel ( ) ; } </s>


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

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


<s> unsigned MipsSEInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { if ( MI . mayStore ( ) ) { if ( ( MI . getOperand ( 1 ) . isFI ( ) ) && ( MI . getOperand ( 2 ) . isImm ( ) ) && ( isZeroImm ( MI . getOperand ( 2 ) ) ) ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

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


<s> SMLoc getStartLoc ( ) const override { return StartLoc ; } </s>

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


"bad insn to frv_print_operand_address:"

Print a memory address as an operand to reference that memory location .


<s> void AMDGPUDAGToDAGISel :: PostprocessISelDAG ( ) { const AMDGPUTargetLowering & Lowering = * static_cast < const AMDGPUTargetLowering * > ( getTargetLowering ( ) ) ; bool IsModified = false ; do { IsModified = false ; for ( SelectionDAG :: allnodes_iterator I = CurDAG -> allnodes_begin ( ) , E = CurDAG -> allnodes_end ( ) ; I != E ; ++ I ) { SDNode * Node = I ; MachineSDNode * MachineNode = dyn_cast < MachineSDNode > ( I ) ; if ( ! MachineNode ) continue ; SDNode * ResNode = Lowering . PostISelFolding ( MachineNode , * CurDAG ) ; if ( ResNode != Node ) { ReplaceUses ( Node , ResNode ) ; IsModified = true ; } } CurDAG -> RemoveDeadNodes ( ) ; } while ( IsModified ) ; } </s>

PostprocessISelDAG ( ) - This hook allows the target to hack on the graph right after selection .


<s> static rtx lm32_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( mode == VOIDmode ) return GEN_INT ( 0 ) ; if ( targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; if ( ! named || ( * cum + LM32_NUM_REGS2 ( mode , type ) > LM32_NUM_ARG_REGS ) ) return NULL_RTX ; return gen_rtx_REG ( mode , * cum + LM32_FIRST_ARG_REG ) ; } </s>

Determine where to put an argument to a function . Value is zero to push the argument on the stack , or a hard register in which to store the argument . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) .


<s> static inline int multcosts ( rtx x ATTRIBUTE_UNUSED ) { if ( sh_multcost >= 0 ) return sh_multcost ; if ( TARGET_SH2 ) { if ( optimize_size ) return 2 ; return 3 ; } if ( optimize_size ) return 5 ; return 20 ; } </s>


<s> static void mips_emit_move_or_split ( rtx dest , rtx src , enum mips_split_type split_type ) { if ( mips_split_move_p ( dest , src , split_type ) ) mips_split_move ( dest , src , split_type ) ; else mips_emit_move ( dest , src ) ; } </s>

Emit a move from SRC to DEST , splitting compound moves into individual instructions . SPLIT_TYPE is the type of split to perform .


<s>
const
char
*
pa_singlemove_string
(
rtx
*
operands
)
{
HOST_WIDE_INT
intval
;
if
(
GET_CODE
(
operands
[
0
]
)
==
MEM
)
return
"stw %r1,%0"
;
if
(
GET_CODE
(
operands
[
1
]
)
==
MEM
)
return
"ldw %1,%0"
;
if
(
GET_CODE
(
operands
[
1
]
)
==
CONST_DOUBLE
)
{
long
i
;
gcc_assert
(
GET_MODE
(
operands
[
1
]
)
==
SFmode
)
;
REAL_VALUE_TO_TARGET_SINGLE
(
*
CONST_DOUBLE_REAL_VALUE
(
operands
[
1
]
)
,
i
)
;
operands
[
1
]
=
GEN_INT
(
i
)
;
}
if
(
GET_CODE
(
operands
[
1
]
)
==
CONST_INT
)
{
intval
=
INTVAL
(
operands
[
1
]
)
;
if
(
VAL_14_BITS_P
(
intval
)
)
return
"ldi %1,%0"
;
else
if
(
(
intval
&
0x7ff
)
==
0
)
return
"ldil L'%1,%0"
;
else
if
(
pa_zdepi_cint_p
(
intval
)
)
return
"{zdepi %Z1,%0|depwi,z %Z1,%0}"
;
else
return
"ldil L'%1,%0\n\tldo R'%1(%0),%0"
;
}
return
"copy %1,%0"
;
}
</s>

Return the best assembler insn template for moving operands [ 1 ] into operands [ 0 ] as a fullword .


<s> MCObjectWriter * createObjectWriter ( raw_pwrite_stream & OS ) const override { StringRef CPU ( "HexagonV4" ) ; return createHexagonELFObjectWriter ( OS , OSABI , CPU ) ; } </s>

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


<s> Value * X86TargetLowering :: getSafeStackPointerLocation ( IRBuilder < > & IRB ) const { if ( Subtarget . getTargetTriple ( ) . isOSContiki ( ) ) return getDefaultSafeStackPointerLocation ( IRB , false ) ; if ( Subtarget . isTargetAndroid ( ) ) { unsigned Offset = ( Subtarget . is64Bit ( ) ) ? 0x48 : 0x24 ; return SegmentOffset ( IRB , Offset , getAddressSpace ( ) ) ; } if ( Subtarget . isTargetFuchsia ( ) ) { return SegmentOffset ( IRB , 0x18 , getAddressSpace ( ) ) ; } return TargetLowering :: getSafeStackPointerLocation ( IRB ) ; } </s>

Return true if the target stores SafeStack pointer at a fixed offset in some non-standard address space , and populates the address space and offset as appropriate .


<s> bool X86DAGToDAGISel :: IsProfitableToFold ( SDValue N , SDNode * U , SDNode * Root ) const { if ( OptLevel == CodeGenOpt :: None ) return false ; if ( ! N . hasOneUse ( ) ) return false ; if ( N . getOpcode ( ) != ISD :: LOAD ) return true ; if ( U == Root ) { switch ( U -> getOpcode ( ) ) { default : break ; case X86ISD :: ADD : case X86ISD :: SUB : case X86ISD :: AND : case X86ISD :: XOR : case X86ISD :: OR : case ISD :: ADD : case ISD :: ADDCARRY : case ISD :: AND : case ISD :: OR : case ISD :: XOR : { SDValue Op1 = U -> getOperand ( 1 ) ; if ( ConstantSDNode * Imm = dyn_cast < ConstantSDNode > ( Op1 ) ) if ( Imm -> getAPIntValue ( ) . isSignedIntN ( 8 ) ) return false ; if ( Op1 . getOpcode ( ) == X86ISD :: Wrapper ) { SDValue Val = Op1 . getOperand ( 0 ) ; if ( Val . getOpcode ( ) == ISD :: TargetGlobalTLSAddress ) return false ; } } } } return true ; } </s>

IsProfitableToFold - Returns true if it 's profitable to fold the specific operand node N of U during instruction selection that starts at Root .


<s> bool preferred_la_operand_p ( rtx op1 , rtx op2 ) { struct s390_address addr ; if ( op2 != const0_rtx ) op1 = gen_rtx_PLUS ( Pmode , op1 , op2 ) ; if ( ! s390_decompose_address ( op1 , & addr ) ) return false ; if ( addr . base && ! REGNO_OK_FOR_BASE_P ( REGNO ( addr . base ) ) ) return false ; if ( addr . indx && ! REGNO_OK_FOR_INDEX_P ( REGNO ( addr . indx ) ) ) return false ; if ( addr . indx && s390_tune == PROCESSOR_2817_Z196 ) return false ; if ( ! TARGET_64BIT && ! addr . pointer ) return false ; if ( addr . pointer ) return true ; if ( ( addr . base && REG_P ( addr . base ) && REG_POINTER ( addr . base ) ) || ( addr . indx && REG_P ( addr . indx ) && REG_POINTER ( addr . indx ) ) ) return true ; return false ; } </s>

Return true if it is valid * and * preferable to use LA to compute the sum of OP1 and OP2 .


<s> bool Z80oldFrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { const MachineFunction & MF = * MBB . getParent ( ) ; const MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; bool UseShadow = shouldUseShadow ( MF ) ; DebugLoc DL = MBB . findDebugLoc ( MI ) ; if ( UseShadow ) { shadowCalleeSavedRegisters ( MBB , MI , DL , MachineInstr :: FrameSetup , CSI ) ; } for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; if ( UseShadow && ! Z80old :: IR16RegClass . contains ( Reg ) ) { continue ; } bool isLiveIn = MRI . isLiveIn ( Reg ) ; if ( ! isLiveIn ) { MBB . addLiveIn ( Reg ) ; } bool CanKill = ! isLiveIn ; if ( CanKill ) { for ( MCRegAliasIterator AReg ( Reg , TRI , false ) ; AReg . isValid ( ) ; ++ AReg ) { if ( MRI . isLiveIn ( * AReg ) ) { CanKill = false ; break ; } } } MachineInstrBuilder MIB ; if ( Reg == Z80old :: AF ) { MIB = BuildMI ( MBB , MI , DL , TII . get ( Z80old :: PUSH16AF ) ) ; } else MIB = BuildMI ( MBB , MI , DL , TII . get ( Z80old :: PUSH16r ) ) . addReg ( Reg , getKillRegState ( CanKill ) ) ; MIB . setMIFlag ( MachineInstr :: FrameSetup ) ; } return true ; } </s>

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


<s>
void
BT
::
run
(
)
{
reset
(
)
;
assert
(
FlowQ
.
empty
(
)
)
;
typedef
GraphTraits
<
const
MachineFunction
*
>
MachineFlowGraphTraits
;
const
MachineBasicBlock
*
Entry
=
MachineFlowGraphTraits
::
getEntryNode
(
&
MF
)
;
unsigned
MaxBN
=
0
;
for
(
MachineFunction
::
const_iterator
I
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
I
!=
E
;
++
I
)
{
assert
(
I
->
getNumber
(
)
>=
0
&&
"Disconnected block"
)
;
unsigned
BN
=
I
->
getNumber
(
)
;
if
(
BN
>
MaxBN
)
MaxBN
=
BN
;
}
BitVector
BlockScanned
(
MaxBN
+
1
)
;
int
EntryN
=
Entry
->
getNumber
(
)
;
FlowQ
.
push
(
CFGEdge
(
1
,
EntryN
)
)
;
while
(
!
FlowQ
.
empty
(
)
)
{
CFGEdge
Edge
=
FlowQ
.
front
(
)
;
FlowQ
.
pop
(
)
;
if
(
EdgeExec
.
count
(
Edge
)
)
continue
;
EdgeExec
.
insert
(
Edge
)
;
const
MachineBasicBlock
&
B
=
*
MF
.
getBlockNumbered
(
Edge
.
second
)
;
MachineBasicBlock
::
const_iterator
It
=
B
.
begin
(
)
,
End
=
B
.
end
(
)
;
while
(
It
!=
End
&&
It
->
isPHI
(
)
)
{
const
MachineInstr
*
PI
=
&
*
It
++
;
InstrExec
.
insert
(
PI
)
;
visitPHI
(
PI
)
;
}
if
(
BlockScanned
[
Edge
.
second
]
)
continue
;
BlockScanned
[
Edge
.
second
]
=
true
;
while
(
It
!=
End
&&
!
It
->
isBranch
(
)
)
{
const
MachineInstr
*
MI
=
&
*
It
++
;
InstrExec
.
insert
(
MI
)
;
visitNonBranch
(
MI
)
;
}
if
(
It
==
End
)
{
MachineFunction
::
const_iterator
BIt
=
&
B
;
MachineFunction
::
const_iterator
Next
=
std
::
next
(
BIt
)
;
if
(
Next
!=
MF
.
end
(
)
)
{
int
ThisN
=
B
.
getNumber
(
)
;
int
NextN
=
Next
->
getNumber
(
)
;
FlowQ
.
push
(
CFGEdge
(
ThisN
,
NextN
)
)
;
}
}
else
{
visitBranchesFrom
(
It
)
;
}
}
if
(
Trace
)
{
dbgs
(
)
<<
"Cells after propagation:\n"
;
for
(
CellMapType
::
iterator
I
=
Map
.
begin
(
)
,
E
=
Map
.
end
(
)
;
I
!=
E
;
++
I
)
dbgs
(
)
<<
PrintReg
(
I
->
first
,
&
ME
.
TRI
)
<<
" -> "
<<
I
->
second
<<
"\n"
;
}
}
</s>

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


<s> bool X86PassConfig :: addLegalizeMachineIR ( ) { return false ; } </s>

This method should install a legalize pass , which converts the instruction sequence into one that can be selected by the target .


<s> bool sh_lshrsi_clobbers_t_reg_p ( rtx shift_amount ) { gcc_assert ( CONST_INT_P ( shift_amount ) ) ; const int shift_amount_i = INTVAL ( shift_amount ) & 31 ; if ( shift_amount_i == 31 ) return true ; return ( ashl_lshr_seq [ shift_amount_i ] . clobbers_t & LSHR_CLOBBERS_T ) != 0 ; } </s>

Return true if a logical right shift consisting of 1/2/8/16 shift instructions will clobber the T bit .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Fast Tile Register Preconfigure"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> virtual const TargetRegisterInfo * getRegisterInfo ( ) const { return & InstrInfo . getRegisterInfo ( ) ; } </s>

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> static int ia64_issue_rate ( ) { return 6 ; } </s>

Return the maximum number of instructions a cpu can issue .


<s> rtx tilepro_return_addr ( int count , rtx frame ATTRIBUTE_UNUSED ) { if ( count != 0 ) return const0_rtx ; return get_hard_reg_initial_val ( Pmode , TILEPRO_LINK_REGNUM ) ; } </s>

Return an RTX indicating where the return address to the calling function can be found .


<s> static bool spe_func_has_64bit_regs_p ( void ) { rtx_insn * insns , * insn ; if ( crtl -> calls_eh_return || cfun -> calls_setjmp || crtl -> has_nonlocal_goto ) return true ; insns = get_insns ( ) ; for ( insn = NEXT_INSN ( insns ) ; insn != NULL_RTX ; insn = NEXT_INSN ( insn ) ) { if ( INSN_P ( insn ) ) { rtx i ; i = PATTERN ( insn ) ; if ( GET_CODE ( i ) == SET ) { machine_mode mode = GET_MODE ( SET_SRC ( i ) ) ; if ( SPE_VECTOR_MODE ( mode ) ) return true ; if ( TARGET_E500_DOUBLE && ( mode == DFmode || FLOAT128_2REG_P ( mode ) ) ) return true ; } } } return false ; } </s>

Return true if the current function uses any GPRs in 64-bit SIMD mode .


<s> bool AAPAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode , raw_ostream & O ) { printOperand ( MI , OpNo , O ) ; return false ; } </s>

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


"Thumb2 instruction size reduction pass"


<s> int PatmosInstrInfo :: getOperandLatency ( const InstrItineraryData * ItinData , const MachineInstr & DefMI , unsigned DefIdx , const MachineInstr & UseMI , unsigned UseIdx ) const { if ( UseMI . isInlineAsm ( ) ) { return getDefOperandLatency ( ItinData , DefMI , DefIdx ) ; } return TargetInstrInfo :: getOperandLatency ( ItinData , DefMI , DefIdx , UseMI , UseIdx ) ; } </s>

Compute and return the use operand latency of a given pair of def and use .


<s> bool HexagonTargetLowering :: isLegalAddressingMode ( const DataLayout & DL , const AddrMode & AM , Type * Ty , unsigned AS ) const { if ( Ty -> isSized ( ) ) { unsigned A = DL . getABITypeAlignment ( Ty ) ; if ( ( AM . BaseOffs % A ) != 0 ) return false ; if ( ! isInt < 11 > ( AM . BaseOffs >> Log2_32 ( A ) ) ) return false ; } if ( AM . BaseGV ) return false ; int Scale = AM . Scale ; if ( Scale < 0 ) Scale = - Scale ; switch ( Scale ) { case 0 : break ; default : return false ; } return true ; } </s>

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


<s> BitVector VERegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( VE :: SX8 ) ; Reserved . set ( VE :: SX9 ) ; Reserved . set ( VE :: SX10 ) ; Reserved . set ( VE :: SX11 ) ; Reserved . set ( VE :: SX12 ) ; Reserved . set ( VE :: SX13 ) ; Reserved . set ( VE :: SX14 ) ; Reserved . set ( VE :: SX15 ) ; Reserved . set ( VE :: SX16 ) ; Reserved . set ( VE :: SX17 ) ; 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 .


getTargetNodeName - This method returns the name of a target specific


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

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


"Do not know how to custom type legalize this operation!"

ReplaceNodeResults - Replace the results of node with an illegal result type with new values built out of custom code .


<s> EVT PPCTargetLowering :: getOptimalMemOpType ( uint64_t Size , unsigned DstAlign , unsigned SrcAlign , bool IsMemset , bool ZeroMemset , bool MemcpyStrSrc , const AttributeList & FuncAttributes ) const { if ( getTargetMachine ( ) . getOptLevel ( ) != CodeGenOpt :: None ) { if ( Subtarget . hasQPX ( ) && Size >= 32 && ( ! IsMemset || Size >= 64 ) && ( ! SrcAlign || SrcAlign >= 32 ) && ( ! DstAlign || DstAlign >= 32 ) && ! FuncAttributes . hasFnAttribute ( Attribute :: NoImplicitFloat ) ) { return MVT :: v4f64 ; } if ( Subtarget . hasAltivec ( ) && Size >= 16 && ( ( ( ! SrcAlign || SrcAlign >= 16 ) && ( ! DstAlign || DstAlign >= 16 ) ) || ( ( IsMemset && Subtarget . hasVSX ( ) ) || Subtarget . hasP8Vector ( ) ) ) ) return MVT :: v4i32 ; } if ( Subtarget . isPPC64 ( ) ) { return MVT :: i64 ; } return MVT :: i32 ; } </s>

It returns EVT : :Other if the type should be determined using generic target-independent logic .


<s>
void
PPCInstPrinter
::
printInst
(
const
MCInst
*
MI
,
raw_ostream
&
O
,
StringRef
Annot
)
{
if
(
MI
->
getOpcode
(
)
==
PPC
::
RLWINM
)
{
unsigned
char
SH
=
MI
->
getOperand
(
2
)
.
getImm
(
)
;
unsigned
char
MB
=
MI
->
getOperand
(
3
)
.
getImm
(
)
;
unsigned
char
ME
=
MI
->
getOperand
(
4
)
.
getImm
(
)
;
bool
useSubstituteMnemonic
=
false
;
if
(
SH
<=
31
&&
MB
==
0
&&
ME
==
(
31
SH
)
)
{
O
<<
"\tslwi "
;
useSubstituteMnemonic
=
true
;
}
if
(
SH
<=
31
&&
MB
==
(
32
SH
)
&&
ME
==
31
)
{
O
<<
"\tsrwi "
;
useSubstituteMnemonic
=
true
;
SH
=
32
SH
;
}
if
(
useSubstituteMnemonic
)
{
printOperand
(
MI
,
0
,
O
)
;
O
<<
", "
;
printOperand
(
MI
,
1
,
O
)
;
O
<<
", "
<<
(
unsigned
int
)
SH
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
}
if
(
(
MI
->
getOpcode
(
)
==
PPC
::
OR
||
MI
->
getOpcode
(
)
==
PPC
::
OR8
)
&&
MI
->
getOperand
(
1
)
.
getReg
(
)
==
MI
->
getOperand
(
2
)
.
getReg
(
)
)
{
O
<<
"\tmr "
;
printOperand
(
MI
,
0
,
O
)
;
O
<<
", "
;
printOperand
(
MI
,
1
,
O
)
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
if
(
MI
->
getOpcode
(
)
==
PPC
::
RLDICR
)
{
unsigned
char
SH
=
MI
->
getOperand
(
2
)
.
getImm
(
)
;
unsigned
char
ME
=
MI
->
getOperand
(
3
)
.
getImm
(
)
;
if
(
63
SH
==
ME
)
{
O
<<
"\tsldi "
;
printOperand
(
MI
,
0
,
O
)
;
O
<<
", "
;
printOperand
(
MI
,
1
,
O
)
;
O
<<
", "
<<
(
unsigned
int
)
SH
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
}
if
(
MI
->
getOpcode
(
)
==
TargetOpcode
::
COPY_TO_REGCLASS
)
return
;
printInstruction
(
MI
,
O
)
;
printAnnotation
(
O
,
Annot
)
;
}
</s>

Print the specified MCInst to the specified raw_ostream .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> EVT PatmosTargetLowering :: getSetCCResultType ( const DataLayout & DL , LLVMContext & Context , EVT VT ) const { return MVT :: i1 ; } </s>

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


<s>
void
ARM64AppleInstPrinter
::
printInst
(
const
MCInst
*
MI
,
raw_ostream
&
O
,
StringRef
Annot
)
{
unsigned
Opcode
=
MI
->
getOpcode
(
)
;
StringRef
Layout
,
Mnemonic
;
bool
IsTbx
;
if
(
isTblTbxInstruction
(
MI
->
getOpcode
(
)
,
Layout
,
IsTbx
)
)
{
O
<<
"\t"
<<
(
IsTbx
"tbx"
:
"tbl"
)
<<
Layout
<<
'\t'
<<
getRegisterName
(
MI
->
getOperand
(
0
)
.
getReg
(
)
,
ARM64
::
vreg
)
<<
", "
;
unsigned
ListOpNum
=
IsTbx
2
:
1
;
printVectorList
(
MI
,
ListOpNum
,
O
,
""
)
;
O
<<
", "
<<
getRegisterName
(
MI
->
getOperand
(
ListOpNum
+
1
)
.
getReg
(
)
,
ARM64
::
vreg
)
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
if
(
LdStNInstrDesc
*
LdStDesc
=
getLdStNInstrDesc
(
Opcode
)
)
{
O
<<
"\t"
<<
LdStDesc
->
Mnemonic
<<
LdStDesc
->
Layout
<<
'\t'
;
printVectorList
(
MI
,
0
,
O
,
""
)
;
if
(
LdStDesc
->
LaneOperand
!=
0
)
O
<<
'['
<<
MI
->
getOperand
(
LdStDesc
->
LaneOperand
)
.
getImm
(
)
<<
']'
;
unsigned
AddrOpNum
=
LdStDesc
->
LaneOperand
+
1
;
unsigned
AddrReg
=
MI
->
getOperand
(
AddrOpNum
)
.
getReg
(
)
;
O
<<
", ["
<<
getRegisterName
(
AddrReg
)
<<
']'
;
if
(
LdStDesc
->
NaturalOffset
!=
0
)
{
unsigned
Reg
=
MI
->
getOperand
(
AddrOpNum
+
1
)
.
getReg
(
)
;
if
(
Reg
!=
ARM64
::
XZR
)
O
<<
", "
<<
getRegisterName
(
Reg
)
;
else
{
assert
(
LdStDesc
->
NaturalOffset
&&
"no offset on post-inc instruction?"
)
;
O
<<
", #"
<<
LdStDesc
->
NaturalOffset
;
}
}
printAnnotation
(
O
,
Annot
)
;
return
;
}
ARM64InstPrinter
::
printInst
(
MI
,
O
,
Annot
)
;
}
</s>


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

Expose LegalizerInfo so the clients can re-use .


<s> bool TriCoreRegisterInfo :: useFPForScavengingIndex ( const MachineFunction & MF ) const { return false ; } </s>

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


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


Pointer authentication builtins that will become NOP on legacy platform . Currently , these builtins are for internal use only ( libgcc EH unwinder ) .


<s> bool X86TargetLowering :: mayBeEmittedAsTailCall ( const CallInst * CI ) const { if ( ! CI -> isTailCall ( ) ) return false ; CallingConv :: ID CalleeCC = CI -> getCallingConv ( ) ; if ( ! mayTailCallThisCC ( CalleeCC ) ) return false ; return true ; } </s>

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


<s>
StringRef
getPassName
(
)
const
override
{
return
"SI Lower i1 Copies"
;
}
</s>

getPassName - Return a nice clean name for a pass .


"GCC does not currently support mixed size types "

"GCC does not currently support return type %qT "

"unsupported return type %qT for %<simd%> functions"

"GCC does not currently support argument type %qT "

"GCC does not currently support simdlen %d for type %qT"


<s> SDValue PIC16TargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { case PIC16ISD :: PIC16Load : return PerformPIC16LoadCombine ( 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 .


<s> const TargetRegisterClass * MOSRegisterInfo :: getLargestLegalSuperClass ( const TargetRegisterClass * RC , const MachineFunction & ) const { if ( RC -> hasSuperClass ( & MOS :: Anyi1RegClass ) ) return & MOS :: Anyi1RegClass ; if ( RC -> hasSuperClass ( & MOS :: Anyi8RegClass ) ) return & MOS :: Anyi8RegClass ; return RC ; } </s>

Returns the largest super class of RC that is legal to use in the current sub-target and has the same spill size .


<s>
SDValue
BPFTargetLowering
::
LowerCallResult
(
SDValue
Chain
,
SDValue
InFlag
,
CallingConv
::
ID
CallConv
,
bool
IsVarArg
,
const
SmallVectorImpl
<
ISD
::
InputArg
>
&
Ins
,
SDLoc
DL
,
SelectionDAG
&
DAG
,
SmallVectorImpl
<
SDValue
>
&
InVals
)
const
{
MachineFunction
&
MF
=
DAG
.
getMachineFunction
(
)
;
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
IsVarArg
,
MF
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
if
(
Ins
.
size
(
)
>=
2
)
{
DiagnosticInfoUnsupported
Err
(
DL
,
*
MF
.
getFunction
(
)
,
"only small returns supported"
,
SDValue
(
)
)
;
DAG
.
getContext
(
)
->
diagnose
(
Err
)
;
}
CCInfo
.
AnalyzeCallResult
(
Ins
,
RetCC_BPF64
)
;
for
(
auto
&
Val
:
RVLocs
)
{
Chain
=
DAG
.
getCopyFromReg
(
Chain
,
DL
,
Val
.
getLocReg
(
)
,
Val
.
getValVT
(
)
,
InFlag
)
.
getValue
(
1
)
;
InFlag
=
Chain
.
getValue
(
2
)
;
InVals
.
push_back
(
Chain
.
getValue
(
0
)
)
;
}
return
Chain
;
}
</s>

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


<s> void NVPTXAsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { MCInst Inst ; lowerToMCInst ( MI , Inst ) ; EmitToStreamer ( * OutStreamer , Inst ) ; } </s>

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


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

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


<s> static void mips_add_gc_roots ( ) { ggc_add_rtx_root ( & mips_load_reg , 1 ) ; ggc_add_rtx_root ( & mips_load_reg2 , 1 ) ; ggc_add_rtx_root ( & mips_load_reg3 , 1 ) ; ggc_add_rtx_root ( & mips_load_reg4 , 1 ) ; ggc_add_rtx_root ( branch_cmp , sizeof ( branch_cmp ) / sizeof ( rtx ) ) ; ggc_add_rtx_root ( & embedded_pic_fnaddr_rtx , 1 ) ; ggc_add_rtx_root ( & mips16_gp_pseudo_rtx , 1 ) ; } </s>

Called to register all of our global variables with the garbage collector .


<s> bool SITargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace , unsigned Align , bool * IsFast ) const { if ( IsFast ) * IsFast = false ; if ( ! VT . isSimple ( ) || VT == MVT :: Other ) return false ; if ( AddrSpace == AMDGPUAS :: LOCAL_ADDRESS || AddrSpace == AMDGPUAS :: REGION_ADDRESS ) { bool AlignedBy4 = ( Align % 4 == 0 ) ; if ( IsFast ) * IsFast = AlignedBy4 ; return AlignedBy4 ; } if ( Subtarget -> hasUnalignedBufferAccess ( ) ) { if ( IsFast ) { * IsFast = ( AddrSpace == AMDGPUAS :: CONSTANT_ADDRESS ) ? ( Align % 4 == 0 ) : true ; } return true ; } if ( VT . bitsLT ( MVT :: i32 ) ) return false ; if ( IsFast ) * IsFast = true ; return VT . bitsGT ( MVT :: i32 ) && Align % 4 == 0 ; } </s>

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


<s>
void
NVPTXAsmPrinter
::
emitBasicBlockStart
(
const
MachineBasicBlock
&
MBB
)
{
AsmPrinter
::
emitBasicBlockStart
(
MBB
)
;
if
(
isLoopHeaderOfNoUnroll
(
MBB
)
)
OutStreamer
->
emitRawText
(
StringRef
(
"\t.pragma \"nounroll\";\n"
)
)
;
}
</s>

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


<s> bool PPCTargetLowering :: getTgtMemIntrinsic ( IntrinsicInfo & Info , const CallInst & I , MachineFunction & MF , unsigned Intrinsic ) const { switch ( Intrinsic ) { case Intrinsic :: ppc_altivec_lvx : case Intrinsic :: ppc_altivec_lvxl : case Intrinsic :: ppc_altivec_lvebx : case Intrinsic :: ppc_altivec_lvehx : case Intrinsic :: ppc_altivec_lvewx : case Intrinsic :: ppc_vsx_lxvd2x : case Intrinsic :: ppc_vsx_lxvw4x : { EVT VT ; switch ( Intrinsic ) { case Intrinsic :: ppc_altivec_lvebx : VT = MVT :: i8 ; break ; case Intrinsic :: ppc_altivec_lvehx : VT = MVT :: i16 ; break ; case Intrinsic :: ppc_altivec_lvewx : VT = MVT :: i32 ; break ; case Intrinsic :: ppc_vsx_lxvd2x : VT = MVT :: v2f64 ; break ; default : VT = MVT :: v4i32 ; break ; } Info . opc = ISD :: INTRINSIC_W_CHAIN ; Info . memVT = VT ; Info . ptrVal = I . getArgOperand ( 0 ) ; Info . offset = - VT . getStoreSize ( ) + 1 ; Info . size = 2 * VT . getStoreSize ( ) - 1 ; Info . align = Align ( 1 ) ; Info . flags = MachineMemOperand :: MOLoad ; return true ; } case Intrinsic :: ppc_altivec_stvx : case Intrinsic :: ppc_altivec_stvxl : case Intrinsic :: ppc_altivec_stvebx : case Intrinsic :: ppc_altivec_stvehx : case Intrinsic :: ppc_altivec_stvewx : case Intrinsic :: ppc_vsx_stxvd2x : case Intrinsic :: ppc_vsx_stxvw4x : { EVT VT ; switch ( Intrinsic ) { case Intrinsic :: ppc_altivec_stvebx : VT = MVT :: i8 ; break ; case Intrinsic :: ppc_altivec_stvehx : VT = MVT :: i16 ; break ; case Intrinsic :: ppc_altivec_stvewx : VT = MVT :: i32 ; break ; case Intrinsic :: ppc_vsx_stxvd2x : VT = MVT :: v2f64 ; break ; default : VT = MVT :: v4i32 ; break ; } Info . opc = ISD :: INTRINSIC_VOID ; Info . memVT = VT ; Info . ptrVal = I . getArgOperand ( 1 ) ; Info . offset = - VT . getStoreSize ( ) + 1 ; Info . size = 2 * VT . getStoreSize ( ) - 1 ; Info . align = Align ( 1 ) ; Info . flags = MachineMemOperand :: MOStore ; return true ; } default : break ; } return false ; } </s>

Given an intrinsic , checks if on the target the intrinsic will need to map to a MemIntrinsicNode ( touches memory ) .


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


<s> bool ARCompactInstrInfo :: isProfitableToIfCvt ( MachineBasicBlock & TMBB , unsigned TCycles , unsigned TExtra , MachineBasicBlock & FMBB , unsigned FCycles , unsigned FExtra , const BranchProbability & Probability ) const { if ( ! TCycles || ! FCycles ) { return false ; } unsigned TUnpredCost = Probability . getNumerator ( ) * TCycles ; TUnpredCost /= Probability . getDenominator ( ) ; uint32_t Comp = Probability . getDenominator ( ) - Probability . getNumerator ( ) ; unsigned FUnpredCost = Comp * FCycles ; FUnpredCost /= Probability . getDenominator ( ) ; unsigned UnpredCost = TUnpredCost + FUnpredCost ; UnpredCost += 1 ; UnpredCost += 10 / 10 ; return ( TCycles + FCycles + TExtra + FExtra ) <= UnpredCost ; } </s>


<s> void function_builder :: add_unique_function ( const function_instance & instance , tree return_type , vec < tree > & argument_types , uint64_t required_extensions , bool force_direct_overloads ) { char * name = get_name ( instance , false ) ; tree fntype = build_function_type_array ( return_type , argument_types . length ( ) , argument_types . address ( ) ) ; tree attrs = get_attributes ( instance ) ; registered_function & rfn = add_function ( instance , name , fntype , attrs , required_extensions , false , false ) ; hashval_t hash = instance . hash ( ) ; registered_function * * rfn_slot = function_table -> find_slot_with_hash ( instance , hash , INSERT ) ; gcc_assert ( ! * rfn_slot ) ; * rfn_slot = & rfn ; char * overload_name = get_name ( instance , true ) ; if ( strcmp ( name , overload_name ) != 0 ) { tree attrs = get_attributes ( instance ) ; bool placeholder_p = ! ( m_direct_overloads || force_direct_overloads ) ; add_function ( instance , overload_name , fntype , attrs , required_extensions , false , placeholder_p ) ; } obstack_free ( & m_string_obstack , name ) ; } </s>

Add a built-in function for INSTANCE , with the argument types given by ARGUMENT_TYPES and the return type given by RETURN_TYPE . NAME is the `` full '' name for C function . OVERLOAD_NAME is the `` short '' name for C++ overloaded function . OVERLOAD_NAME can be nullptr because some instance does n't have C++ overloaded function .


<s> bool SIFoldOperands :: runOnMachineFunction ( MachineFunction & MF ) { if ( skipFunction ( * MF . getFunction ( ) ) ) return false ; MRI = & MF . getRegInfo ( ) ; ST = & MF . getSubtarget < SISubtarget > ( ) ; TII = ST -> getInstrInfo ( ) ; TRI = & TII -> getRegisterInfo ( ) ; const SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; bool IsIEEEMode = ST -> enableIEEEBit ( MF ) || ! MFI -> hasNoSignedZerosFPMath ( ) ; for ( MachineBasicBlock * MBB : depth_first ( & MF ) ) { MachineBasicBlock :: iterator I , Next ; for ( I = MBB -> begin ( ) ; I != MBB -> end ( ) ; I = Next ) { Next = std :: next ( I ) ; MachineInstr & MI = * I ; tryFoldInst ( TII , & MI ) ; if ( ! TII -> isFoldableCopy ( MI ) ) { if ( IsIEEEMode || ! tryFoldOMod ( MI ) ) tryFoldClamp ( MI ) ; continue ; } MachineOperand & OpToFold = MI . getOperand ( 1 ) ; bool FoldingImm = OpToFold . isImm ( ) || OpToFold . isFI ( ) ; if ( ! FoldingImm && ! OpToFold . isReg ( ) ) continue ; if ( OpToFold . isReg ( ) && ! TargetRegisterInfo :: isVirtualRegister ( OpToFold . getReg ( ) ) ) continue ; MachineOperand & Dst = MI . getOperand ( 0 ) ; if ( Dst . isReg ( ) && ! TargetRegisterInfo :: isVirtualRegister ( Dst . getReg ( ) ) ) continue ; foldInstOperand ( MI , OpToFold ) ; } } return false ; } </s>

runOnMachineFunction - Emit the function body .


<s>
const
char
*
pru_output_signed_cbranch_zeroop2
(
rtx
*
operands
,
bool
is_near
)
{
static
char
buf
[
1024
]
;
enum
rtx_code
code
=
GET_CODE
(
operands
[
0
]
)
;
int
regop_sign_bit_pos
=
sign_bit_position
(
operands
[
1
]
)
;
if
(
code
==
LT
)
{
if
(
is_near
)
snprintf
(
buf
,
sizeof
(
buf
)
,
"qbbs\t%%l3, %%1, %d\n\t"
,
regop_sign_bit_pos
)
;
else
snprintf
(
buf
,
sizeof
(
buf
)
,
"qbbc\t.+8, %%1, %d\n\t"
"jmp\t%%%%label(%%l3)"
,
regop_sign_bit_pos
)
;
}
else
if
(
code
==
GE
)
{
if
(
is_near
)
snprintf
(
buf
,
sizeof
(
buf
)
,
"qbbc\t%%l3, %%1, %d\n\t"
,
regop_sign_bit_pos
)
;
else
snprintf
(
buf
,
sizeof
(
buf
)
,
"qbbs\t.+8, %%1, %d\n\t"
"jmp\t%%%%label(%%l3)"
,
regop_sign_bit_pos
)
;
}
else
gcc_unreachable
(
)
;
return
buf
;
}
</s>

Optimized version of pru_output_signed_cbranch_ubyteop2 for constant zero second operand .


<s> void add ( const IndexRange & Range ) { push_back ( Range ) ; } </s>


<s> int uses_TOC ( void ) { rtx_insn * insn ; int ret = 1 ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( INSN_P ( insn ) ) { rtx pat = PATTERN ( insn ) ; int i ; if ( GET_CODE ( pat ) == PARALLEL ) for ( i = 0 ; i < XVECLEN ( pat , 0 ) ; i ++ ) { rtx sub = XVECEXP ( pat , 0 , i ) ; if ( GET_CODE ( sub ) == USE ) { sub = XEXP ( sub , 0 ) ; if ( GET_CODE ( sub ) == UNSPEC && XINT ( sub , 1 ) == UNSPEC_TOC ) return ret ; } } } else if ( crtl -> has_bb_partition && NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_SWITCH_TEXT_SECTIONS ) ret = 2 ; } return 0 ; } </s>

This retuns nonzero if the current function uses the TOC . This is determined by the presence of ( unspec ... 7 ) , which is generated by the various load_toc_ * patterns .


<s> static unsigned int mips16e_find_first_register ( unsigned int mask , const unsigned char * regs , unsigned int size ) { unsigned int i ; for ( i = 0 ; i < size ; i ++ ) if ( BITSET_P ( mask , regs [ i ] ) ) break ; return i ; } </s>

Return the index of the lowest X in the range [ 0 , SIZE ) for which bit REGS [ X ] is set in MASK . Return SIZE if there is no such X .


<s>
const
char
*
getPassName
(
)
const
{
return
"TOY PreRmit"
;
}
</s>


<s> Register getExceptionPointerRegister ( const Constant * PersonalityFn ) const override { return ABI . IsCheriPureCap ( ) ? Mips :: C16 : ( ABI . IsN64 ( ) ? Mips :: A0_64 : Mips :: A0 ) ; } </s>

If a physical register , this returns the register that receives the exception address on entry to an EH pad .


<s> static unsigned findDeadCallerSavedReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , const M68kRegisterInfo * TRI ) { const MachineFunction * MF = MBB . getParent ( ) ; if ( MF -> callsEHReturn ( ) ) return 0 ; const TargetRegisterClass & AvailableRegs = * TRI -> getRegsForTailCall ( * MF ) ; if ( MBBI == MBB . end ( ) ) return 0 ; switch ( MBBI -> getOpcode ( ) ) { default : return 0 ; case TargetOpcode :: PATCHABLE_RET : case M68k :: RET : { SmallSet < uint16_t , 8 > Uses ; for ( unsigned i = 0 , e = MBBI -> getNumOperands ( ) ; i != e ; ++ i ) { MachineOperand & MO = MBBI -> getOperand ( i ) ; if ( ! MO . isReg ( ) || MO . isDef ( ) ) continue ; unsigned Reg = MO . getReg ( ) ; if ( ! Reg ) continue ; for ( MCRegAliasIterator AI ( Reg , TRI , true ) ; AI . isValid ( ) ; ++ AI ) Uses . insert ( * AI ) ; } for ( auto CS : AvailableRegs ) if ( ! Uses . count ( CS ) ) return CS ; } } return 0 ; } </s>

findDeadCallerSavedReg - Return a caller-saved register that is n't live when it reaches the `` return '' instruction .


<s> bool arc_double_limm_p ( rtx value ) { HOST_WIDE_INT low , high ; gcc_assert ( GET_CODE ( value ) == CONST_DOUBLE ) ; if ( TARGET_DPFP ) return true ; low = CONST_DOUBLE_LOW ( value ) ; high = CONST_DOUBLE_HIGH ( value ) ; if ( low & 0x80000000 ) { return ( ( ( unsigned HOST_WIDE_INT ) low <= 0xffffffff && high == 0 ) || ( ( ( low & - ( unsigned HOST_WIDE_INT ) 0x80000000 ) == - ( unsigned HOST_WIDE_INT ) 0x80000000 ) && high == - 1 ) ) ; } else { return ( unsigned HOST_WIDE_INT ) low <= 0x7fffffff && high == 0 ; } } </s>

Return 1 if VALUE , a const_double , will fit in a limm ( 4 byte number ) . We assume the value can be either signed or unsigned .


<s> bool runOnMachineFunction ( MachineFunction & MF ) { const PatmosMachineFunctionInfo * PMFI = MF . getInfo < PatmosMachineFunctionInfo > ( ) ; bool Changed = false ; if ( MinSubfunctionAlignment > MF . getAlignment ( ) ) { MF . ensureAlignment ( MinSubfunctionAlignment ) ; Changed = true ; } for ( MachineFunction :: iterator i = MF . begin ( ) , ie = MF . end ( ) ; i != ie ; ++ i ) { unsigned align ; if ( PMFI -> isMethodCacheRegionEntry ( i ) ) { align = MinSubfunctionAlignment ; } else { align = MinBasicBlockAlignment ; } if ( align > i -> getAlignment ( ) ) { i -> setAlignment ( align ) ; Changed = true ; } } return Changed ; } </s>


<s> int m32c_reg_class_from_constraint ( char c ATTRIBUTE_UNUSED , const char * s ) { if ( memcmp ( s , "Rsp" , 3 ) == 0 ) return SP_REGS ; if ( memcmp ( s , "Rfb" , 3 ) == 0 ) return FB_REGS ; if ( memcmp ( s , "Rsb" , 3 ) == 0 ) return SB_REGS ; if ( memcmp ( s , "Rcr" , 3 ) == 0 && TARGET_A16 ) return CR_REGS ; if ( memcmp ( s , "Rcl" , 3 ) == 0 && TARGET_A24 ) return CR_REGS ; if ( memcmp ( s , "R0w" , 3 ) == 0 ) return R0_REGS ; if ( memcmp ( s , "R1w" , 3 ) == 0 ) return R1_REGS ; if ( memcmp ( s , "R2w" , 3 ) == 0 ) return R2_REGS ; if ( memcmp ( s , "R3w" , 3 ) == 0 ) return R3_REGS ; if ( memcmp ( s , "R02" , 3 ) == 0 ) return R02_REGS ; if ( memcmp ( s , "R03" , 3 ) == 0 ) return R03_REGS ; if ( memcmp ( s , "Rdi" , 3 ) == 0 ) return DI_REGS ; if ( memcmp ( s , "Rhl" , 3 ) == 0 ) return HL_REGS ; if ( memcmp ( s , "R23" , 3 ) == 0 ) return R23_REGS ; if ( memcmp ( s , "Raa" , 3 ) == 0 ) return A_REGS ; if ( memcmp ( s , "Raw" , 3 ) == 0 && TARGET_A16 ) return A_REGS ; if ( memcmp ( s , "Ral" , 3 ) == 0 && TARGET_A24 ) return A_REGS ; if ( memcmp ( s , "Rqi" , 3 ) == 0 ) return QI_REGS ; if ( memcmp ( s , "Rad" , 3 ) == 0 ) return AD_REGS ; if ( memcmp ( s , "Rsi" , 3 ) == 0 ) return SI_REGS ; if ( memcmp ( s , "Rhi" , 3 ) == 0 ) return HI_REGS ; if ( memcmp ( s , "Rhc" , 3 ) == 0 ) return HC_REGS ; if ( memcmp ( s , "Rra" , 3 ) == 0 ) return RA_REGS ; if ( memcmp ( s , "Rfl" , 3 ) == 0 ) return FLG_REGS ; if ( memcmp ( s , "Rmm" , 3 ) == 0 ) { if ( fixed_regs [ MEM0_REGNO ] ) return NO_REGS ; return MEM_REGS ; } if ( memcmp ( s , "Rpi" , 3 ) == 0 ) { if ( TARGET_A16 ) return HI_REGS ; else return RA_REGS ; } if ( memcmp ( s , "Rpa" , 3 ) == 0 ) return NO_REGS ; return NO_REGS ; } </s>

Implements REG_CLASS_FROM_CONSTRAINT . Note that some constraints only match for certain chip families .


<s> int ix86_check_movabs ( rtx insn , int opnum ) { rtx set , mem ; set = PATTERN ( insn ) ; if ( GET_CODE ( set ) == PARALLEL ) set = XVECEXP ( set , 0 , 0 ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; mem = XEXP ( set , opnum ) ; while ( GET_CODE ( mem ) == SUBREG ) mem = SUBREG_REG ( mem ) ; gcc_assert ( GET_CODE ( mem ) == MEM ) ; return ( volatile_ok || ! MEM_VOLATILE_P ( mem ) ) ; } </s>

Return nonzero if OPNUM 's MEM should be matched in movabs * patterns .


<s> bool hasFusion ( ) const { return hasFuseAES ( ) || hasFuseLiterals ( ) ; } </s>

Return true if the CPU supports any kind of instruction fusion .


<s> static reg_class_t xtensa_preferred_output_reload_class ( rtx x ATTRIBUTE_UNUSED , reg_class_t rclass ) { if ( rclass == AR_REGS || rclass == GR_REGS ) return RL_REGS ; return rclass ; } </s>

Worker function for TARGET_PREFERRED_OUTPUT_RELOAD_CLASS .


<s> bool cris_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { enum cris_symbol_type t ; if ( flag_pic ) return LEGITIMATE_PIC_OPERAND_P ( x ) ; t = cris_symbol_type_of ( x ) ; return t == cris_no_symbol || t == cris_offsettable_symbol || t == cris_unspec ; } </s>

Worker function for TARGET_LEGITIMATE_CONSTANT_P . We have to handle PIC constants that are n't legitimized . FIXME : there used to be a guarantee that the target LEGITIMATE_CONSTANT_P did n't have to handle PIC constants , but no more ( 4.7 era ) ; testcase : glibc init-first.c . While that may be seen as a bug , that guarantee seems a wart by design , so do n't bother ; fix the documentation instead .


<s> static unsigned char m32c_class_max_nregs ( reg_class_t regclass , machine_mode mode ) { int rn ; unsigned char max = 0 ; for ( rn = 0 ; rn < FIRST_PSEUDO_REGISTER ; rn ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) regclass ] , rn ) ) { unsigned char n = m32c_hard_regno_nregs ( rn , mode ) ; if ( max < n ) max = n ; } return max ; } </s>

Implements CLASS_MAX_NREGS . We calculate this according to its documented meaning , to avoid potential inconsistencies with actual class definitions .


<s> static poly_int64 m68k_return_pops_args ( tree fundecl , tree funtype , poly_int64 size ) { return ( ( TARGET_RTD && ( ! fundecl || TREE_CODE ( fundecl ) != IDENTIFIER_NODE ) && ( ! stdarg_p ( funtype ) ) ) ? ( HOST_WIDE_INT ) size : 0 ) ; } </s>

On the 68000 , the RTS insn can not pop anything . On the 68010 , the RTD insn may be used to pop them if the number of args is fixed , but if the number is variable then the caller must pop them all . RTD ca n't be used for library calls now because the library is compiled with the Unix compiler . Use of RTD is a selectable option , since it is incompatible with standard Unix calling sequences . If the option is not selected , the caller must always pop the args .


<s> bool lowerOperand ( const MachineOperand & MO , MCOperand & MCOp ) const { return LowerRISCVMachineOperandToMCOperand ( MO , MCOp , * this ) ; } </s>

Wrapper for MCInstLowering.lowerOperand ( ) for the tblgen'erated pseudo lowering .


<s> int null_epilogue ( ) { return ( reload_completed && ! needs_regstack_p ( ) && get_frame_size ( ) == 0 && current_function_pretend_args_size == 0 ) ; } </s>

return 1 if there is n't anything tricky to do


<s>
static
void
replace_swap_with_copy
(
swap_web_entry
*
insn_entry
,
unsigned
i
)
{
rtx_insn
*
insn
=
insn_entry
[
i
]
.
insn
;
rtx
body
=
PATTERN
(
insn
)
;
rtx
src_reg
=
XEXP
(
SET_SRC
(
body
)
,
0
)
;
rtx
copy
=
gen_rtx_SET
(
SET_DEST
(
body
)
,
src_reg
)
;
rtx_insn
*
new_insn
=
emit_insn_before
(
copy
,
insn
)
;
set_block_for_insn
(
new_insn
,
BLOCK_FOR_INSN
(
insn
)
)
;
df_insn_rescan
(
new_insn
)
;
if
(
dump_file
)
{
unsigned
int
new_uid
=
INSN_UID
(
new_insn
)
;
fprintf
(
dump_file
,
"Replacing swap %d with copy %d\n"
,
i
,
new_uid
)
;
}
df_insn_delete
(
insn
)
;
remove_insn
(
insn
)
;
insn
->
set_deleted
(
)
;
}
</s>

Find the insn from the Ith table entry , which is known to be a register swap Y = SWAP ( X ) . Replace it with a copy Y = X .

powerpcspe
0
"Replacing swap %d with copy %d\n"


<s> static void frv_registers_update_1 ( rtx x , const_rtx pat ATTRIBUTE_UNUSED , void * data ) { unsigned int regno ; if ( GET_CODE ( x ) == REG ) FOR_EACH_REGNO ( regno , x ) frv_packet . regstate [ regno ] |= * ( regstate_t * ) data ; if ( GET_CODE ( x ) == MEM ) { if ( frv_packet . num_mems < ARRAY_SIZE ( frv_packet . mems ) ) { frv_packet . mems [ frv_packet . num_mems ] . mem = x ; frv_packet . mems [ frv_packet . num_mems ] . cond = * ( regstate_t * ) data ; } frv_packet . num_mems ++ ; } } </s>

A note_stores callback . DATA points to the regstate_t condition under which X is modified . Update FRV_PACKET accordingly .


<s> unsigned R600RegisterInfo :: getHWRegChan ( unsigned reg ) const { return this -> getEncodingValue ( reg ) >> HW_CHAN_SHIFT ; } </s>

get the HW encoding for a register 's channel .


<s> static void mark_frame_related ( rtx insn ) { RTX_FRAME_RELATED_P ( insn ) = 1 ; insn = PATTERN ( insn ) ; if ( GET_CODE ( insn ) == PARALLEL ) { unsigned int i ; for ( i = 0 ; i < ( unsigned ) XVECLEN ( insn , 0 ) ; i ++ ) RTX_FRAME_RELATED_P ( XVECEXP ( insn , 0 , i ) ) = 1 ; } } </s>

Mark INSN as being frame related . If it is a PARALLEL then mark each element as being frame related as well .


"Can only put epilog before 'retl' instruction!"


<s> static int arm_adjust_cost ( rtx_insn * insn , int dep_type , rtx_insn * dep , int cost , unsigned int ) { rtx i_pat , d_pat ; if ( TARGET_THUMB1 && dep_type == 0 && recog_memoized ( insn ) == CODE_FOR_cbranchsi4_insn && recog_memoized ( dep ) >= 0 && get_attr_conds ( dep ) == CONDS_SET ) return 0 ; if ( current_tune -> sched_adjust_cost != NULL ) { if ( ! current_tune -> sched_adjust_cost ( insn , dep_type , dep , & cost ) ) return cost ; } if ( dep_type == REG_DEP_ANTI || dep_type == REG_DEP_OUTPUT ) return 0 ; if ( dep_type == 0 && CALL_P ( insn ) ) return 1 ; if ( ( i_pat = single_set ( insn ) ) != NULL && MEM_P ( SET_SRC ( i_pat ) ) && ( d_pat = single_set ( dep ) ) != NULL && MEM_P ( SET_DEST ( d_pat ) ) ) { rtx src_mem = XEXP ( SET_SRC ( i_pat ) , 0 ) ; if ( ( SYMBOL_REF_P ( src_mem ) && CONSTANT_POOL_ADDRESS_P ( src_mem ) ) || reg_mentioned_p ( stack_pointer_rtx , src_mem ) || reg_mentioned_p ( frame_pointer_rtx , src_mem ) || reg_mentioned_p ( hard_frame_pointer_rtx , src_mem ) ) return 1 ; } return cost ; } </s>

This function implements the target macro TARGET_SCHED_ADJUST_COST . It corrects the value of COST based on the relationship between INSN and DEP through the dependence LINK . It returns the new value . There is a per-core adjust_cost hook to adjust scheduler costs and the per-core hook can choose to completely override the generic adjust_cost function . Only put bits of code into arm_adjust_cost that are common across all cores .


<s> static bool sh_pass_in_reg_p ( const CUMULATIVE_ARGS & cum , machine_mode mode , const_tree type ) { return ( ( type == 0 || ( ! TREE_ADDRESSABLE ( type ) && ( ! ( TARGET_HITACHI || cum . renesas_abi ) || ! ( AGGREGATE_TYPE_P ( type ) || ( ! TARGET_FPU_ANY && ( GET_MODE_CLASS ( mode ) == MODE_FLOAT && GET_MODE_SIZE ( mode ) > GET_MODE_SIZE ( SFmode ) ) ) ) ) ) ) && ! cum . force_mem && ( TARGET_SH2E ? ( ( mode ) == BLKmode ? ( ( cum . arg_count [ ( int ) SH_ARG_INT ] * UNITS_PER_WORD + int_size_in_bytes ( type ) ) <= NPARM_REGS ( SImode ) * UNITS_PER_WORD ) : ( ( sh_round_reg ( cum , mode ) + HARD_REGNO_NREGS ( BASE_ARG_REG ( mode ) , mode ) ) <= NPARM_REGS ( mode ) ) ) : sh_round_reg ( cum , mode ) < NPARM_REGS ( mode ) ) ) ; } </s>

Return true if arg of the specified mode should be be passed in a register or false otherwise .


<s>
bool
PPCInstrInfo
::
getMemOperandWithOffsetWidth
(
const
MachineInstr
&
LdSt
,
const
MachineOperand
*
&
BaseReg
,
int64_t
&
Offset
,
unsigned
&
Width
,
const
TargetRegisterInfo
*
TRI
)
const
{
assert
(
LdSt
.
mayLoadOrStore
(
)
&&
"Expected a memory operation."
)
;
if
(
LdSt
.
getNumExplicitOperands
(
)
!=
3
)
return
false
;
if
(
!
LdSt
.
getOperand
(
1
)
.
isImm
(
)
||
!
LdSt
.
getOperand
(
2
)
.
isReg
(
)
)
return
false
;
if
(
!
LdSt
.
hasOneMemOperand
(
)
)
return
false
;
Width
=
(
*
LdSt
.
memoperands_begin
(
)
)
->
getSize
(
)
;
Offset
=
LdSt
.
getOperand
(
1
)
.
getImm
(
)
;
BaseReg
=
&
LdSt
.
getOperand
(
2
)
;
return
true
;
}
</s>

Return true if get the base operand , byte offset of an instruction and the memory width .


<s> static bool nios2_simple_const_p ( const_rtx cst ) { HOST_WIDE_INT val = INTVAL ( cst ) ; return SMALL_INT ( val ) || SMALL_INT_UNSIGNED ( val ) || UPPER16_INT ( val ) ; } </s>

Return true if CST is a constant within range of movi/movui/movhi .


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

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


<s> bool TVMReFunc :: runOnModule ( Module & M ) { if ( ! TVMEnableMReFunc ) return false ; bool Changed = false ; for ( Function & F : M ) { if ( ! F . isDeclaration ( ) ) continue ; switch ( F . getIntrinsicID ( ) ) { case Intrinsic :: tvm_sendrawmsg : if ( processSendRawMsgUses ( F ) ) Changed = true ; break ; default : break ; } } return Changed ; } </s>

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


<s> void rs6000_asm_output_dwarf_pcrel ( FILE * file , int size , const char * label ) { fputs ( integer_asm_op ( size , FALSE ) , file ) ; assemble_name ( file , label ) ; fputs ( "-$" , file ) ; } </s>

Overide the default 'SYMBOL- . ' syntax with AIX compatible 'SYMBOL- $ ' .


<s> static int pa_issue_rate ( ) { switch ( pa_cpu ) { case PROCESSOR_700 : return 1 ; case PROCESSOR_7100 : return 2 ; case PROCESSOR_7100LC : return 2 ; case PROCESSOR_7200 : return 2 ; case PROCESSOR_8000 : return 4 ; default : abort ( ) ; } } </s>

The 700 can only issue a single insn at a time . The 7XXX processors can issue two insns at a time . The 8000 can issue 4 insns at a time .


<s> static bool arc_process_double_reg_moves ( rtx * operands ) { rtx dest = operands [ 0 ] ; rtx src = operands [ 1 ] ; enum usesDxState { none , srcDx , destDx , maxDx } ; enum usesDxState state = none ; if ( refers_to_regno_p ( 40 , 44 , src , 0 ) ) state = srcDx ; if ( refers_to_regno_p ( 40 , 44 , dest , 0 ) ) { gcc_assert ( state == none ) ; state = destDx ; } if ( state == none ) return false ; if ( state == srcDx ) { if ( TARGET_DPFP_DISABLE_LRSR ) { rtx set = gen_rtx_SET ( dest , src ) ; rtx use1 = gen_rtx_USE ( VOIDmode , const1_rtx ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , set , use1 ) ) ) ; } else { rtx destHigh = simplify_gen_subreg ( SImode , dest , DFmode , 4 ) ; rtx destLow = simplify_gen_subreg ( SImode , dest , DFmode , 0 ) ; emit_insn ( gen_rtx_SET ( destHigh , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( 1 , src ) , VUNSPEC_ARC_LR_HIGH ) ) ) ; emit_insn ( gen_rtx_SET ( destLow , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( 1 , src ) , VUNSPEC_ARC_LR ) ) ) ; } } else if ( state == destDx ) { rtx srcHigh = simplify_gen_subreg ( SImode , src , DFmode , 4 ) ; rtx srcLow = simplify_gen_subreg ( SImode , src , DFmode , 0 ) ; emit_insn ( gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( 3 , dest , srcHigh , srcLow ) , VUNSPEC_ARC_DEXCL_NORES ) ) ; } else gcc_unreachable ( ) ; return true ; } </s>

Handle DOUBLE_REGS uses . Operand 0 : destination register Operand 1 : source register


<s> FastISel * WebAssembly :: createFastISel ( FunctionLoweringInfo & FuncInfo , const TargetLibraryInfo * LibInfo ) { return new WebAssemblyFastISel ( FuncInfo , LibInfo ) ; } </s>

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


<s> void CSKYInstPrinter :: printRegName ( raw_ostream & O , unsigned RegNo ) const { if ( PrintBranchImmAsAddress ) O << getRegisterName ( RegNo , ABIRegNames ? CSKY :: ABIRegAltName : CSKY :: NoRegAltName ) ; else O << getRegisterName ( RegNo ) ; } </s>

CSKY CSKY CSKY::ABIRegAltName CSKY::NoRegAltName


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

Allocate and return a hazard recognizer to use for this target when scheduling the machine instructions before register allocation .

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


<s> bool TOYPassConfig :: addInstSelector ( ) { addPass ( createTOYISelDag ( getTOYTargetMachine ( ) , getOptLevel ( ) ) ) ; return false ; } </s>

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


<s> bool GCNPassConfig :: addInstSelector ( ) { AMDGPUPassConfig :: addInstSelector ( ) ; addPass ( & SIFixSGPRCopiesID ) ; addPass ( createSILowerI1CopiesPass ( ) ) ; return false ; } </s>


<s> static rtx_insn * m68k_emit_movem ( rtx base , HOST_WIDE_INT offset , unsigned int count , unsigned int regno , unsigned int mask , bool store_p , bool adjust_stack_p ) { int i ; rtx body , addr , src , operands [ 2 ] ; machine_mode mode ; body = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( adjust_stack_p + count ) ) ; mode = reg_raw_mode [ regno ] ; i = 0 ; if ( adjust_stack_p ) { src = plus_constant ( Pmode , base , ( count * GET_MODE_SIZE ( mode ) * ( HOST_WIDE_INT ) ( store_p ? - 1 : 1 ) ) ) ; XVECEXP ( body , 0 , i ++ ) = gen_rtx_SET ( base , src ) ; } for ( ; mask != 0 ; mask >>= 1 , regno ++ ) if ( mask & 1 ) { addr = plus_constant ( Pmode , base , offset ) ; operands [ ! store_p ] = gen_frame_mem ( mode , addr ) ; operands [ store_p ] = gen_rtx_REG ( mode , regno ) ; XVECEXP ( body , 0 , i ++ ) = gen_rtx_SET ( operands [ 0 ] , operands [ 1 ] ) ; offset += GET_MODE_SIZE ( mode ) ; } gcc_assert ( i == XVECLEN ( body , 0 ) ) ; return emit_insn ( body ) ; } </s>

Emit RTL for a MOVEM or FMOVEM instruction . BASE + OFFSET represents the lowest memory address . COUNT is the number of registers to be moved , with register REGNO + I being moved if bit I of MASK is set . STORE_P specifies the direction of the move and ADJUST_STACK_P says whether or not this is pre-decrement ( if STORE_P ) or post-increment ( if ! STORE_P ) operation .


<s> unsigned HexagonInstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { switch ( MI -> getOpcode ( ) ) { default : break ; case Hexagon :: STriw : case Hexagon :: STrid : case Hexagon :: STrih : case Hexagon :: STrib : if ( MI -> getOperand ( 2 ) . isFI ( ) && MI -> getOperand ( 1 ) . isImm ( ) && ( MI -> getOperand ( 1 ) . getImm ( ) == 0 ) ) { FrameIndex = MI -> getOperand ( 0 ) . getIndex ( ) ; return MI -> getOperand ( 2 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s> rtx aarch64_simd_vect_par_cnst_half ( machine_mode mode , bool high ) { int nunits = GET_MODE_NUNITS ( mode ) ; rtvec v = rtvec_alloc ( nunits / 2 ) ; int high_base = nunits / 2 ; int low_base = 0 ; int base ; rtx t1 ; int i ; if ( BYTES_BIG_ENDIAN ) base = high ? low_base : high_base ; else base = high ? high_base : low_base ; for ( i = 0 ; i < nunits / 2 ; i ++ ) RTVEC_ELT ( v , i ) = GEN_INT ( base + i ) ; t1 = gen_rtx_PARALLEL ( mode , v ) ; return t1 ; } </s>

Construct and return a PARALLEL RTX vector with elements numbering the lanes of either the high ( HIGH == TRUE ) or low ( HIGH == FALSE ) half of the vector - from the perspective of the architecture . This does not line up with GCC 's perspective on lane numbers , so we end up with different masks depending on our target endian-ness . The diagram below may help . We must draw the distinction when building masks which select one half of the vector . An instruction selecting architectural low-lanes for a big-endian target , must be described using a mask selecting GCC high-lanes . Big-Endian Little-EndianGCC 0 1 2 3 3 2 1 0 | x | x | x | x | | x | x | x | x |Architecture 3 2 1 0 3 2 1 0Low Mask : { 2 , 3 } { 0 , 1 } High Mask : { 0 , 1 } { 2 , 3 }


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


<s> unsigned ARMBaseRegisterInfo :: getRARegister ( ) const { return ARM :: LR ; } </s>

This method should return the register where the return address can be found .


<s> bool PTXTargetMachine :: addInstSelector ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { PM . add ( createPTXISelDag ( * this , OptLevel ) ) ; PM . add ( createPTXMFInfoExtract ( * this , OptLevel ) ) ; return false ; } </s>


<s> bool SystemZInstrInfo :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL = DebugLoc :: getUnknownLoc ( ) ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetRegisterInfo * RegInfo = MF . getTarget ( ) . getRegisterInfo ( ) ; SystemZMachineFunctionInfo * MFI = MF . getInfo < SystemZMachineFunctionInfo > ( ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; const TargetRegisterClass * RegClass = CSI [ i ] . getRegClass ( ) ; if ( RegClass == & SystemZ :: FP64RegClass ) loadRegFromStackSlot ( MBB , MI , Reg , CSI [ i ] . getFrameIdx ( ) , RegClass ) ; } unsigned LowReg = MFI -> getLowReg ( ) , HighReg = MFI -> getHighReg ( ) ; unsigned StartOffset = RegSpillOffsets [ LowReg ] ; if ( StartOffset ) { MachineInstrBuilder MIB = BuildMI ( MBB , MI , DL , get ( ( LowReg == HighReg ? SystemZ :: MOV64rm : SystemZ :: MOV64rmm ) ) ) ; MIB . addReg ( LowReg , RegState :: Define ) ; if ( LowReg != HighReg ) MIB . addReg ( HighReg , RegState :: Define ) ; MIB . addReg ( ( RegInfo -> hasFP ( MF ) ? SystemZ :: R11D : SystemZ :: R15D ) ) ; MIB . addImm ( StartOffset ) ; if ( LowReg == HighReg ) MIB . addReg ( 0 ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( Reg != LowReg && Reg != HighReg ) MIB . addReg ( Reg , RegState :: ImplicitDefine ) ; } } 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> void HexagonInstrInfo :: storeRegToStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , Register SrcReg , bool isKill , int FI , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL = MBB . findDebugLoc ( I ) ; MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; unsigned SlotAlign = MFI . getObjectAlignment ( FI ) ; unsigned KillFlag = getKillRegState ( isKill ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FI ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FI ) , SlotAlign ) ; if ( Hexagon :: IntRegsRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: S2_storeri_io ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else if ( Hexagon :: DoubleRegsRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: S2_storerd_io ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else if ( Hexagon :: PredRegsRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: STriw_pred ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else if ( Hexagon :: ModRegsRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: STriw_ctr ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else if ( Hexagon :: HvxQRRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: PS_vstorerq_ai ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else if ( Hexagon :: HvxVRRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: PS_vstorerv_ai ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else if ( Hexagon :: HvxWRRegClass . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( Hexagon :: PS_vstorerw_ai ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addReg ( SrcReg , KillFlag ) . addMemOperand ( MMO ) ; } else { llvm_unreachable ( "Unimplemented" ) ; } } </s>

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


<s> static bool nds32_legitimate_index_p ( machine_mode outer_mode , rtx index , bool strict ) { int regno ; rtx op0 ; rtx op1 ; switch ( GET_CODE ( index ) ) { case REG : regno = REGNO ( index ) ; if ( strict ) return REGNO_OK_FOR_INDEX_P ( regno ) ; else return true ; case CONST_INT : if ( GET_MODE_SIZE ( outer_mode ) == 1 ) { if ( ! satisfies_constraint_Is15 ( index ) ) return false ; return true ; } if ( GET_MODE_SIZE ( outer_mode ) == 2 && NDS32_HALF_WORD_ALIGN_P ( INTVAL ( index ) ) ) { if ( ! satisfies_constraint_Is16 ( index ) ) return false ; return true ; } if ( GET_MODE_SIZE ( outer_mode ) == 4 && NDS32_SINGLE_WORD_ALIGN_P ( INTVAL ( index ) ) ) { if ( ! satisfies_constraint_Is17 ( index ) ) return false ; return true ; } if ( GET_MODE_SIZE ( outer_mode ) == 8 && NDS32_SINGLE_WORD_ALIGN_P ( INTVAL ( index ) ) ) { if ( ! satisfies_constraint_Is17 ( gen_int_mode ( INTVAL ( index ) + 4 , SImode ) ) ) return false ; return true ; } return false ; case MULT : op0 = XEXP ( index , 0 ) ; op1 = XEXP ( index , 1 ) ; if ( REG_P ( op0 ) && CONST_INT_P ( op1 ) ) { int multiplier ; multiplier = INTVAL ( op1 ) ; if ( multiplier != 1 && multiplier != 2 && multiplier != 4 ) return false ; regno = REGNO ( op0 ) ; if ( strict ) return REGNO_OK_FOR_INDEX_P ( regno ) ; else return true ; } return false ; case ASHIFT : op0 = XEXP ( index , 0 ) ; op1 = XEXP ( index , 1 ) ; if ( REG_P ( op0 ) && CONST_INT_P ( op1 ) ) { int sv ; sv = INTVAL ( op1 ) ; if ( sv != 0 && sv != 1 && sv != 2 ) return false ; regno = REGNO ( op0 ) ; if ( strict ) return REGNO_OK_FOR_INDEX_P ( regno ) ; else return true ; } return false ; default : return false ; } } </s>

Function that check if 'INDEX ' is valid to be a index rtx for address . OUTER_MODE : Machine mode of outer address rtx . INDEX : Check if this rtx is valid to be a index for address . STRICT : If it is true , we are in reload pass or after reload pass .


<s>
bool
HexagonAsmParser
::
MatchAndEmitInstruction
(
SMLoc
IDLoc
,
unsigned
&
Opcode
,
OperandVector
&
Operands
,
MCStreamer
&
Out
,
uint64_t
&
ErrorInfo
,
bool
MatchingInlineAsm
)
{
if
(
!
InBrackets
)
{
MCB
.
clear
(
)
;
MCB
.
addOperand
(
MCOperand
::
createImm
(
0
)
)
;
}
HexagonOperand
&
FirstOperand
=
static_cast
<
HexagonOperand
&
>
(
*
Operands
[
0
]
)
;
if
(
FirstOperand
.
isToken
(
)
&&
FirstOperand
.
getToken
(
)
==
"{"
)
{
assert
(
Operands
.
size
(
)
==
1
&&
"Brackets should be by themselves"
)
;
if
(
InBrackets
)
{
getParser
(
)
.
Error
(
IDLoc
,
"Already in a packet"
)
;
InBrackets
=
false
;
return
true
;
}
InBrackets
=
true
;
return
false
;
}
if
(
FirstOperand
.
isToken
(
)
&&
FirstOperand
.
getToken
(
)
==
"}"
)
{
assert
(
Operands
.
size
(
)
==
1
&&
"Brackets should be by themselves"
)
;
if
(
!
InBrackets
)
{
getParser
(
)
.
Error
(
IDLoc
,
"Not in a packet"
)
;
return
true
;
}
InBrackets
=
false
;
if
(
matchBundleOptions
(
)
)
return
true
;
return
finishBundle
(
IDLoc
,
Out
)
;
}
MCInst
*
SubInst
=
getParser
(
)
.
getContext
(
)
.
createMCInst
(
)
;
if
(
matchOneInstruction
(
*
SubInst
,
IDLoc
,
Operands
,
ErrorInfo
,
MatchingInlineAsm
)
)
{
if
(
InBrackets
)
eatToEndOfPacket
(
)
;
return
true
;
}
HexagonMCInstrInfo
::
extendIfNeeded
(
getParser
(
)
.
getContext
(
)
,
MII
,
MCB
,
*
SubInst
)
;
MCB
.
addOperand
(
MCOperand
::
createInst
(
SubInst
)
)
;
if
(
!
InBrackets
)
return
finishBundle
(
IDLoc
,
Out
)
;
return
false
;
}
</s>

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

Hexagon
Hexagon
0
Hexagon
Hexagon
0
"{"
1
"Brackets should be by themselves"
"Already in a packet"
"}"
1
"Brackets should be by themselves"
"Not in a packet"
Hexagon


<s>
bool
PPCRegisterInfo
::
needsFrameBaseReg
(
MachineInstr
*
MI
,
int64_t
Offset
)
const
{
assert
(
Offset
<
0
&&
"Local offset must be negative"
)
;
unsigned
OpC
=
MI
->
getOpcode
(
)
;
if
(
!
ImmToIdxMap
.
count
(
OpC
)
)
return
false
;
if
(
(
OpC
==
PPC
::
ADDI
||
OpC
==
PPC
::
ADDI8
)
&&
MI
->
getOperand
(
2
)
.
getImm
(
)
==
0
)
return
false
;
MachineBasicBlock
&
MBB
=
*
MI
->
getParent
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
const
PPCFrameLowering
*
TFI
=
getFrameLowering
(
MF
)
;
unsigned
StackEst
=
TFI
->
determineFrameLayout
(
MF
,
false
,
true
)
;
if
(
!
StackEst
)
return
false
;
Offset
+=
StackEst
;
return
!
isFrameOffsetLegal
(
MI
,
getBaseRegister
(
MF
)
,
Offset
)
;
}
</s>

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


<s> ScheduleHazardRecognizer * ARMBaseInstrInfo :: CreateTargetHazardRecognizer ( const TargetMachine * TM , const ScheduleDAG * DAG ) const { if ( usePreRAHazardRecognizer ( ) ) { const InstrItineraryData * II = TM -> getInstrItineraryData ( ) ; return new ScoreboardHazardRecognizer ( II , DAG , "pre-RA-sched" ) ; } return TargetInstrInfo :: CreateTargetHazardRecognizer ( TM , DAG ) ; } </s>


<s> static void m32c_print_operand_address ( FILE * stream , machine_mode , rtx address ) { if ( GET_CODE ( address ) == MEM ) address = XEXP ( address , 0 ) ; else gcc_assert ( GET_CODE ( address ) == REG ) ; m32c_print_operand ( stream , address , 0 ) ; } </s>

Implements PRINT_OPERAND_ADDRESS . Nothing unusual here .


<s> static rtx set_frame_related_p ( void ) { rtx seq = get_insns ( ) ; rtx insn ; end_sequence ( ) ; if ( ! seq ) return NULL_RTX ; if ( INSN_P ( seq ) ) { insn = seq ; while ( insn != NULL_RTX ) { RTX_FRAME_RELATED_P ( insn ) = 1 ; insn = NEXT_INSN ( insn ) ; } seq = emit_insn ( seq ) ; } else { seq = emit_insn ( seq ) ; RTX_FRAME_RELATED_P ( seq ) = 1 ; } return seq ; } </s>

Helper function to set RTX_FRAME_RELATED_P on instructions , including sequences .


<s> SDValue PPCTargetLowering :: BuildSDIVPow2 ( SDNode * N , const APInt & Divisor , SelectionDAG & DAG , SmallVectorImpl < SDNode * > & Created ) const { EVT VT = N -> getValueType ( 0 ) ; if ( VT == MVT :: i64 && ! Subtarget . isPPC64 ( ) ) return SDValue ( ) ; if ( ( VT != MVT :: i32 && VT != MVT :: i64 ) || ! ( Divisor . isPowerOf2 ( ) || Divisor . isNegatedPowerOf2 ( ) ) ) return SDValue ( ) ; SDLoc DL ( N ) ; SDValue N0 = N -> getOperand ( 0 ) ; bool IsNegPow2 = Divisor . isNegatedPowerOf2 ( ) ; unsigned Lg2 = ( IsNegPow2 ? - Divisor : Divisor ) . countTrailingZeros ( ) ; SDValue ShiftAmt = DAG . getConstant ( Lg2 , DL , VT ) ; SDValue Op = DAG . getNode ( PPCISD :: SRA_ADDZE , DL , VT , N0 , ShiftAmt ) ; Created . push_back ( Op . getNode ( ) ) ; if ( IsNegPow2 ) { Op = DAG . getNode ( ISD :: SUB , DL , VT , DAG . getConstant ( 0 , DL , VT ) , Op ) ; Created . push_back ( Op . getNode ( ) ) ; } return Op ; } </s>

Targets may override this function to provide custom SDIV lowering for power-of-2 denominators .


<s> bool SPURegisterInfo :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return MFI -> getStackSize ( ) && needsFP ( MF ) ; } </s>

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


<s> unsigned getLength ( ) const { return CurType . Length ; } </s>

Return the number of bytes of data in this stream .


Return a nonzero value if XINSN is a legitimate address for a memory operand of the indicated MODE . STRICT is nonzero if this function is called during reload .


<s> void pru_register_pragmas ( void ) { c_register_pragma ( NULL , "ctable_entry" , pru_pragma_ctable_entry ) ; c_register_pragma ( NULL , "CTABLE_ENTRY" , pru_pragma_ctable_entry ) ; c_register_addr_space ( "__regio_symbol" , ADDR_SPACE_REGIO ) ; } </s>


<s> bool X86ATTAsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getIdentifier ( ) ; if ( IDVal == ".word" ) return ParseDirectiveWord ( 2 , DirectiveID . getLoc ( ) ) ; return true ; } </s>

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


<s> static int mova_p ( rtx insn ) { return ( GET_CODE ( insn ) == INSN && GET_CODE ( PATTERN ( insn ) ) == SET && GET_CODE ( SET_SRC ( PATTERN ( insn ) ) ) == UNSPEC && XINT ( SET_SRC ( PATTERN ( insn ) ) , 1 ) == UNSPEC_MOVA && GET_CODE ( XVECEXP ( SET_SRC ( PATTERN ( insn ) ) , 0 , 0 ) ) == LABEL_REF ) ; } </s>

Return true if the specified insn is a mova insn .


<s>
void
HexagonCommonGEP
::
collect
(
)
{
ValueVect
BO
;
getBlockTraversalOrder
(
&
Fn
->
front
(
)
,
BO
)
;
ValueToNodeMap
NM
;
for
(
ValueVect
::
iterator
I
=
BO
.
begin
(
)
,
E
=
BO
.
end
(
)
;
I
!=
E
;
++
I
)
{
BasicBlock
*
B
=
cast
<
BasicBlock
>
(
*
I
)
;
for
(
BasicBlock
::
iterator
J
=
B
->
begin
(
)
,
F
=
B
->
end
(
)
;
J
!=
F
;
++
J
)
{
if
(
!
isa
<
GetElementPtrInst
>
(
J
)
)
continue
;
GetElementPtrInst
*
GepI
=
cast
<
GetElementPtrInst
>
(
J
)
;
if
(
isHandledGepForm
(
GepI
)
)
processGepInst
(
GepI
,
NM
)
;
}
}
LLVM_DEBUG
(
dbgs
(
)
<<
"Gep nodes after initial collection:\n"
<<
Nodes
)
;
}
</s>

Analyze the given instruction MI and fill in the Uses , Defs and DeadDefs list based on the MachineOperand flags .

Hexagon
Hexagon
"Gep nodes after initial collection:\n"


<s> unsigned P2AsmParser :: getReg ( int RC , int RegNo ) { return * ( getContext ( ) . getRegisterInfo ( ) -> getRegClass ( RC ) . begin ( ) + RegNo ) ; } </s>

Returns the register associated with this edge .


<s> bool MOSAsmBackend :: fixupNeedsRelaxationAdvanced ( const MCFixup & Fixup , bool Resolved , uint64_t Value , const MCRelaxableFragment * DF , const MCAsmLayout & Layout , const bool WasForced ) const { bool BankRelax = false ; MOSAsmBackend :: relaxInstructionTo ( DF -> getInst ( ) , * DF -> getSubtargetInfo ( ) , BankRelax ) ; auto Info = getFixupKindInfo ( Fixup . getKind ( ) ) ; const auto * MME = dyn_cast < MOSMCExpr > ( Fixup . getValue ( ) ) ; if ( MME != nullptr ) { return ( Info . TargetSize > ( BankRelax ? 16 : 8 ) ) ; } if ( Info . TargetSize > ( BankRelax ? 16 : 8 ) ) { return true ; } const char * FixupNameStart = Fixup . getValue ( ) -> getLoc ( ) . getPointer ( ) ; if ( FixupNameStart == nullptr ) { return true ; } StringRef FixupName ( FixupNameStart , getFixupLength ( FixupNameStart ) ) ; for ( const auto & Symbol : Layout . getAssembler ( ) . symbols ( ) ) { const auto SymbolName = Symbol . getName ( ) ; if ( FixupName == SymbolName ) { if ( ! Symbol . isInSection ( ) ) { return true ; } const auto & Section = Symbol . getSection ( ) ; const auto * ELFSection = dyn_cast_or_null < MCSectionELF > ( & Section ) ; if ( ELFSection == nullptr ) { return true ; } if ( ( ELFSection -> getFlags ( ) & ELF :: SHF_MOS_ZEROPAGE ) != 0 ) { return false ; } if ( isZeroPageSectionName ( ELFSection -> getName ( ) ) ) return false ; } } return true ; } </s>

Target specific predicate for whether a given fixup requires the associated instruction to be relaxed .


<s>
static
void
mips_output_filename
(
FILE
*
stream
,
const
char
*
name
)
{
if
(
dwarf_debuginfo_p
(
)
)
return
;
else
if
(
mips_output_filename_first_time
)
{
mips_output_filename_first_time
=
0
;
num_source_filenames
+=
1
;
current_function_file
=
name
;
fprintf
(
stream
,
"\t.file\t%d "
,
num_source_filenames
)
;
output_quoted_string
(
stream
,
name
)
;
putc
(
'\n'
,
stream
)
;
}
else
if
(
name
!=
current_function_file
&&
strcmp
(
name
,
current_function_file
)
!=
0
)
{
num_source_filenames
+=
1
;
current_function_file
=
name
;
fprintf
(
stream
,
"\t.file\t%d "
,
num_source_filenames
)
;
output_quoted_string
(
stream
,
name
)
;
putc
(
'\n'
,
stream
)
;
}
}
</s>

Emit a new filename to a stream . If we are smuggling stabs , try to put out a MIPS ECOFF file and a stab .


<s> static rtx s390_delegitimize_address ( rtx orig_x ) { rtx x , y ; orig_x = delegitimize_mem_from_attrs ( orig_x ) ; x = orig_x ; if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , 0 ) ) && REGNO ( XEXP ( x , 0 ) ) == PIC_OFFSET_TABLE_REGNUM && GET_CODE ( XEXP ( x , 1 ) ) == CONST ) { HOST_WIDE_INT offset = 0 ; y = XEXP ( XEXP ( x , 1 ) , 0 ) ; if ( GET_CODE ( y ) == PLUS && GET_CODE ( XEXP ( y , 1 ) ) == CONST_INT ) { offset = INTVAL ( XEXP ( y , 1 ) ) ; y = XEXP ( y , 0 ) ; } if ( GET_CODE ( y ) == UNSPEC && ( XINT ( y , 1 ) == UNSPEC_GOTOFF || XINT ( y , 1 ) == UNSPEC_PLTOFF ) ) return plus_constant ( Pmode , XVECEXP ( y , 0 , 0 ) , offset ) ; } if ( GET_CODE ( x ) != MEM ) return orig_x ; x = XEXP ( x , 0 ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , 1 ) ) == CONST && GET_CODE ( XEXP ( x , 0 ) ) == REG && REGNO ( XEXP ( x , 0 ) ) == PIC_OFFSET_TABLE_REGNUM ) { y = XEXP ( XEXP ( x , 1 ) , 0 ) ; if ( GET_CODE ( y ) == UNSPEC && XINT ( y , 1 ) == UNSPEC_GOT ) y = XVECEXP ( y , 0 , 0 ) ; else return orig_x ; } else if ( GET_CODE ( x ) == CONST ) { y = XEXP ( x , 0 ) ; if ( GET_CODE ( y ) == UNSPEC && ( XINT ( y , 1 ) == UNSPEC_GOTENT || XINT ( y , 1 ) == UNSPEC_PLT31 ) ) y = XVECEXP ( y , 0 , 0 ) ; else return orig_x ; } else return orig_x ; if ( GET_MODE ( orig_x ) != Pmode ) { if ( GET_MODE ( orig_x ) == BLKmode ) return orig_x ; y = lowpart_subreg ( GET_MODE ( orig_x ) , y , Pmode ) ; if ( y == NULL_RTX ) return orig_x ; } return y ; } </s>

In the name of slightly smaller debug output , and to cater to general assembler lossage , recognize various UNSPEC sequences and turn them back into a direct symbol reference .


<s> bool AMDGPULibFunc :: parse ( StringRef FuncName , AMDGPULibFunc & F ) { if ( FuncName . empty ( ) ) { F . Impl = std :: unique_ptr < AMDGPULibFuncImpl > ( ) ; return false ; } if ( eatTerm ( FuncName , "_Z" ) ) F . Impl = std :: make_unique < AMDGPUMangledLibFunc > ( ) ; else F . Impl = std :: make_unique < AMDGPUUnmangledLibFunc > ( ) ; if ( F . Impl -> parseFuncName ( FuncName ) ) return true ; F . Impl = std :: unique_ptr < AMDGPULibFuncImpl > ( ) ; return false ; } </s>

Parses just-constructed SpecialCaseList entries from a memory buffer .

AMDGPU AMDGPU AMDGPU AMDGPU "_Z" AMDGPU AMDGPU AMDGPU


<s> Register MSP430RegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const MSP430FrameLowering * TFI = getFrameLowering ( MF ) ; return TFI -> hasFP ( MF ) ? MSP430 :: FP : MSP430 :: SP ; } </s>


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

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


runOnMachineFunction - Emit the function body .


<s> static void sh_emit_set_t_insn ( rtx insn , machine_mode mode ) { if ( TARGET_FPU_ANY && GET_MODE_CLASS ( mode ) == MODE_FLOAT && GET_CODE ( insn ) != PARALLEL ) { insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 3 , insn , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( SImode , FPSCR_STAT_REG ) ) , gen_rtx_USE ( VOIDmode , gen_rtx_REG ( SImode , FPSCR_MODES_REG ) ) ) ) ; } emit_insn ( insn ) ; } </s>

Emit INSN , possibly in a PARALLEL with an USE/CLOBBER of FPSCR bits in case of floating-point comparisons .


<s> static void frv_optimize_membar ( void ) { basic_block bb ; struct frv_io * first_io ; rtx_insn * * last_membar ; compute_bb_for_insn ( ) ; first_io = XCNEWVEC ( struct frv_io , last_basic_block_for_fn ( cfun ) ) ; last_membar = XCNEWVEC ( rtx_insn * , last_basic_block_for_fn ( cfun ) ) ; FOR_EACH_BB_FN ( bb , cfun ) frv_optimize_membar_local ( bb , & first_io [ bb -> index ] , & last_membar [ bb -> index ] ) ; FOR_EACH_BB_FN ( bb , cfun ) if ( last_membar [ bb -> index ] != 0 ) frv_optimize_membar_global ( bb , first_io , last_membar [ bb -> index ] ) ; free ( first_io ) ; free ( last_membar ) ; } </s>

Remove redundant membars from the current function .


<s> virtual const unsigned * getCalleeSavedRegs ( const MachineFunction * MF = 0 ) const { static const unsigned CalleeSavedRegs [ ] = { 0 } ; return CalleeSavedRegs ; } </s>


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

getPassName - Return a nice clean name for a pass .


<s> bool mips_use_by_pieces_infrastructure_p ( unsigned HOST_WIDE_INT size , unsigned int align , enum by_pieces_operation op , bool speed_p ) { if ( op == STORE_BY_PIECES ) return mips_store_by_pieces_p ( size , align ) ; if ( op == MOVE_BY_PIECES && HAVE_movmemsi ) { if ( currently_expanding_to_rtl ) return false ; if ( align < BITS_PER_WORD ) return size < UNITS_PER_WORD ; return size <= MIPS_MAX_MOVE_BYTES_STRAIGHT ; } return default_use_by_pieces_infrastructure_p ( size , align , op , speed_p ) ; } </s>


<s> static bool isSafeToMove ( const MachineInstr * Def , const MachineInstr * Insert , AliasAnalysis & AA , const MachineRegisterInfo & MRI ) { assert ( Def -> getParent ( ) == Insert -> getParent ( ) ) ; if ( Def -> getOpcode ( ) == WebAssembly :: CATCH || Def -> getOpcode ( ) == WebAssembly :: EXTRACT_EXCEPTION_I32 ) { const MachineBasicBlock * MBB = Def -> getParent ( ) ; auto NextI = std :: next ( MachineBasicBlock :: const_iterator ( Def ) ) ; for ( auto E = MBB -> end ( ) ; NextI != E && NextI -> isDebugInstr ( ) ; ++ NextI ) ; if ( NextI != Insert ) return false ; } SmallVector < unsigned , 4 > MutableRegisters ; for ( const MachineOperand & MO : Def -> operands ( ) ) { if ( ! MO . isReg ( ) || MO . isUndef ( ) ) continue ; unsigned Reg = MO . getReg ( ) ; if ( MO . isDead ( ) && Insert -> definesRegister ( Reg ) && ! Insert -> readsRegister ( Reg ) ) continue ; if ( TargetRegisterInfo :: isPhysicalRegister ( Reg ) ) { if ( Reg == WebAssembly :: ARGUMENTS ) continue ; if ( ! MRI . isPhysRegModified ( Reg ) ) continue ; return false ; } if ( ! MO . isDef ( ) && ! MRI . hasOneDef ( Reg ) ) MutableRegisters . push_back ( Reg ) ; } bool Read = false , Write = false , Effects = false , StackPointer = false ; query ( * Def , AA , Read , Write , Effects , StackPointer ) ; bool HasMutableRegisters = ! MutableRegisters . empty ( ) ; if ( ! Read && ! Write && ! Effects && ! StackPointer && ! HasMutableRegisters ) return true ; MachineBasicBlock :: const_iterator D ( Def ) , I ( Insert ) ; for ( -- I ; I != D ; -- I ) { bool InterveningRead = false ; bool InterveningWrite = false ; bool InterveningEffects = false ; bool InterveningStackPointer = false ; query ( * I , AA , InterveningRead , InterveningWrite , InterveningEffects , InterveningStackPointer ) ; if ( Effects && InterveningEffects ) return false ; if ( Read && InterveningWrite ) return false ; if ( Write && ( InterveningRead || InterveningWrite ) ) return false ; if ( StackPointer && InterveningStackPointer ) return false ; for ( unsigned Reg : MutableRegisters ) for ( const MachineOperand & MO : I -> operands ( ) ) if ( MO . isReg ( ) && MO . isDef ( ) && MO . getReg ( ) == Reg ) return false ; } return true ; } </s>

Return true if it is safe to move this instruction .


<s> TargetTransformInfo :: PopcntSupportKind getPopcntSupport ( unsigned TyWidth ) { if ( TyWidth == 32 ) return TTI :: PSK_FastHardware ; return TTI :: PSK_Software ; } </s>

Return hardware support for population count .


<s>
void
HexagonInstPrinter
::
printInst
(
MCInst
const
*
MI
,
raw_ostream
&
O
,
StringRef
Annot
,
const
MCSubtargetInfo
&
STI
)
{
const
char
startPacket
=
'{'
,
endPacket
=
'}'
;
if
(
MI
->
getOpcode
(
)
==
Hexagon
::
ENDLOOP0
)
{
assert
(
HexagonMCInstrInfo
::
isPacketEnd
(
*
MI
)
&&
"Loop-end must also end the packet"
)
;
if
(
HexagonMCInstrInfo
::
isPacketBegin
(
*
MI
)
)
{
MCInst
Nop
;
StringRef
NoAnnot
;
Nop
.
setOpcode
(
Hexagon
::
A2_nop
)
;
HexagonMCInstrInfo
::
setPacketBegin
(
Nop
,
HexagonMCInstrInfo
::
isPacketBegin
(
*
MI
)
)
;
printInst
(
&
Nop
,
O
,
NoAnnot
,
STI
)
;
}
if
(
HexagonMCInstrInfo
::
isPacketEnd
(
*
MI
)
)
O
<<
PacketPadding
<<
endPacket
;
printInstruction
(
MI
,
O
)
;
}
else
{
if
(
HexagonMCInstrInfo
::
isPacketBegin
(
*
MI
)
)
O
<<
PacketPadding
<<
startPacket
<<
'\n'
;
printInstruction
(
MI
,
O
)
;
if
(
HexagonMCInstrInfo
::
isPacketEnd
(
*
MI
)
)
O
<<
'\n'
<<
PacketPadding
<<
endPacket
;
}
printAnnotation
(
O
,
Annot
)
;
}
</s>

Print the specified MCInst to the specified raw_ostream .

Hexagon
Hexagon
Hexagon::ENDLOOP0
Hexagon
"Loop-end must also end the packet"
Hexagon
Hexagon::A2_nop
Hexagon
Hexagon
Hexagon
Hexagon
Hexagon


<s> static rtx nvptx_get_drap_rtx ( void ) { if ( TARGET_SOFT_STACK && stack_realign_drap ) return arg_pointer_rtx ; return NULL_RTX ; } </s>

Return Dynamic ReAlignment Pointer RTX . For PTX there is n't any .


<s> inline bool bundle_state_hasher :: equal ( const bundle_state * state1 , const bundle_state * state2 ) { return ( state1 -> insn_num == state2 -> insn_num && memcmp ( state1 -> dfa_state , state2 -> dfa_state , dfa_state_size ) == 0 ) ; } </s>


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

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