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

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


runOnMachineFunction - Emit the function body .


<s> static bool use_32bit_hwmult ( void ) { static const char * known_32bit_mult_mcus [ ] = { "msp430f4783" , "msp430f4793" , "msp430f4784" , "msp430f4794" , "msp430f47126" , "msp430f47127" , "msp430f47163" , "msp430f47173" , "msp430f47183" , "msp430f47193" , "msp430f47166" , "msp430f47176" , "msp430f47186" , "msp430f47196" , "msp430f47167" , "msp430f47177" , "msp430f47187" , "msp430f47197" } ; static const char * cached_match = NULL ; static bool cached_result ; int i ; if ( msp430_hwmult_type == LARGE ) return true ; if ( target_mcu == NULL || msp430_hwmult_type != AUTO ) return false ; if ( target_mcu == cached_match ) return cached_result ; cached_match = target_mcu ; for ( i = ARRAY_SIZE ( known_32bit_mult_mcus ) ; i -- ; ) if ( strcasecmp ( target_mcu , known_32bit_mult_mcus [ i ] ) == 0 ) return cached_result = true ; return cached_result = false ; } </s>

Returns true if the current MCU has a second generation 32-bit hardware multiplier .


<s> bool isValid ( ) { return isFIBase ( ) || ( isRegBase ( ) && getReg ( ) != 0 ) ; } </s>

Returns true if this iterator is still pointing at a valid entry .


<s>
MCSymbol
*
MSP430MCInstLower
::
GetBlockAddressSymbol
(
const
MachineOperand
&
MO
)
const
{
switch
(
MO
.
getTargetFlags
(
)
)
{
default
:
llvm_unreachable
(
"Unknown target flag on GV operand"
)
;
case
0
:
break
;
}
return
Printer
.
GetBlockAddressSymbol
(
MO
.
getBlockAddress
(
)
)
;
}
</s>

Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block .


<s> static void arm_init_neon_builtins ( void ) { unsigned int i , fcode = ARM_BUILTIN_NEON_PATTERN_START ; arm_init_simd_builtin_types ( ) ; arm_init_simd_builtin_scalar_types ( ) ; tree lane_check_fpr = build_function_type_list ( void_type_node , intSI_type_node , intSI_type_node , NULL ) ; arm_builtin_decls [ ARM_BUILTIN_NEON_LANE_CHECK ] = add_builtin_function ( "__builtin_arm_lane_check" , lane_check_fpr , ARM_BUILTIN_NEON_LANE_CHECK , BUILT_IN_MD , NULL , NULL_TREE ) ; for ( i = 0 ; i < ARRAY_SIZE ( neon_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & neon_builtin_data [ i ] ; arm_init_builtin ( fcode , d , "__builtin_neon" ) ; } } </s>

Set up all the NEON builtins , even builtins for instructions that are not in the current target ISA to allow the user to compile particular modules with different target specific options that differ from the command line options . Such builtins will be rejected in arm_expand_builtin .


<s> void RISCVDAGToDAGISel :: PostprocessISelDAG ( ) { SelectionDAG :: allnodes_iterator Position = CurDAG -> allnodes_end ( ) ; bool MadeChange = false ; while ( Position != CurDAG -> allnodes_begin ( ) ) { SDNode * N = & * -- Position ; if ( N -> use_empty ( ) || ! N -> isMachineOpcode ( ) ) continue ; MadeChange |= doPeepholeSExtW ( N ) ; MadeChange |= doPeepholeLoadStoreADDI ( N ) ; } if ( MadeChange ) CurDAG -> RemoveDeadNodes ( ) ; } </s>

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


"%qE attribute only applies to functions"

Check `` fast_interrupt '' , `` interrupt '' and `` naked '' attributes .


<s> unsigned HSAILInstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { const MCInstrDesc & MCID = get ( MI -> getOpcode ( ) ) ; if ( ! MCID . mayLoad ( ) || ! MI -> hasOneMemOperand ( ) ) return HSAIL :: NoRegister ; const MachineOperand * Segment = getNamedOperand ( * MI , HSAIL :: OpName :: segment ) ; if ( ! Segment || Segment -> getImm ( ) != HSAILAS :: SPILL_ADDRESS ) return HSAIL :: NoRegister ; int AddressIdx = HSAIL :: getNamedOperandIdx ( MI -> getOpcode ( ) , HSAIL :: OpName :: address ) ; const MachineOperand & Base = MI -> getOperand ( AddressIdx + HSAILADDRESS :: BASE ) ; if ( Base . isFI ( ) ) { FrameIndex = Base . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } return HSAIL :: NoRegister ; } </s>

isLoadFromStackSlot - If the specified machine instruction is a direct load from a stack slot , return the virtual or physical register number of the destination along with the FrameIndex of the loaded stack slot .

HSAIL HSAIL HSAIL::NoRegister HSAIL::OpName HSAILAS::SPILL_ADDRESS HSAIL::NoRegister HSAIL::getNamedOperandIdx HSAIL::OpName HSAILADDRESS::BASE 0 HSAIL::NoRegister


<s> int ARMBaseInstrInfo :: getInstrLatency ( const InstrItineraryData * ItinData , SDNode * Node ) const { if ( ! Node -> isMachineOpcode ( ) ) return 1 ; if ( ! ItinData || ItinData -> isEmpty ( ) ) return 1 ; unsigned Opcode = Node -> getMachineOpcode ( ) ; switch ( Opcode ) { default : return ItinData -> getStageLatency ( get ( Opcode ) . getSchedClass ( ) ) ; case ARM :: VLDMQIA : case ARM :: VLDMQDB : case ARM :: VSTMQIA : case ARM :: VSTMQDB : return 2 ; } } </s>

Compute the instruction latency of a given instruction .

ARM ARM 1 1 ARM::VLDMQIA ARM::VLDMQDB ARM::VSTMQIA ARM::VSTMQDB 2


<s> X86TargetMachine :: X86TargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , Optional < CodeModel :: Model > CM , CodeGenOpt :: Level OL , bool JIT ) : LLVMTargetMachine ( T , computeDataLayout ( TT ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , JIT , RM ) , getEffectiveX86CodeModel ( CM , JIT , TT . getArch ( ) == Triple :: x86_64 ) , OL ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) { if ( TT . isPS4 ( ) || TT . isOSBinFormatMachO ( ) ) { this -> Options . TrapUnreachable = true ; this -> Options . NoTrapAfterNoreturn = TT . isOSBinFormatMachO ( ) ; } setMachineOutliner ( true ) ; setSupportsDebugEntryValues ( true ) ; initAsmInfo ( ) ; } </s>


<s> MachineBasicBlock * MipsSETargetLowering :: EmitInstrWithCustomInserter ( MachineInstr * MI , MachineBasicBlock * BB ) const { switch ( MI -> getOpcode ( ) ) { default : return MipsTargetLowering :: EmitInstrWithCustomInserter ( MI , BB ) ; case Mips :: BPOSGE32_PSEUDO : return emitBPOSGE32 ( MI , BB ) ; case Mips :: SNZ_B_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_B ) ; case Mips :: SNZ_H_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_H ) ; case Mips :: SNZ_W_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_W ) ; case Mips :: SNZ_D_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_D ) ; case Mips :: SNZ_V_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BNZ_V ) ; case Mips :: SZ_B_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_B ) ; case Mips :: SZ_H_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_H ) ; case Mips :: SZ_W_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_W ) ; case Mips :: SZ_D_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_D ) ; case Mips :: SZ_V_PSEUDO : return emitMSACBranchPseudo ( MI , BB , Mips :: BZ_V ) ; case Mips :: COPY_FW_PSEUDO : return emitCOPY_FW ( MI , BB ) ; case Mips :: COPY_FD_PSEUDO : return emitCOPY_FD ( MI , BB ) ; case Mips :: INSERT_FW_PSEUDO : return emitINSERT_FW ( MI , BB ) ; case Mips :: INSERT_FD_PSEUDO : return emitINSERT_FD ( MI , BB ) ; case Mips :: INSERT_B_VIDX_PSEUDO : case Mips :: INSERT_B_VIDX64_PSEUDO : return emitINSERT_DF_VIDX ( MI , BB , 1 , false ) ; case Mips :: INSERT_H_VIDX_PSEUDO : case Mips :: INSERT_H_VIDX64_PSEUDO : return emitINSERT_DF_VIDX ( MI , BB , 2 , false ) ; case Mips :: INSERT_W_VIDX_PSEUDO : case Mips :: INSERT_W_VIDX64_PSEUDO : return emitINSERT_DF_VIDX ( MI , BB , 4 , false ) ; case Mips :: INSERT_D_VIDX_PSEUDO : case Mips :: INSERT_D_VIDX64_PSEUDO : return emitINSERT_DF_VIDX ( MI , BB , 8 , false ) ; case Mips :: INSERT_FW_VIDX_PSEUDO : case Mips :: INSERT_FW_VIDX64_PSEUDO : return emitINSERT_DF_VIDX ( MI , BB , 4 , true ) ; case Mips :: INSERT_FD_VIDX_PSEUDO : case Mips :: INSERT_FD_VIDX64_PSEUDO : return emitINSERT_DF_VIDX ( MI , BB , 8 , true ) ; case Mips :: FILL_FW_PSEUDO : return emitFILL_FW ( MI , BB ) ; case Mips :: FILL_FD_PSEUDO : return emitFILL_FD ( MI , BB ) ; case Mips :: FEXP2_W_1_PSEUDO : return emitFEXP2_W_1 ( MI , BB ) ; case Mips :: FEXP2_D_1_PSEUDO : return emitFEXP2_D_1 ( MI , BB ) ; } } </s>

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


<s> rtx extract_shift_reg ( rtx alu_shift_rtx ) { alu_shift_rtx = extract_pattern_from_insn ( alu_shift_rtx ) ; rtx alu_rtx = SET_SRC ( alu_shift_rtx ) ; rtx shift_rtx ; if ( REG_P ( XEXP ( alu_rtx , 0 ) ) ) shift_rtx = XEXP ( alu_rtx , 1 ) ; else shift_rtx = XEXP ( alu_rtx , 0 ) ; return XEXP ( shift_rtx , 0 ) ; } </s>

Extract the register of the shift operand from an ALU_SHIFT rtx .


<s> void GCNMaxOccupancySchedStrategy :: initialize ( ScheduleDAGMI * DAG ) { GenericScheduler :: initialize ( DAG ) ; const SIRegisterInfo * SRI = static_cast < const SIRegisterInfo * > ( TRI ) ; MF = & DAG -> MF ; const GCNSubtarget & ST = MF -> getSubtarget < GCNSubtarget > ( ) ; const int ErrorMargin = 3 ; SGPRExcessLimit = Context -> RegClassInfo -> getNumAllocatableRegs ( & AMDGPU :: SGPR_32RegClass ) - ErrorMargin ; VGPRExcessLimit = Context -> RegClassInfo -> getNumAllocatableRegs ( & AMDGPU :: VGPR_32RegClass ) - ErrorMargin ; if ( TargetOccupancy ) { SGPRCriticalLimit = ST . getMaxNumSGPRs ( TargetOccupancy , true ) ; VGPRCriticalLimit = ST . getMaxNumVGPRs ( TargetOccupancy ) ; } else { SGPRCriticalLimit = SRI -> getRegPressureSetLimit ( DAG -> MF , SRI -> getSGPRPressureSet ( ) ) ; VGPRCriticalLimit = SRI -> getRegPressureSetLimit ( DAG -> MF , SRI -> getVGPRPressureSet ( ) ) ; } SGPRCriticalLimit -= ErrorMargin ; VGPRCriticalLimit -= ErrorMargin ; } </s>

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


<s> static struct machine_function * mips_init_machine_status ( void ) { return ggc_cleared_alloc < machine_function > ( ) ; } </s>

Allocate a chunk of memory for per-function machine-dependent data .


