<s> bool WebAssemblyInstrInfo :: analyzeBranch ( MachineBasicBlock & MBB , MachineBasicBlock * & TBB , MachineBasicBlock * & FBB , SmallVectorImpl < MachineOperand > & Cond , bool ) const { bool HaveCond = false ; for ( MachineInstr & MI : MBB . terminators ( ) ) { switch ( MI . getOpcode ( ) ) { default : return true ; case WebAssembly :: BR_IF : if ( HaveCond ) return true ; if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; Cond . push_back ( MachineOperand :: CreateImm ( true ) ) ; Cond . push_back ( MI . getOperand ( 1 ) ) ; TBB = MI . getOperand ( 0 ) . getMBB ( ) ; HaveCond = true ; break ; case WebAssembly :: BR_UNLESS : if ( HaveCond ) return true ; if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; Cond . push_back ( MachineOperand :: CreateImm ( false ) ) ; Cond . push_back ( MI . getOperand ( 1 ) ) ; TBB = MI . getOperand ( 0 ) . getMBB ( ) ; HaveCond = true ; break ; case WebAssembly :: BR : if ( ! MI . getOperand ( 0 ) . isMBB ( ) ) return true ; if ( ! HaveCond ) TBB = MI . getOperand ( 0 ) . getMBB ( ) ; else FBB = MI . getOperand ( 0 ) . getMBB ( ) ; break ; } if ( MI . isBarrier ( ) ) break ; } return false ; } </s>

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


<s>
SDValue
SparcTargetLowering
::
withTargetFlags
(
SDValue
Op
,
unsigned
TF
,
SelectionDAG
&
DAG
)
const
{
if
(
const
GlobalAddressSDNode
*
GA
=
dyn_cast
<
GlobalAddressSDNode
>
(
Op
)
)
return
DAG
.
getTargetGlobalAddress
(
GA
->
getGlobal
(
)
,
SDLoc
(
GA
)
,
GA
->
getValueType
(
0
)
,
GA
->
getOffset
(
)
,
TF
)
;
if
(
const
ConstantPoolSDNode
*
CP
=
dyn_cast
<
ConstantPoolSDNode
>
(
Op
)
)
return
DAG
.
getTargetConstantPool
(
CP
->
getConstVal
(
)
,
CP
->
getValueType
(
0
)
,
CP
->
getAlignment
(
)
,
CP
->
getOffset
(
)
,
TF
)
;
if
(
const
BlockAddressSDNode
*
BA
=
dyn_cast
<
BlockAddressSDNode
>
(
Op
)
)
return
DAG
.
getTargetBlockAddress
(
BA
->
getBlockAddress
(
)
,
Op
.
getValueType
(
)
,
0
,
TF
)
;
if
(
const
ExternalSymbolSDNode
*
ES
=
dyn_cast
<
ExternalSymbolSDNode
>
(
Op
)
)
return
DAG
.
getTargetExternalSymbol
(
ES
->
getSymbol
(
)
,
ES
->
getValueType
(
0
)
,
TF
)
;
llvm_unreachable
(
"Unhandled address SDNode"
)
;
}
</s>


"RESTORE_ACC does not define its destination"

lowerACCRestore - Generate the code to restore the accumulator register .


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

Returns the register associated with this edge .


<s> static bool aarch64_tribools_ok_for_inlining_p ( int caller , int callee , int dont_care , int def ) { if ( callee == dont_care ) return true ; if ( caller == dont_care ) return true ; return ( callee == caller || callee == def ) ; } </s>

Helper for aarch64_can_inline_p . In the case where CALLER and CALLEE are tri-bool options ( yes , no , do n't care ) and the default value is DEF , determine whether to reject inlining .


"Pseudo opcode found in EmitInstruction()"

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


<s> TargetIRAnalysis AArch64TargetMachine :: getTargetIRAnalysis ( ) { return TargetIRAnalysis ( [ this ] ( Function & F ) { return TargetTransformInfo ( AArch64TTIImpl ( this , F ) ) ; } ) ; } </s>

Get a TargetIRAnalysis appropriate for the target .


<s> static int rs6000_use_sched_lookahead_guard ( rtx_insn * insn , int ready_index ) { if ( ready_index == 0 ) return 0 ; if ( rs6000_tune != PROCESSOR_CELL ) return 0 ; gcc_assert ( insn != NULL_RTX && INSN_P ( insn ) ) ; if ( ! reload_completed || is_nonpipeline_insn ( insn ) || is_microcoded_insn ( insn ) ) return 1 ; return 0 ; } </s>

We are choosing insn from the ready queue . Return zero if INSN can be chosen .


<s> int ccr_bit ( rtx op , int scc_p ) { enum rtx_code code = GET_CODE ( op ) ; machine_mode cc_mode ; int cc_regnum ; int base_bit ; rtx reg ; if ( ! COMPARISON_P ( op ) ) return - 1 ; reg = XEXP ( op , 0 ) ; gcc_assert ( GET_CODE ( reg ) == REG && CR_REGNO_P ( REGNO ( reg ) ) ) ; cc_mode = GET_MODE ( reg ) ; cc_regnum = REGNO ( reg ) ; base_bit = 4 * ( cc_regnum - CR0_REGNO ) ; validate_condition_mode ( code , cc_mode ) ; gcc_assert ( ! scc_p || code == EQ || code == GT || code == LT || code == UNORDERED || code == GTU || code == LTU ) ; switch ( code ) { case NE : return scc_p ? base_bit + 3 : base_bit + 2 ; case EQ : return base_bit + 2 ; case GT : case GTU : case UNLE : return base_bit + 1 ; case LT : case LTU : case UNGE : return base_bit ; case ORDERED : case UNORDERED : return base_bit + 3 ; case GE : case GEU : return scc_p ? base_bit + 3 : base_bit ; case LE : case LEU : return scc_p ? base_bit + 3 : base_bit + 1 ; default : gcc_unreachable ( ) ; } } </s>

Given a comparison operation , return the bit number in CCR to test . We know this is a valid comparison . SCC_P is 1 if this is for an scc . That means that % D will have been used instead of % C , so the bits will be in different places . Return -1 if OP is n't a valid comparison for some reason .


<s> unsigned getPointerSize ( ) const { return 4 ; } </s>

Layout pointer size in bytes , rounded up to a whole number of bytes .


<s> unsigned AMDGPUTargetLowering :: ComputeNumSignBitsForTargetNode ( SDValue Op , const SelectionDAG & DAG , unsigned Depth ) const { switch ( Op . getOpcode ( ) ) { case AMDGPUISD :: BFE_I32 : { ConstantSDNode * Width = dyn_cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; if ( ! Width ) return 1 ; unsigned SignBits = 32 - Width -> getZExtValue ( ) + 1 ; ConstantSDNode * Offset = dyn_cast < ConstantSDNode > ( Op . getOperand ( 1 ) ) ; if ( ! Offset || ! Offset -> isNullValue ( ) ) return SignBits ; unsigned Op0SignBits = DAG . ComputeNumSignBits ( Op . getOperand ( 0 ) , Depth + 1 ) ; return std :: max ( SignBits , Op0SignBits ) ; } case AMDGPUISD :: BFE_U32 : { ConstantSDNode * Width = dyn_cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; return Width ? 32 - ( Width -> getZExtValue ( ) & 0x1f ) : 1 ; } case AMDGPUISD :: CARRY : case AMDGPUISD :: BORROW : return 31 ; default : return 1 ; } } </s>

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


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

getPassName - Return a nice clean name for a pass .


<s> uint32_t HSAILMachineFunctionInfo :: getStackSize ( ) { if ( mStackSize == - 1 ) { uint32_t privSize = 0 ; const MachineFrameInfo * MFI = mMF -> getFrameInfo ( ) ; privSize = MFI -> getOffsetAdjustment ( ) + MFI -> getStackSize ( ) ; const HSAILTargetMachine * TM = reinterpret_cast < const HSAILTargetMachine * > ( & mMF -> getTarget ( ) ) ; bool addStackSize = TM -> getOptLevel ( ) == CodeGenOpt :: None ; Function :: const_arg_iterator I = mMF -> getFunction ( ) -> arg_begin ( ) ; Function :: const_arg_iterator Ie = mMF -> getFunction ( ) -> arg_end ( ) ; while ( I != Ie ) { Type * curType = I -> getType ( ) ; ++ I ; if ( dyn_cast < PointerType > ( curType ) ) { Type * CT = dyn_cast < PointerType > ( curType ) -> getElementType ( ) ; if ( CT -> isStructTy ( ) && dyn_cast < PointerType > ( curType ) -> getAddressSpace ( ) == HSAILAS :: PRIVATE_ADDRESS ) { addStackSize = true ; } } } if ( addStackSize ) { privSize += getScratchSize ( ) ; } mStackSize = privSize ; } return ( uint32_t ) mStackSize ; } </s>

Return the number of bytes that must be allocated to hold all of the fixed size frame objects .


<s> static bool ix86_save_reg ( unsigned int regno , bool maybe_eh_return , bool ignore_outlined ) { if ( cfun -> machine -> no_caller_saved_registers ) { rtx reg = crtl -> return_rtx ; if ( reg ) { unsigned int i = REGNO ( reg ) ; unsigned int nregs = REG_NREGS ( reg ) ; while ( nregs -- > 0 ) if ( ( i + nregs ) == regno ) return false ; reg = crtl -> return_bnd ; if ( reg ) { i = REGNO ( reg ) ; nregs = REG_NREGS ( reg ) ; while ( nregs -- > 0 ) if ( ( i + nregs ) == regno ) return false ; } } return ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ! STACK_REGNO_P ( regno ) && ! MMX_REGNO_P ( regno ) && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) ) ; } if ( regno == REAL_PIC_OFFSET_TABLE_REGNUM && pic_offset_table_rtx ) { if ( ix86_use_pseudo_pic_reg ( ) ) { if ( ! TARGET_64BIT && flag_pic && crtl -> profile ) return true ; } else if ( df_regs_ever_live_p ( REAL_PIC_OFFSET_TABLE_REGNUM ) || crtl -> profile || crtl -> calls_eh_return || crtl -> uses_const_pool || cfun -> has_nonlocal_label ) return ix86_select_alt_pic_regnum ( ) == INVALID_REGNUM ; } if ( crtl -> calls_eh_return && maybe_eh_return ) { unsigned i ; for ( i = 0 ; ; i ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( ignore_outlined && cfun -> machine -> call_ms2sysv ) { unsigned count = cfun -> machine -> call_ms2sysv_extra_regs + xlogue_layout :: MIN_REGS ; if ( xlogue_layout :: is_stub_managed_reg ( regno , count ) ) return false ; } if ( crtl -> drap_reg && regno == REGNO ( crtl -> drap_reg ) && ! cfun -> machine -> no_drap_save_restore ) return true ; return ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] && ! fixed_regs [ regno ] && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) ) ; } </s>


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


<s> const TargetRegisterClass * X86RegisterInfo :: getMatchingSuperRegClass ( const TargetRegisterClass * A , const TargetRegisterClass * B , unsigned SubIdx ) const { if ( ! Is64Bit && SubIdx == X86 :: sub_8bit ) { A = X86GenRegisterInfo :: getSubClassWithSubReg ( A , X86 :: sub_8bit_hi ) ; if ( ! A ) return nullptr ; } return X86GenRegisterInfo :: getMatchingSuperRegClass ( A , B , SubIdx ) ; } </s>

getMatchingSuperRegClass - Return a subclass of the specified register class A so that each register in it has a sub-register of the specified sub-register index which is in the specified register class B .


<s> void X86InsertPrefetch :: getAnalysisUsage ( AnalysisUsage & AU ) const { AU . setPreservesAll ( ) ; AU . addRequired < MachineModuleInfo > ( ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s>
Value
*
Simplifier
::
simplify
(
Context
&
C
)
{
WorkListType
Q
;
Q
.
push_back
(
C
.
Root
)
;
unsigned
Count
=
0
;
const
unsigned
Limit
=
100000
;
while
(
!
Q
.
empty
(
)
)
{
if
(
Count
++
>=
Limit
)
break
;
Instruction
*
U
=
dyn_cast
<
Instruction
>
(
Q
.
pop_front_val
(
)
)
;
if
(
!
U
||
U
->
getParent
(
)
||
!
C
.
Used
.
count
(
U
)
)
continue
;
bool
Changed
=
false
;
for
(
Rule
&
R
:
Rules
)
{
Value
*
W
=
R
(
U
,
C
.
Ctx
)
;
if
(
!
W
)
continue
;
Changed
=
true
;
C
.
record
(
W
)
;
C
.
replace
(
U
,
W
)
;
Q
.
push_back
(
C
.
Root
)
;
break
;
}
if
(
!
Changed
)
{
for
(
Value
*
Op
:
U
->
operands
(
)
)
Q
.
push_back
(
Op
)
;
}
}
assert
(
Count
<
Limit
&&
"Infinite loop in HLIR/simplify?"
)
;
return
C
.
Root
;
}
</s>

Go through all the nodes in the graph and collapse any two nodes ' a ' and ' b ' if all of the following are true :


<s> static OR1KOperand * CreateReg ( unsigned RegNo , SMLoc S , SMLoc E ) { OR1KOperand * Op = new OR1KOperand ( Register ) ; Op -> Reg . RegNum = RegNo ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>

CreateReg - Allocate a single virtual register for the given type .


<s> rtx gen_split_move_double ( rtx operands [ ] ) { machine_mode mode = GET_MODE ( operands [ 0 ] ) ; rtx dest = operands [ 0 ] ; rtx src = operands [ 1 ] ; rtx val ; if ( GET_CODE ( dest ) == SUBREG ) alter_subreg ( & dest , true ) ; if ( GET_CODE ( src ) == SUBREG ) alter_subreg ( & src , true ) ; start_sequence ( ) ; if ( REG_P ( dest ) ) { int dregno = REGNO ( dest ) ; if ( REG_P ( src ) ) { int sregno = REGNO ( src ) ; int reverse = ( dregno == sregno + 1 ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , reverse , TRUE , mode ) , operand_subword ( src , reverse , TRUE , mode ) ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , ! reverse , TRUE , mode ) , operand_subword ( src , ! reverse , TRUE , mode ) ) ) ; } else if ( CONST_INT_P ( src ) || GET_CODE ( src ) == CONST_DOUBLE ) { rtx words [ 2 ] ; split_double ( src , & words [ 0 ] , & words [ 1 ] ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , 0 , TRUE , mode ) , words [ 0 ] ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , 1 , TRUE , mode ) , words [ 1 ] ) ) ; } else if ( MEM_P ( src ) ) { int reverse = refers_to_regno_p ( dregno , XEXP ( src , 0 ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , reverse , TRUE , mode ) , adjust_address ( src , SImode , reverse * UNITS_PER_WORD ) ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , ! reverse , TRUE , mode ) , adjust_address ( src , SImode , ! reverse * UNITS_PER_WORD ) ) ) ; } else gcc_unreachable ( ) ; } else if ( MEM_P ( dest ) && REG_P ( src ) ) { emit_insn ( gen_rtx_SET ( adjust_address ( dest , SImode , 0 ) , operand_subword ( src , 0 , TRUE , mode ) ) ) ; emit_insn ( gen_rtx_SET ( adjust_address ( dest , SImode , UNITS_PER_WORD ) , operand_subword ( src , 1 , TRUE , mode ) ) ) ; } else gcc_unreachable ( ) ; val = get_insns ( ) ; end_sequence ( ) ; return val ; } </s>

Split a 2 word move ( DI or DF ) into component parts .


<s>
bool
mayNeedRelaxation
(
const
MCInst
&
Inst
)
const
{
llvm_unreachable
(
"mayNeedRelaxation() unimplemented"
)
;
}
</s>

Check whether the given instruction may need relaxation .


<s> HOST_WIDE_INT c6x_initial_elimination_offset ( int from , int to ) { struct c6x_frame frame ; c6x_compute_frame_layout ( & frame ) ; if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return 0 ; else if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return - frame . frame_pointer_offset ; else { gcc_assert ( to == STACK_POINTER_REGNUM ) ; if ( from == ARG_POINTER_REGNUM ) return frame . to_allocate + ( frame . push_rts ? 56 : 0 ) ; gcc_assert ( from == FRAME_POINTER_REGNUM ) ; return frame . to_allocate - frame . frame_pointer_offset ; } } </s>

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


<s> bool SystemZTargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT , bool ForCodeSize ) const { if ( Imm . isZero ( ) || Imm . isNegZero ( ) ) return true ; return SystemZVectorConstantInfo ( Imm ) . isVectorConstantLegal ( Subtarget ) ; } </s>

Returns true if the target can instruction select the specified FP immediate natively .


<s> static rtx m68k_call_m68k_read_tp ( void ) { rtx a0 ; rtx eqv ; rtx_insn * insns ; rtx dest ; start_sequence ( ) ; m68k_libcall_value_in_a0_p = true ; a0 = emit_library_call_value ( m68k_get_m68k_read_tp ( ) , NULL_RTX , LCT_PURE , Pmode ) ; m68k_libcall_value_in_a0_p = false ; insns = get_insns ( ) ; end_sequence ( ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , const1_rtx ) , UNSPEC_RELOC32 ) ; gcc_assert ( can_create_pseudo_p ( ) ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , a0 , eqv ) ; return dest ; } </s>

Emit instruction sequence that calls __m68k_read_tp . A pseudo register with result of __m68k_read_tp call is returned .


<s> bool isLegalMaskedLoad ( Type * DataType , Align Alignment ) { return isLegalMaskedLoadStore ( DataType , Alignment ) ; } </s>

Return true if the target supports masked load .


<s>
const
char
*
getPassName
(
)
const
override
{
return
"SI Fold Operands"
;
}
</s>


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

Return true if the heuristic to prefer icmp eq zero should be used in code gen prepare .


<s> static void rs6000_assemble_visibility ( tree decl , int vis ) { if ( TARGET_XCOFF ) return ; if ( DEFAULT_ABI == ABI_AIX && DOT_SYMBOLS && TREE_CODE ( decl ) == FUNCTION_DECL ) { static const char * const visibility_types [ ] = { NULL , "protected" , "hidden" , "internal" } ; const char * name , * type ; name = ( ( * targetm . strip_name_encoding ) ( IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ) ) ; type = visibility_types [ vis ] ; fprintf ( asm_out_file , "\t.%s\t%s\n" , type , name ) ; fprintf ( asm_out_file , "\t.%s\t.%s\n" , type , name ) ; } else default_assemble_visibility ( decl , vis ) ; } </s>

Emit an assembler directive to set symbol visibility for DECL to VISIBILITY_TYPE .


<s> bool enableShrinkWrapping ( const MachineFunction & MF ) const override { return true ; } </s>

Returns true if the target will correctly handle shrink wrapping .


<s> static int mergeSPUpdates ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , unsigned StackPtr , bool doMergeWithPrevious ) { if ( ( doMergeWithPrevious && MBBI == MBB . begin ( ) ) || ( ! doMergeWithPrevious && MBBI == MBB . end ( ) ) ) return 0 ; MachineBasicBlock :: iterator PI = doMergeWithPrevious ? std :: prev ( MBBI ) : MBBI ; MachineBasicBlock :: iterator NI = doMergeWithPrevious ? 0 : std :: next ( MBBI ) ; unsigned Opc = PI -> getOpcode ( ) ; int Offset = 0 ; if ( ( Opc == X86 :: ADD64ri32 || Opc == X86 :: ADD64ri8 || Opc == X86 :: ADD32ri || Opc == X86 :: ADD32ri8 || Opc == X86 :: LEA32r || Opc == X86 :: LEA64_32r ) && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { Offset += PI -> getOperand ( 2 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } else if ( ( Opc == X86 :: SUB64ri32 || Opc == X86 :: SUB64ri8 || Opc == X86 :: SUB32ri || Opc == X86 :: SUB32ri8 ) && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { Offset -= PI -> getOperand ( 2 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } return Offset ; } </s>

Check the instruction before/after the passed instruction .


<s> bool AArch64CallLowering :: isTypeIsValidForThisReturn ( EVT Ty ) const { return Ty . getSizeInBits ( ) == 64 ; } </s>

For targets which support the `` returned '' parameter attribute , returns true if the given type is a valid one to use with `` returned '' .


<s> static tree alpha_fold_builtin_zapnot ( tree * op , unsigned HOST_WIDE_INT opint [ ] , long op_const ) { if ( op_const & 2 ) { unsigned HOST_WIDE_INT mask = 0 ; int i ; for ( i = 0 ; i < 8 ; ++ i ) if ( ( opint [ 1 ] >> i ) & 1 ) mask |= ( unsigned HOST_WIDE_INT ) 0xff << ( i * 8 ) ; if ( op_const & 1 ) return build_int_cst ( alpha_dimode_u , opint [ 0 ] & mask ) ; if ( op ) return fold_build2 ( BIT_AND_EXPR , alpha_dimode_u , op [ 0 ] , build_int_cst ( alpha_dimode_u , mask ) ) ; } else if ( ( op_const & 1 ) && opint [ 0 ] == 0 ) return build_int_cst ( alpha_dimode_u , 0 ) ; return NULL ; } </s>

Fold the builtin for the ZAPNOT instruction . This is essentially a specialized form of an AND operation . Other byte manipulation instructions are defined in terms of this instruction , so this is also used as a subroutine for other builtins . OP contains the tree operands ; OPINT contains the extracted integer values . Bit N of OP_CONST it set if OPINT [ N ] is valid . OP may be null if only OPINT may be considered .


<s> unsigned AAPInstrInfo :: insertIndirectBranch ( MachineBasicBlock & MBB , MachineBasicBlock & DestBB , const DebugLoc & DL , int64_t BrOffset , RegScavenger * RS ) const { auto & MI = * BuildMI ( & MBB , DL , get ( AAP :: BRA ) ) . addMBB ( & DestBB ) ; return getInstSizeInBytes ( MI ) ; } </s>

Insert an unconditional indirect branch at the end of MBB to NewDestBB .


<s> inline hashval_t registered_function_hasher :: hash ( value_type value ) { return value -> instance . hash ( ) ; } </s>

Hash function for builtin functions with up to 3 arguments and a return type .


Call FN for each register that is saved by the current function . SP_OFFSET is the offset of the current stack pointer from the start of the frame .


<s> void rs6000_emit_le_vsx_move ( rtx dest , rtx source , machine_mode mode ) { gcc_assert ( ! BYTES_BIG_ENDIAN && VECTOR_MEM_VSX_P ( mode ) && ! TARGET_P9_VECTOR && ! gpr_or_gpr_p ( dest , source ) && ( MEM_P ( source ) ^ MEM_P ( dest ) ) ) ; if ( MEM_P ( source ) ) { gcc_assert ( REG_P ( dest ) || GET_CODE ( dest ) == SUBREG ) ; rs6000_emit_le_vsx_load ( dest , source , mode ) ; } else { if ( ! REG_P ( source ) ) source = force_reg ( mode , source ) ; rs6000_emit_le_vsx_store ( dest , source , mode ) ; } } </s>

Emit a sequence representing a little-endian VSX load or store , moving data from SOURCE to DEST in mode MODE . This is done separately from rs6000_emit_move to ensure it is called only during expand . LE VSX loads and stores introduced later are handled with a split . The expand-time RTL generation allows us to optimize away redundant pairs of register-permutes .


"Wasn't expecting to be able to lower this!"

LowerOperation - Provide custom lowering hooks for some operations .


<s> const InstrItineraryData * getInstrItineraryData ( ) const override { return & InstrItins ; } </s>

getInstrItineraryData - Returns instruction itinerary data for the target or specific subtarget .


<s> static void ix86_emit_restore_regs_using_pop ( void ) { unsigned int regno ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ! SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , false ) ) ix86_emit_restore_reg_using_pop ( gen_rtx_REG ( word_mode , regno ) ) ; } </s>

Emit code to restore saved registers using POP insns .


<s> int nonpic_symbol_mentioned_p ( rtx x ) { register const char * fmt ; register int i ; if ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || GET_CODE ( x ) == PC ) return 1 ; if ( GET_CODE ( x ) == CONST_DOUBLE ) return 0 ; if ( GET_CODE ( x ) == UNSPEC && ( XINT ( x , 1 ) == UNSPEC_PIC || XINT ( x , 1 ) == UNSPEC_GOT || XINT ( x , 1 ) == UNSPEC_GOTOFF || XINT ( x , 1 ) == UNSPEC_GOTPLT || XINT ( x , 1 ) == UNSPEC_GOTTPOFF || XINT ( x , 1 ) == UNSPEC_DTPOFF || XINT ( x , 1 ) == UNSPEC_PLT ) ) return 0 ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - 1 ; i >= 0 ; i -- ) { if ( fmt [ i ] == 'E' ) { register int j ; for ( j = XVECLEN ( x , i ) - 1 ; j >= 0 ; j -- ) if ( nonpic_symbol_mentioned_p ( XVECEXP ( x , i , j ) ) ) return 1 ; } else if ( fmt [ i ] == 'e' && nonpic_symbol_mentioned_p ( XEXP ( x , i ) ) ) return 1 ; } return 0 ; } </s>

Return TRUE if X references a SYMBOL_REF or LABEL_REF whose symbol is n't protected by a PIC unspec .