<s> rtx function_arg ( CUMULATIVE_ARGS cum , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED ) { int basereg ; int num_args ; if ( type && AGGREGATE_TYPE_P ( type ) ) basereg = 16 ; else { gcc_assert ( ! COMPLEX_MODE_P ( mode ) ) ; if ( TARGET_FPREGS && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) basereg = 32 + 16 ; else basereg = 16 ; } { if ( mode == VOIDmode ) return alpha_arg_info_reg_val ( cum ) ; num_args = cum . num_args ; if ( num_args >= 6 || targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; } { int size ; if ( mode == VOIDmode ) { int i ; HOST_WIDE_INT lo ; HOST_WIDE_INT hi ; rtx ciw ; lo = 0 ; for ( i = 0 ; i < cum . num_reg_words && i < 5 ; i ++ ) if ( cum . reg_args_type [ i ] ) lo |= ( 1 << ( 7 - i ) ) ; if ( cum . num_reg_words == 6 && cum . reg_args_type [ 5 ] ) lo |= 7 ; else lo |= cum . num_reg_words ; hi = ( cum . num_args << 20 ) | cum . num_arg_words ; lo = lo | ( ( HOST_WIDE_INT ) cum . num_args << 52 ) | ( ( HOST_WIDE_INT ) cum . num_arg_words << 32 ) ; hi = 0 ; ciw = immed_double_const ( lo , hi , DImode ) ; return gen_rtx_UNSPEC ( DImode , gen_rtvec ( 1 , ciw ) , UNSPEC_UMK_LOAD_CIW ) ; } size = ALPHA_ARG_SIZE ( mode , type , named ) ; num_args = cum . num_reg_words ; if ( cum . force_stack || cum . num_reg_words + size > 6 || targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; else if ( type && TYPE_MODE ( type ) == BLKmode ) { rtx reg1 , reg2 ; reg1 = gen_rtx_REG ( DImode , num_args + 16 ) ; reg1 = gen_rtx_EXPR_LIST ( DImode , reg1 , const0_rtx ) ; if ( size == 0 ) return NULL_RTX ; else if ( size == 1 ) return gen_rtx_PARALLEL ( mode , gen_rtvec ( 1 , reg1 ) ) ; else { reg2 = gen_rtx_REG ( DImode , num_args + 17 ) ; reg2 = gen_rtx_EXPR_LIST ( DImode , reg2 , GEN_INT ( 8 ) ) ; return gen_rtx_PARALLEL ( mode , gen_rtvec ( 2 , reg1 , reg2 ) ) ; } } } { if ( cum >= 6 ) return NULL_RTX ; num_args = cum ; if ( type == void_type_node ) basereg = 16 ; else if ( targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; } return gen_rtx_REG ( mode , num_args + basereg ) ; } </s>

Return an RTL expression containing the register for the given mode , or 0 if the argument is to be passed on the stack . INCOMING_P is nonzero if this is an incoming argument to the current function .


<s> bool MLxExpansion :: runOnMachineFunction ( MachineFunction & Fn ) { if ( skipFunction ( * Fn . getFunction ( ) ) ) return false ; TII = static_cast < const ARMBaseInstrInfo * > ( Fn . getSubtarget ( ) . getInstrInfo ( ) ) ; TRI = Fn . getSubtarget ( ) . getRegisterInfo ( ) ; MRI = & Fn . getRegInfo ( ) ; const ARMSubtarget * STI = & Fn . getSubtarget < ARMSubtarget > ( ) ; if ( ! STI -> isCortexA9 ( ) ) return false ; isLikeA9 = STI -> isLikeA9 ( ) || STI -> isSwift ( ) ; isSwift = STI -> isSwift ( ) ; bool Modified = false ; for ( MachineBasicBlock & MBB : Fn ) Modified |= ExpandFPMLxInstructions ( MBB ) ; return Modified ; } </s>


<s>
const
char
*
mt_asm_output_opcode
(
FILE
*
f
ATTRIBUTE_UNUSED
,
const
char
*
ptr
)
{
if
(
mt_nops_required
)
fprintf
(
f
,
";# need %d nops because of %s\n\t"
,
mt_nops_required
,
mt_nop_reasons
)
;
while
(
mt_nops_required
)
{
fprintf
(
f
,
"nop\n\t"
)
;
mt_nops_required
;
}
return
ptr
;
}
</s>

mt
";# need %d nops because of %s\n\t"
"nop\n\t"


<s>
void
rs6000_xcoff_declare_function_name
(
FILE
*
file
,
const
char
*
name
,
tree
decl
)
{
char
*
buffer
=
(
char
*
)
alloca
(
strlen
(
name
)
+
1
)
;
char
*
p
;
int
dollar_inside
=
0
;
struct
declare_alias_data
data
=
{
file
,
false
}
;
strcpy
(
buffer
,
name
)
;
p
=
strchr
(
buffer
,
'$'
)
;
while
(
p
)
{
*
p
=
'_'
;
dollar_inside
++
;
p
=
strchr
(
p
+
1
,
'$'
)
;
}
if
(
TREE_PUBLIC
(
decl
)
)
{
if
(
!
RS6000_WEAK
||
!
DECL_WEAK
(
decl
)
)
{
if
(
dollar_inside
)
{
fprintf
(
file
,
"\t.rename .%s,\".%s\"\n"
,
buffer
,
name
)
;
fprintf
(
file
,
"\t.rename %s,\"%s\"\n"
,
buffer
,
name
)
;
}
fputs
(
"\t.globl ."
,
file
)
;
RS6000_OUTPUT_BASENAME
(
file
,
buffer
)
;
putc
(
'\n'
,
file
)
;
}
}
else
{
if
(
dollar_inside
)
{
fprintf
(
file
,
"\t.rename .%s,\".%s\"\n"
,
buffer
,
name
)
;
fprintf
(
file
,
"\t.rename %s,\"%s\"\n"
,
buffer
,
name
)
;
}
fputs
(
"\t.lglobl ."
,
file
)
;
RS6000_OUTPUT_BASENAME
(
file
,
buffer
)
;
putc
(
'\n'
,
file
)
;
}
fputs
(
"\t.csect "
,
file
)
;
RS6000_OUTPUT_BASENAME
(
file
,
buffer
)
;
fputs
(
TARGET_32BIT
"[DS]\n"
:
"[DS],3\n"
,
file
)
;
RS6000_OUTPUT_BASENAME
(
file
,
buffer
)
;
fputs
(
":\n"
,
file
)
;
symtab_node
::
get
(
decl
)
->
call_for_symbol_and_aliases
(
rs6000_declare_alias
,
&
data
,
true
)
;
fputs
(
TARGET_32BIT
"\t.long ."
:
"\t.llong ."
,
file
)
;
RS6000_OUTPUT_BASENAME
(
file
,
buffer
)
;
fputs
(
", TOC[tc0], 0\n"
,
file
)
;
in_section
=
;
switch_to_section
(
function_section
(
decl
)
)
;
putc
(
'.'
,
file
)
;
RS6000_OUTPUT_BASENAME
(
file
,
buffer
)
;
fputs
(
":\n"
,
file
)
;
data
.
function_descriptor
=
true
;
symtab_node
::
get
(
decl
)
->
call_for_symbol_and_aliases
(
rs6000_declare_alias
,
&
data
,
true
)
;
if
(
!
DECL_IGNORED_P
(
decl
)
)
{
if
(
write_symbols
==
DBX_DEBUG
||
write_symbols
==
XCOFF_DEBUG
)
xcoffout_declare_function
(
file
,
decl
,
buffer
)
;
else
if
(
write_symbols
==
DWARF2_DEBUG
)
{
name
=
(
*
targetm
.
strip_name_encoding
)
(
name
)
;
fprintf
(
file
,
"\t.function .%s,.%s,2,0\n"
,
name
,
name
)
;
}
}
return
;
}
</s>

This macro produces the initial definition of a function name . On the RS/6000 , we need to place an extra ' . ' in the function name and output the function descriptor . Dollar signs are converted to underscores . The csect for the function will have already been created when text_section was selected . We do have to go back to that csect , however . The third and fourth parameters to the .function pseudo-op ( 16 and 044 ) are placeholders which no longer have any use . Because AIX assembler 's .set command has unexpected semantics , we output all aliases as alternative labels in front of the definition .


<s> static bool arm_cxx_guard_mask_bit ( void ) { return TARGET_AAPCS_BASED ; } </s>

The EABI says test the least significant bit of a guard variable .


<s> void HexagonTargetMachine :: registerPassBuilderCallbacks ( PassBuilder & PB ) { PB . registerLateLoopOptimizationsEPCallback ( [ = ] ( LoopPassManager & LPM , PassBuilder :: OptimizationLevel Level ) { LPM . addPass ( HexagonLoopIdiomRecognitionPass ( ) ) ; } ) ; PB . registerLoopOptimizerEndEPCallback ( [ = ] ( LoopPassManager & LPM , PassBuilder :: OptimizationLevel Level ) { LPM . addPass ( HexagonVectorLoopCarriedReusePass ( ) ) ; } ) ; } </s>

Invoke the PassBuilder callback registration .


"instruction requires a CPU feature not currently enabled"

"source and destination must be different"

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


<s> static rtx push ( int rn ) { rtx x ; if ( rn == FPUL_REG ) x = gen_push_fpul ( ) ; else if ( rn == FPSCR_REG ) x = gen_push_fpscr ( ) ; else if ( TARGET_FPU_DOUBLE && TARGET_FMOVD && ! TARGET_FPU_SINGLE && FP_OR_XD_REGISTER_P ( rn ) ) { if ( FP_REGISTER_P ( rn ) && ( rn - FIRST_FP_REG ) & 1 ) return NULL_RTX ; x = gen_push_4 ( gen_rtx_REG ( DFmode , rn ) ) ; } else if ( TARGET_SH2E && FP_REGISTER_P ( rn ) ) x = gen_push_e ( gen_rtx_REG ( SFmode , rn ) ) ; else x = gen_push ( gen_rtx_REG ( SImode , rn ) ) ; x = emit_frame_insn ( x ) ; add_reg_note ( x , REG_INC , gen_rtx_REG ( SImode , STACK_POINTER_REGNUM ) ) ; return x ; } </s>

Output RTL to push register RN onto the stack .


<s> enum reg_class alpha_preferred_reload_class ( rtx x , enum reg_class class ) { if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) return class ; if ( GET_CODE ( x ) == CONST_INT || GET_CODE ( x ) == CONST_DOUBLE || GET_CODE ( x ) == CONST_VECTOR ) { if ( class == FLOAT_REGS ) return NO_REGS ; if ( class == ALL_REGS ) return GENERAL_REGS ; return class ; } if ( CONSTANT_P ( x ) ) return ( class == ALL_REGS ? GENERAL_REGS : class ) ; return class ; } </s>

On the Alpha , all ( non-symbolic ) constants except zero go into a floating-point register via memory . Note that we can not return anything that is not a subset of CLASS , and that some symbolic constants can not be dropped to memory .


<s> static rtx altivec_expand_lxvr_builtin ( enum insn_code icode , tree exp , rtx target , bool blk , bool sign_extend ) { rtx pat , addr ; tree arg0 = CALL_EXPR_ARG ( exp , 0 ) ; tree arg1 = CALL_EXPR_ARG ( exp , 1 ) ; machine_mode tmode = insn_data [ icode ] . operand [ 0 ] . mode ; machine_mode smode = insn_data [ icode ] . operand [ 1 ] . mode ; machine_mode mode0 = Pmode ; machine_mode mode1 = Pmode ; rtx op0 = expand_normal ( arg0 ) ; rtx op1 = expand_normal ( arg1 ) ; if ( icode == CODE_FOR_nothing ) return 0 ; if ( arg0 == error_mark_node || arg1 == error_mark_node ) return const0_rtx ; if ( target == 0 || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ 0 ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; op1 = copy_to_mode_reg ( mode1 , op1 ) ; if ( op0 == const0_rtx ) addr = gen_rtx_MEM ( blk ? BLKmode : tmode , op1 ) ; else { op0 = copy_to_mode_reg ( mode0 , op0 ) ; addr = gen_rtx_MEM ( blk ? BLKmode : smode , gen_rtx_PLUS ( Pmode , op1 , op0 ) ) ; } if ( sign_extend ) { rtx discratch = gen_reg_rtx ( DImode ) ; rtx tiscratch = gen_reg_rtx ( TImode ) ; pat = GEN_FCN ( icode ) ( tiscratch , addr ) ; if ( ! pat ) return 0 ; emit_insn ( pat ) ; rtx scratch = gen_lowpart ( smode , tiscratch ) ; if ( icode == CODE_FOR_vsx_lxvrbx ) emit_insn ( gen_extendqidi2 ( discratch , scratch ) ) ; else if ( icode == CODE_FOR_vsx_lxvrhx ) emit_insn ( gen_extendhidi2 ( discratch , scratch ) ) ; else if ( icode == CODE_FOR_vsx_lxvrwx ) emit_insn ( gen_extendsidi2 ( discratch , scratch ) ) ; if ( icode == CODE_FOR_vsx_lxvrdx ) discratch = scratch ; emit_insn ( gen_extendditi2 ( target , discratch ) ) ; return target ; } else { pat = GEN_FCN ( icode ) ( target , addr ) ; if ( ! pat ) return 0 ; emit_insn ( pat ) ; return target ; } return 0 ; } </s>

For the load and sign extend rightmost elements ; load and zero extend rightmost element builtins .


<s> int ia64_move_ok ( rtx dst , rtx src ) { if ( GET_CODE ( dst ) != MEM ) return 1 ; if ( GET_CODE ( src ) == MEM ) return 0 ; if ( register_operand ( src , VOIDmode ) ) return 1 ; if ( INTEGRAL_MODE_P ( GET_MODE ( dst ) ) ) return src == const0_rtx ; else return GET_CODE ( src ) == CONST_DOUBLE && CONST_DOUBLE_OK_FOR_G ( src ) ; } </s>

Return 1 if the operands of a move are ok .


<s> bool RISCVTargetLowering :: isSExtCheaperThanZExt ( EVT SrcVT , EVT DstVT ) const { return Subtarget . is64Bit ( ) && SrcVT == MVT :: i32 && DstVT == MVT :: i64 ; } </s>

Return true if sign-extension from FromTy to ToTy is cheaper than zero-extension .


<s> bool isMachineVerifierClean ( ) const override { return false ; } </s>

Returns true if the target is expected to pass all machine verifier checks .


<s>
MachineBasicBlock
*
XCoreTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
*
MI
,
MachineBasicBlock
*
BB
)
const
{
const
TargetInstrInfo
&
TII
=
*
Subtarget
.
getInstrInfo
(
)
;
DebugLoc
dl
=
MI
->
getDebugLoc
(
)
;
assert
(
(
MI
->
getOpcode
(
)
==
XCore
::
SELECT_CC
)
&&
"Unexpected instr type to insert"
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
MachineFunction
::
iterator
It
=
++
BB
->
getIterator
(
)
;
MachineBasicBlock
*
thisMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
copy0MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
sinkMBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
F
->
insert
(
It
,
copy0MBB
)
;
F
->
insert
(
It
,
sinkMBB
)
;
sinkMBB
->
splice
(
sinkMBB
->
begin
(
)
,
BB
,
std
::
next
(
MachineBasicBlock
::
iterator
(
MI
)
)
,
BB
->
end
(
)
)
;
sinkMBB
->
transferSuccessorsAndUpdatePHIs
(
BB
)
;
BB
->
addSuccessor
(
copy0MBB
)
;
BB
->
addSuccessor
(
sinkMBB
)
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
XCore
::
BRFT_lru6
)
)
.
addReg
(
MI
->
getOperand
(
1
)
.
getReg
(
)
)
.
addMBB
(
sinkMBB
)
;
BB
=
copy0MBB
;
BB
->
addSuccessor
(
sinkMBB
)
;
BB
=
sinkMBB
;
BuildMI
(
*
BB
,
BB
->
begin
(
)
,
dl
,
TII
.
get
(
XCore
::
PHI
)
,
MI
->
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
->
getOperand
(
3
)
.
getReg
(
)
)
.
addMBB
(
copy0MBB
)
.
addReg
(
MI
->
getOperand
(
2
)
.
getReg
(
)
)
.
addMBB
(
thisMBB
)
;
MI
->
eraseFromParent
(
)
;
return
BB
;
}
</s>


<s> HOST_WIDE_INT bfin_initial_elimination_offset ( int from , int to ) { HOST_WIDE_INT offset = 0 ; if ( from == ARG_POINTER_REGNUM ) offset = n_regs_saved_by_prologue ( ) * 4 ; if ( to == STACK_POINTER_REGNUM ) { if ( crtl -> outgoing_args_size >= FIXED_STACK_AREA ) offset += crtl -> outgoing_args_size ; else if ( crtl -> outgoing_args_size ) offset += FIXED_STACK_AREA ; offset += get_frame_size ( ) ; } return offset ; } </s>

Return the offset between two registers , one to be eliminated , and the other its replacement , at the start of a routine .


"Object file emission is not supported with PTX"

Add passes to the specified pass manager to get the specified file emitted .


<s> bool SITargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace , unsigned Align , bool * IsFast ) const { if ( IsFast ) * IsFast = false ; if ( VT == MVT :: Other || ( VT != MVT :: Other && VT . getSizeInBits ( ) > 1024 && VT . getStoreSize ( ) > 16 ) ) { return false ; } if ( AddrSpace == AMDGPUAS :: LOCAL_ADDRESS || AddrSpace == AMDGPUAS :: REGION_ADDRESS ) { bool AlignedBy4 = ( Align % 4 == 0 ) ; if ( IsFast ) * IsFast = AlignedBy4 ; return AlignedBy4 ; } if ( ! Subtarget -> hasUnalignedScratchAccess ( ) && ( AddrSpace == AMDGPUAS :: PRIVATE_ADDRESS || AddrSpace == AMDGPUAS :: FLAT_ADDRESS ) ) { return false ; } 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> const BPFSubtarget * getSubtargetImpl ( ) const override { return & Subtarget ; } </s>

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


<s> std :: pair < uint16_t , uint16_t > X86InstrInfo :: getExecutionDomain ( const MachineInstr & MI ) const { uint16_t domain = ( MI . getDesc ( ) . TSFlags >> X86II :: SSEDomainShift ) & 3 ; bool hasAVX2 = Subtarget . hasAVX2 ( ) ; uint16_t validDomains = 0 ; if ( domain && lookup ( MI . getOpcode ( ) , domain ) ) validDomains = 0xe ; else if ( domain && lookupAVX2 ( MI . getOpcode ( ) , domain ) ) validDomains = hasAVX2 ? 0xe : 0x6 ; else if ( domain && lookupAVX512 ( MI . getOpcode ( ) , domain ) ) validDomains = 0xe ; return std :: make_pair ( domain , validDomains ) ; } </s>

Return the current execution domain and bit mask of possible domains for instruction .


<s> TargetLowering :: AtomicExpansionKind X86TargetLowering :: shouldExpandAtomicLoadInIR ( LoadInst * LI ) const { Type * MemType = LI -> getType ( ) ; bool NoImplicitFloatOps = LI -> getFunction ( ) -> hasFnAttribute ( Attribute :: NoImplicitFloat ) ; if ( MemType -> getPrimitiveSizeInBits ( ) == 64 && ! Subtarget . is64Bit ( ) && ! Subtarget . useSoftFloat ( ) && ! NoImplicitFloatOps && Subtarget . hasSSE2 ( ) ) return AtomicExpansionKind :: None ; return needsCmpXchgNb ( MemType ) ? AtomicExpansionKind :: CmpXChg : AtomicExpansionKind :: None ; } </s>

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


<s> bool MSP430AsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count , const MCSubtargetInfo * STI ) const { if ( ( Count % 2 ) != 0 ) return false ; uint64_t NopCount = Count / 2 ; while ( NopCount -- ) OS . write ( "\x03\x43" , 2 ) ; return true ; } </s>

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


<s> const MCPhysReg * SystemZRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { if ( MF -> getSubtarget ( ) . getTargetLowering ( ) -> supportSwiftError ( ) && MF -> getFunction ( ) . getAttributes ( ) . hasAttrSomewhere ( Attribute :: SwiftError ) ) return CSR_SystemZ_SwiftError_SaveList ; return CSR_SystemZ_SaveList ; } </s>


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

Get the Init value of the specified global variable .

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


<s>
void
ARMInstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
SrcReg
,
bool
isKill
,
int
FI
,
const
TargetRegisterClass
*
RC
)
const
{
DebugLoc
DL
=
DebugLoc
::
getUnknownLoc
(
)
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
if
(
RC
==
ARM
::
GPRRegisterClass
)
{
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
ARMFunctionInfo
*
AFI
=
MF
.
getInfo
<
ARMFunctionInfo
>
(
)
;
if
(
AFI
->
isThumbFunction
(
)
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tSpill
)
)
.
addReg
(
SrcReg
,
false
,
false
,
isKill
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
;
else
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
STR
)
)
.
addReg
(
SrcReg
,
false
,
false
,
isKill
)
.
addFrameIndex
(
FI
)
.
addReg
(
0
)
.
addImm
(
0
)
)
;
}
else
if
(
RC
==
ARM
::
DPRRegisterClass
)
{
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
FSTD
)
)
.
addReg
(
SrcReg
,
false
,
false
,
isKill
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
)
;
}
else
{
assert
(
RC
==
ARM
::
SPRRegisterClass
&&
"Unknown regclass!"
)
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
FSTS
)
)
.
addReg
(
SrcReg
,
false
,
false
,
isKill
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
)
;
}
}
</s>

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

ARM
ARM
ARM::GPRRegisterClass
ARM
ARM
ARM::tSpill
0
ARM::STR
0
0
ARM::DPRRegisterClass
ARM::FSTD
0
ARM::SPRRegisterClass
"Unknown regclass!"
ARM::FSTS
0


<s> bool SIInstrInfo :: shouldClusterMemOps ( ArrayRef < const MachineOperand * > BaseOps1 , ArrayRef < const MachineOperand * > BaseOps2 , unsigned NumLoads , unsigned NumBytes ) const { assert ( ! BaseOps1 . empty ( ) && ! BaseOps2 . empty ( ) ) ; const MachineInstr & FirstLdSt = * BaseOps1 . front ( ) -> getParent ( ) ; const MachineInstr & SecondLdSt = * BaseOps2 . front ( ) -> getParent ( ) ; if ( ! memOpsHaveSameBasePtr ( FirstLdSt , BaseOps1 , SecondLdSt , BaseOps2 ) ) return false ; const MachineOperand * FirstDst = nullptr ; const MachineOperand * SecondDst = nullptr ; if ( ( isMUBUF ( FirstLdSt ) && isMUBUF ( SecondLdSt ) ) || ( isMTBUF ( FirstLdSt ) && isMTBUF ( SecondLdSt ) ) || ( isMIMG ( FirstLdSt ) && isMIMG ( SecondLdSt ) ) || ( isFLAT ( FirstLdSt ) && isFLAT ( SecondLdSt ) ) ) { const unsigned MaxGlobalLoadCluster = 7 ; if ( NumLoads > MaxGlobalLoadCluster ) return false ; FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: vdata ) ; if ( ! FirstDst ) FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: vdst ) ; SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: vdata ) ; if ( ! SecondDst ) SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: vdst ) ; } else if ( isSMRD ( FirstLdSt ) && isSMRD ( SecondLdSt ) ) { FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: sdst ) ; SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: sdst ) ; } else if ( isDS ( FirstLdSt ) && isDS ( SecondLdSt ) ) { FirstDst = getNamedOperand ( FirstLdSt , AMDGPU :: OpName :: vdst ) ; SecondDst = getNamedOperand ( SecondLdSt , AMDGPU :: OpName :: vdst ) ; } if ( ! FirstDst || ! SecondDst ) return false ; unsigned LoadClusterThreshold = 16 ; const MachineRegisterInfo & MRI = FirstLdSt . getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; const Register Reg = FirstDst -> getReg ( ) ; const TargetRegisterClass * DstRC = Register :: isVirtualRegister ( Reg ) ? MRI . getRegClass ( Reg ) : RI . getPhysRegClass ( Reg ) ; return ( ( NumLoads - 1 ) * ( RI . getRegSizeInBits ( * DstRC ) / 8 ) ) <= LoadClusterThreshold ; } </s>

Returns true if the two given memory operations should be scheduled adjacent .

AMDGPU SI 7 AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName AMDGPU::OpName 16 1 8


<s> int loongarch_idiv_insns ( machine_mode mode ATTRIBUTE_UNUSED ) { int count ; count = 1 ; if ( TARGET_CHECK_ZERO_DIV ) count += 2 ; return count ; } </s>

Return the number of instructions needed for an integer division .


"Suitable Machine Function for outlining must track liveness"

Optional target hook that returns true if MBB is safe to outline from , and returns any target-specific information in Flags .


<s> unsigned int ix86_local_alignment ( tree exp , machine_mode mode , unsigned int align ) { tree type , decl ; if ( exp && DECL_P ( exp ) ) { type = TREE_TYPE ( exp ) ; decl = exp ; } else { type = exp ; decl = NULL ; } if ( ! TARGET_64BIT && align == 64 && ix86_preferred_stack_boundary < 64 && ( mode == DImode || ( type && TYPE_MODE ( type ) == DImode ) ) && ( ! type || ! TYPE_USER_ALIGN ( type ) ) && ( ! decl || ! DECL_USER_ALIGN ( decl ) ) ) align = 32 ; if ( ! type ) { if ( mode == XFmode && align < GET_MODE_ALIGNMENT ( DFmode ) ) align = GET_MODE_ALIGNMENT ( DFmode ) ; return align ; } if ( TARGET_IAMCU ) return align ; if ( TARGET_64BIT && optimize_function_for_speed_p ( cfun ) && TARGET_SSE ) { if ( AGGREGATE_TYPE_P ( type ) && ( va_list_type_node == NULL_TREE || ( TYPE_MAIN_VARIANT ( type ) != TYPE_MAIN_VARIANT ( va_list_type_node ) ) ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( TYPE_SIZE ( type ) , 16 ) && align < 128 ) return 128 ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < 64 ) return 64 ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < 128 ) return 128 ; } else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < 64 ) return 64 ; if ( ( TYPE_MODE ( type ) == XCmode || TYPE_MODE ( type ) == TCmode ) && align < 128 ) return 128 ; } else if ( ( TREE_CODE ( type ) == RECORD_TYPE || TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == QUAL_UNION_TYPE ) && TYPE_FIELDS ( type ) ) { if ( DECL_MODE ( TYPE_FIELDS ( type ) ) == DFmode && align < 64 ) return 64 ; if ( ALIGN_MODE_128 ( DECL_MODE ( TYPE_FIELDS ( type ) ) ) && align < 128 ) return 128 ; } else if ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == VECTOR_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) { if ( TYPE_MODE ( type ) == DFmode && align < 64 ) return 64 ; if ( ALIGN_MODE_128 ( TYPE_MODE ( type ) ) && align < 128 ) return 128 ; } return align ; } </s>

Compute the alignment for a local variable . TYPE is the data type , and ALIGN is the alignment that the object would ordinarily have . The value of this macro is used instead of that alignment to align the object .


<s> static rtx aarch64_progress_pointer ( rtx pointer ) { HOST_WIDE_INT amount = GET_MODE_SIZE ( GET_MODE ( pointer ) ) ; return aarch64_move_pointer ( pointer , amount ) ; } </s>

Return a new RTX holding the result of moving POINTER forward by the size of the mode it points to .


<s> static struct machine_function * rl78_init_machine_status ( void ) { struct machine_function * m ; m = ggc_cleared_alloc < machine_function > ( ) ; m -> virt_insns_ok = 1 ; return m ; } </s>

This is our init_machine_status , as set in rl78_option_override .


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

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


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

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


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

Return information about object file lowering .


<s> Value * ARMTargetLowering :: emitStoreConditional ( IRBuilder < > & Builder , Value * Val , Value * Addr , AtomicOrdering Ord ) const { Module * M = Builder . GetInsertBlock ( ) -> getParent ( ) -> getParent ( ) ; bool IsRelease = isReleaseOrStronger ( Ord ) ; if ( Val -> getType ( ) -> getPrimitiveSizeInBits ( ) == 64 ) { Intrinsic :: ID Int = IsRelease ? Intrinsic :: arm_stlexd : Intrinsic :: arm_strexd ; Function * Strex = Intrinsic :: getDeclaration ( M , Int ) ; Type * Int32Ty = Type :: getInt32Ty ( M -> getContext ( ) ) ; Value * Lo = Builder . CreateTrunc ( Val , Int32Ty , "lo" ) ; Value * Hi = Builder . CreateTrunc ( Builder . CreateLShr ( Val , 32 ) , Int32Ty , "hi" ) ; if ( ! Subtarget -> isLittle ( ) ) std :: swap ( Lo , Hi ) ; Addr = Builder . CreateBitCast ( Addr , Type :: getInt8PtrTy ( M -> getContext ( ) ) ) ; return Builder . CreateCall ( Strex , { Lo , Hi , Addr } ) ; } Intrinsic :: ID Int = IsRelease ? Intrinsic :: arm_stlex : Intrinsic :: arm_strex ; Type * Tys [ ] = { Addr -> getType ( ) } ; Function * Strex = Intrinsic :: getDeclaration ( M , Int , Tys ) ; return Builder . CreateCall ( Strex , { Builder . CreateZExtOrBitCast ( Val , Strex -> getFunctionType ( ) -> getParamType ( 0 ) ) , Addr } ) ; } </s>

Perform a store-conditional operation to Addr .


<s>
void
relaxInstruction
(
const
MCInst
&
Inst
,
const
MCSubtargetInfo
&
STI
,
MCInst
&
Res
)
const
override
{
llvm_unreachable
(
"RelaxInstruction() unimplemented"
)
;
}
</s>

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


<s> const Cpu0AnalyzeImmediate :: InstSeq & Cpu0AnalyzeImmediate :: Analyze ( uint64_t Imm , unsigned Size , bool LastInstrIsADDiu ) { this -> Size = Size ; ADDiu = Cpu0 :: ADDiu ; ORi = Cpu0 :: ORi ; SHL = Cpu0 :: SHL ; LUi = Cpu0 :: LUi ; InstSeqLs SeqLs ; if ( LastInstrIsADDiu | ! Imm ) GetInstSeqLsADDiu ( Imm , Size , SeqLs ) ; else GetInstSeqLs ( Imm , Size , SeqLs ) ; GetShortestSeq ( SeqLs , Insts ) ; return Insts ; } </s>

Analyze - Get an instruction sequence to load immediate Imm .