<s> const TargetRegisterClass * TeakRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { if ( Kind == 1 ) return & Teak :: ABRegsRegClass ; return & Teak :: GRRegsRegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .

Teak Teak 1 Teak::ABRegsRegClass Teak::GRRegsRegClass


"insertBranch must not be told to insert a fallthrough"

"RISCV branch conditions have two components!"

Insert branch code into the end of the specified MachineBasicBlock .


<s> virtual bool runOnMachineFunction ( MachineFunction & MF ) { const X86TargetMachine * TM = static_cast < const X86TargetMachine * > ( & MF . getTarget ( ) ) ; const TargetFrameLowering * TFI = TM -> getFrameLowering ( ) ; MachineRegisterInfo & RI = MF . getRegInfo ( ) ; X86MachineFunctionInfo * FuncInfo = MF . getInfo < X86MachineFunctionInfo > ( ) ; unsigned StackAlignment = TFI -> getStackAlignment ( ) ; for ( unsigned i = 0 , e = RI . getNumVirtRegs ( ) ; i != e ; ++ i ) { unsigned Reg = TargetRegisterInfo :: index2VirtReg ( i ) ; if ( RI . getRegClass ( Reg ) -> getAlignment ( ) > StackAlignment ) { FuncInfo -> setForceFramePointer ( true ) ; return true ; } } return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> void CSKYTargetStreamer :: finish ( ) { if ( ConstantCounter != 0 ) { ConstantPool -> emitAll ( Streamer ) ; } finishAttributeSection ( ) ; } </s>

finish - after all the new live ranges have been created , compute the remaining live range , and rewrite instructions to use the new registers .


<s>
void
ARMAsmBackend
::
relaxInstruction
(
const
MCInst
&
Inst
,
MCInst
&
Res
)
const
{
unsigned
RelaxedOp
=
getRelaxedOpcode
(
Inst
.
getOpcode
(
)
)
;
if
(
RelaxedOp
==
Inst
.
getOpcode
(
)
)
{
SmallString
<
256
>
Tmp
;
raw_svector_ostream
OS
(
Tmp
)
;
Inst
.
dump_pretty
(
OS
)
;
OS
<<
"\n"
;
report_fatal_error
(
"unexpected instruction to relax: "
+
OS
.
str
(
)
)
;
}
if
(
(
Inst
.
getOpcode
(
)
==
ARM
::
tCBZ
||
Inst
.
getOpcode
(
)
==
ARM
::
tCBNZ
)
&&
RelaxedOp
==
ARM
::
tHINT
)
{
Res
.
setOpcode
(
RelaxedOp
)
;
Res
.
addOperand
(
MCOperand
::
createImm
(
0
)
)
;
Res
.
addOperand
(
MCOperand
::
createImm
(
14
)
)
;
Res
.
addOperand
(
MCOperand
::
createReg
(
0
)
)
;
return
;
}
Res
=
Inst
;
Res
.
setOpcode
(
RelaxedOp
)
;
}
</s>

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


<s> const unsigned * BlackfinRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { using namespace BF ; static const unsigned CalleeSavedRegs [ ] = { FP , R4 , R5 , R6 , R7 , P3 , P4 , P5 , 0 } ; return CalleeSavedRegs ; } </s>


<s> void MSP430FrameLowering :: emitPrologue ( MachineFunction & MF ) const { MachineBasicBlock & MBB = MF . front ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; MSP430MachineFunctionInfo * MSP430FI = MF . getInfo < MSP430MachineFunctionInfo > ( ) ; const MSP430InstrInfo & TII = * static_cast < const MSP430InstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; DebugLoc DL = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; uint64_t StackSize = MFI -> getStackSize ( ) ; uint64_t NumBytes = 0 ; if ( hasFP ( MF ) ) { uint64_t FrameSize = StackSize - 2 ; NumBytes = FrameSize - MSP430FI -> getCalleeSavedFrameSize ( ) ; MFI -> setOffsetAdjustment ( - NumBytes ) ; BuildMI ( MBB , MBBI , DL , TII . get ( MSP430 :: PUSH16r ) ) . addReg ( MSP430 :: FPW , RegState :: Kill ) ; BuildMI ( MBB , MBBI , DL , TII . get ( MSP430 :: MOV16rr ) , MSP430 :: FPW ) . addReg ( MSP430 :: SPW ) ; for ( MachineFunction :: iterator I = llvm :: next ( MF . begin ( ) ) , E = MF . end ( ) ; I != E ; ++ I ) I -> addLiveIn ( MSP430 :: FPW ) ; } else NumBytes = StackSize - MSP430FI -> getCalleeSavedFrameSize ( ) ; while ( MBBI != MBB . end ( ) && ( MBBI -> getOpcode ( ) == MSP430 :: PUSH16r ) ) ++ MBBI ; if ( MBBI != MBB . end ( ) ) DL = MBBI -> getDebugLoc ( ) ; if ( NumBytes ) { if ( NumBytes ) { MachineInstr * MI = BuildMI ( MBB , MBBI , DL , TII . get ( MSP430 :: SUB16ri ) , MSP430 :: SPW ) . addReg ( MSP430 :: SPW ) . addImm ( NumBytes ) ; MI -> getOperand ( 3 ) . setIsDead ( ) ; } } } </s>

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


<s> static int function_arg_slotno ( const struct sparc_args * cum , machine_mode mode , const_tree type , bool named , bool incoming , int * pregno , int * ppadding ) { int regbase = ( incoming ? SPARC_INCOMING_INT_ARG_FIRST : SPARC_OUTGOING_INT_ARG_FIRST ) ; int slotno = cum -> words ; enum mode_class mclass ; int regno ; * ppadding = 0 ; if ( type && TREE_ADDRESSABLE ( type ) ) return - 1 ; if ( TARGET_ARCH32 && mode == BLKmode && type && TYPE_ALIGN ( type ) % PARM_BOUNDARY != 0 ) return - 1 ; if ( TARGET_ARCH64 && ( type ? TYPE_ALIGN ( type ) : GET_MODE_ALIGNMENT ( mode ) ) >= 128 && ( slotno & 1 ) != 0 ) slotno ++ , * ppadding = 1 ; mclass = GET_MODE_CLASS ( mode ) ; if ( type && TREE_CODE ( type ) == VECTOR_TYPE ) { if ( TREE_CODE ( TREE_TYPE ( type ) ) == REAL_TYPE ) { gcc_assert ( mode == BLKmode ) ; } else { gcc_assert ( mode != BLKmode ) ; mclass = MODE_FLOAT ; } } switch ( mclass ) { case MODE_FLOAT : case MODE_COMPLEX_FLOAT : case MODE_VECTOR_INT : if ( TARGET_ARCH64 && TARGET_FPU && named ) { if ( slotno >= SPARC_FP_ARG_MAX ) return - 1 ; regno = SPARC_FP_ARG_FIRST + slotno * 2 ; if ( GET_MODE_SIZE ( mode ) <= 4 ) regno ++ ; break ; } case MODE_INT : case MODE_COMPLEX_INT : if ( slotno >= SPARC_INT_ARG_MAX ) return - 1 ; regno = regbase + slotno ; break ; case MODE_RANDOM : if ( mode == VOIDmode ) return - 1 ; gcc_assert ( mode == BLKmode ) ; if ( TARGET_ARCH32 || ! type || ( TREE_CODE ( type ) != RECORD_TYPE && TREE_CODE ( type ) != VECTOR_TYPE ) ) { if ( slotno >= SPARC_INT_ARG_MAX ) return - 1 ; regno = regbase + slotno ; } else { if ( slotno >= SPARC_FP_ARG_MAX ) return - 1 ; if ( TREE_CODE ( type ) == RECORD_TYPE ) { classify_data_t data = { false , false , false } ; traverse_record_type < classify_data_t , classify_registers > ( type , named , & data ) ; if ( data . fp_regs && ! data . fp_regs_in_first_word && slotno >= SPARC_FP_ARG_MAX - 1 ) return - 1 ; if ( ! data . fp_regs && data . int_regs && slotno >= SPARC_INT_ARG_MAX ) return - 1 ; } return slotno ; } break ; default : gcc_unreachable ( ) ; } * pregno = regno ; return slotno ; } </s>

Compute the slot number to pass an argument in . Return the slot number or -1 if passing on the stack . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) . INCOMING_P is zero for FUNCTION_ARG , nonzero for FUNCTION_INCOMING_ARG . * PREGNO records the register number to use if scalar type . * PPADDING records the amount of padding needed in words .


<s>
const
char
*
getPassName
(
)
const
override
{
return
"ARM64 load / store optimization pass"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> const char * NVPTXTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return 0 ; case NVPTXISD :: CALL : return "NVPTXISD::CALL" ; case NVPTXISD :: RET_FLAG : return "NVPTXISD::RET_FLAG" ; case NVPTXISD :: Wrapper : return "NVPTXISD::Wrapper" ; case NVPTXISD :: DeclareParam : return "NVPTXISD::DeclareParam" ; case NVPTXISD :: DeclareScalarParam : return "NVPTXISD::DeclareScalarParam" ; case NVPTXISD :: DeclareRet : return "NVPTXISD::DeclareRet" ; case NVPTXISD :: DeclareRetParam : return "NVPTXISD::DeclareRetParam" ; case NVPTXISD :: PrintCall : return "NVPTXISD::PrintCall" ; case NVPTXISD :: LoadParam : return "NVPTXISD::LoadParam" ; case NVPTXISD :: LoadParamV2 : return "NVPTXISD::LoadParamV2" ; case NVPTXISD :: LoadParamV4 : return "NVPTXISD::LoadParamV4" ; case NVPTXISD :: StoreParam : return "NVPTXISD::StoreParam" ; case NVPTXISD :: StoreParamV2 : return "NVPTXISD::StoreParamV2" ; case NVPTXISD :: StoreParamV4 : return "NVPTXISD::StoreParamV4" ; case NVPTXISD :: StoreParamS32 : return "NVPTXISD::StoreParamS32" ; case NVPTXISD :: StoreParamU32 : return "NVPTXISD::StoreParamU32" ; case NVPTXISD :: CallArgBegin : return "NVPTXISD::CallArgBegin" ; case NVPTXISD :: CallArg : return "NVPTXISD::CallArg" ; case NVPTXISD :: LastCallArg : return "NVPTXISD::LastCallArg" ; case NVPTXISD :: CallArgEnd : return "NVPTXISD::CallArgEnd" ; case NVPTXISD :: CallVoid : return "NVPTXISD::CallVoid" ; case NVPTXISD :: CallVal : return "NVPTXISD::CallVal" ; case NVPTXISD :: CallSymbol : return "NVPTXISD::CallSymbol" ; case NVPTXISD :: Prototype : return "NVPTXISD::Prototype" ; case NVPTXISD :: MoveParam : return "NVPTXISD::MoveParam" ; case NVPTXISD :: StoreRetval : return "NVPTXISD::StoreRetval" ; case NVPTXISD :: StoreRetvalV2 : return "NVPTXISD::StoreRetvalV2" ; case NVPTXISD :: StoreRetvalV4 : return "NVPTXISD::StoreRetvalV4" ; case NVPTXISD :: PseudoUseParam : return "NVPTXISD::PseudoUseParam" ; case NVPTXISD :: RETURN : return "NVPTXISD::RETURN" ; case NVPTXISD :: CallSeqBegin : return "NVPTXISD::CallSeqBegin" ; case NVPTXISD :: CallSeqEnd : return "NVPTXISD::CallSeqEnd" ; case NVPTXISD :: LoadV2 : return "NVPTXISD::LoadV2" ; case NVPTXISD :: LoadV4 : return "NVPTXISD::LoadV4" ; case NVPTXISD :: LDGV2 : return "NVPTXISD::LDGV2" ; case NVPTXISD :: LDGV4 : return "NVPTXISD::LDGV4" ; case NVPTXISD :: LDUV2 : return "NVPTXISD::LDUV2" ; case NVPTXISD :: LDUV4 : return "NVPTXISD::LDUV4" ; case NVPTXISD :: StoreV2 : return "NVPTXISD::StoreV2" ; case NVPTXISD :: StoreV4 : return "NVPTXISD::StoreV4" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


" Declaring this symbol tells the CRT that it should"

"copy all variables from program memory to RAM on startup"

"clear the zeroed data section on startup"


"Attempt to copy register that is not GPR or FPR"


<s> SDNode * MipsDAGToDAGISel :: getGlobalBaseReg ( ) { unsigned GlobalBaseReg = MF -> getInfo < MipsFunctionInfo > ( ) -> getGlobalBaseReg ( ) ; return CurDAG -> getRegister ( GlobalBaseReg , TLI -> getPointerTy ( ) ) . getNode ( ) ; } </s>

getGlobalBaseReg - Return a virtual register initialized with the the global base register value .


<s> AtomicOrdering getFailureOrdering ( ) const { return FailureOrdering ; } </s>

For cmpxchg atomic operations , return the atomic ordering requirements when store does not occur .


<s> FunctionPass * createTargetRegisterAllocator ( bool ) override { return nullptr ; } </s>

createTargetRegisterAllocator - Create the register allocator pass for this target at the current optimization level .


<s> const InstrItineraryData * getInstrItineraryData ( ) const override { return Subtarget -> inMips16Mode ( ) ? nullptr : & getSubtargetImpl ( ) -> getInstrItineraryData ( ) ; } </s>


<s> bool runOnModule ( Module & M ) override { FeatureBitset Features = coalesceFeatures ( M ) ; std :: string FeatureStr = getFeatureString ( Features ) ; WasmTM -> setTargetFeatureString ( FeatureStr ) ; for ( auto & F : M ) replaceFeatures ( F , FeatureStr ) ; bool StrippedAtomics = false ; bool StrippedTLS = false ; if ( ! Features [ WebAssembly :: FeatureAtomics ] ) StrippedAtomics = stripAtomics ( M ) ; if ( ! Features [ WebAssembly :: FeatureBulkMemory ] ) StrippedTLS = stripThreadLocals ( M ) ; if ( StrippedAtomics && ! StrippedTLS ) stripThreadLocals ( M ) ; else if ( StrippedTLS && ! StrippedAtomics ) stripAtomics ( M ) ; recordFeatures ( M , Features , StrippedAtomics || StrippedTLS ) ; return true ; } </s>

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


<s> static tree fully_fold_convert ( tree type , tree expr ) { tree result = fold_convert ( type , expr ) ; bool maybe_const = true ; if ( ! c_dialect_cxx ( ) ) result = c_fully_fold ( result , false , & maybe_const ) ; return result ; } </s>

In addition to calling fold_convert for EXPR of type TYPE , also call c_fully_fold to remove any C_MAYBE_CONST_EXPRs that could be hiding there ( PR47197 ) .


<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 ( ) ; 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> MCFragment * findAssociatedFragment ( ) const override { return getSubExpr ( ) -> findAssociatedFragment ( ) ; } </s>

Find the `` associated section '' for this expression , which is currently defined as the absolute section for constants , or otherwise the section associated with the first defined symbol in the expression .


<s> static inline _uw8 next_unwind_byte ( __gnu_unwind_state * uws ) { _uw8 b ; if ( uws -> bytes_left == 0 ) { if ( uws -> words_left == 0 ) return CODE_FINISH ; uws -> words_left -- ; uws -> data = * ( uws -> next ++ ) ; uws -> bytes_left = 3 ; } else uws -> bytes_left -- ; b = ( uws -> data >> 24 ) & 0xff ; uws -> data <<= 8 ; return b ; } </s>

Return the next byte of unwinding information , or CODE_FINISH if there is no data remaining .


"invalid feature modifier %qs in %<-mcpu=%s%>"

Validate a command-line -mcpu option . Parse the cpu and extensions ( if any ) specified in STR and throw errors if appropriate . Put the results if they are valid in RES and ISA_FLAGS . Return whether the option is valid .


<s> int shmedia_cleanup_truncate ( rtx * p , void * n_changes ) { rtx x = * p , reg ; if ( GET_CODE ( x ) != TRUNCATE ) return 0 ; reg = XEXP ( x , 0 ) ; if ( GET_MODE_SIZE ( GET_MODE ( reg ) ) > 8 && GET_CODE ( reg ) == REG ) { enum machine_mode reg_mode = GET_MODE ( reg ) ; XEXP ( x , 0 ) = simplify_subreg ( DImode , reg , reg_mode , subreg_lowpart_offset ( DImode , reg_mode ) ) ; * ( int * ) n_changes += 1 ; return - 1 ; } return 0 ; } </s>

Look through X cleaning up truncates of registers that span multiple actual hard registers . Return the number of changes made .


<s>
unsigned
HexagonInstrInfo
::
reduceLoopCount
(
MachineBasicBlock
&
MBB
,
MachineInstr
*
IndVar
,
MachineInstr
&
Cmp
,
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
SmallVectorImpl
<
MachineInstr
*
>
&
PrevInsts
,
unsigned
Iter
,
unsigned
MaxIter
)
const
{
assert
(
(
!
IndVar
)
&&
isEndLoopN
(
Cmp
.
getOpcode
(
)
)
&&
"Expecting a hardware loop"
)
;
MachineFunction
*
MF
=
MBB
.
getParent
(
)
;
DebugLoc
DL
=
Cmp
.
getDebugLoc
(
)
;
SmallPtrSet
<
MachineBasicBlock
*
,
8
>
VisitedBBs
;
MachineInstr
*
Loop
=
findLoopInstr
(
&
MBB
,
Cmp
.
getOpcode
(
)
,
VisitedBBs
)
;
if
(
!
Loop
)
return
0
;
if
(
Loop
->
getOpcode
(
)
==
Hexagon
::
J2_loop0i
||
Loop
->
getOpcode
(
)
==
Hexagon
::
J2_loop1i
)
{
int64_t
Offset
=
Loop
->
getOperand
(
1
)
.
getImm
(
)
;
if
(
Offset
<=
1
)
Loop
->
eraseFromParent
(
)
;
else
Loop
->
getOperand
(
1
)
.
setImm
(
Offset
1
)
;
return
Offset
1
;
}
assert
(
Loop
->
getOpcode
(
)
==
Hexagon
::
J2_loop0r
&&
"Unexpected instruction"
)
;
unsigned
LoopCount
=
Loop
->
getOperand
(
1
)
.
getReg
(
)
;
unsigned
LoopEnd
=
createVR
(
MF
,
MVT
::
i1
)
;
MachineInstr
*
NewCmp
=
BuildMI
(
&
MBB
,
DL
,
get
(
Hexagon
::
C2_cmpgtui
)
,
LoopEnd
)
.
addReg
(
LoopCount
)
.
addImm
(
1
)
;
unsigned
NewLoopCount
=
createVR
(
MF
,
MVT
::
i32
)
;
MachineInstr
*
NewAdd
=
BuildMI
(
&
MBB
,
DL
,
get
(
Hexagon
::
A2_addi
)
,
NewLoopCount
)
.
addReg
(
LoopCount
)
.
addImm
(
1
)
;
for
(
SmallVectorImpl
<
MachineInstr
*
>
::
iterator
I
=
PrevInsts
.
begin
(
)
,
E
=
PrevInsts
.
end
(
)
;
I
!=
E
;
++
I
)
(
*
I
)
->
substituteRegister
(
LoopCount
,
NewLoopCount
,
0
,
getRegisterInfo
(
)
)
;
PrevInsts
.
clear
(
)
;
PrevInsts
.
push_back
(
NewCmp
)
;
PrevInsts
.
push_back
(
NewAdd
)
;
if
(
Iter
==
MaxIter
)
BuildMI
(
&
MBB
,
DL
,
get
(
Hexagon
::
J2_loop0r
)
)
.
addMBB
(
Loop
->
getOperand
(
0
)
.
getMBB
(
)
)
.
addReg
(
NewLoopCount
)
;
if
(
Iter
==
0
)
Loop
->
eraseFromParent
(
)
;
Cond
.
push_back
(
MachineOperand
::
CreateImm
(
Hexagon
::
J2_jumpf
)
)
;
Cond
.
push_back
(
NewCmp
->
getOperand
(
0
)
)
;
return
NewLoopCount
;
}
</s>

Generate code to reduce the loop iteration by one and check if the loop is finished .


<s>
bool
DeadCodeElimination
::
erase
(
const
SetVector
<
NodeId
>
&
Nodes
)
{
if
(
Nodes
.
empty
(
)
)
return
false
;
NodeList
DRNs
,
DINs
;
for
(
auto
I
:
Nodes
)
{
auto
BA
=
DFG
.
addr
<
NodeBase
*
>
(
I
)
;
uint16_t
Type
=
BA
.
Addr
->
getType
(
)
;
if
(
Type
==
NodeAttrs
::
Ref
)
{
DRNs
.
push_back
(
DFG
.
addr
<
RefNode
*
>
(
I
)
)
;
continue
;
}
uint16_t
Kind
=
BA
.
Addr
->
getKind
(
)
;
if
(
Kind
==
NodeAttrs
::
Stmt
||
Kind
==
NodeAttrs
::
Phi
)
{
for
(
auto
N
:
NodeAddr
<
CodeNode
*
>
(
BA
)
.
Addr
->
members
(
DFG
)
)
DRNs
.
push_back
(
N
)
;
DINs
.
push_back
(
DFG
.
addr
<
InstrNode
*
>
(
I
)
)
;
}
else
{
llvm_unreachable
(
"Unexpected code node"
)
;
return
false
;
}
}
auto
UsesFirst
=
[
]
(
NodeAddr
<
RefNode
*
>
A
,
NodeAddr
<
RefNode
*
>
B
)
->
bool
{
uint16_t
KindA
=
A
.
Addr
->
getKind
(
)
,
KindB
=
B
.
Addr
->
getKind
(
)
;
if
(
KindA
==
NodeAttrs
::
Use
&&
KindB
==
NodeAttrs
::
Def
)
return
true
;
if
(
KindA
==
NodeAttrs
::
Def
&&
KindB
==
NodeAttrs
::
Use
)
return
false
;
return
A
.
Id
<
B
.
Id
;
}
;
std
::
sort
(
DRNs
.
begin
(
)
,
DRNs
.
end
(
)
,
UsesFirst
)
;
if
(
trace
(
)
)
dbgs
(
)
<<
"Removing dead ref nodes:\n"
;
for
(
NodeAddr
<
RefNode
*
>
RA
:
DRNs
)
{
if
(
trace
(
)
)
dbgs
(
)
<<
"  "
<<
PrintNode
<
RefNode
*
>
(
RA
,
DFG
)
<<
'\n'
;
if
(
DFG
.
IsUse
(
RA
)
)
DFG
.
unlinkUse
(
RA
,
true
)
;
else
if
(
DFG
.
IsDef
(
RA
)
)
DFG
.
unlinkDef
(
RA
,
true
)
;
}
for
(
NodeAddr
<
InstrNode
*
>
IA
:
DINs
)
{
NodeAddr
<
BlockNode
*
>
BA
=
IA
.
Addr
->
getOwner
(
DFG
)
;
BA
.
Addr
->
removeMember
(
IA
,
DFG
)
;
if
(
!
DFG
.
IsCode
<
NodeAttrs
::
Stmt
>
(
IA
)
)
continue
;
MachineInstr
*
MI
=
NodeAddr
<
StmtNode
*
>
(
IA
)
.
Addr
->
getCode
(
)
;
if
(
trace
(
)
)
dbgs
(
)
<<
"erasing: "
<<
*
MI
;
MI
->
eraseFromParent
(
)
;
}
return
true
;
}
</s>

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

Hexagon
"Unexpected code node"
"Removing dead ref nodes:\n"
"  "
"erasing: "


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addRequired < MachineDominatorTree > ( ) ; AU . addPreserved < MachineDominatorTree > ( ) ; MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> static bool pdp11_scalar_mode_supported_p ( machine_mode mode ) { if ( mode == SFmode ) return true ; return default_scalar_mode_supported_p ( mode ) ; } </s>


<s> int mems_ok_for_quad_peep ( rtx mem1 , rtx mem2 ) { rtx addr1 , addr2 ; unsigned int reg1 , reg2 ; int offset1 , offset2 ; if ( MEM_VOLATILE_P ( mem1 ) || MEM_VOLATILE_P ( mem2 ) ) return 0 ; addr1 = XEXP ( mem1 , 0 ) ; addr2 = XEXP ( mem2 , 0 ) ; if ( GET_CODE ( addr1 ) == PLUS ) { if ( GET_CODE ( XEXP ( addr1 , 0 ) ) != REG ) return 0 ; else { reg1 = REGNO ( XEXP ( addr1 , 0 ) ) ; if ( GET_CODE ( XEXP ( addr1 , 1 ) ) != CONST_INT ) return 0 ; offset1 = INTVAL ( XEXP ( addr1 , 1 ) ) ; } } else if ( GET_CODE ( addr1 ) != REG ) return 0 ; else { reg1 = REGNO ( addr1 ) ; offset1 = 0 ; } if ( GET_CODE ( addr2 ) == PLUS ) { if ( GET_CODE ( XEXP ( addr2 , 0 ) ) != REG ) return 0 ; else { reg2 = REGNO ( XEXP ( addr2 , 0 ) ) ; if ( GET_CODE ( XEXP ( addr2 , 1 ) ) != CONST_INT ) return 0 ; offset2 = INTVAL ( XEXP ( addr2 , 1 ) ) ; } } else if ( GET_CODE ( addr2 ) != REG ) return 0 ; else { reg2 = REGNO ( addr2 ) ; offset2 = 0 ; } if ( reg1 != reg2 ) return 0 ; if ( offset2 != offset1 + 8 ) return 0 ; return 1 ; } </s>

Return 1 if addr1 and addr2 are suitable for lfq or stfq insn . addr1 and addr2 must be in consecutive memory locations ( addr2 == addr1 + 8 ) .


<s> bool mn10300_match_ccmode ( rtx insn , machine_mode cc_mode ) { rtx op1 , flags ; machine_mode flags_mode ; gcc_checking_assert ( XVECLEN ( PATTERN ( insn ) , 0 ) == 2 ) ; op1 = XVECEXP ( PATTERN ( insn ) , 0 , 0 ) ; gcc_checking_assert ( GET_CODE ( SET_SRC ( op1 ) ) == COMPARE ) ; flags = SET_DEST ( op1 ) ; flags_mode = GET_MODE ( flags ) ; if ( GET_MODE ( SET_SRC ( op1 ) ) != flags_mode ) return false ; if ( GET_MODE_CLASS ( flags_mode ) != MODE_CC ) return false ; if ( cc_flags_for_mode ( flags_mode ) & ~ cc_flags_for_mode ( cc_mode ) ) return false ; return true ; } </s>

A helper function for matching parallels that set the flags .


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


<s> bool SITargetLowering :: getAddrModeArguments ( IntrinsicInst * II , SmallVectorImpl < Value * > & Ops , Type * & AccessTy ) const { switch ( II -> getIntrinsicID ( ) ) { case Intrinsic :: amdgcn_atomic_inc : case Intrinsic :: amdgcn_atomic_dec : case Intrinsic :: amdgcn_ds_fadd : case Intrinsic :: amdgcn_ds_fmin : case Intrinsic :: amdgcn_ds_fmax : { Value * Ptr = II -> getArgOperand ( 0 ) ; AccessTy = II -> getType ( ) ; Ops . push_back ( Ptr ) ; return true ; } default : return false ; } } </s>

CodeGenPrepare sinks address calculations into the same BB as Load/Store instructions reading the address .


<s> bool AMDGPUTargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT ) const { EVT ScalarVT = VT . getScalarType ( ) ; return ( ScalarVT == MVT :: f32 || ScalarVT == MVT :: f64 ) ; } </s>

Returns true if the target can instruction select the specified FP immediate natively .


"Frame offsets outside of the signed 32-bit range not supported"

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


<s>
const
char
*
TGSITargetLowering
::
getTargetNodeName
(
unsigned
Opcode
)
const
{
switch
(
Opcode
)
{
case
TGSIISD
::
LOAD_INPUT
:
return
"TGSIISD::LOAD_INPUT"
;
case
TGSIISD
::
CALL
:
return
"TGSIISD::CALL"
;
case
TGSIISD
::
RET
:
return
"TGSIISD::RET"
;
default
:
llvm_unreachable
(
"Invalid opcode"
)
;
}
}
</s>

getTargetNodeName - This method returns the name of a target specific

TGSI
TGSI
TGSIISD::LOAD_INPUT
"TGSIISD::LOAD_INPUT"
TGSIISD::CALL
"TGSIISD::CALL"
TGSIISD::RET
"TGSIISD::RET"
"Invalid opcode"


<s> virtual const MipsSubtarget * getSubtargetImpl ( ) const { return & Subtarget ; } </s>

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


<s>
void
ELFTeeRISCAsmBackend
::
applyFixup
(
const
MCFixup
&
Fixup
,
char
*
Data
,
unsigned
DataSize
,
uint64_t
Value
)
const
{
unsigned
Size
=
getFixupKindSize
(
Fixup
.
getKind
(
)
)
;
assert
(
Fixup
.
getOffset
(
)
+
Size
<=
DataSize
&&
"Invalid fixup offset!"
)
;
char
*
data
=
Data
+
Fixup
.
getOffset
(
)
;
switch
(
Size
)
{
default
:
llvm_unreachable
(
"Cannot fixup unknown value."
)
;
case
1
:
llvm_unreachable
(
"Cannot fixup 1 byte value."
)
;
case
8
:
llvm_unreachable
(
"Cannot fixup 8 byte value."
)
;
case
4
:
case
2
:
llvm_unreachable
(
"Write Code here to fixup\n"
)
;
}
}
</s>

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


<s> bool HexagonTargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace , unsigned Alignment , MachineMemOperand :: Flags Flags , bool * Fast ) const { MVT SVT = VT . getSimpleVT ( ) ; if ( Subtarget . isHVXVectorType ( SVT , true ) ) return allowsHvxMisalignedMemoryAccesses ( SVT , Alignment , Flags , Fast ) ; if ( Fast ) * Fast = false ; return false ; } </s>

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