<s>
bool
RISCVAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
{
if
(
getSTI
(
)
.
getFeatureBits
(
)
[
RISCV
::
FeatureRelax
]
)
{
auto
*
Assembler
=
getTargetStreamer
(
)
.
getStreamer
(
)
.
getAssemblerPtr
(
)
;
if
(
Assembler
!=
nullptr
)
{
RISCVAsmBackend
&
MAB
=
static_cast
<
RISCVAsmBackend
&
>
(
Assembler
->
getBackend
(
)
)
;
MAB
.
setForceRelocs
(
)
;
}
}
Operands
.
push_back
(
RISCVOperand
::
createToken
(
Name
,
NameLoc
,
isRV64
(
)
)
)
;
if
(
getLexer
(
)
.
is
(
AsmToken
::
EndOfStatement
)
)
{
getParser
(
)
.
Lex
(
)
;
return
false
;
}
if
(
parseOperand
(
Operands
,
Name
)
)
return
true
;
unsigned
OperandIdx
=
1
;
while
(
getLexer
(
)
.
is
(
AsmToken
::
Comma
)
)
{
getLexer
(
)
.
Lex
(
)
;
if
(
parseOperand
(
Operands
,
Name
)
)
return
true
;
++
OperandIdx
;
}
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
SMLoc
Loc
=
getLexer
(
)
.
getLoc
(
)
;
getParser
(
)
.
eatToEndOfStatement
(
)
;
return
Error
(
Loc
,
"unexpected token"
)
;
}
getParser
(
)
.
Lex
(
)
;
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .

RISCV
RISCV
RISCV::FeatureRelax
RISCV
RISCV
RISCV
1
"unexpected token"


<s>
const
char
*
getPassName
(
)
const
{
return
"Remove sign extends"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s>
unsigned
ARMBaseInstrInfo
::
getPartialRegUpdateClearance
(
const
MachineInstr
&
MI
,
unsigned
OpNum
,
const
TargetRegisterInfo
*
TRI
)
const
{
auto
PartialUpdateClearance
=
Subtarget
.
getPartialUpdateClearance
(
)
;
if
(
!
PartialUpdateClearance
)
return
0
;
assert
(
TRI
&&
"Need TRI instance"
)
;
const
MachineOperand
&
MO
=
MI
.
getOperand
(
OpNum
)
;
if
(
MO
.
readsReg
(
)
)
return
0
;
Register
Reg
=
MO
.
getReg
(
)
;
int
UseOp
=
1
;
switch
(
MI
.
getOpcode
(
)
)
{
case
ARM
::
VLDRS
:
case
ARM
::
FCONSTS
:
case
ARM
::
VMOVSR
:
case
ARM
::
VMOVv8i8
:
case
ARM
::
VMOVv4i16
:
case
ARM
::
VMOVv2i32
:
case
ARM
::
VMOVv2f32
:
case
ARM
::
VMOVv1i64
:
UseOp
=
MI
.
findRegisterUseOperandIdx
(
Reg
,
false
,
TRI
)
;
break
;
case
ARM
::
VLD1LNd32
:
UseOp
=
3
;
break
;
default
:
return
0
;
}
if
(
UseOp
!=
1
&&
MI
.
getOperand
(
UseOp
)
.
readsReg
(
)
)
return
0
;
if
(
Register
::
isVirtualRegister
(
Reg
)
)
{
if
(
!
MO
.
getSubReg
(
)
||
MI
.
readsVirtualRegister
(
Reg
)
)
return
0
;
}
else
if
(
ARM
::
SPRRegClass
.
contains
(
Reg
)
)
{
unsigned
DReg
=
TRI
->
getMatchingSuperReg
(
Reg
,
ARM
::
ssub_0
,
&
ARM
::
DPRRegClass
)
;
if
(
!
DReg
||
!
MI
.
definesRegister
(
DReg
,
TRI
)
)
return
0
;
}
return
PartialUpdateClearance
;
}
</s>

Inform the BreakFalseDeps pass how many idle instructions we would like before a partial register update .


<s>
const
char
*
JVMTargetLowering
::
getTargetNodeName
(
unsigned
Opcode
)
const
{
switch
(
Opcode
)
{
default
:
llvm_unreachable
(
"Unhandled target opcode.\n"
)
;
break
;
case
JVMISD
::
ALLOC
:
return
"JVMISD::ALLOC"
;
case
JVMISD
::
ADD
:
return
"JVMISD::ADD"
;
case
JVMISD
::
AND
:
return
"JVMISD::AND"
;
case
JVMISD
::
DIV
:
return
"JVMISD::DIV"
;
case
JVMISD
::
EXTEND
:
return
"JVMISD::EXTEND"
;
case
JVMISD
::
ARGUMENT
:
return
"JVMISD::ARGUMENT"
;
case
JVMISD
::
LOAD
:
return
"JVMISD::LOAD"
;
case
JVMISD
::
LOAD_W_CHAIN
:
return
"JVMISD::LOAD_W_CHAIN"
;
case
JVMISD
::
MUL
:
return
"JVMISD::MUL"
;
case
JVMISD
::
SHL
:
return
"JVMISD::SHL"
;
case
JVMISD
::
SRL
:
return
"JVMISD::SRL"
;
case
JVMISD
::
SRA
:
return
"JVMISD::SRA"
;
case
JVMISD
::
STORENR
:
return
"JVMISD::STORENR"
;
case
JVMISD
::
STORE
:
return
"JVMISD::STORE"
;
case
JVMISD
::
TRUNC
:
return
"JVMISD::TRUNC"
;
case
JVMISD
::
FIELD_ACC_R
:
return
"JVMISD::FIELD_ACC_R"
;
case
JVMISD
::
FIELD_ACC_W
:
return
"JVMISD::FIELD_ACC_W"
;
case
JVMISD
::
INDEX_ACC
:
return
"JVMISD::INDEX_ACC"
;
case
JVMISD
::
INVOKENV
:
return
"JVMISD::INVOKENV"
;
case
JVMISD
::
OR
:
return
"JVMISD::OR"
;
case
JVMISD
::
SUB
:
return
"JVMISD::SUB"
;
case
JVMISD
::
CMP
:
return
"JVMISD::CMP"
;
case
JVMISD
::
CALL
:
return
"JVMISD::CALL"
;
case
JVMISD
::
REM
:
return
"JVMISD::REM"
;
case
JVMISD
::
RET
:
return
"JVMISD::RET"
;
case
JVMISD
::
DUP
:
return
"JVMISD::DUP"
;
case
JVMISD
::
BR_CC
:
return
"JVMISD::BR_CC"
;
case
JVMISD
::
BR_CONST_CC
:
return
"JVMISD::BR_CONST_CC"
;
case
JVMISD
::
XOR
:
return
"JVMISD::XOR"
;
}
return
nullptr
;
}
</s>

getTargetNodeName - This method returns the name of a target specific

JVM
JVM
"Unhandled target opcode.\n"
JVMISD::ALLOC
"JVMISD::ALLOC"
JVMISD::ADD
"JVMISD::ADD"
JVMISD::AND
"JVMISD::AND"
JVMISD::DIV
"JVMISD::DIV"
JVMISD::EXTEND
"JVMISD::EXTEND"
JVMISD::ARGUMENT
"JVMISD::ARGUMENT"
JVMISD::LOAD
"JVMISD::LOAD"
JVMISD::LOAD_W_CHAIN
"JVMISD::LOAD_W_CHAIN"
JVMISD::MUL
"JVMISD::MUL"
JVMISD::SHL
"JVMISD::SHL"
JVMISD::SRL
"JVMISD::SRL"
JVMISD::SRA
"JVMISD::SRA"
JVMISD::STORENR
"JVMISD::STORENR"
JVMISD::STORE
"JVMISD::STORE"
JVMISD::TRUNC
"JVMISD::TRUNC"
JVMISD::FIELD_ACC_R
"JVMISD::FIELD_ACC_R"
JVMISD::FIELD_ACC_W
"JVMISD::FIELD_ACC_W"
JVMISD::INDEX_ACC
"JVMISD::INDEX_ACC"
JVMISD::INVOKENV
"JVMISD::INVOKENV"
JVMISD::OR
"JVMISD::OR"
JVMISD::SUB
"JVMISD::SUB"
JVMISD::CMP
"JVMISD::CMP"
JVMISD::CALL
"JVMISD::CALL"
JVMISD::REM
"JVMISD::REM"
JVMISD::RET
"JVMISD::RET"
JVMISD::DUP
"JVMISD::DUP"
JVMISD::BR_CC
"JVMISD::BR_CC"
JVMISD::BR_CONST_CC
"JVMISD::BR_CONST_CC"
JVMISD::XOR
"JVMISD::XOR"


<s>
unsigned
Mips16InstrInfo
::
getOppositeBranchOpc
(
unsigned
Opc
)
const
{
switch
(
Opc
)
{
case
Mips
::
BeqzRxImmX16
:
return
Mips
::
BnezRxImmX16
;
case
Mips
::
BnezRxImmX16
:
return
Mips
::
BeqzRxImmX16
;
case
Mips
::
BeqzRxImm16
:
return
Mips
::
BnezRxImm16
;
case
Mips
::
BnezRxImm16
:
return
Mips
::
BeqzRxImm16
;
case
Mips
::
BteqzT8CmpX16
:
return
Mips
::
BtnezT8CmpX16
;
case
Mips
::
BteqzT8SltX16
:
return
Mips
::
BtnezT8SltX16
;
case
Mips
::
BteqzT8SltiX16
:
return
Mips
::
BtnezT8SltiX16
;
case
Mips
::
Btnez16
:
return
Mips
::
Bteqz16
;
case
Mips
::
BtnezX16
:
return
Mips
::
BteqzX16
;
case
Mips
::
BtnezT8CmpiX16
:
return
Mips
::
BteqzT8CmpiX16
;
case
Mips
::
BtnezT8SltuX16
:
return
Mips
::
BteqzT8SltuX16
;
case
Mips
::
BtnezT8SltiuX16
:
return
Mips
::
BteqzT8SltiuX16
;
case
Mips
::
Bteqz16
:
return
Mips
::
Btnez16
;
case
Mips
::
BteqzX16
:
return
Mips
::
BtnezX16
;
case
Mips
::
BteqzT8CmpiX16
:
return
Mips
::
BtnezT8CmpiX16
;
case
Mips
::
BteqzT8SltuX16
:
return
Mips
::
BtnezT8SltuX16
;
case
Mips
::
BteqzT8SltiuX16
:
return
Mips
::
BtnezT8SltiuX16
;
case
Mips
::
BtnezT8CmpX16
:
return
Mips
::
BteqzT8CmpX16
;
case
Mips
::
BtnezT8SltX16
:
return
Mips
::
BteqzT8SltX16
;
case
Mips
::
BtnezT8SltiX16
:
return
Mips
::
BteqzT8SltiX16
;
}
llvm_unreachable
(
"Illegal opcode!"
)
;
}
</s>

getOppositeBranchOpc - Return the inverse of the specified opcode , e.g .


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { if ( ( Count % 4 ) != 0 ) return false ; for ( uint64_t i = 0 ; i < Count ; i += 4 ) OW -> Write32 ( 0x00000000 ) ; return true ; } </s>

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


<s> bool RISCVTargetLowering :: getTgtMemIntrinsic ( IntrinsicInfo & Info , const CallInst & I , MachineFunction & MF , unsigned Intrinsic ) const { switch ( Intrinsic ) { default : return false ; case Intrinsic :: riscv_masked_atomicrmw_xchg_i32 : case Intrinsic :: riscv_masked_atomicrmw_add_i32 : case Intrinsic :: riscv_masked_atomicrmw_sub_i32 : case Intrinsic :: riscv_masked_atomicrmw_nand_i32 : case Intrinsic :: riscv_masked_atomicrmw_max_i32 : case Intrinsic :: riscv_masked_atomicrmw_min_i32 : case Intrinsic :: riscv_masked_atomicrmw_umax_i32 : case Intrinsic :: riscv_masked_atomicrmw_umin_i32 : case Intrinsic :: riscv_masked_cmpxchg_i32 : PointerType * PtrTy = cast < PointerType > ( I . getArgOperand ( 0 ) -> getType ( ) ) ; Info . opc = ISD :: INTRINSIC_W_CHAIN ; Info . memVT = MVT :: getVT ( PtrTy -> getElementType ( ) ) ; Info . ptrVal = I . getArgOperand ( 0 ) ; Info . offset = 0 ; Info . align = Align ( 4 ) ; Info . flags = MachineMemOperand :: MOLoad | MachineMemOperand :: MOStore | MachineMemOperand :: MOVolatile ; return true ; } } </s>

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


"The number of element should not be zero."

Target-specific combining of register parts into its original value .


<s> J2ConstantPoolValue * J2ConstantPoolValue :: Create ( const Constant * Value ) { return new J2ConstantPoolValue ( Value ) ; } </s>

Construct a unary instruction , given the opcode and an operand .


<s> MVT M68kTargetLowering :: getScalarShiftAmountTy ( const DataLayout & DL , EVT Ty ) const { if ( Ty . isSimple ( ) ) { return Ty . getSimpleVT ( ) ; } return MVT :: getIntegerVT ( 8 * DL . getPointerSize ( 0 ) ) ; } </s>

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


"TriCore DAG->DAG Pattern Instruction Selection"


<s> const uint32_t * MipsRegisterInfo :: getCallPreservedMask ( CallingConv :: ID ) const { if ( Subtarget . isSingleFloat ( ) ) return CSR_SingleFloatOnly_RegMask ; if ( Subtarget . isABI_N64 ( ) ) return CSR_N64_RegMask ; if ( Subtarget . isABI_N32 ( ) ) return CSR_N32_RegMask ; if ( Subtarget . isFP64bit ( ) ) return CSR_O32_FP64_RegMask ; return CSR_O32_RegMask ; } </s>

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


<s> SDValue HexagonTargetLowering :: LowerReturn ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , const SmallVectorImpl < SDValue > & OutVals , SDLoc dl , SelectionDAG & DAG ) const { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeReturn ( Outs , RetCC_Hexagon ) ; SDValue Flag ; SmallVector < SDValue , 4 > RetOps ( 1 , Chain ) ; for ( unsigned i = 0 ; i != RVLocs . size ( ) ; ++ i ) { CCValAssign & VA = RVLocs [ i ] ; Chain = DAG . getCopyToReg ( Chain , dl , VA . getLocReg ( ) , OutVals [ i ] , Flag ) ; Flag = Chain . getValue ( 1 ) ; RetOps . push_back ( DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ) ; } RetOps [ 0 ] = Chain ; if ( Flag . getNode ( ) ) RetOps . push_back ( Flag ) ; return DAG . getNode ( HexagonISD :: RET_FLAG , dl , MVT :: Other , RetOps ) ; } </s>

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


<s> SMLoc getLoc ( ) const { return Parser . getTok ( ) . getLoc ( ) ; } </s>

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


<s> void X86TargetLowering :: insertSSPDeclarations ( Module & M ) const { if ( Subtarget . getTargetTriple ( ) . isOSMSVCRT ( ) ) { M . getOrInsertGlobal ( "__security_cookie" , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ; auto * SecurityCheckCookie = cast < Function > ( M . getOrInsertFunction ( "__security_check_cookie" , Type :: getVoidTy ( M . getContext ( ) ) , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ) ; SecurityCheckCookie -> setCallingConv ( CallingConv :: X86_FastCall ) ; SecurityCheckCookie -> addAttribute ( 1 , Attribute :: AttrKind :: InReg ) ; return ; } if ( hasStackGuardSlotTLS ( Subtarget . getTargetTriple ( ) ) ) return ; TargetLowering :: insertSSPDeclarations ( M ) ; } </s>

Inserts necessary declarations for SSP ( stack protection ) purpose .


"sret virtual register not created in entry block"


<s> const char * OR1KTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( ( OR1KISD :: NodeType ) Opcode ) { default : return NULL ; case OR1KISD :: ADJDYNALLOC : return "OR1KISD::ADJDYNALLOC" ; case OR1KISD :: RET_FLAG : return "OR1KISD::RET_FLAG" ; case OR1KISD :: CALL : return "OR1KISD::CALL" ; case OR1KISD :: SELECT_CC : return "OR1KISD::SELECT_CC" ; case OR1KISD :: SET_FLAG : return "OR1KISD::SET_FLAG" ; case OR1KISD :: BR_CC : return "OR1KISD::BR_CC" ; case OR1KISD :: Wrapper : return "OR1KISD::Wrapper" ; case OR1KISD :: FF1 : return "OR1KISD::FF1" ; case OR1KISD :: FL1 : return "OR1KISD::FL1" ; case OR1KISD :: HI : return "OR1KISD::HI" ; case OR1KISD :: LO : return "OR1KISD::LO" ; } } </s>


<s> static void get_pc_thunk_name ( char name [ 32 ] , unsigned int regno ) { gcc_assert ( ! TARGET_64BIT ) ; if ( USE_HIDDEN_LINKONCE ) sprintf ( name , "__x86.get_pc_thunk.%s" , reg_names [ regno ] ) ; else ASM_GENERATE_INTERNAL_LABEL ( name , "LPR" , regno ) ; } </s>

Fills in the label name that should be used for a pc thunk for the given register .


<s> const MCPhysReg * MipsRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { if ( Subtarget . isSingleFloat ( ) ) return CSR_SingleFloatOnly_SaveList ; if ( Subtarget . isFPXX ( ) ) return CSR_O32_FPXX_SaveList ; return CSR_O32_SaveList ; } </s>


<s> static void avr_asm_init_sections ( void ) { if ( AVR_HAVE_JMP_CALL ) { progmem_swtable_section = get_unnamed_section ( 0 , output_section_asm_op , "\t.section\t.progmem.gcc_sw_table" ",\"a\",@progbits" ) ; } else { progmem_swtable_section = get_unnamed_section ( SECTION_CODE , output_section_asm_op , "\t.section\t.progmem.gcc_sw_table" ",\"ax\",@progbits" ) ; } readonly_data_section -> unnamed . callback = avr_output_data_section_asm_op ; data_section -> unnamed . callback = avr_output_data_section_asm_op ; bss_section -> unnamed . callback = avr_output_bss_section_asm_op ; } </s>

Implement ` TARGET_ASM_INIT_SECTIONS ' .


<s> EVT X86TargetLowering :: getSetCCResultType ( const DataLayout & DL , LLVMContext & , EVT VT ) const { if ( ! VT . isVector ( ) ) return Subtarget -> hasAVX512 ( ) ? MVT :: i1 : MVT :: i8 ; const unsigned NumElts = VT . getVectorNumElements ( ) ; const EVT EltVT = VT . getVectorElementType ( ) ; if ( VT . is512BitVector ( ) ) { if ( Subtarget -> hasAVX512 ( ) ) if ( EltVT == MVT :: i32 || EltVT == MVT :: i64 || EltVT == MVT :: f32 || EltVT == MVT :: f64 ) switch ( NumElts ) { case 8 : return MVT :: v8i1 ; case 16 : return MVT :: v16i1 ; } if ( Subtarget -> hasBWI ( ) ) if ( EltVT == MVT :: i8 || EltVT == MVT :: i16 ) switch ( NumElts ) { case 32 : return MVT :: v32i1 ; case 64 : return MVT :: v64i1 ; } } if ( VT . is256BitVector ( ) || VT . is128BitVector ( ) ) { if ( Subtarget -> hasVLX ( ) ) if ( EltVT == MVT :: i32 || EltVT == MVT :: i64 || EltVT == MVT :: f32 || EltVT == MVT :: f64 ) switch ( NumElts ) { case 2 : return MVT :: v2i1 ; case 4 : return MVT :: v4i1 ; case 8 : return MVT :: v8i1 ; } if ( Subtarget -> hasBWI ( ) && Subtarget -> hasVLX ( ) ) if ( EltVT == MVT :: i8 || EltVT == MVT :: i16 ) switch ( NumElts ) { case 8 : return MVT :: v8i1 ; case 16 : return MVT :: v16i1 ; case 32 : return MVT :: v32i1 ; } } return VT . changeVectorElementTypeToInteger ( ) ; } </s>

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


<s> bool ShouldShrinkFPConstant ( EVT VT ) const { return VT != MVT :: f128 ; } </s>

If true , then instruction selection should seek to shrink the FP constant of the specified type to a smaller type in order to save space and / or reduce runtime .


<s> bool X86TargetLowering :: shouldConvertConstantLoadToIntImm ( const APInt & Imm , Type * Ty ) const { assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 || BitSize > 64 ) return false ; return true ; } </s>

Returns true if it is beneficial to convert a load of a constant to just the constant itself .


<s> RegisterAggr & RegisterAggr :: insert ( RegisterRef RR ) { RegisterRef NR = normalize ( RR ) ; auto F = Masks . find ( NR . Reg ) ; if ( F == Masks . end ( ) ) Masks . insert ( { NR . Reg , NR . Mask } ) ; else F -> second |= NR . Mask ; const TargetRegisterInfo & TRI = PRI . getTRI ( ) ; for ( MCRegUnitIterator U ( RR . Reg , & TRI ) ; U . isValid ( ) ; ++ U ) { MCRegUnitRootIterator R ( * U , & TRI ) ; ++ R ; if ( ! R . isValid ( ) ) continue ; ExpAliasUnits . set ( * U ) ; CheckUnits = true ; } return * this ; } </s>

insert - Append entry to the vector if it does n't already exist .


<s> bool IA64TargetMachine :: addPreEmitPass ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { PM . add ( createIA64BundlingPass ( * this ) ) ; return true ; } </s>

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


<s> bool X86LowerTileCopy :: runOnMachineFunction ( MachineFunction & MF ) { const X86Subtarget & ST = MF . getSubtarget < X86Subtarget > ( ) ; const X86InstrInfo * TII = ST . getInstrInfo ( ) ; bool Changed = false ; for ( MachineBasicBlock & MBB : MF ) { for ( MachineInstr & MI : llvm :: make_early_inc_range ( MBB ) ) { if ( ! MI . isCopy ( ) ) continue ; MachineOperand & DstMO = MI . getOperand ( 0 ) ; MachineOperand & SrcMO = MI . getOperand ( 1 ) ; Register SrcReg = SrcMO . getReg ( ) ; Register DstReg = DstMO . getReg ( ) ; if ( ! X86 :: TILERegClass . contains ( DstReg , SrcReg ) ) continue ; const TargetRegisterInfo * TRI = ST . getRegisterInfo ( ) ; unsigned Size = TRI -> getSpillSize ( X86 :: TILERegClass ) ; Align Alignment = TRI -> getSpillAlign ( X86 :: TILERegClass ) ; int TileSS = MF . getFrameInfo ( ) . CreateSpillStackObject ( Size , Alignment ) ; Size = TRI -> getSpillSize ( X86 :: GR64RegClass ) ; Alignment = TRI -> getSpillAlign ( X86 :: GR64RegClass ) ; int StrideSS = MF . getFrameInfo ( ) . CreateSpillStackObject ( Size , Alignment ) ; Register GR64Cand = X86 :: RAX ; const DebugLoc & DL = MI . getDebugLoc ( ) ; BuildMI ( MBB , MI , DL , TII -> get ( X86 :: IMPLICIT_DEF ) , GR64Cand ) ; addFrameReference ( BuildMI ( MBB , MI , DL , TII -> get ( X86 :: MOV64mr ) ) , StrideSS ) . addReg ( GR64Cand ) ; BuildMI ( MBB , MI , DL , TII -> get ( X86 :: MOV64ri ) , GR64Cand ) . addImm ( 64 ) ; unsigned Opc = X86 :: TILESTORED ; MachineInstr * NewMI = addFrameReference ( BuildMI ( MBB , MI , DL , TII -> get ( Opc ) ) , TileSS ) . addReg ( SrcReg , getKillRegState ( SrcMO . isKill ( ) ) ) ; MachineOperand & MO = NewMI -> getOperand ( 2 ) ; MO . setReg ( GR64Cand ) ; MO . setIsKill ( true ) ; Opc = X86 :: TILELOADD ; NewMI = addFrameReference ( BuildMI ( MBB , MI , DL , TII -> get ( Opc ) , DstReg ) , TileSS ) ; addFrameReference ( BuildMI ( MBB , MI , DL , TII -> get ( X86 :: MOV64rm ) , GR64Cand ) , StrideSS ) ; MI . eraseFromParent ( ) ; Changed = true ; } } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool HexagonMCInstrInfo :: isPredicated ( MCInstrInfo const & MCII , MCInst const & MCI ) { const uint64_t F = HexagonMCInstrInfo :: getDesc ( MCII , MCI ) . TSFlags ; return ( ( F >> HexagonII :: PredicatedPos ) & HexagonII :: PredicatedMask ) ; } </s>

Returns true if the instruction is already predicated .

Hexagon Hexagon Hexagon HexagonII::PredicatedPos HexagonII::PredicatedMask


<s> static struct aarch64_arch_driver_info * get_arch_from_id ( const char * id ) { unsigned int i = 0 ; for ( i = 0 ; aarch64_arches [ i ] . id != NULL ; i ++ ) { if ( strcmp ( id , aarch64_arches [ i ] . id ) == 0 ) return & aarch64_arches [ i ] ; } return NULL ; } </s>

Return an aarch64_arch_driver_info for the architecture described by ID , or NULL if ID describes something we do n't know about .


<s>
InstructionCost
AArch64TTIImpl
::
getMinMaxReductionCost
(
VectorType
*
Ty
,
VectorType
*
CondTy
,
bool
IsPairwise
,
bool
IsUnsigned
,
TTI
::
TargetCostKind
CostKind
)
{
if
(
!
isa
<
ScalableVectorType
>
(
Ty
)
)
return
BaseT
::
getMinMaxReductionCost
(
Ty
,
CondTy
,
IsPairwise
,
IsUnsigned
,
CostKind
)
;
assert
(
(
isa
<
ScalableVectorType
>
(
Ty
)
&&
isa
<
ScalableVectorType
>
(
CondTy
)
)
&&
"Both vector needs to be scalable"
)
;
std
::
pair
<
InstructionCost
,
MVT
>
LT
=
TLI
->
getTypeLegalizationCost
(
DL
,
Ty
)
;
InstructionCost
LegalizationCost
=
0
;
if
(
LT
.
first
>
1
)
{
Type
*
LegalVTy
=
EVT
(
LT
.
second
)
.
getTypeForEVT
(
Ty
->
getContext
(
)
)
;
unsigned
CmpOpcode
=
Ty
->
isFPOrFPVectorTy
(
)
Instruction
::
FCmp
:
Instruction
::
ICmp
;
LegalizationCost
=
getCmpSelInstrCost
(
CmpOpcode
,
LegalVTy
,
LegalVTy
,
CmpInst
::
BAD_ICMP_PREDICATE
,
CostKind
)
+
getCmpSelInstrCost
(
Instruction
::
Select
,
LegalVTy
,
LegalVTy
,
CmpInst
::
BAD_ICMP_PREDICATE
,
CostKind
)
;
LegalizationCost
*=
LT
.
first
1
;
}
return
LegalizationCost
+
2
;
}
</s>

Try to calculate op costs for min/max reduction operations .


"Arch64 does not support GOT PC rel with extra offset"

Get the target specific PC relative GOT entry relocation .


<s> static void rs6000_init_sched_context ( void * _sc , bool clean_p ) { rs6000_sched_context_t sc = ( rs6000_sched_context_t ) _sc ; if ( clean_p ) { sc -> cached_can_issue_more = 0 ; sc -> last_scheduled_insn = NULL ; sc -> load_store_pendulum = 0 ; sc -> divide_cnt = 0 ; sc -> vec_pairing = 0 ; } else { sc -> cached_can_issue_more = cached_can_issue_more ; sc -> last_scheduled_insn = last_scheduled_insn ; sc -> load_store_pendulum = load_store_pendulum ; sc -> divide_cnt = divide_cnt ; sc -> vec_pairing = vec_pairing ; } } </s>

If CLEAN_P is true then initializes _SC with clean data , and from the global context otherwise .


<s> static int ix86_fp_comparison_cost ( enum rtx_code code ) { int fcomi_cost , sahf_cost , arithmetics_cost = 1024 ; int min ; fcomi_cost = ix86_fp_comparison_fcomi_cost ( code ) ; sahf_cost = ix86_fp_comparison_sahf_cost ( code ) ; min = arithmetics_cost = ix86_fp_comparison_arithmetics_cost ( code ) ; if ( min > sahf_cost ) min = sahf_cost ; if ( min > fcomi_cost ) min = fcomi_cost ; return min ; } </s>

Compute cost of the comparison done using any method . See ix86_fp_comparison_arithmetics_cost for the metrics .


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

Returns the register associated with this edge .


<s> static rtx mips_call_tls_get_addr ( rtx sym , enum mips_symbol_type type , rtx v0 ) { rtx insn , loc , a0 ; a0 = gen_rtx_REG ( Pmode , GP_ARG_FIRST ) ; if ( ! mips_tls_symbol ) mips_tls_symbol = init_one_libfunc ( "__tls_get_addr" ) ; loc = mips_unspec_address ( sym , type ) ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( Pmode , a0 , gen_rtx_LO_SUM ( Pmode , pic_offset_table_rtx , loc ) ) ) ; insn = mips_expand_call ( MIPS_CALL_NORMAL , v0 , mips_tls_symbol , const0_rtx , NULL_RTX , false ) ; RTL_CONST_CALL_P ( insn ) = 1 ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , a0 ) ; insn = get_insns ( ) ; end_sequence ( ) ; return insn ; } </s>

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


<s> const char * host_detect_local_cpu ( int argc , const char * * argv ) { const char * cpu = NULL ; char * buf = NULL ; kstat_ctl_t * kc ; kstat_t * ksp ; kstat_named_t * brand = NULL ; char buf [ 128 ] ; FILE * f ; int i ; if ( argc < 1 ) return NULL ; if ( strcmp ( argv [ 0 ] , "cpu" ) && strcmp ( argv [ 0 ] , "tune" ) ) return NULL ; kc = kstat_open ( ) ; if ( kc != NULL ) { ksp = kstat_lookup ( kc , CONST_CAST2 ( char * , const char * , "cpu_info" ) , - 1 , NULL ) ; if ( ksp != NULL && kstat_read ( kc , ksp , NULL ) != - 1 && ksp -> ks_type == KSTAT_TYPE_NAMED ) brand = ( kstat_named_t * ) kstat_data_lookup ( ksp , CONST_CAST2 ( char * , const char * , "brand" ) ) ; if ( brand != NULL && brand -> data_type == KSTAT_DATA_STRING ) buf = KSTAT_NAMED_STR_PTR ( brand ) ; } kstat_close ( kc ) ; for ( i = 0 ; cpu_names [ i ] . name != NULL ; i ++ ) if ( strcmp ( buf , cpu_names [ i ] . name ) == 0 ) cpu = cpu_names [ i ] . cpu ; f = fopen ( "/proc/cpuinfo" , "r" ) ; if ( f == NULL ) return NULL ; while ( fgets ( buf , sizeof ( buf ) , f ) != NULL ) if ( startswith ( buf , "cpu\t\t:" ) ) { for ( i = 0 ; cpu_names [ i ] . name ; i ++ ) if ( strstr ( buf , cpu_names [ i ] . name ) != NULL ) { cpu = cpu_names [ i ] . cpu ; break ; } break ; } fclose ( f ) ; if ( cpu == NULL ) return NULL ; return concat ( "-m" , argv [ 0 ] , "=" , cpu , NULL ) ; } </s>

This will be called by the spec parser in gcc.cc when it sees a % : local_cpu_detect ( args ) construct . Currently it will be called with either `` cpu '' or `` tune '' as argument depending on if -mcpu=native or -mtune=native is to be substituted . It returns a string containing new command line parameters to be put at the place of the above two options , depending on what CPU this is executed . E.g . `` -mcpu=ultrasparc3 '' on an UltraSPARC III for -mcpu=native . If the routine ca n't detect a known processor , the -mcpu or -mtune option is discarded . ARGC and ARGV are set depending on the actual arguments given in the spec .


<s> void arm_asm_output_labelref ( FILE * stream , const char * name ) { int skip ; int verbatim = 0 ; while ( ( skip = arm_get_strip_length ( * name ) ) ) { verbatim |= ( * name == '*' ) ; name += skip ; } if ( verbatim ) fputs ( name , stream ) ; else asm_fprintf ( stream , "%U%s" , name ) ; } </s>

If there is a ' * ' anywhere in the name 's prefix , then emit the stripped name verbatim , otherwise prepend an underscore if leading underscores are being used .


"ready list ooo attributes - sched state: %d\n"

This function is called via hook TARGET_SCHED_REORDER before issuing one insn from list READY which contains * NREADYP entries . For target z10 it reorders load instructions to avoid early load conflicts in the floating point pipeline


"ReplaceNodeResults not implemented for this op for WebAssembly!"

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


<s> void expand_epilogue ( ) { int size ; register int regno ; int return_size ; rtx scratch ; if ( reload_completed != 1 ) abort ( ) ; size = get_frame_size ( ) ; if ( current_function_return_rtx == 0 ) return_size = 0 ; else if ( GET_CODE ( current_function_return_rtx ) == MEM ) return_size = HARD_REG_SIZE ; else return_size = GET_MODE_SIZE ( GET_MODE ( current_function_return_rtx ) ) ; if ( return_size > HARD_REG_SIZE ) scratch = iy_reg ; else scratch = ix_reg ; for ( regno = SOFT_REG_LAST ; regno >= SOFT_REG_FIRST ; regno -- ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) { emit_move_after_reload ( gen_rtx ( REG , HImode , regno ) , stack_pop_word , scratch ) ; } } if ( TARGET_M6812 && ( size > 4 || size == 3 ) ) { emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( size ) ) ) ; } else if ( size > 8 ) { rtx insn ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( HImode , stack_pointer_rtx , GEN_INT ( size ) ) ) , gen_rtx_CLOBBER ( VOIDmode , scratch ) ) ) ; emit_insn ( insn ) ; } else { int i ; for ( i = 2 ; i <= size ; i += 2 ) emit_move_after_reload ( scratch , stack_pop_word , scratch ) ; if ( size & 1 ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( 1 ) ) ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pop_word , scratch ) ; if ( current_function_interrupt ) { emit_move_after_reload ( gen_rtx ( REG , HImode , SOFT_SAVED_XY_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( gen_rtx ( REG , HImode , SOFT_Z_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( m68hc11_soft_tmp_reg , stack_pop_word , scratch ) ; } else if ( current_function_trap && return_size != 0 ) { rtx addr_reg = stack_pointer_rtx ; if ( ! TARGET_M6812 ) { emit_move_after_reload ( scratch , stack_pointer_rtx , 0 ) ; addr_reg = scratch ; } emit_move_after_reload ( gen_rtx ( MEM , HImode , gen_rtx ( PLUS , HImode , addr_reg , GEN_INT ( 1 ) ) ) , d_reg , 0 ) ; if ( return_size > HARD_REG_SIZE ) emit_move_after_reload ( gen_rtx ( MEM , HImode , gen_rtx ( PLUS , HImode , addr_reg , GEN_INT ( 3 ) ) ) , ix_reg , 0 ) ; } emit_jump_insn ( gen_return ( ) ) ; } </s>


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

Encode the given Inst to bytes and append to CB .

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


<s> void mips_final_prescan_insn ( rtx_insn * insn , rtx * opvec , int noperands ) { if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == UNSPEC_VOLATILE && XINT ( PATTERN ( insn ) , 1 ) == UNSPEC_CONSTTABLE ) mips_set_text_contents_type ( asm_out_file , "__pool_" , XINT ( XVECEXP ( PATTERN ( insn ) , 0 , 0 ) , 0 ) , FALSE ) ; if ( mips_need_noat_wrapper_p ( insn , opvec , noperands ) ) mips_push_asm_switch ( & mips_noat ) ; } </s>


<s> void SITargetLowering :: finalizeLowering ( MachineFunction & MF ) const { MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; SIMachineFunctionInfo * Info = MF . getInfo < SIMachineFunctionInfo > ( ) ; const SIRegisterInfo * TRI = Subtarget -> getRegisterInfo ( ) ; if ( Info -> isEntryFunction ( ) ) { reservePrivateMemoryRegs ( getTargetMachine ( ) , MF , * TRI , * Info ) ; } assert ( ! TRI -> isSubRegister ( Info -> getScratchRSrcReg ( ) , Info -> getStackPtrOffsetReg ( ) ) ) ; if ( Info -> getStackPtrOffsetReg ( ) != AMDGPU :: SP_REG ) MRI . replaceRegWith ( AMDGPU :: SP_REG , Info -> getStackPtrOffsetReg ( ) ) ; if ( Info -> getScratchRSrcReg ( ) != AMDGPU :: PRIVATE_RSRC_REG ) MRI . replaceRegWith ( AMDGPU :: PRIVATE_RSRC_REG , Info -> getScratchRSrcReg ( ) ) ; if ( Info -> getFrameOffsetReg ( ) != AMDGPU :: FP_REG ) MRI . replaceRegWith ( AMDGPU :: FP_REG , Info -> getFrameOffsetReg ( ) ) ; if ( Info -> getScratchWaveOffsetReg ( ) != AMDGPU :: SCRATCH_WAVE_OFFSET_REG ) { MRI . replaceRegWith ( AMDGPU :: SCRATCH_WAVE_OFFSET_REG , Info -> getScratchWaveOffsetReg ( ) ) ; } Info -> limitOccupancy ( MF ) ; TargetLoweringBase :: finalizeLowering ( MF ) ; } </s>

Execute target specific actions to finalize target lowering .


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


<s>
static
void
xstormy16_print_operand
(
FILE
*
file
,
rtx
x
,
int
code
)
{
switch
(
code
)
{
case
'B'
:
{
static
int
bits_set
[
8
]
=
{
0
,
1
,
1
,
2
,
1
,
2
,
2
,
3
}
;
HOST_WIDE_INT
xx
=
1
;
HOST_WIDE_INT
l
;
if
(
CONST_INT_P
(
x
)
)
xx
=
INTVAL
(
x
)
;
else
output_operand_lossage
(
"'B' operand is not constant"
)
;
if
(
bits_set
[
xx
&
7
]
<=
1
)
{
if
(
(
~
xx
&
~
(
HOST_WIDE_INT
)
0xff
)
==
0
)
xx
&=
0xff
;
else
if
(
(
~
xx
&
~
(
HOST_WIDE_INT
)
0xffff
)
==
0
)
xx
&=
0xffff
;
l
=
exact_log2
(
xx
)
;
}
else
{
if
(
(
xx
&
~
(
HOST_WIDE_INT
)
0xff
)
==
0
)
xx
|=
~
(
HOST_WIDE_INT
)
0xff
;
else
if
(
(
xx
&
~
(
HOST_WIDE_INT
)
0xffff
)
==
0
)
xx
|=
~
(
HOST_WIDE_INT
)
0xffff
;
l
=
exact_log2
(
~
xx
)
;
}
if
(
l
==
1
)
output_operand_lossage
(
"'B' operand has multiple bits set"
)
;
fprintf
(
file
,
IMMEDIATE_PREFIX
HOST_WIDE_INT_PRINT_DEC
,
l
)
;
return
;
}
case
'C'
:
if
(
GET_CODE
(
x
)
==
SYMBOL_REF
)
assemble_name
(
file
,
XSTR
(
x
,
0
)
)
;
else
if
(
LABEL_P
(
x
)
)
output_asm_label
(
x
)
;
else
xstormy16_print_operand_address
(
file
,
x
)
;
return
;
case
'o'
:
case
'O'
:
{
HOST_WIDE_INT
xx
=
0
;
if
(
CONST_INT_P
(
x
)
)
xx
=
INTVAL
(
x
)
;
else
output_operand_lossage
(
"'o' operand is not constant"
)
;
if
(
code
==
'O'
)
xx
=
xx
;
fprintf
(
file
,
IMMEDIATE_PREFIX
HOST_WIDE_INT_PRINT_DEC
,
xx
1
)
;
return
;
}
case
'b'
:
{
HOST_WIDE_INT
xx
=
1
;
HOST_WIDE_INT
l
;
if
(
CONST_INT_P
(
x
)
)
xx
=
INTVAL
(
x
)
;
else
output_operand_lossage
(
"'B' operand is not constant"
)
;
l
=
7
xx
;
fputs
(
IMMEDIATE_PREFIX
,
file
)
;
fprintf
(
file
,
HOST_WIDE_INT_PRINT_DEC
,
l
)
;
return
;
}
case
0
:
break
;
default
:
output_operand_lossage
(
"xstormy16_print_operand: unknown code"
)
;
return
;
}
switch
(
GET_CODE
(
x
)
)
{
case
REG
:
fputs
(
reg_names
[
REGNO
(
x
)
]
,
file
)
;
break
;
case
MEM
:
xstormy16_print_operand_address
(
file
,
XEXP
(
x
,
0
)
)
;
break
;
default
:
fputs
(
IMMEDIATE_PREFIX
,
file
)
;
output_addr_const
(
file
,
x
)
;
break
;
}
return
;
}
</s>

Print an operand to an assembler instruction .


<s> bool M680x0ExpandPseudo :: runOnMachineFunction ( MachineFunction & MF ) { STI = & static_cast < const M680x0Subtarget & > ( MF . getSubtarget ( ) ) ; TII = STI -> getInstrInfo ( ) ; TRI = STI -> getRegisterInfo ( ) ; MFI = MF . getInfo < M680x0MachineFunctionInfo > ( ) ; FL = STI -> getFrameLowering ( ) ; bool Modified = false ; for ( MachineBasicBlock & MBB : MF ) Modified |= ExpandMBB ( MBB ) ; return Modified ; } </s>


<s>
bool
SIInstrInfo
::
isInlineConstant
(
const
MachineOperand
&
MO
,
uint8_t
OperandType
)
const
{
if
(
!
MO
.
isImm
(
)
||
OperandType
<
AMDGPU
::
OPERAND_SRC_FIRST
||
OperandType
>
AMDGPU
::
OPERAND_SRC_LAST
)
return
false
;
int64_t
Imm
=
MO
.
getImm
(
)
;
switch
(
OperandType
)
{
case
AMDGPU
::
OPERAND_REG_IMM_INT32
:
case
AMDGPU
::
OPERAND_REG_IMM_FP32
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_INT32
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_FP32
:
case
AMDGPU
::
OPERAND_REG_INLINE_AC_INT32
:
case
AMDGPU
::
OPERAND_REG_INLINE_AC_FP32
:
{
int32_t
Trunc
=
static_cast
<
int32_t
>
(
Imm
)
;
return
AMDGPU
::
isInlinableLiteral32
(
Trunc
,
ST
.
hasInv2PiInlineImm
(
)
)
;
}
case
AMDGPU
::
OPERAND_REG_IMM_INT64
:
case
AMDGPU
::
OPERAND_REG_IMM_FP64
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_INT64
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_FP64
:
return
AMDGPU
::
isInlinableLiteral64
(
MO
.
getImm
(
)
,
ST
.
hasInv2PiInlineImm
(
)
)
;
case
AMDGPU
::
OPERAND_REG_IMM_INT16
:
case
AMDGPU
::
OPERAND_REG_IMM_FP16
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_INT16
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_FP16
:
case
AMDGPU
::
OPERAND_REG_INLINE_AC_INT16
:
case
AMDGPU
::
OPERAND_REG_INLINE_AC_FP16
:
{
if
(
isInt
<
16
>
(
Imm
)
||
isUInt
<
16
>
(
Imm
)
)
{
int16_t
Trunc
=
static_cast
<
int16_t
>
(
Imm
)
;
return
ST
.
has16BitInsts
(
)
&&
AMDGPU
::
isInlinableLiteral16
(
Trunc
,
ST
.
hasInv2PiInlineImm
(
)
)
;
}
return
false
;
}
case
AMDGPU
::
OPERAND_REG_IMM_V2INT16
:
case
AMDGPU
::
OPERAND_REG_IMM_V2FP16
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_V2INT16
:
case
AMDGPU
::
OPERAND_REG_INLINE_C_V2FP16
:
case
AMDGPU
::
OPERAND_REG_INLINE_AC_V2INT16
:
case
AMDGPU
::
OPERAND_REG_INLINE_AC_V2FP16
:
{
uint32_t
Trunc
=
static_cast
<
uint32_t
>
(
Imm
)
;
return
AMDGPU
::
isInlinableLiteralV216
(
Trunc
,
ST
.
hasInv2PiInlineImm
(
)
)
;
}
default
:
llvm_unreachable
(
"invalid bitwidth"
)
;
}
}
</s>

returns true if the operand OpIdx in MI is a valid inline immediate .


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

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


<s> static void s390_optimize_register_info ( ) { char clobbered_regs [ 32 ] ; int i ; gcc_assert ( epilogue_completed ) ; gcc_assert ( ! cfun -> machine -> split_branches_pending_p ) ; s390_regs_ever_clobbered ( clobbered_regs ) ; for ( i = 0 ; i < 32 ; i ++ ) clobbered_regs [ i ] = clobbered_regs [ i ] && ! global_regs [ i ] ; clobbered_regs [ RETURN_REGNUM ] |= ( TARGET_TPF_PROFILING || cfun_frame_layout . save_return_addr_p || crtl -> calls_eh_return ) ; memset ( cfun_frame_layout . gpr_save_slots , SAVE_SLOT_NONE , 6 ) ; for ( i = 6 ; i < 16 ; i ++ ) if ( ! clobbered_regs [ i ] ) cfun_gpr_save_slot ( i ) = SAVE_SLOT_NONE ; s390_register_info_set_ranges ( ) ; s390_register_info_stdarg_gpr ( ) ; } </s>

This function is called by s390_optimize_prologue in order to get rid of unnecessary GPR save/restore instructions . The register info for the GPRs is re-computed and the ranges are re-calculated .


<s> static bool aarch64_vector_mode_p ( machine_mode mode ) { return aarch64_vector_mode_supported_p ( mode ) || aarch64_vect_struct_mode_p ( mode ) ; } </s>

Return TRUE if MODE is any of the vector modes .


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

Print the specified MCInst to the specified raw_ostream .


<s> F2003fSubtarget & F2003fSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = CPU ; if ( CPUName . empty ( ) ) CPUName = "2003f" ; ParseSubtargetFeatures ( CPUName , FS ) ; return * this ; } </s>

initializeSubtargetDependencies - Initializes using a CPU , a TuneCPU , and feature string so that we can use initializer lists for subtarget initialization .


"Target must either be thumb or support ARM operations!"

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


<s> bool ARMPassConfig :: addInstSelector ( ) { addPass ( createARMISelDag ( getARMTargetMachine ( ) , getOptLevel ( ) ) ) ; const ARMSubtarget * Subtarget = & getARMSubtarget ( ) ; if ( Subtarget -> isTargetELF ( ) && ! Subtarget -> isThumb1Only ( ) && TM -> Options . EnableFastISel ) addPass ( createARMGlobalBaseRegPass ( ) ) ; return false ; } </s>

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


<s> static int ix86_avx_u128_mode_after ( int mode , rtx_insn * insn ) { rtx pat = PATTERN ( insn ) ; if ( vzeroupper_pattern ( pat , VOIDmode ) || vzeroall_pattern ( pat , VOIDmode ) ) return AVX_U128_CLEAN ; if ( CALL_P ( insn ) ) { bool avx_upper_reg_found = false ; note_stores ( insn , ix86_check_avx_upper_stores , & avx_upper_reg_found ) ; return avx_upper_reg_found ? AVX_U128_DIRTY : AVX_U128_CLEAN ; } return mode ; } </s>

Calculate mode of upper 128bit AVX registers after the insn .


<s> int h8300_ldm_stm_parallel ( rtvec vec , int load_p , int first ) { rtx last ; int nregs , i , regno , adjust ; if ( GET_NUM_ELEM ( vec ) < 3 ) return false ; nregs = GET_NUM_ELEM ( vec ) - first - 1 ; regno = h8300_ldm_stm_regno ( RTVEC_ELT ( vec , first ) , load_p , 0 , nregs ) ; if ( regno < 0 || regno + nregs > 8 ) return false ; if ( ! TARGET_H8300SX ) { if ( ( regno & 1 ) != 0 ) return false ; if ( nregs > 2 && ( regno & 3 ) != 0 ) return false ; } for ( i = 1 ; i < nregs ; i ++ ) if ( h8300_ldm_stm_regno ( RTVEC_ELT ( vec , first + i ) , load_p , i , nregs ) != regno + i ) return false ; last = RTVEC_ELT ( vec , first + nregs ) ; adjust = ( load_p ? nregs : - nregs ) * 4 ; return ( GET_CODE ( last ) == SET && SET_DEST ( last ) == stack_pointer_rtx && h8300_stack_offset_p ( SET_SRC ( last ) , adjust ) ) ; } </s>

Return true if the elements of VEC starting at FIRST describe an ldm or stm instruction ( LOAD_P says which ) .


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

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


<s> rtx s390_emit_call ( rtx addr_location , rtx tls_call , rtx result_reg , rtx retaddr_reg ) { bool plt_call = false ; rtx insn ; rtx call ; rtx clobber ; rtvec vec ; if ( GET_CODE ( addr_location ) == SYMBOL_REF ) { if ( flag_pic && ! SYMBOL_REF_LOCAL_P ( addr_location ) ) { addr_location = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , addr_location ) , UNSPEC_PLT ) ; addr_location = gen_rtx_CONST ( Pmode , addr_location ) ; plt_call = true ; } if ( ! TARGET_SMALL_EXEC && ! TARGET_CPU_ZARCH ) { if ( flag_pic ) addr_location = legitimize_pic_address ( addr_location , 0 ) ; else addr_location = force_reg ( Pmode , addr_location ) ; } } if ( retaddr_reg == NULL_RTX && GET_CODE ( addr_location ) != SYMBOL_REF && ! plt_call ) { emit_move_insn ( gen_rtx_REG ( Pmode , SIBCALL_REGNUM ) , addr_location ) ; addr_location = gen_rtx_REG ( Pmode , SIBCALL_REGNUM ) ; } addr_location = gen_rtx_MEM ( QImode , addr_location ) ; call = gen_rtx_CALL ( VOIDmode , addr_location , const0_rtx ) ; if ( result_reg != NULL_RTX ) call = gen_rtx_SET ( VOIDmode , result_reg , call ) ; if ( retaddr_reg != NULL_RTX ) { clobber = gen_rtx_CLOBBER ( VOIDmode , retaddr_reg ) ; if ( tls_call != NULL_RTX ) vec = gen_rtvec ( 3 , call , clobber , gen_rtx_USE ( VOIDmode , tls_call ) ) ; else vec = gen_rtvec ( 2 , call , clobber ) ; call = gen_rtx_PARALLEL ( VOIDmode , vec ) ; } insn = emit_call_insn ( call ) ; if ( ( ! TARGET_64BIT && plt_call ) || tls_call != NULL_RTX ) { gcc_assert ( retaddr_reg != NULL_RTX ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , pic_offset_table_rtx ) ; } return insn ; } </s>

This function is used by the call expanders of the machine description . It emits the call insn itself together with the necessary operations to adjust the target address and returns the emitted insn . ADDR_LOCATION is the target address rtx TLS_CALL the location of the thread-local symbol RESULT_REG the register where the result of the call should be stored RETADDR_REG the register where the return address should be stored If this parameter is NULL_RTX the call is considered to be a sibling call .


"Memory Tagging Extension does not support %<-mabi=ilp32%>"

"argument %d must be a constant immediate "

Expand an expression EXP that calls a MEMTAG built-in FCODE with result going to TARGET .


<s> static rtx nvptx_expand_builtin ( tree exp , rtx target , rtx ARG_UNUSED ( subtarget ) , machine_mode mode , int ignore ) { tree fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , 0 ) ; switch ( DECL_MD_FUNCTION_CODE ( fndecl ) ) { case NVPTX_BUILTIN_SHUFFLE : case NVPTX_BUILTIN_SHUFFLELL : return nvptx_expand_shuffle ( exp , target , mode , ignore ) ; case NVPTX_BUILTIN_WORKER_ADDR : return nvptx_expand_shared_addr ( exp , target , mode , ignore , false ) ; case NVPTX_BUILTIN_VECTOR_ADDR : return nvptx_expand_shared_addr ( exp , target , mode , ignore , true ) ; case NVPTX_BUILTIN_CMP_SWAP : case NVPTX_BUILTIN_CMP_SWAPLL : return nvptx_expand_cmp_swap ( exp , target , mode , ignore ) ; case NVPTX_BUILTIN_MEMBAR_GL : emit_insn ( gen_nvptx_membar_gl ( ) ) ; return NULL_RTX ; case NVPTX_BUILTIN_MEMBAR_CTA : emit_insn ( gen_nvptx_membar_cta ( ) ) ; return NULL_RTX ; default : gcc_unreachable ( ) ; } } </s>

Expand an expression EXP that calls a built-in function , with result going to TARGET if that 's convenient ( and in mode MODE if that 's convenient ) . SUBTARGET may be used as the target for computing one of EXP 's operands . IGNORE is nonzero if the value is to be ignored .


<s>
StringRef
getPassName
(
)
const
override
{
return
"MVE VPT block insertion pass"
;
}
</s>

getPassName - Return a nice clean name for a pass .


"\nGCNUpwardRPTracker error: Tracked and"

"GCNUpwardRPTracker error: Pressure sets different\nTracked: "

Returns true if this iterator is still pointing at a valid entry .


<s> bool ARMPassConfig :: addPreRegAlloc ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createARMLoadStoreOptimizationPass ( true ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None && getARMSubtarget ( ) . isCortexA9 ( ) ) addPass ( createMLxExpansionPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None && getARMSubtarget ( ) . isCortexA15 ( ) && getARMSubtarget ( ) . hasNEON ( ) && ! DisableA15SDOptimization ) { addPass ( createA15SDOptimizerPass ( ) ) ; } return true ; } </s>

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


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


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

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


<s> void WebAssemblyPassConfig :: addIRPasses ( ) { if ( TM -> Options . ThreadModel == ThreadModel :: Single ) addPass ( createLowerAtomicPass ( ) ) ; else addPass ( createAtomicExpandPass ( TM ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>

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


<s> void IA64RegisterInfo :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { if ( hasFP ( MF ) ) { MachineInstr * Old = I ; unsigned Amount = Old -> getOperand ( 0 ) . getImm ( ) ; DebugLoc dl = Old -> getDebugLoc ( ) ; if ( Amount != 0 ) { unsigned Align = MF . getTarget ( ) . getFrameInfo ( ) -> getStackAlignment ( ) ; Amount = ( Amount + Align - 1 ) / Align * Align ; if ( Old -> getOpcode ( ) == IA64 :: ADJUSTCALLSTACKDOWN ) { BuildMI ( MBB , I , dl , TII . get ( IA64 :: ADDIMM22 ) , IA64 :: r12 ) . addReg ( IA64 :: r12 ) . addImm ( - Amount ) ; } else { assert ( Old -> getOpcode ( ) == IA64 :: ADJUSTCALLSTACKUP ) ; BuildMI ( MBB , I , dl , TII . get ( IA64 :: ADDIMM22 ) , IA64 :: r12 ) . addReg ( IA64 :: r12 ) . addImm ( Amount ) ; } } } MBB . erase ( I ) ; } </s>

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


<s>
int
ix86_attr_length_immediate_default
(
rtx
insn
,
int
shortform
)
{
int
len
=
0
;
int
i
;
extract_insn_cached
(
insn
)
;
for
(
i
=
recog_data
.
n_operands
1
;
i
>=
0
;
i
)
if
(
CONSTANT_P
(
recog_data
.
operand
[
i
]
)
)
{
gcc_assert
(
!
len
)
;
if
(
shortform
&&
GET_CODE
(
recog_data
.
operand
[
i
]
)
==
CONST_INT
&&
CONST_OK_FOR_LETTER_P
(
INTVAL
(
recog_data
.
operand
[
i
]
)
,
'K'
)
)
len
=
1
;
else
{
switch
(
get_attr_mode
(
insn
)
)
{
case
MODE_QI
:
len
+=
1
;
break
;
case
MODE_HI
:
len
+=
2
;
break
;
case
MODE_SI
:
len
+=
4
;
break
;
case
MODE_DI
:
len
+=
4
;
break
;
default
:
fatal_insn
(
"unknown insn mode"
,
insn
)
;
}
}
}
return
len
;
}
</s>

Compute default value for `` length_immediate '' attribute . When SHORTFORM is set expect that insn have 8bit immediate alternative .


<s> bool X86RegisterInfo :: isArgumentRegister ( const MachineFunction & MF , MCRegister Reg ) const { const X86Subtarget & ST = MF . getSubtarget < X86Subtarget > ( ) ; const TargetRegisterInfo & TRI = * ST . getRegisterInfo ( ) ; auto IsSubReg = [ & ] ( MCRegister RegA , MCRegister RegB ) { return TRI . isSuperOrSubRegisterEq ( RegA , RegB ) ; } ; if ( ! ST . is64Bit ( ) ) return llvm :: any_of ( SmallVector < MCRegister > { X86 :: EAX , X86 :: ECX , X86 :: EDX } , [ & ] ( MCRegister & RegA ) { return IsSubReg ( RegA , Reg ) ; } ) || ( ST . hasMMX ( ) && X86 :: VR64RegClass . contains ( Reg ) ) ; CallingConv :: ID CC = MF . getFunction ( ) . getCallingConv ( ) ; if ( CC == CallingConv :: X86_64_SysV && IsSubReg ( X86 :: RAX , Reg ) ) return true ; if ( llvm :: any_of ( SmallVector < MCRegister > { X86 :: RDX , X86 :: RCX , X86 :: R8 , X86 :: R9 } , [ & ] ( MCRegister & RegA ) { return IsSubReg ( RegA , Reg ) ; } ) ) return true ; if ( CC != CallingConv :: Win64 && llvm :: any_of ( SmallVector < MCRegister > { X86 :: RDI , X86 :: RSI } , [ & ] ( MCRegister & RegA ) { return IsSubReg ( RegA , Reg ) ; } ) ) return true ; if ( ST . hasSSE1 ( ) && llvm :: any_of ( SmallVector < MCRegister > { X86 :: XMM0 , X86 :: XMM1 , X86 :: XMM2 , X86 :: XMM3 , X86 :: XMM4 , X86 :: XMM5 , X86 :: XMM6 , X86 :: XMM7 } , [ & ] ( MCRegister & RegA ) { return IsSubReg ( RegA , Reg ) ; } ) ) return true ; return false ; } </s>

isArgumentReg - Returns true if Reg can be used as an argument to a function .


<s> void output_profile_hook ( int labelno ATTRIBUTE_UNUSED ) { if ( TARGET_PROFILE_KERNEL ) return ; if ( DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_ELFv2 ) { if ( NO_PROFILE_COUNTERS ) emit_library_call ( init_one_libfunc ( RS6000_MCOUNT ) , LCT_NORMAL , VOIDmode ) ; else { char buf [ 30 ] ; const char * label_name ; rtx fun ; ASM_GENERATE_INTERNAL_LABEL ( buf , "LP" , labelno ) ; label_name = ggc_strdup ( ( * targetm . strip_name_encoding ) ( buf ) ) ; fun = gen_rtx_SYMBOL_REF ( Pmode , label_name ) ; emit_library_call ( init_one_libfunc ( RS6000_MCOUNT ) , LCT_NORMAL , VOIDmode , fun , Pmode ) ; } } else if ( DEFAULT_ABI == ABI_DARWIN ) { const char * mcount_name = RS6000_MCOUNT ; int caller_addr_regno = LR_REGNO ; crtl -> uses_pic_offset_table = 1 ; if ( MACHOPIC_INDIRECT && crtl -> uses_pic_offset_table ) caller_addr_regno = 0 ; emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , mcount_name ) , LCT_NORMAL , VOIDmode , gen_rtx_REG ( Pmode , caller_addr_regno ) , Pmode ) ; } } </s>


<s> void rs6000_emit_sCOND ( machine_mode mode , rtx operands [ ] ) { rtx condition_rtx = rs6000_generate_compare ( operands [ 1 ] , mode ) ; rtx_code cond_code = GET_CODE ( condition_rtx ) ; if ( FLOAT_MODE_P ( mode ) && HONOR_NANS ( mode ) && ! ( FLOAT128_VECTOR_P ( mode ) && ! TARGET_FLOAT128_HW ) ) ; else if ( cond_code == NE || cond_code == GE || cond_code == LE || cond_code == GEU || cond_code == LEU || cond_code == ORDERED || cond_code == UNGE || cond_code == UNLE ) { rtx not_result = gen_reg_rtx ( CCEQmode ) ; rtx not_op , rev_cond_rtx ; machine_mode cc_mode ; cc_mode = GET_MODE ( XEXP ( condition_rtx , 0 ) ) ; rev_cond_rtx = gen_rtx_fmt_ee ( rs6000_reverse_condition ( cc_mode , cond_code ) , SImode , XEXP ( condition_rtx , 0 ) , const0_rtx ) ; not_op = gen_rtx_COMPARE ( CCEQmode , rev_cond_rtx , const0_rtx ) ; emit_insn ( gen_rtx_SET ( not_result , not_op ) ) ; condition_rtx = gen_rtx_EQ ( VOIDmode , not_result , const0_rtx ) ; } machine_mode op_mode = GET_MODE ( XEXP ( operands [ 1 ] , 0 ) ) ; if ( op_mode == VOIDmode ) op_mode = GET_MODE ( XEXP ( operands [ 1 ] , 1 ) ) ; if ( TARGET_POWERPC64 && ( op_mode == DImode || FLOAT_MODE_P ( mode ) ) ) { PUT_MODE ( condition_rtx , DImode ) ; convert_move ( operands [ 0 ] , condition_rtx , 0 ) ; } else { PUT_MODE ( condition_rtx , SImode ) ; emit_insn ( gen_rtx_SET ( operands [ 0 ] , condition_rtx ) ) ; } } </s>


<s>
void
Thumb1InstrInfo
::
loadRegFromStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
DestReg
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
assert
(
(
RC
==
&
ARM
::
tGPRRegClass
||
(
TargetRegisterInfo
::
isPhysicalRegister
(
DestReg
)
&&
isARMLowRegister
(
DestReg
)
)
)
&&
"Unknown regclass!"
)
;
if
(
RC
==
&
ARM
::
tGPRRegClass
||
(
TargetRegisterInfo
::
isPhysicalRegister
(
DestReg
)
&&
isARMLowRegister
(
DestReg
)
)
)
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
MachineFrameInfo
&
MFI
=
*
MF
.
getFrameInfo
(
)
;
MachineMemOperand
*
MMO
=
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getFixedStack
(
FI
)
,
MachineMemOperand
::
MOLoad
,
MFI
.
getObjectSize
(
FI
)
,
MFI
.
getObjectAlignment
(
FI
)
)
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tLDRspi
)
,
DestReg
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
)
;
}
}
</s>

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

ARM
ARM::tGPRRegClass
ARM
"Unknown regclass!"
ARM::tGPRRegClass
ARM
ARM::tLDRspi
0


<s> static uint32_t negate ( uint32_t Cmp ) { if ( Cmp == EQ ) return NE ; if ( Cmp == NE ) return EQ ; assert ( ( Cmp & ( L | G ) ) != ( L | G ) ) ; return Cmp ^ ( L | G ) ; } </s>


<s> static rtx gen_stack_pointer_inc ( rtx increment ) { return gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , increment ) ) ; } </s>

Generate an increment for the stack pointer .


<s> MachineBasicBlock :: iterator X86FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { bool reserveCallFrame = hasReservedCallFrame ( MF ) ; unsigned Opcode = I -> getOpcode ( ) ; bool isDestroy = Opcode == TII . getCallFrameDestroyOpcode ( ) ; DebugLoc DL = I -> getDebugLoc ( ) ; uint64_t Amount = ! reserveCallFrame ? TII . getFrameSize ( * I ) : 0 ; uint64_t InternalAmt = ( isDestroy || Amount ) ? TII . getFrameAdjustment ( * I ) : 0 ; I = MBB . erase ( I ) ; auto InsertPos = skipDebugInstructionsForward ( I , MBB . end ( ) ) ; if ( ! reserveCallFrame ) { unsigned StackAlign = getStackAlignment ( ) ; Amount = alignTo ( Amount , StackAlign ) ; MachineModuleInfo & MMI = MF . getMMI ( ) ; const Function & F = MF . getFunction ( ) ; bool WindowsCFI = MF . getTarget ( ) . getMCAsmInfo ( ) -> usesWindowsCFI ( ) ; bool DwarfCFI = ! WindowsCFI && ( MMI . hasDebugInfo ( ) || F . needsUnwindTableEntry ( ) ) ; bool HasDwarfEHHandlers = ! WindowsCFI && ! MF . getLandingPads ( ) . empty ( ) ; if ( HasDwarfEHHandlers && ! isDestroy && MF . getInfo < X86MachineFunctionInfo > ( ) -> getHasPushSequences ( ) ) BuildCFI ( MBB , InsertPos , DL , MCCFIInstruction :: createGnuArgsSize ( nullptr , Amount ) ) ; if ( Amount == 0 ) return I ; Amount -= InternalAmt ; if ( isDestroy && InternalAmt && DwarfCFI && ! hasFP ( MF ) ) BuildCFI ( MBB , InsertPos , DL , MCCFIInstruction :: createAdjustCfaOffset ( nullptr , - InternalAmt ) ) ; int64_t StackAdjustment = isDestroy ? Amount : - Amount ; if ( StackAdjustment ) { StackAdjustment += mergeSPUpdates ( MBB , InsertPos , true ) ; StackAdjustment += mergeSPUpdates ( MBB , InsertPos , false ) ; if ( StackAdjustment ) { if ( ! ( F . optForMinSize ( ) && adjustStackWithPops ( MBB , InsertPos , DL , StackAdjustment ) ) ) BuildStackAdjustment ( MBB , InsertPos , DL , StackAdjustment , false ) ; } } if ( DwarfCFI && ! hasFP ( MF ) ) { int64_t CfaAdjustment = - StackAdjustment ; if ( CfaAdjustment ) { BuildCFI ( MBB , InsertPos , DL , MCCFIInstruction :: createAdjustCfaOffset ( nullptr , CfaAdjustment ) ) ; } } return I ; } if ( isDestroy && InternalAmt ) { MachineBasicBlock :: iterator CI = I ; MachineBasicBlock :: iterator B = MBB . begin ( ) ; while ( CI != B && ! std :: prev ( CI ) -> isCall ( ) ) -- CI ; BuildStackAdjustment ( MBB , CI , DL , - InternalAmt , false ) ; } return I ; } </s>


<s> int rs6000_register_move_cost ( enum machine_mode mode , enum reg_class from , enum reg_class to ) { if ( reg_classes_intersect_p ( to , GENERAL_REGS ) || reg_classes_intersect_p ( from , GENERAL_REGS ) ) { if ( ! reg_classes_intersect_p ( to , GENERAL_REGS ) ) from = to ; if ( from == FLOAT_REGS || from == ALTIVEC_REGS ) return ( rs6000_memory_move_cost ( mode , from , 0 ) + rs6000_memory_move_cost ( mode , GENERAL_REGS , 0 ) ) ; else if ( from == CR_REGS ) return 4 ; else return 2 * hard_regno_nregs [ 0 ] [ mode ] ; } else if ( reg_classes_intersect_p ( to , from ) ) return mode == TFmode ? 4 : 2 ; else return ( rs6000_register_move_cost ( mode , GENERAL_REGS , to ) + rs6000_register_move_cost ( mode , from , GENERAL_REGS ) ) ; } </s>

A C expression returning the cost of moving data from a register of class CLASS1 to one of CLASS2 .


<s> RISCVSubtarget & RISCVSubtarget :: initializeSubtargetDependencies ( const Triple & TT , StringRef CPU , StringRef TuneCPU , StringRef FS , StringRef ABIName ) { bool Is64Bit = TT . isArch64Bit ( ) ; if ( CPU . empty ( ) || CPU == "generic" ) CPU = Is64Bit ? "generic-rv64" : "generic-rv32" ; if ( TuneCPU . empty ( ) ) TuneCPU = CPU ; ParseSubtargetFeatures ( CPU , TuneCPU , FS ) ; if ( Is64Bit ) { XLenVT = MVT :: i64 ; XLen = 64 ; } TargetABI = RISCVABI :: computeTargetABI ( TT , getFeatureBits ( ) , ABIName ) ; RISCVFeatures :: validate ( TT , getFeatureBits ( ) ) ; return * this ; } </s>

initializeSubtargetDependencies - Initializes using a CPU , a TuneCPU , and feature string so that we can use initializer lists for subtarget initialization .


"sret virtual register not created in entry block"

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


<s> void X86RegisterInfo :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { if ( ! hasReservedCallFrame ( MF ) ) { MachineInstr * Old = I ; uint64_t Amount = Old -> getOperand ( 0 ) . getImm ( ) ; if ( Amount != 0 ) { Amount = ( Amount + StackAlign - 1 ) / StackAlign * StackAlign ; MachineInstr * New = 0 ; if ( Old -> getOpcode ( ) == getCallFrameSetupOpcode ( ) ) { New = BuildMI ( MF , Old -> getDebugLoc ( ) , TII . get ( Is64Bit ? X86 :: SUB64ri32 : X86 :: SUB32ri ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } else { assert ( Old -> getOpcode ( ) == getCallFrameDestroyOpcode ( ) ) ; uint64_t CalleeAmt = Old -> getOperand ( 1 ) . getImm ( ) ; Amount -= CalleeAmt ; if ( Amount ) { unsigned Opc = ( Amount < 128 ) ? ( Is64Bit ? X86 :: ADD64ri8 : X86 :: ADD32ri8 ) : ( Is64Bit ? X86 :: ADD64ri32 : X86 :: ADD32ri ) ; New = BuildMI ( MF , Old -> getDebugLoc ( ) , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } } if ( New ) { New -> getOperand ( 3 ) . setIsDead ( ) ; MBB . insert ( I , New ) ; } } } else if ( I -> getOpcode ( ) == getCallFrameDestroyOpcode ( ) ) { if ( uint64_t CalleeAmt = I -> getOperand ( 1 ) . getImm ( ) ) { unsigned Opc = ( CalleeAmt < 128 ) ? ( Is64Bit ? X86 :: SUB64ri8 : X86 :: SUB32ri8 ) : ( Is64Bit ? X86 :: SUB64ri32 : X86 :: SUB32ri ) ; MachineInstr * Old = I ; MachineInstr * New = BuildMI ( MF , Old -> getDebugLoc ( ) , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addImm ( CalleeAmt ) ; New -> getOperand ( 3 ) . setIsDead ( ) ; MBB . insert ( I , New ) ; } } MBB . erase ( I ) ; } </s>