<s> BitVector SystemZRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; const SystemZFrameLowering * TFI = getFrameLowering ( MF ) ; const SystemZSubtarget * Subtarget = & MF . getSubtarget < SystemZSubtarget > ( ) ; SystemZCallingConventionRegisters * Regs = Subtarget -> getSpecialRegisters ( ) ; if ( TFI -> hasFP ( MF ) ) for ( MCRegAliasIterator AI ( Regs -> getFramePointerRegister ( ) , this , true ) ; AI . isValid ( ) ; ++ AI ) Reserved . set ( * AI ) ; for ( MCRegAliasIterator AI ( Regs -> getStackPointerRegister ( ) , this , true ) ; AI . isValid ( ) ; ++ AI ) Reserved . set ( * AI ) ; Reserved . set ( SystemZ :: A0 ) ; Reserved . set ( SystemZ :: A1 ) ; Reserved . set ( SystemZ :: FPC ) ; return Reserved ; } </s>

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

SystemZ SystemZ SystemZ SystemZ SystemZ SystemZ SystemZ::A0 SystemZ::A1 SystemZ::FPC


<s> SDValue ARMSelectionDAGInfo :: EmitTargetCodeForMemmove ( SelectionDAG & DAG , const SDLoc & dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , Align Alignment , bool isVolatile , MachinePointerInfo DstPtrInfo , MachinePointerInfo SrcPtrInfo ) const { return EmitSpecializedLibcall ( DAG , dl , Chain , Dst , Src , Size , Alignment . value ( ) , RTLIB :: MEMMOVE ) ; } </s>

Emit target-specific code that performs a memmove .


<s> bool NVPTXLowerAggrCopies :: runOnFunction ( Function & F ) { SmallVector < LoadInst * , 4 > AggrLoads ; SmallVector < MemIntrinsic * , 4 > MemCalls ; const DataLayout & DL = F . getParent ( ) -> getDataLayout ( ) ; LLVMContext & Context = F . getParent ( ) -> getContext ( ) ; const TargetTransformInfo & TTI = getAnalysis < TargetTransformInfoWrapperPass > ( ) . getTTI ( F ) ; for ( BasicBlock & BB : F ) { for ( Instruction & I : BB ) { if ( LoadInst * LI = dyn_cast < LoadInst > ( & I ) ) { if ( ! LI -> hasOneUse ( ) ) continue ; if ( DL . getTypeStoreSize ( LI -> getType ( ) ) < MaxAggrCopySize ) continue ; if ( StoreInst * SI = dyn_cast < StoreInst > ( LI -> user_back ( ) ) ) { if ( SI -> getOperand ( 0 ) != LI ) continue ; AggrLoads . push_back ( LI ) ; } } else if ( MemIntrinsic * IntrCall = dyn_cast < MemIntrinsic > ( & I ) ) { if ( ConstantInt * LenCI = dyn_cast < ConstantInt > ( IntrCall -> getLength ( ) ) ) { if ( LenCI -> getZExtValue ( ) >= MaxAggrCopySize ) { MemCalls . push_back ( IntrCall ) ; } } else { MemCalls . push_back ( IntrCall ) ; } } } } if ( AggrLoads . size ( ) == 0 && MemCalls . size ( ) == 0 ) { return false ; } for ( LoadInst * LI : AggrLoads ) { auto * SI = cast < StoreInst > ( * LI -> user_begin ( ) ) ; Value * SrcAddr = LI -> getOperand ( 0 ) ; Value * DstAddr = SI -> getOperand ( 1 ) ; unsigned NumLoads = DL . getTypeStoreSize ( LI -> getType ( ) ) ; ConstantInt * CopyLen = ConstantInt :: get ( Type :: getInt32Ty ( Context ) , NumLoads ) ; createMemCpyLoopKnownSize ( SI , SrcAddr , DstAddr , CopyLen , LI -> getAlign ( ) , SI -> getAlign ( ) , LI -> isVolatile ( ) , SI -> isVolatile ( ) , true , TTI ) ; SI -> eraseFromParent ( ) ; LI -> eraseFromParent ( ) ; } for ( MemIntrinsic * MemCall : MemCalls ) { if ( MemCpyInst * Memcpy = dyn_cast < MemCpyInst > ( MemCall ) ) { expandMemCpyAsLoop ( Memcpy , TTI ) ; } else if ( MemMoveInst * Memmove = dyn_cast < MemMoveInst > ( MemCall ) ) { expandMemMoveAsLoop ( Memmove ) ; } else if ( MemSetInst * Memset = dyn_cast < MemSetInst > ( MemCall ) ) { expandMemSetAsLoop ( Memset ) ; } MemCall -> eraseFromParent ( ) ; } return true ; } </s>

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


<s>
void
RISCVDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
MVT
XLenVT
=
Subtarget
->
getXLenVT
(
)
;
if
(
Node
->
isMachineOpcode
(
)
)
{
DEBUG
(
dbgs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
dbgs
(
)
<<
"\n"
)
;
Node
->
setNodeId
(
1
)
;
return
;
}
EVT
VT
=
Node
->
getValueType
(
0
)
;
if
(
Opcode
==
ISD
::
Constant
&&
VT
==
XLenVT
)
{
auto
*
ConstNode
=
cast
<
ConstantSDNode
>
(
Node
)
;
if
(
ConstNode
->
isNullValue
(
)
)
{
SDValue
New
=
CurDAG
->
getCopyFromReg
(
CurDAG
->
getEntryNode
(
)
,
SDLoc
(
Node
)
,
RISCV
::
X0
,
XLenVT
)
;
ReplaceNode
(
Node
,
New
.
getNode
(
)
)
;
return
;
}
}
if
(
Opcode
==
ISD
::
FrameIndex
)
{
SDLoc
DL
(
Node
)
;
SDValue
Imm
=
CurDAG
->
getTargetConstant
(
0
,
DL
,
XLenVT
)
;
int
FI
=
dyn_cast
<
FrameIndexSDNode
>
(
Node
)
->
getIndex
(
)
;
EVT
VT
=
Node
->
getValueType
(
0
)
;
SDValue
TFI
=
CurDAG
->
getTargetFrameIndex
(
FI
,
VT
)
;
ReplaceNode
(
Node
,
CurDAG
->
getMachineNode
(
RISCV
::
ADDI
,
DL
,
VT
,
TFI
,
Imm
)
)
;
return
;
}
SelectCode
(
Node
)
;
}
</s>

Main hook for targets to transform nodes into machine nodes .


<s>
const
char
*
output_v9branch
(
rtx
op
,
rtx
dest
,
int
reg
,
int
label
,
int
reversed
,
int
annul
,
rtx_insn
*
insn
)
{
static
char
string
[
64
]
;
enum
rtx_code
code
=
GET_CODE
(
op
)
;
machine_mode
mode
=
GET_MODE
(
XEXP
(
op
,
0
)
)
;
rtx
note
;
int
far
;
char
*
p
;
far
=
get_attr_length
(
insn
)
>=
3
;
if
(
reversed
^
far
)
code
=
reverse_condition
(
code
)
;
gcc_assert
(
mode
==
DImode
)
;
switch
(
code
)
{
case
NE
:
strcpy
(
string
,
"brnz"
)
;
break
;
case
EQ
:
strcpy
(
string
,
"brz"
)
;
break
;
case
GE
:
strcpy
(
string
,
"brgez"
)
;
break
;
case
LT
:
strcpy
(
string
,
"brlz"
)
;
break
;
case
LE
:
strcpy
(
string
,
"brlez"
)
;
break
;
case
GT
:
strcpy
(
string
,
"brgz"
)
;
break
;
default
:
gcc_unreachable
(
)
;
}
p
=
strchr
(
string
,
'\0'
)
;
if
(
annul
&&
!
far
)
{
strcpy
(
p
,
",a"
)
;
p
+=
2
;
}
if
(
insn
&&
(
note
=
find_reg_note
(
insn
,
REG_BR_PROB
,
NULL_RTX
)
)
)
{
strcpy
(
p
,
(
(
XINT
(
note
,
0
)
>=
REG_BR_PROB_BASE
/
2
)
^
far
)
",pt"
:
",pn"
)
;
p
+=
3
;
}
*
p
=
p
<
string
+
8
'\t'
:
' '
;
p
++
;
*
p
++
=
'%'
;
*
p
++
=
'0'
+
reg
;
*
p
++
=
','
;
*
p
++
=
' '
;
if
(
far
)
{
int
veryfar
=
1
,
delta
;
if
(
INSN_ADDRESSES_SET_P
(
)
)
{
delta
=
(
INSN_ADDRESSES
(
INSN_UID
(
dest
)
)
INSN_ADDRESSES
(
INSN_UID
(
insn
)
)
)
;
if
(
delta
>=
260000
&&
delta
<
260000
)
veryfar
=
0
;
}
strcpy
(
p
,
".+12\n\t nop\n\t"
)
;
if
(
annul
||
!
final_sequence
)
p
[
3
]
=
'6'
;
p
+=
12
;
if
(
veryfar
)
{
strcpy
(
p
,
"b\t"
)
;
p
+=
2
;
}
else
{
strcpy
(
p
,
"ba,pt\t%%xcc, "
)
;
p
+=
13
;
}
}
*
p
++
=
'%'
;
*
p
++
=
'l'
;
*
p
++
=
'0'
+
label
;
*
p
++
=
'%'
;
*
p
++
=
'#'
;
*
p
=
'\0'
;
return
string
;
}
</s>

Return the string to output a conditional branch to LABEL , testing register REG . LABEL is the operand number of the label ; REG is the operand number of the reg . OP is the conditional expression . The mode of REG says what kind of comparison we made . REVERSED is non-zero if we should reverse the sense of the comparison . ANNUL is non-zero if we should generate an annulling branch . NOOP is non-zero if we have to follow this branch by a noop .


<s> unsigned getMinimumNopSize ( ) const override { return 2 ; } </s>

Returns the minimum size of a nop in bytes on this target .


<s> Z80Subtarget & Z80Subtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { ParseSubtargetFeatures ( CPU , FS ) ; HasIdxHalfRegs = HasUndocOps ; return * this ; } </s>

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


<s> int h8300_hard_regno_mode_ok ( int regno , enum machine_mode mode ) { if ( TARGET_H8300 ) return ( ( regno & 1 ) == 0 ) || ( mode == HImode ) || ( mode == QImode ) ; else return regno == MAC_REG ? mode == SImode : 1 ; } </s>

Worker function for HARD_REGNO_MODE_OK .


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

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


<s> virtual ScheduleDAGInstrs * createMachineScheduler ( MachineSchedContext * C ) const { return createPatmosVLIWMachineSched ( C ) ; } </s>

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


<s>
StringRef
getPassName
(
)
const
override
{
return
"GBZ80 DAG->DAG Instruction Selection"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool isEqualTo ( const MCExpr * X ) const override { if ( auto * E = dyn_cast < X86MCExpr > ( X ) ) return getRegNo ( ) == E -> getRegNo ( ) ; return false ; } </s>

Test whether two SDValues are known to compare equal .


<s> static bool tilepro_emit_setcc_internal ( rtx res , enum rtx_code code , rtx op0 , rtx op1 , machine_mode cmp_mode ) { rtx tmp ; bool swap = false ; if ( cmp_mode == DImode ) { return tilepro_emit_setcc_internal_di ( res , code , op0 , op1 ) ; } switch ( code ) { case EQ : case NE : case LE : case LT : case LEU : case LTU : break ; case GE : case GT : case GEU : case GTU : swap = true ; break ; default : gcc_unreachable ( ) ; } if ( swap ) { code = swap_condition ( code ) ; tmp = op0 , op0 = op1 , op1 = tmp ; } if ( ! reg_or_0_operand ( op0 , SImode ) ) op0 = force_reg ( SImode , op0 ) ; if ( ! CONST_INT_P ( op1 ) && ! register_operand ( op1 , SImode ) ) op1 = force_reg ( SImode , op1 ) ; emit_insn ( gen_rtx_SET ( res , gen_rtx_fmt_ee ( code , SImode , op0 , op1 ) ) ) ; return true ; } </s>

Certain simplifications can be done to make invalid setcc operations valid . Return the final comparison , or NULL if we ca n't work .


Print the operand address represented by the rtx addr


<s> int microblaze_regno_ok_for_base_p ( int regno , int strict ) { if ( regno >= FIRST_PSEUDO_REGISTER ) { if ( ! strict ) return true ; regno = reg_renumber [ regno ] ; } if ( regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM ) return true ; return GP_REG_P ( regno ) ; } </s>


";; Sequence not recognized, giving up.\n\n"

Return true if we see an insn stream generated by casesi expander together with an extension to SImode of the switch value . If this is the case , fill in the insns from casesi to INSNS [ 1 .. 5 ] and the SImode extension to INSNS [ 0 ] . Moreover , extract the operands of pattern casesi_ < mode > _sequence forged from the sequence to recog_data .


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

Return the MCSymbol for the specified ExternalSymbol .


<s> static void rs6000_maybe_dead ( rtx insn ) { REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_MAYBE_DEAD , const0_rtx , REG_NOTES ( insn ) ) ; } </s>


<s> static void ix86_avx256_split_vector_move_misalign ( rtx op0 , rtx op1 ) { rtx m ; rtx ( * extract ) ( rtx , rtx , rtx ) ; rtx ( * load_unaligned ) ( rtx , rtx ) ; rtx ( * store_unaligned ) ( rtx , rtx ) ; machine_mode mode ; switch ( GET_MODE ( op0 ) ) { default : gcc_unreachable ( ) ; case V32QImode : extract = gen_avx_vextractf128v32qi ; load_unaligned = gen_avx_loaddquv32qi ; store_unaligned = gen_avx_storedquv32qi ; mode = V16QImode ; break ; case V8SFmode : extract = gen_avx_vextractf128v8sf ; load_unaligned = gen_avx_loadups256 ; store_unaligned = gen_avx_storeups256 ; mode = V4SFmode ; break ; case V4DFmode : extract = gen_avx_vextractf128v4df ; load_unaligned = gen_avx_loadupd256 ; store_unaligned = gen_avx_storeupd256 ; mode = V2DFmode ; break ; } if ( MEM_P ( op1 ) ) { if ( TARGET_AVX256_SPLIT_UNALIGNED_LOAD && optimize_insn_for_speed_p ( ) ) { rtx r = gen_reg_rtx ( mode ) ; m = adjust_address ( op1 , mode , 0 ) ; emit_move_insn ( r , m ) ; m = adjust_address ( op1 , mode , 16 ) ; r = gen_rtx_VEC_CONCAT ( GET_MODE ( op0 ) , r , m ) ; emit_move_insn ( op0 , r ) ; } else if ( misaligned_operand ( op1 , GET_MODE ( op1 ) ) ) emit_insn ( gen_rtx_SET ( VOIDmode , op0 , op1 ) ) ; else emit_insn ( load_unaligned ( op0 , op1 ) ) ; } else if ( MEM_P ( op0 ) ) { if ( TARGET_AVX256_SPLIT_UNALIGNED_STORE && optimize_insn_for_speed_p ( ) ) { m = adjust_address ( op0 , mode , 0 ) ; emit_insn ( extract ( m , op1 , const0_rtx ) ) ; m = adjust_address ( op0 , mode , 16 ) ; emit_insn ( extract ( m , op1 , const1_rtx ) ) ; } else emit_insn ( store_unaligned ( op0 , op1 ) ) ; } else gcc_unreachable ( ) ; } </s>

Split 32-byte AVX unaligned load and store if needed .


<s> int R600InstrInfo :: getSrcIdx ( unsigned Opcode , unsigned SrcNum ) const { static const unsigned OpTable [ ] = { AMDGPU :: OpName :: src0 , AMDGPU :: OpName :: src1 , AMDGPU :: OpName :: src2 } ; assert ( SrcNum < 3 ) ; return getOperandIdx ( Opcode , OpTable [ SrcNum ] ) ; } </s>

Return the subregister index that SrcReg will be coalesced into , or 0 .


Convert the CONST_WIDE_INT operand OP to broadcast in MODE .


<s> bool SystemZAsmPrinter :: PrintAsmMemoryOperand ( const MachineInstr * MI , unsigned OpNo , const char * ExtraCode , raw_ostream & OS ) { SystemZInstPrinter :: printAddress ( MAI , MI -> getOperand ( OpNo ) . getReg ( ) , MCOperand :: createImm ( MI -> getOperand ( OpNo + 1 ) . getImm ( ) ) , MI -> getOperand ( OpNo + 2 ) . getReg ( ) , OS ) ; return false ; } </s>

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


<s> static void mips16_split_long_branches ( void ) { bool something_changed ; if ( ! TARGET_MIPS16 ) return ; do { rtx_insn * insn ; rtx_jump_insn * jump_insn ; shorten_branches ( get_insns ( ) ) ; something_changed = false ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( ( jump_insn = dyn_cast < rtx_jump_insn * > ( insn ) ) && get_attr_length ( jump_insn ) > 4 && ( any_condjump_p ( jump_insn ) || any_uncondjump_p ( jump_insn ) ) ) { rtx old_label , temp , saved_temp ; rtx_code_label * new_label ; rtx target ; rtx_insn * jump , * jump_sequence ; start_sequence ( ) ; saved_temp = gen_rtx_REG ( Pmode , AT_REGNUM ) ; temp = gen_rtx_REG ( Pmode , GP_REG_FIRST + 2 ) ; emit_move_insn ( saved_temp , temp ) ; old_label = JUMP_LABEL ( jump_insn ) ; target = gen_rtx_LABEL_REF ( Pmode , old_label ) ; mips16_load_branch_target ( temp , target ) ; jump = emit_jump_insn ( PMODE_INSN ( gen_indirect_jump_and_restore , ( temp , temp , saved_temp ) ) ) ; JUMP_LABEL ( jump ) = old_label ; LABEL_NUSES ( old_label ) ++ ; mips16_lay_out_constants ( false ) ; if ( simplejump_p ( jump_insn ) ) new_label = NULL ; else { new_label = gen_label_rtx ( ) ; emit_label ( new_label ) ; } jump_sequence = get_insns ( ) ; end_sequence ( ) ; emit_insn_after ( jump_sequence , jump_insn ) ; if ( new_label ) invert_jump ( jump_insn , new_label , false ) ; else delete_insn ( jump_insn ) ; something_changed = true ; } } while ( something_changed ) ; } </s>

If we 're compiling a MIPS16 function , look for and split any long branches . This must be called after all other instruction modifications in mips_reorg .


"The Prefetches vector should contain at least a value if "

"Unexpected change in X86 operand offset order."

runOnMachineFunction - Emit the function body .


<s> bool X86FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { DebugLoc DL = MBB . findDebugLoc ( MI ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; const X86Subtarget & STI = MF . getTarget ( ) . getSubtarget < X86Subtarget > ( ) ; unsigned Opc = STI . is64Bit ( ) ? X86 :: PUSH64r : X86 :: PUSH32r ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; if ( ! X86 :: GR64RegClass . contains ( Reg ) && ! X86 :: GR32RegClass . contains ( Reg ) ) continue ; MBB . addLiveIn ( Reg ) ; BuildMI ( MBB , MI , DL , TII . get ( Opc ) ) . addReg ( Reg , RegState :: Kill ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; if ( X86 :: GR64RegClass . contains ( Reg ) || X86 :: GR32RegClass . contains ( Reg ) ) continue ; MBB . addLiveIn ( Reg ) ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . storeRegToStackSlot ( MBB , MI , Reg , true , CSI [ i - 1 ] . getFrameIdx ( ) , RC , TRI ) ; -- MI ; MI -> setFlag ( MachineInstr :: FrameSetup ) ; ++ MI ; } return true ; } </s>

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


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { AttributeSet FnAttrs = MF . getFunction ( ) -> getAttributes ( ) ; ForCodeSize = FnAttrs . hasAttribute ( AttributeSet :: FunctionIndex , Attribute :: OptimizeForSize ) || FnAttrs . hasAttribute ( AttributeSet :: FunctionIndex , Attribute :: MinSize ) ; Subtarget = & TM . getSubtarget < AArch64Subtarget > ( ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ; } </s>


<s> bool LanaiInstrInfo :: analyzeCompare ( const MachineInstr & MI , Register & SrcReg , Register & SrcReg2 , int & CmpMask , int & CmpValue ) const { switch ( MI . getOpcode ( ) ) { default : break ; case Lanai :: SFSUB_F_RI_LO : case Lanai :: SFSUB_F_RI_HI : SrcReg = MI . getOperand ( 0 ) . getReg ( ) ; SrcReg2 = Register ( ) ; CmpMask = ~ 0 ; CmpValue = MI . getOperand ( 1 ) . getImm ( ) ; return true ; case Lanai :: SFSUB_F_RR : SrcReg = MI . getOperand ( 0 ) . getReg ( ) ; SrcReg2 = MI . getOperand ( 1 ) . getReg ( ) ; CmpMask = ~ 0 ; CmpValue = 0 ; return true ; } return false ; } </s>

analyzeCompare - For a comparison instruction , return the source registers in SrcReg and SrcReg2 if having two register operands , and the value it compares against in CmpValue .


<s> bool ARMFrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; MachineFunction & MF = * MBB . getParent ( ) ; ARMFunctionInfo * AFI = MF . getInfo < ARMFunctionInfo > ( ) ; bool isVarArg = AFI -> getVarArgsRegSaveSize ( ) > 0 ; unsigned PopOpc = AFI -> isThumbFunction ( ) ? ARM :: t2LDMIA_UPD : ARM :: LDMIA_UPD ; unsigned LdrOpc = AFI -> isThumbFunction ( ) ? ARM :: t2LDR_POST : ARM :: LDR_POST_IMM ; unsigned FltOpc = ARM :: VLDMDIA_UPD ; emitPopInst ( MBB , MI , CSI , FltOpc , 0 , isVarArg , true , & isARMArea3Register ) ; emitPopInst ( MBB , MI , CSI , PopOpc , LdrOpc , isVarArg , false , & isARMArea2Register ) ; emitPopInst ( MBB , MI , CSI , PopOpc , LdrOpc , isVarArg , false , & isARMArea1Register ) ; return true ; } </s>

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


<s> rtx gen_acc1 ( void ) { return gen_rtx_REG ( SImode , TARGET_BIG_ENDIAN ? 56 : 57 ) ; } </s>

Return a REG rtx for acc1 . N.B . the gcc-internal representation may differ from the hardware register number in order to allow the generic code to correctly split the concatenation of acc1 and acc2 .


<s> bool SIInsertSkips :: runOnMachineFunction ( MachineFunction & MF ) { const SISubtarget & ST = MF . getSubtarget < SISubtarget > ( ) ; TII = ST . getInstrInfo ( ) ; TRI = & TII -> getRegisterInfo ( ) ; SkipThreshold = SkipThresholdFlag ; bool HaveKill = false ; bool MadeChange = false ; SmallVector < MachineBasicBlock * , 16 > ExecBranchStack ; MachineFunction :: iterator NextBB ; MachineBasicBlock * EmptyMBBAtEnd = nullptr ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; BI = NextBB ) { NextBB = std :: next ( BI ) ; MachineBasicBlock & MBB = * BI ; if ( ! ExecBranchStack . empty ( ) && ExecBranchStack . back ( ) == & MBB ) { ExecBranchStack . pop_back ( ) ; } if ( HaveKill && ExecBranchStack . empty ( ) ) { HaveKill = false ; } MachineBasicBlock :: iterator I , Next ; for ( I = MBB . begin ( ) ; I != MBB . end ( ) ; I = Next ) { Next = std :: next ( I ) ; MachineInstr & MI = * I ; switch ( MI . getOpcode ( ) ) { case AMDGPU :: SI_MASK_BRANCH : { ExecBranchStack . push_back ( MI . getOperand ( 0 ) . getMBB ( ) ) ; MadeChange |= skipMaskBranch ( MI , MBB ) ; break ; } case AMDGPU :: S_BRANCH : { if ( MBB . isLayoutSuccessor ( MI . getOperand ( 0 ) . getMBB ( ) ) ) MI . eraseFromParent ( ) ; break ; } case AMDGPU :: SI_KILL_TERMINATOR : { MadeChange = true ; kill ( MI ) ; if ( ExecBranchStack . empty ( ) ) { if ( skipIfDead ( MI , * NextBB ) ) { NextBB = std :: next ( BI ) ; BE = MF . end ( ) ; Next = MBB . end ( ) ; } } else { HaveKill = true ; } MI . eraseFromParent ( ) ; break ; } case AMDGPU :: SI_RETURN : { assert ( ! MF . getInfo < SIMachineFunctionInfo > ( ) -> returnsVoid ( ) ) ; if ( BI != -- MF . end ( ) || I != MBB . getFirstTerminator ( ) ) { if ( ! EmptyMBBAtEnd ) { EmptyMBBAtEnd = MF . CreateMachineBasicBlock ( ) ; MF . insert ( MF . end ( ) , EmptyMBBAtEnd ) ; } MBB . addSuccessor ( EmptyMBBAtEnd ) ; BuildMI ( * BI , I , MI . getDebugLoc ( ) , TII -> get ( AMDGPU :: S_BRANCH ) ) . addMBB ( EmptyMBBAtEnd ) ; I -> eraseFromParent ( ) ; } } default : break ; } } } return MadeChange ; } </s>


<s>
unsigned
CSKYMCCodeEmitter
::
getMachineOpValue
(
const
MCInst
&
MI
,
const
MCOperand
&
MO
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
const
{
if
(
MO
.
isReg
(
)
)
return
Ctx
.
getRegisterInfo
(
)
->
getEncodingValue
(
MO
.
getReg
(
)
)
;
if
(
MO
.
isImm
(
)
)
return
static_cast
<
unsigned
>
(
MO
.
getImm
(
)
)
;
llvm_unreachable
(
"Unhandled expression!"
)
;
return
0
;
}
</s>

getMachineOpValue - Return binary encoding of operand .


<s> inline void count_registers ( const_tree field , int bitpos , bool fp , assign_data_t * data ) { if ( fp ) { int nregs ; machine_mode mode ; if ( compute_int_layout ( bitpos , data , & nregs ) ) data -> nregs += nregs ; if ( compute_fp_layout ( field , bitpos , data , & nregs , & mode ) ) data -> nregs += nregs ; } else { if ( data -> intoffset < 0 ) data -> intoffset = bitpos ; } } </s>

A subroutine of function_arg_record_value . Count the number of registers to be assigned for FIELD and between PARMS- > intoffset and BITPOS .


<s> alias_set_type ix86_GOT_alias_set ( void ) { static alias_set_type set = - 1 ; if ( set == - 1 ) set = new_alias_set ( ) ; return set ; } </s>

Return an unique alias set for the GOT .


<s> bool M68kInstrInfo :: analyzeBranch ( MachineBasicBlock & MBB , MachineBasicBlock * & TBB , MachineBasicBlock * & FBB , SmallVectorImpl < MachineOperand > & Cond , bool AllowModify ) const { return AnalyzeBranchImpl ( MBB , TBB , FBB , Cond , AllowModify ) ; } </s>

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


<s> BitVector Nios2RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { static const MCPhysReg ReservedCPURegs [ ] = { Nios2 :: ZERO , Nios2 :: AT , Nios2 :: SP , Nios2 :: RA , Nios2 :: PC , Nios2 :: GP } ; BitVector Reserved ( getNumRegs ( ) ) ; for ( unsigned I = 0 ; I < array_lengthof ( ReservedCPURegs ) ; ++ I ) Reserved . set ( ReservedCPURegs [ I ] ) ; return Reserved ; } </s>

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


<s> unsigned X86TargetLowering :: getExceptionSelectorRegister ( const Constant * PersonalityFn ) const { assert ( ! isFuncletEHPersonality ( classifyEHPersonality ( PersonalityFn ) ) ) ; return Subtarget . isTarget64BitLP64 ( ) ? X86 :: RDX : X86 :: EDX ; } </s>

If a physical register , this returns the register that receives the exception typeid on entry to a landing pad .


<s> static bool expand_perm_with_merge ( const struct expand_vec_perm_d & d ) { bool merge_lo_p = true ; bool merge_hi_p = true ; if ( d . nelt % 2 ) return false ; for ( int telt = 0 ; telt < d . nelt ; telt ++ ) if ( d . perm [ telt ] != telt / 2 + ( telt % 2 ) * d . nelt ) { merge_hi_p = false ; break ; } if ( ! merge_hi_p ) { for ( int telt = 0 ; telt < d . nelt ; telt ++ ) if ( d . perm [ telt ] != ( telt + d . nelt ) / 2 + ( telt % 2 ) * d . nelt ) { merge_lo_p = false ; break ; } } else merge_lo_p = false ; if ( d . testing_p ) return merge_lo_p || merge_hi_p ; if ( merge_lo_p || merge_hi_p ) s390_expand_merge ( d . target , d . op0 , d . op1 , merge_hi_p ) ; return merge_lo_p || merge_hi_p ; } </s>

Try to expand the vector permute operation described by D using the vector merge instructions vml and vmh . Return true if vector merge could be used .


<s> unsigned MipsSEInstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { unsigned Opc = MI -> getOpcode ( ) ; if ( ( Opc == Mips :: LW ) || ( Opc == Mips :: LD ) || ( Opc == Mips :: LWC1 ) || ( Opc == Mips :: LDC1 ) || ( Opc == Mips :: LDC164 ) ) { if ( ( MI -> getOperand ( 1 ) . isFI ( ) ) && ( MI -> getOperand ( 2 ) . isImm ( ) ) && ( isZeroImm ( MI -> getOperand ( 2 ) ) ) ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

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 .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Combine STU / STI instructions"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> SDNode * NVPTXDAGToDAGISel :: Select ( SDNode * N ) { if ( N -> isMachineOpcode ( ) ) return NULL ; SDNode * ResNode = NULL ; switch ( N -> getOpcode ( ) ) { case ISD :: LOAD : ResNode = SelectLoad ( N ) ; break ; case ISD :: STORE : ResNode = SelectStore ( N ) ; break ; } if ( ResNode ) return ResNode ; return SelectCode ( N ) ; } </s>

Main hook for targets to transform nodes into machine nodes .


<s> void TriCoreRegisterInfo :: eliminateFrameIndex ( MachineBasicBlock :: iterator II , int SPAdj , unsigned FIOperandNum , RegScavenger * RS ) const { assert ( SPAdj == 0 && "Unexpected" ) ; MachineInstr & MI = * II ; const MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; DebugLoc dl = MI . getDebugLoc ( ) ; MachineBasicBlock & MBB = * MI . getParent ( ) ; const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; MachineOperand & FIOp = MI . getOperand ( FIOperandNum ) ; unsigned FI = FIOp . getIndex ( ) ; const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; unsigned BasePtr = ( TFI -> hasFP ( MF ) ? TriCore :: A14 : TriCore :: A10 ) ; unsigned ImmOpIdx = 0 ; if ( MI . getOpcode ( ) == TriCore :: ADDrc ) { int Offset = MFI -> getObjectOffset ( FI ) ; Offset = - Offset ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MI . setDesc ( TII . get ( TriCore :: MOVDrr ) ) ; MI . getOperand ( FIOperandNum ) . ChangeToRegister ( BasePtr , false ) ; if ( Offset == 0 ) return ; unsigned DstReg = MI . getOperand ( 0 ) . getReg ( ) ; if ( Offset < 0 ) { BuildMI ( MBB , std :: next ( II ) , dl , TII . get ( TriCore :: ADDrc ) , DstReg ) . addReg ( DstReg ) . addImm ( Offset ) ; } else BuildMI ( MBB , std :: next ( II ) , dl , TII . get ( TriCore :: ADDrc ) , DstReg ) . addReg ( DstReg ) . addImm ( - Offset ) ; return ; } ImmOpIdx = FIOperandNum + 1 ; MachineOperand & ImmOp = MI . getOperand ( ImmOpIdx ) ; int Offset = MFI -> getObjectOffset ( FI ) ; FIOp . ChangeToRegister ( BasePtr , false ) ; ImmOp . setImm ( Offset ) ; } </s>

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


<s> void Thumb1RegisterInfo :: emitLoadConstPool ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , DebugLoc dl , unsigned DestReg , unsigned SubIdx , int Val , ARMCC :: CondCodes Pred , unsigned PredReg , unsigned MIFlags ) const { MachineFunction & MF = * MBB . getParent ( ) ; MachineConstantPool * ConstantPool = MF . getConstantPool ( ) ; const Constant * C = ConstantInt :: get ( Type :: getInt32Ty ( MBB . getParent ( ) -> getFunction ( ) -> getContext ( ) ) , Val ) ; unsigned Idx = ConstantPool -> getConstantPoolIndex ( C , 4 ) ; BuildMI ( MBB , MBBI , dl , TII . get ( ARM :: tLDRpci ) ) . addReg ( DestReg , getDefRegState ( true ) , SubIdx ) . addConstantPoolIndex ( Idx ) . addImm ( Pred ) . addReg ( PredReg ) . setMIFlags ( MIFlags ) ; } </s>

emitLoadConstPool - Emits a load from constpool to materialize the specified immediate .


<s> static rtx arm_pic_static_addr ( rtx orig , rtx reg ) { rtx l1 , labelno , offset_rtx , insn ; gcc_assert ( flag_pic ) ; labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; offset_rtx = plus_constant ( Pmode , l1 , TARGET_ARM ? 8 : 4 ) ; offset_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 2 , orig , offset_rtx ) , UNSPEC_SYMBOL_OFFSET ) ; offset_rtx = gen_rtx_CONST ( Pmode , offset_rtx ) ; insn = emit_insn ( gen_pic_load_addr_unified ( reg , offset_rtx , labelno ) ) ; return insn ; } </s>

Generate code to load the address of a static var when flag_pic is set .


<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 ; return std :: make_pair ( domain , validDomains ) ; } </s>

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


<s> inline static rtx_insn * emit_set_insn ( rtx x , rtx y ) { return emit_insn ( gen_rtx_SET ( x , y ) ) ; } </s>

Emit an insn that 's a simple single-set . Both the operands must be known to be valid .


<s>
unsigned
ARMCodeEmitter
::
getMachineOpValue
(
const
MachineInstr
&
MI
,
const
MachineOperand
&
MO
)
const
{
if
(
MO
.
isReg
(
)
)
return
getARMRegisterNumbering
(
MO
.
getReg
(
)
)
;
else
if
(
MO
.
isImm
(
)
)
return
static_cast
<
unsigned
>
(
MO
.
getImm
(
)
)
;
else
if
(
MO
.
isGlobal
(
)
)
emitGlobalAddress
(
MO
.
getGlobal
(
)
,
ARM
::
reloc_arm_branch
,
true
,
false
)
;
else
if
(
MO
.
isSymbol
(
)
)
emitExternalSymbolAddress
(
MO
.
getSymbolName
(
)
,
ARM
::
reloc_arm_branch
)
;
else
if
(
MO
.
isCPI
(
)
)
{
const
MCInstrDesc
&
MCID
=
MI
.
getDesc
(
)
;
unsigned
Reloc
=
(
(
MCID
.
TSFlags
&
ARMII
::
FormMask
)
==
ARMII
::
VFPLdStFrm
)
ARM
::
reloc_arm_vfp_cp_entry
:
ARM
::
reloc_arm_cp_entry
;
emitConstPoolAddress
(
MO
.
getIndex
(
)
,
Reloc
)
;
}
else
if
(
MO
.
isJTI
(
)
)
emitJumpTableAddress
(
MO
.
getIndex
(
)
,
ARM
::
reloc_arm_relative
)
;
else
if
(
MO
.
isMBB
(
)
)
emitMachineBasicBlock
(
MO
.
getMBB
(
)
,
ARM
::
reloc_arm_branch
)
;
else
llvm_unreachable
(
"Unable to encode MachineOperand!"
)
;
return
0
;
}
</s>


<s> bool runOnModule ( Module & M ) override { SetVector < Function * > Functions ; AnalysisGetter AG ; for ( Function & F : M ) Functions . insert ( & F ) ; CallGraphUpdater CGUpdater ; BumpPtrAllocator Allocator ; AMDGPUInformationCache InfoCache ( M , AG , Allocator , nullptr , * TM ) ; Attributor A ( Functions , InfoCache , CGUpdater ) ; for ( Function & F : M ) { A . getOrCreateAAFor < AAAMDAttributes > ( IRPosition :: function ( F ) ) ; A . getOrCreateAAFor < AAAMDWorkGroupSize > ( IRPosition :: function ( F ) ) ; } ChangeStatus Change = A . run ( ) ; return Change == ChangeStatus :: CHANGED ; } </s>

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


<s> static void riscv_restore_reg ( rtx reg , rtx mem ) { rtx insn = riscv_emit_move ( reg , mem ) ; rtx dwarf = NULL_RTX ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; REG_NOTES ( insn ) = dwarf ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } </s>


<s> unsigned HexagonInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : break ; case Hexagon :: S2_storerb_io : case Hexagon :: S2_storerh_io : case Hexagon :: S2_storeri_io : case Hexagon :: S2_storerd_io : case Hexagon :: V6_vS32b_ai : case Hexagon :: V6_vS32Ub_ai : case Hexagon :: STriw_pred : case Hexagon :: STriw_mod : case Hexagon :: PS_vstorerq_ai : case Hexagon :: PS_vstorerw_ai : { const MachineOperand & OpFI = MI . getOperand ( 0 ) ; if ( ! OpFI . isFI ( ) ) return 0 ; const MachineOperand & OpOff = MI . getOperand ( 1 ) ; if ( ! OpOff . isImm ( ) || OpOff . getImm ( ) != 0 ) return 0 ; FrameIndex = OpFI . getIndex ( ) ; return MI . getOperand ( 2 ) . getReg ( ) ; } case Hexagon :: S2_pstorerbt_io : case Hexagon :: S2_pstorerbf_io : case Hexagon :: S2_pstorerht_io : case Hexagon :: S2_pstorerhf_io : case Hexagon :: S2_pstorerit_io : case Hexagon :: S2_pstorerif_io : case Hexagon :: S2_pstorerdt_io : case Hexagon :: S2_pstorerdf_io : { const MachineOperand & OpFI = MI . getOperand ( 1 ) ; if ( ! OpFI . isFI ( ) ) return 0 ; const MachineOperand & OpOff = MI . getOperand ( 2 ) ; if ( ! OpOff . isImm ( ) || OpOff . getImm ( ) != 0 ) return 0 ; FrameIndex = OpFI . getIndex ( ) ; return MI . getOperand ( 3 ) . getReg ( ) ; } } return 0 ; } </s>

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


"unknown architecture specific memory model"

"%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger "

"%<HLE_RELEASE%> not used with %<RELEASE%> or stronger "

Validate target specific memory model bits in VAL .


<s> static NodeRef getEntryNode ( SPScope * G ) { return G ; } </s>

Return the token chain corresponding to the entry of the function .


<s>
void
AMDGPUAsmPrinter
::
emitEndOfAsmFile
(
Module
&
M
)
{
if
(
!
getTargetStreamer
(
)
)
return
;
if
(
TM
.
getTargetTriple
(
)
.
getOS
(
)
!=
Triple
::
AMDHSA
||
isHsaAbiVersion2
(
getGlobalSTI
(
)
)
)
getTargetStreamer
(
)
->
EmitISAVersion
(
)
;
if
(
TM
.
getTargetTriple
(
)
.
getOS
(
)
==
Triple
::
AMDHSA
)
{
HSAMetadataStream
->
end
(
)
;
bool
Success
=
HSAMetadataStream
->
emitTo
(
*
getTargetStreamer
(
)
)
;
(
void
)
Success
;
assert
(
Success
&&
"Malformed HSA Metadata"
)
;
}
}
</s>

This virtual method can be overridden by targets that want to emit something at the end of their file .


<s> bool AArch64CallLowering :: lowerFormalArguments ( MachineIRBuilder & MIRBuilder , const Function & F , ArrayRef < unsigned > VRegs ) const { auto & Args = F . getArgumentList ( ) ; MachineFunction & MF = MIRBuilder . getMF ( ) ; MachineBasicBlock & MBB = MIRBuilder . getMBB ( ) ; MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; auto & DL = F . getParent ( ) -> getDataLayout ( ) ; SmallVector < ArgInfo , 8 > SplitArgs ; unsigned i = 0 ; for ( auto & Arg : Args ) { ArgInfo OrigArg { VRegs [ i ] , Arg . getType ( ) } ; setArgFlags ( OrigArg , i + 1 , DL , F ) ; splitToValueTypes ( OrigArg , SplitArgs , DL , MRI , [ & ] ( ArrayRef < unsigned > Regs , ArrayRef < uint64_t > Offsets ) { MIRBuilder . buildSequence ( VRegs [ i ] , Regs , Offsets ) ; } ) ; ++ i ; } if ( ! MBB . empty ( ) ) MIRBuilder . setInstr ( * MBB . begin ( ) ) ; const AArch64TargetLowering & TLI = * getTLI < AArch64TargetLowering > ( ) ; CCAssignFn * AssignFn = TLI . CCAssignFnForCall ( F . getCallingConv ( ) , false ) ; FormalArgHandler Handler ( MIRBuilder , MRI , AssignFn ) ; if ( ! handleAssignments ( MIRBuilder , SplitArgs , Handler ) ) return false ; MIRBuilder . setMBB ( MBB ) ; return true ; } </s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by VRegs , for GlobalISel .


<s> virtual void EmitInstruction ( const MachineInstr * MI ) { SmallString < 128 > Str ; raw_svector_ostream OS ( Str ) ; printInstruction ( MI , OS ) ; OutStreamer . EmitRawText ( OS . str ( ) ) ; } </s>

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


<s> const char * TL45TargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( ( TL45ISD :: NodeType ) Opcode ) { case TL45ISD :: FIRST_NUMBER : break ; case TL45ISD :: RET : return "TL45ISD::RET" ; case TL45ISD :: CALL : return "TL45ISD::CALL" ; case TL45ISD :: JMP : return "TL45ISD::JMP" ; case TL45ISD :: NAND : return "TL45ISD::NAND" ; case TL45ISD :: CMP_SKIP : return "TL45ISD::CMP_SKIP" ; case TL45ISD :: CMP_JMP : return "TL45ISD::CMP_JMP" ; case TL45ISD :: CMPI_JMP : return "TL45ISD::CMPI_JMP" ; case TL45ISD :: SUB_TERM : return "TL45ISD::SUB_TERM" ; case TL45ISD :: SELECT_MOVE : return "TL45ISD::SELECT_MOVE" ; case TL45ISD :: CMP_SELECT_MOVE : return "TL45ISD::CMP_SELECT_MOVE" ; } return nullptr ; } </s>

getTargetNodeName - This method returns the name of a target specific


<s> static scalar_int_mode spu_addr_space_address_mode ( addr_space_t addrspace ) { switch ( addrspace ) { case ADDR_SPACE_GENERIC : return Pmode ; case ADDR_SPACE_EA : return EAmode ; default : gcc_unreachable ( ) ; } } </s>

Return the appropriate mode for a named address address .


<s>
SUnit
*
GCNMaxOccupancySchedStrategy
::
pickNode
(
bool
&
IsTopNode
)
{
if
(
DAG
->
top
(
)
==
DAG
->
bottom
(
)
)
{
assert
(
Top
.
Available
.
empty
(
)
&&
Top
.
Pending
.
empty
(
)
&&
Bot
.
Available
.
empty
(
)
&&
Bot
.
Pending
.
empty
(
)
&&
"ReadyQ garbage"
)
;
return
nullptr
;
}
SUnit
*
SU
;
do
{
if
(
RegionPolicy
.
OnlyTopDown
)
{
SU
=
Top
.
pickOnlyChoice
(
)
;
if
(
!
SU
)
{
CandPolicy
NoPolicy
;
TopCand
.
reset
(
NoPolicy
)
;
pickNodeFromQueue
(
Top
,
NoPolicy
,
DAG
->
getTopRPTracker
(
)
,
TopCand
)
;
assert
(
TopCand
.
Reason
!=
NoCand
&&
"failed to find a candidate"
)
;
SU
=
TopCand
.
SU
;
}
IsTopNode
=
true
;
}
else
if
(
RegionPolicy
.
OnlyBottomUp
)
{
SU
=
Bot
.
pickOnlyChoice
(
)
;
if
(
!
SU
)
{
CandPolicy
NoPolicy
;
BotCand
.
reset
(
NoPolicy
)
;
pickNodeFromQueue
(
Bot
,
NoPolicy
,
DAG
->
getBotRPTracker
(
)
,
BotCand
)
;
assert
(
BotCand
.
Reason
!=
NoCand
&&
"failed to find a candidate"
)
;
SU
=
BotCand
.
SU
;
}
IsTopNode
=
false
;
}
else
{
SU
=
pickNodeBidirectional
(
IsTopNode
)
;
}
}
while
(
SU
->
isScheduled
)
;
if
(
SU
->
isTopReady
(
)
)
Top
.
removeReady
(
SU
)
;
if
(
SU
->
isBottomReady
(
)
)
Bot
.
removeReady
(
SU
)
;
if
(
!
HasClusteredNodes
&&
SU
->
getInstr
(
)
->
mayLoadOrStore
(
)
)
{
for
(
SDep
&
Dep
:
SU
->
Preds
)
{
if
(
Dep
.
isCluster
(
)
)
{
HasClusteredNodes
=
true
;
break
;
}
}
}
LLVM_DEBUG
(
dbgs
(
)
<<
"Scheduling SU("
<<
SU
->
NodeNum
<<
") "
<<
*
SU
->
getInstr
(
)
)
;
return
SU
;
}
</s>

Pick the next node to schedule , or return NULL .

AMDGPU
"ReadyQ garbage"
"failed to find a candidate"
"failed to find a candidate"
"Scheduling SU("
") "


"OR1K PIC Global Base Reg Initialization"

getPassName - Return a nice clean name for a pass .


<s> bool XCoreInstrInfo :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI ) const { if ( CSI . empty ( ) ) { return true ; } MachineFunction * MF = MBB . getParent ( ) ; const MachineFrameInfo * MFI = MF -> getFrameInfo ( ) ; MachineModuleInfo * MMI = MFI -> getMachineModuleInfo ( ) ; XCoreFunctionInfo * XFI = MF -> getInfo < XCoreFunctionInfo > ( ) ; bool emitFrameMoves = XCoreRegisterInfo :: needsFrameMoves ( * MF ) ; DebugLoc DL = DebugLoc :: getUnknownLoc ( ) ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; for ( std :: vector < CalleeSavedInfo > :: const_iterator it = CSI . begin ( ) ; it != CSI . end ( ) ; ++ it ) { MBB . addLiveIn ( it -> getReg ( ) ) ; storeRegToStackSlot ( MBB , MI , it -> getReg ( ) , true , it -> getFrameIdx ( ) , it -> getRegClass ( ) ) ; if ( emitFrameMoves ) { unsigned SaveLabelId = MMI -> NextLabelID ( ) ; BuildMI ( MBB , MI , DL , get ( XCore :: DBG_LABEL ) ) . addImm ( SaveLabelId ) ; XFI -> getSpillLabels ( ) . push_back ( std :: pair < unsigned , CalleeSavedInfo > ( SaveLabelId , * it ) ) ; } } return true ; } </s>

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

XCore XCore XCore XCore XCore XCore::DBG_LABEL


"Encountered a global variable kind that is "

Emit the specified global variable to the .s file .


<s> bool AMDGPUInstrInfo :: isPredicable ( MachineInstr * MI ) const { return MI -> getDesc ( ) . isPredicable ( ) ; } </s>

Return true if the specified instruction can be predicated .


<s> BitVector MSP430RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; const TargetFrameLowering * TFI = MF . getTarget ( ) . getFrameLowering ( ) ; Reserved . set ( MSP430 :: PCB ) ; Reserved . set ( MSP430 :: SPB ) ; Reserved . set ( MSP430 :: SRB ) ; Reserved . set ( MSP430 :: CGB ) ; Reserved . set ( MSP430 :: PCW ) ; Reserved . set ( MSP430 :: SPW ) ; Reserved . set ( MSP430 :: SRW ) ; Reserved . set ( MSP430 :: CGW ) ; if ( TFI -> hasFP ( MF ) ) { Reserved . set ( MSP430 :: FPB ) ; Reserved . set ( MSP430 :: FPW ) ; } return Reserved ; } </s>

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


<s> MachineBasicBlock :: iterator NVPTXFrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { return 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> void sparc_profile_hook ( int labelno ) { char buf [ 32 ] ; rtx lab , fun ; fun = gen_rtx_SYMBOL_REF ( Pmode , MCOUNT_FUNCTION ) ; if ( NO_PROFILE_COUNTERS ) { emit_library_call ( fun , LCT_NORMAL , VOIDmode , 0 ) ; } else { ASM_GENERATE_INTERNAL_LABEL ( buf , "LP" , labelno ) ; lab = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( buf ) ) ; emit_library_call ( fun , LCT_NORMAL , VOIDmode , 1 , lab , Pmode ) ; } } </s>

Output rtl to increment the profiler label LABELNO for profiling a function entry .


<s> static char * locate_lib ( char * lib_name ) { int lib_len = strlen ( lib_name ) ; const char * exts [ 3 ] ; int i ; if ( staticp ) { exts [ 0 ] = ".a" ; exts [ 1 ] = ".olb" ; exts [ 2 ] = ".exe" ; } else { exts [ 0 ] = ".exe" ; exts [ 1 ] = ".a" ; exts [ 2 ] = ".olb" ; } for ( i = 0 ; i < search_dirs_len ; i ++ ) { char * buf ; int l ; int j ; l = strlen ( search_dirs [ i ] ) ; buf = ( char * ) alloca ( l + 4 + lib_len + 4 + 1 ) ; memcpy ( buf , search_dirs [ i ] , l ) ; memcpy ( buf + l , "/lib" , 4 ) ; l += 4 ; memcpy ( buf + l , lib_name , lib_len ) ; l += lib_len ; for ( j = 0 ; j < 3 ; j ++ ) { strcpy ( buf + l , exts [ j ] ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; } } return NULL ; } </s>

Locate library LIB_NAME on the library path .


<s> static bool epiphany_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return ( regno & 1 ) == 0 && GPR_P ( regno ) ; else return true ; } </s>


<s>
void
XCoreTargetLowering
::
ReplaceNodeResults
(
SDNode
*
N
,
SmallVectorImpl
<
SDValue
>
&
Results
,
SelectionDAG
&
DAG
)
const
{
switch
(
N
->
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Don't know how to custom expand this!"
)
;
case
ISD
::
ADD
:
case
ISD
::
SUB
:
Results
.
push_back
(
ExpandADDSUB
(
N
,
DAG
)
)
;
return
;
}
}
</s>

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

XCore
XCore
"Don't know how to custom expand this!"
ISD::ADD
ISD::SUB


"alignment (%u) for %s exceeds maximum alignment "

Both the HP and GNU assemblers under HP-UX provide a .comm directive that does n't allow the alignment of global common storage to be directly specified . The SOM linker aligns common storage based on the rounded value of the NUM_BYTES parameter in the .comm directive . It 's not possible to use the .align directive as it does n't affect the alignment of the label associated with a .comm directive .


<s> bool riscv_store_data_bypass_p ( rtx_insn * out_insn , rtx_insn * in_insn ) { rtx out_set , in_set ; rtx out_pat , in_pat ; rtx out_exp , in_exp ; int i , j ; in_set = single_set ( in_insn ) ; if ( in_set ) { if ( MEM_P ( SET_DEST ( in_set ) ) ) { out_set = single_set ( out_insn ) ; if ( ! out_set ) { out_pat = PATTERN ( out_insn ) ; if ( GET_CODE ( out_pat ) == PARALLEL ) { for ( i = 0 ; i < XVECLEN ( out_pat , 0 ) ; i ++ ) { out_exp = XVECEXP ( out_pat , 0 , i ) ; if ( ( GET_CODE ( out_exp ) == CLOBBER ) || ( GET_CODE ( out_exp ) == USE ) ) continue ; else if ( GET_CODE ( out_exp ) != SET ) return false ; } } } } } else { in_pat = PATTERN ( in_insn ) ; if ( GET_CODE ( in_pat ) != PARALLEL ) return false ; for ( i = 0 ; i < XVECLEN ( in_pat , 0 ) ; i ++ ) { in_exp = XVECEXP ( in_pat , 0 , i ) ; if ( ( GET_CODE ( in_exp ) == CLOBBER ) || ( GET_CODE ( in_exp ) == USE ) ) continue ; else if ( GET_CODE ( in_exp ) != SET ) return false ; if ( MEM_P ( SET_DEST ( in_exp ) ) ) { out_set = single_set ( out_insn ) ; if ( ! out_set ) { out_pat = PATTERN ( out_insn ) ; if ( GET_CODE ( out_pat ) != PARALLEL ) return false ; for ( j = 0 ; j < XVECLEN ( out_pat , 0 ) ; j ++ ) { out_exp = XVECEXP ( out_pat , 0 , j ) ; if ( ( GET_CODE ( out_exp ) == CLOBBER ) || ( GET_CODE ( out_exp ) == USE ) ) continue ; else if ( GET_CODE ( out_exp ) != SET ) return false ; } } } } } return store_data_bypass_p ( out_insn , in_insn ) ; } </s>

Given that there exists at least one variable that is set ( produced ) by OUT_INSN and read ( consumed ) by IN_INSN , return true iff IN_INSN represents one or more memory store operations and none of the variables set by OUT_INSN is used by IN_INSN as the address of a store operation . If either IN_INSN or OUT_INSN does not represent a `` single '' RTL SET expression ( as loosely defined by the implementation of the single_set function ) or a PARALLEL with only SETs , CLOBBERs , and USEs inside , this function returns false . Borrowed from rs6000 , riscv_store_data_bypass_p checks for certain conditions that result in assertion failures in the generic store_data_bypass_p function and returns FALSE in such cases . This is required to make -msave-restore work with the sifive-7 pipeline description .


<s> static void frv_reorg ( void ) { if ( optimize > 0 && TARGET_OPTIMIZE_MEMBAR && cfun -> machine -> has_membar_p ) frv_optimize_membar ( ) ; frv_num_nops = 0 ; frv_register_nop ( gen_nop ( ) ) ; if ( TARGET_MEDIA ) frv_register_nop ( gen_mnop ( ) ) ; if ( TARGET_HARD_FLOAT ) frv_register_nop ( gen_fnop ( ) ) ; shorten_branches ( get_insns ( ) ) ; frv_packet_address = 0 ; frv_for_each_packet ( frv_reorg_packet ) ; } </s>

Implement TARGET_MACHINE_DEPENDENT_REORG . Divide the instructions into packets and check whether we need to insert nops in order to fulfill the processor 's issue requirements . Also , if the user has requested a certain alignment for a label , try to meet that alignment by inserting nops in the previous packet .


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

Emit target-specific code that performs a memset .


<s> unsigned SIRegisterInfo :: findUnusedRegister ( const MachineRegisterInfo & MRI , const TargetRegisterClass * RC ) const { for ( TargetRegisterClass :: iterator I = RC -> begin ( ) , E = RC -> end ( ) ; I != E ; ++ I ) { if ( ! MRI . isPhysRegUsed ( * I ) ) return * I ; } return AMDGPU :: NoRegister ; } </s>

Returns a lowest register that is not used at any point in the function .


<s> static rtx rl78_subreg ( machine_mode mode , rtx r , machine_mode omode , int byte ) { if ( GET_CODE ( r ) == MEM ) return adjust_address ( r , mode , byte ) ; else return simplify_gen_subreg ( mode , r , omode , byte ) ; } </s>

Simplify_gen_subreg ( ) does n't handle memory references the way we need it to below , so we use this function for when we must get a valid subreg in a `` natural '' state .


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

Returns true if the target requires post PEI scavenging of registers for materializing frame index constants .


<s> static int pru_function_arg_regi ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; size_t argsize = pru_function_arg_size ( mode , type ) ; size_t i , bi ; int regi = - 1 ; if ( ! pru_arg_in_reg_bysize ( argsize ) ) return - 1 ; if ( ! named ) return - 1 ; for ( i = 0 ; regi < 0 && i < ARRAY_SIZE ( cum -> regs_used ) ; i ++ ) { gcc_assert ( argsize == 1 || argsize == 2 || argsize == 3 || argsize == 4 || argsize == 8 ) ; if ( ( argsize >= 4 ) && ( i % 4 ) != 0 ) continue ; if ( argsize == 3 && ( i % 4 ) != 0 ) continue ; if ( argsize == 2 && ( i % 4 ) == 3 ) continue ; for ( bi = 0 ; bi < argsize && ( bi + i ) < ARRAY_SIZE ( cum -> regs_used ) ; bi ++ ) { if ( cum -> regs_used [ bi + i ] ) break ; } if ( bi == argsize ) regi = FIRST_ARG_REGNUM + i ; } return regi ; } </s>

Helper function to get the starting storage HW register for an argument , or -1 if it must be passed on stack . The cum_v state is not changed .


<s> bool function_expander :: overlaps_input_p ( rtx x ) { for ( unsigned int i = 0 ; i < args . length ( ) ; ++ i ) if ( reg_overlap_mentioned_p ( x , args [ i ] ) ) return true ; return false ; } </s>


"register_move_cost %s from %s to %s = %d\n"

Implements REGISTER_MOVE_COST . We make impossible moves prohibitively expensive , like trying to put QIs in r2/r3 ( there are no opcodes to do that ) . We also discourage use of mem * registers since they 're really memory .


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

"Unexpected result type for CTR decrement intrinsic"