<s> bool PPCPassConfig :: addPreRegAlloc ( ) { if ( getPPCSubtarget ( ) . hasVSX ( ) ) { initializePPCVSXFMAMutatePass ( * PassRegistry :: getPassRegistry ( ) ) ; insertPass ( VSXFMAMutateEarly ? & RegisterCoalescerID : & MachineSchedulerID , & PPCVSXFMAMutateID ) ; } return false ; } </s>

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


<s> static unsigned int pa_hard_regno_nregs ( unsigned int regno ATTRIBUTE_UNUSED , machine_mode mode ) { return PA_HARD_REGNO_NREGS ( regno , mode ) ; } </s>


<s> static tree rs6000_vector_type ( const char * name , tree elt_type , unsigned num_elts ) { tree result = build_vector_type ( elt_type , num_elts ) ; result = build_variant_type_copy ( result ) ; add_builtin_type ( name , result ) ; return result ; } </s>

Create a builtin vector type with a name . Taking care not to give the canonical type a name .


<s> const MCExpr * X86_64MachoTargetObjectFile :: getTTypeGlobalReference ( const GlobalValue * GV , unsigned Encoding , const TargetMachine & TM , MachineModuleInfo * MMI , MCStreamer & Streamer ) const { if ( ( Encoding & DW_EH_PE_indirect ) && ( Encoding & DW_EH_PE_pcrel ) ) { const MCSymbol * Sym = TM . getSymbol ( GV ) ; const MCExpr * Res = MCSymbolRefExpr :: create ( Sym , MCSymbolRefExpr :: VK_GOTPCREL , getContext ( ) ) ; const MCExpr * Four = MCConstantExpr :: create ( 4 , getContext ( ) ) ; return MCBinaryExpr :: createAdd ( Res , Four , getContext ( ) ) ; } return TargetLoweringObjectFileMachO :: getTTypeGlobalReference ( GV , Encoding , TM , MMI , Streamer ) ; } </s>

The mach-o version of this method defaults to returning a stub reference .


<s>
bool
SystemZRegisterInfo
::
shouldCoalesce
(
MachineInstr
*
MI
,
const
TargetRegisterClass
*
SrcRC
,
unsigned
SubReg
,
const
TargetRegisterClass
*
DstRC
,
unsigned
DstSubReg
,
const
TargetRegisterClass
*
NewRC
,
LiveIntervals
&
LIS
)
const
{
assert
(
MI
->
isCopy
(
)
&&
"Only expecting COPY instructions"
)
;
if
(
!
(
NewRC
->
hasSuperClassEq
(
&
SystemZ
::
GR128BitRegClass
)
&&
(
getRegSizeInBits
(
*
SrcRC
)
<=
64
||
getRegSizeInBits
(
*
DstRC
)
<=
64
)
)
)
return
true
;
unsigned
WideOpNo
=
(
getRegSizeInBits
(
*
SrcRC
)
==
128
1
:
0
)
;
Register
GR128Reg
=
MI
->
getOperand
(
WideOpNo
)
.
getReg
(
)
;
Register
GRNarReg
=
MI
->
getOperand
(
(
WideOpNo
==
1
)
0
:
1
)
.
getReg
(
)
;
LiveInterval
&
IntGR128
=
LIS
.
getInterval
(
GR128Reg
)
;
LiveInterval
&
IntGRNar
=
LIS
.
getInterval
(
GRNarReg
)
;
MachineBasicBlock
*
MBB
=
MI
->
getParent
(
)
;
MachineInstr
*
FirstMI_GR128
=
LIS
.
getInstructionFromIndex
(
IntGR128
.
beginIndex
(
)
)
;
MachineInstr
*
FirstMI_GRNar
=
LIS
.
getInstructionFromIndex
(
IntGRNar
.
beginIndex
(
)
)
;
MachineInstr
*
LastMI_GR128
=
LIS
.
getInstructionFromIndex
(
IntGR128
.
endIndex
(
)
)
;
MachineInstr
*
LastMI_GRNar
=
LIS
.
getInstructionFromIndex
(
IntGRNar
.
endIndex
(
)
)
;
if
(
(
!
FirstMI_GR128
||
FirstMI_GR128
->
getParent
(
)
!=
MBB
)
||
(
!
FirstMI_GRNar
||
FirstMI_GRNar
->
getParent
(
)
!=
MBB
)
||
(
!
LastMI_GR128
||
LastMI_GR128
->
getParent
(
)
!=
MBB
)
||
(
!
LastMI_GRNar
||
LastMI_GRNar
->
getParent
(
)
!=
MBB
)
)
return
false
;
MachineBasicBlock
::
iterator
MII
=
nullptr
,
MEE
=
nullptr
;
if
(
WideOpNo
==
1
)
{
MII
=
FirstMI_GR128
;
MEE
=
LastMI_GRNar
;
}
else
{
MII
=
FirstMI_GRNar
;
MEE
=
LastMI_GR128
;
}
BitVector
PhysClobbered
(
getNumRegs
(
)
)
;
MEE
++
;
for
(
;
MII
!=
MEE
;
++
MII
)
{
for
(
const
MachineOperand
&
MO
:
MII
->
operands
(
)
)
if
(
MO
.
isReg
(
)
&&
Register
::
isPhysicalRegister
(
MO
.
getReg
(
)
)
)
{
for
(
MCSuperRegIterator
SI
(
MO
.
getReg
(
)
,
this
,
true
)
;
SI
.
isValid
(
)
;
++
SI
)
if
(
NewRC
->
contains
(
*
SI
)
)
{
PhysClobbered
.
set
(
*
SI
)
;
break
;
}
}
}
unsigned
const
DemandedFreeGR128
=
3
;
if
(
PhysClobbered
.
count
(
)
>
(
NewRC
->
getNumRegs
(
)
DemandedFreeGR128
)
)
return
false
;
return
true
;
}
</s>


<s> static void s300_set_up_by_prologue ( hard_reg_set_container * regs ) { if ( cfun -> machine -> base_reg && ! call_used_regs [ REGNO ( cfun -> machine -> base_reg ) ] ) SET_HARD_REG_BIT ( regs -> set , REGNO ( cfun -> machine -> base_reg ) ) ; } </s>


<s> int byte_accesses_mergeable_p ( rtx addr1 , rtx addr2 ) { HOST_WIDE_INT offset1 , offset2 ; rtx reg1 , reg2 ; if ( REG_P ( addr1 ) ) { reg1 = addr1 ; offset1 = 0 ; } else if ( GET_CODE ( addr1 ) == PLUS && REG_P ( XEXP ( addr1 , 0 ) ) && GET_CODE ( XEXP ( addr1 , 1 ) ) == CONST_INT ) { reg1 = XEXP ( addr1 , 0 ) ; offset1 = INTVAL ( XEXP ( addr1 , 1 ) ) ; } else return 0 ; if ( REG_P ( addr2 ) ) { reg2 = addr2 ; offset2 = 0 ; } else if ( GET_CODE ( addr2 ) == PLUS && REG_P ( XEXP ( addr2 , 0 ) ) && GET_CODE ( XEXP ( addr2 , 1 ) ) == CONST_INT ) { reg2 = XEXP ( addr2 , 0 ) ; offset2 = INTVAL ( XEXP ( addr2 , 1 ) ) ; } else return 0 ; if ( ( ( reg1 == stack_pointer_rtx && reg2 == stack_pointer_rtx ) || ( reg1 == frame_pointer_rtx && reg2 == frame_pointer_rtx ) ) && offset1 % 2 == 0 && offset1 + 1 == offset2 ) return 1 ; return 0 ; } </s>

Return nonzero if ADDR1 and ADDR2 point to consecutive memory locations that can be accessed as a 16-bit word .


<s> bool SystemZTargetLowering :: isLegalAddressingMode ( const DataLayout & DL , const AddrMode & AM , Type * Ty , unsigned AS , Instruction * I ) const { if ( AM . BaseGV ) return false ; if ( ! isInt < 20 > ( AM . BaseOffs ) ) return false ; AddressingMode SupportedAM ( true , true ) ; if ( I != nullptr ) SupportedAM = supportedAddressingMode ( I , Subtarget . hasVector ( ) ) ; if ( ! SupportedAM . LongDisplacement && ! isUInt < 12 > ( AM . BaseOffs ) ) return false ; if ( ! SupportedAM . IndexReg ) return AM . Scale == 0 ; else return AM . Scale == 0 || AM . Scale == 1 ; } </s>

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


<s> MCObjectWriter * createObjectWriter ( raw_ostream & OS ) const { bool is64 = getPointerSize ( ) == 8 ; return createELFObjectWriter ( new PPCELFObjectWriter ( is64 , OSType , is64 ? ELF :: EM_PPC64 : ELF :: EM_PPC , true , false ) , OS , false ) ; } </s>

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


<s> ~ SystemZXPLINK64Registers ( ) { } </s>

Destroys the object . Bogus destructor overriding base class destructor .


<s> static int avr_regs_to_save ( HARD_REG_SET * set ) { int reg , count ; int int_or_sig_p = ( interrupt_function_p ( current_function_decl ) || signal_function_p ( current_function_decl ) ) ; int leaf_func_p = leaf_function_p ( ) ; if ( set ) CLEAR_HARD_REG_SET ( * set ) ; count = 0 ; if ( TREE_THIS_VOLATILE ( current_function_decl ) ) return 0 ; for ( reg = 0 ; reg < 32 ; reg ++ ) { if ( fixed_regs [ reg ] ) continue ; if ( ( int_or_sig_p && ! leaf_func_p && call_used_regs [ reg ] ) || ( regs_ever_live [ reg ] && ( int_or_sig_p || ! call_used_regs [ reg ] ) && ! ( frame_pointer_needed && ( reg == REG_Y || reg == ( REG_Y + 1 ) ) ) ) ) { if ( set ) SET_HARD_REG_BIT ( * set , reg ) ; count ++ ; } } return count ; } </s>

Return the number of hard registers to push/pop in the prologue/epilogue of the current function , and optionally store these registers in SET .


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

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


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

Return information about object file lowering .


<s> AVRSubtarget :: AVRSubtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const AVRTargetMachine & TM ) : AVRGenSubtargetInfo ( TT , CPU , FS ) , ELFArch ( 0 ) , m_hasSRAM ( false ) , m_hasJMPCALL ( false ) , m_hasIJMPCALL ( false ) , m_hasEIJMPCALL ( false ) , m_hasADDSUBIW ( false ) , m_hasSmallStack ( false ) , m_hasMOVW ( false ) , m_hasLPM ( false ) , m_hasLPMX ( false ) , m_hasELPM ( false ) , m_hasELPMX ( false ) , m_hasSPM ( false ) , m_hasSPMX ( false ) , m_hasDES ( false ) , m_supportsRMW ( false ) , m_supportsMultiplication ( false ) , m_hasBREAK ( false ) , m_hasTinyEncoding ( false ) , m_hasMemMappedGPR ( false ) , m_FeatureSetDummy ( false ) , InstrInfo ( ) , FrameLowering ( ) , TLInfo ( TM , initializeSubtargetDependencies ( CPU , FS , TM ) ) , TSInfo ( ) { ParseSubtargetFeatures ( CPU , FS ) ; } </s>


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

Allocate a new , cleared machine_function structure .


<s> void MipsPassConfig :: addIRPasses ( ) { TargetPassConfig :: addIRPasses ( ) ; addPass ( createAtomicExpandPass ( & getMipsTargetMachine ( ) ) ) ; if ( getMipsSubtarget ( ) . os16 ( ) ) addPass ( createMipsOs16Pass ( getMipsTargetMachine ( ) ) ) ; if ( getMipsSubtarget ( ) . inMips16HardFloat ( ) ) addPass ( createMips16HardFloatPass ( getMipsTargetMachine ( ) ) ) ; } </s>

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

Mips Mips Mips Mips Mips Mips Mips Mips Mips Mips


<s> MachineInstr * SIInstrInfo :: convertToThreeAddress ( MachineFunction :: iterator & MBB , MachineInstr & MI , LiveVariables * LV ) const { bool IsF16 = false ; switch ( MI . getOpcode ( ) ) { default : return nullptr ; case AMDGPU :: V_MAC_F16_e64 : IsF16 = true ; case AMDGPU :: V_MAC_F32_e64 : break ; case AMDGPU :: V_MAC_F16_e32 : IsF16 = true ; case AMDGPU :: V_MAC_F32_e32 : { int Src0Idx = AMDGPU :: getNamedOperandIdx ( MI . getOpcode ( ) , AMDGPU :: OpName :: src0 ) ; const MachineOperand * Src0 = & MI . getOperand ( Src0Idx ) ; if ( Src0 -> isImm ( ) && ! isInlineConstant ( MI , Src0Idx , * Src0 ) ) return nullptr ; break ; } } const MachineOperand * Dst = getNamedOperand ( MI , AMDGPU :: OpName :: vdst ) ; const MachineOperand * Src0 = getNamedOperand ( MI , AMDGPU :: OpName :: src0 ) ; const MachineOperand * Src1 = getNamedOperand ( MI , AMDGPU :: OpName :: src1 ) ; const MachineOperand * Src2 = getNamedOperand ( MI , AMDGPU :: OpName :: src2 ) ; return BuildMI ( * MBB , MI , MI . getDebugLoc ( ) , get ( IsF16 ? AMDGPU :: V_MAD_F16 : AMDGPU :: V_MAD_F32 ) ) . addOperand ( * Dst ) . addImm ( 0 ) . addOperand ( * Src0 ) . addImm ( 0 ) . addOperand ( * Src1 ) . addImm ( 0 ) . addOperand ( * Src2 ) . addImm ( 0 ) . addImm ( 0 ) ; } </s>

convertToThreeAddress - This method must be implemented by targets that set the M_CONVERTIBLE_TO_3_ADDR flag .


<s> static MCSubtargetInfo * createMCSubtargetInfo ( const Triple & TT , StringRef CPU , StringRef FS ) { return createWebAssemblyMCSubtargetInfoImpl ( TT , CPU , FS ) ; } </s>

createMCSubtargetInfo - Create a MCSubtargetInfo implementation .


"cannot specify both -msep-data and -mid-shared-library"

"-fPIC is not currently supported on the 68000 or 68010"

Set global variables as needed for the options enabled .


<s> bool LoongArchAsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count , const MCSubtargetInfo * STI ) const { if ( Count % 4 != 0 ) return false ; for ( ; Count >= 4 ; Count -= 4 ) support :: endian :: write < uint32_t > ( OS , 0x03400000 , support :: little ) ; return true ; } </s>

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


<s> MachineInstr * SIInstrInfo :: convertToThreeAddress ( MachineFunction :: iterator & MBB , MachineInstr & MI , LiveVariables * LV ) const { bool IsF16 = false ; switch ( MI . getOpcode ( ) ) { default : return nullptr ; case AMDGPU :: V_MAC_F16_e64 : IsF16 = true ; case AMDGPU :: V_MAC_F32_e64 : break ; case AMDGPU :: V_MAC_F16_e32 : IsF16 = true ; case AMDGPU :: V_MAC_F32_e32 : { int Src0Idx = AMDGPU :: getNamedOperandIdx ( MI . getOpcode ( ) , AMDGPU :: OpName :: src0 ) ; const MachineOperand * Src0 = & MI . getOperand ( Src0Idx ) ; if ( Src0 -> isImm ( ) && ! isInlineConstant ( MI , Src0Idx , * Src0 ) ) return nullptr ; break ; } } const MachineOperand * Dst = getNamedOperand ( MI , AMDGPU :: OpName :: vdst ) ; const MachineOperand * Src0 = getNamedOperand ( MI , AMDGPU :: OpName :: src0 ) ; const MachineOperand * Src0Mods = getNamedOperand ( MI , AMDGPU :: OpName :: src0_modifiers ) ; const MachineOperand * Src1 = getNamedOperand ( MI , AMDGPU :: OpName :: src1 ) ; const MachineOperand * Src1Mods = getNamedOperand ( MI , AMDGPU :: OpName :: src1_modifiers ) ; const MachineOperand * Src2 = getNamedOperand ( MI , AMDGPU :: OpName :: src2 ) ; const MachineOperand * Clamp = getNamedOperand ( MI , AMDGPU :: OpName :: clamp ) ; const MachineOperand * Omod = getNamedOperand ( MI , AMDGPU :: OpName :: omod ) ; return BuildMI ( * MBB , MI , MI . getDebugLoc ( ) , get ( IsF16 ? AMDGPU :: V_MAD_F16 : AMDGPU :: V_MAD_F32 ) ) . add ( * Dst ) . addImm ( Src0Mods ? Src0Mods -> getImm ( ) : 0 ) . add ( * Src0 ) . addImm ( Src1Mods ? Src1Mods -> getImm ( ) : 0 ) . add ( * Src1 ) . addImm ( 0 ) . add ( * Src2 ) . addImm ( Clamp ? Clamp -> getImm ( ) : 0 ) . addImm ( Omod ? Omod -> getImm ( ) : 0 ) ; } </s>


<s> void aarch64_expand_epilogue ( bool for_sibcall ) { aarch64_layout_frame ( ) ; HOST_WIDE_INT initial_adjust = cfun -> machine -> frame . initial_adjust ; HOST_WIDE_INT callee_adjust = cfun -> machine -> frame . callee_adjust ; HOST_WIDE_INT final_adjust = cfun -> machine -> frame . final_adjust ; HOST_WIDE_INT callee_offset = cfun -> machine -> frame . callee_offset ; unsigned reg1 = cfun -> machine -> frame . wb_candidate1 ; unsigned reg2 = cfun -> machine -> frame . wb_candidate2 ; rtx cfi_ops = NULL ; rtx_insn * insn ; bool need_barrier_p = ( get_frame_size ( ) + cfun -> machine -> frame . saved_varargs_size ) != 0 ; if ( final_adjust > crtl -> outgoing_args_size || cfun -> calls_alloca || crtl -> calls_eh_return ) { emit_insn ( gen_stack_tie ( stack_pointer_rtx , stack_pointer_rtx ) ) ; need_barrier_p = false ; } if ( frame_pointer_needed && ( final_adjust || cfun -> calls_alloca ) ) { insn = emit_insn ( gen_add3_insn ( stack_pointer_rtx , hard_frame_pointer_rtx , GEN_INT ( - callee_offset ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = callee_adjust == 0 ; } else aarch64_add_sp ( IP1_REGNUM , final_adjust , df_regs_ever_live_p ( IP1_REGNUM ) ) ; aarch64_restore_callee_saves ( DImode , callee_offset , R0_REGNUM , R30_REGNUM , callee_adjust != 0 , & cfi_ops ) ; aarch64_restore_callee_saves ( DFmode , callee_offset , V0_REGNUM , V31_REGNUM , callee_adjust != 0 , & cfi_ops ) ; if ( need_barrier_p ) emit_insn ( gen_stack_tie ( stack_pointer_rtx , stack_pointer_rtx ) ) ; if ( callee_adjust != 0 ) aarch64_pop_regs ( reg1 , reg2 , callee_adjust , & cfi_ops ) ; if ( callee_adjust != 0 || initial_adjust > 65536 ) { insn = get_last_insn ( ) ; rtx new_cfa = plus_constant ( Pmode , stack_pointer_rtx , initial_adjust ) ; REG_NOTES ( insn ) = alloc_reg_note ( REG_CFA_DEF_CFA , new_cfa , cfi_ops ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; cfi_ops = NULL ; } aarch64_add_sp ( IP0_REGNUM , initial_adjust , df_regs_ever_live_p ( IP0_REGNUM ) ) ; if ( cfi_ops ) { insn = get_last_insn ( ) ; cfi_ops = alloc_reg_note ( REG_CFA_DEF_CFA , stack_pointer_rtx , cfi_ops ) ; REG_NOTES ( insn ) = cfi_ops ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } if ( aarch64_return_address_signing_enabled ( ) && ( for_sibcall || ! TARGET_ARMV8_3 || crtl -> calls_eh_return ) ) { insn = emit_insn ( gen_autisp ( ) ) ; add_reg_note ( insn , REG_CFA_TOGGLE_RA_MANGLE , const0_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } if ( crtl -> calls_eh_return ) { emit_insn ( gen_add2_insn ( stack_pointer_rtx , EH_RETURN_STACKADJ_RTX ) ) ; } emit_use ( gen_rtx_REG ( DImode , LR_REGNUM ) ) ; if ( ! for_sibcall ) emit_jump_insn ( ret_rtx ) ; } </s>

Generate the epilogue instructions for returning from a function .


Invoke the PassBuilder callback registration .


<s> bool SystemZTargetLowering :: findOptimalMemOpLowering ( std :: vector < EVT > & MemOps , unsigned Limit , const MemOp & Op , unsigned DstAS , unsigned SrcAS , const AttributeList & FuncAttributes ) const { const int MVCFastLen = 16 ; if ( Op . isMemcpy ( ) && Op . allowOverlap ( ) && Op . size ( ) <= MVCFastLen ) return false ; if ( Op . isMemset ( ) && Op . size ( ) - 1 <= MVCFastLen ) return false ; if ( Op . isZeroMemset ( ) ) return false ; return TargetLowering :: findOptimalMemOpLowering ( MemOps , Limit , Op , DstAS , SrcAS , FuncAttributes ) ; } </s>

Determines the optimal series of memory ops to replace the memset / memcpy .


<s> bool ARMBaseInstrInfo :: isProfitableToUnpredicate ( MachineBasicBlock & TMBB , MachineBasicBlock & FMBB ) const { return Subtarget . isSwift ( ) ; } </s>

Return true if it 's profitable to unpredicate one side of a 'diamond ' , i.e .


<s>
const
char
*
getPassName
(
)
const
override
{
return
"Hexagon Hardware Loops"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s>
unsigned
LoongArchMCCodeEmitter
::
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!"
)
;
}
</s>

getMachineOpValue - Return binary encoding of operand .

LoongArch
LoongArch
"Unhandled expression!"


<s> void expand_fusion_p9_store ( rtx * operands ) { rtx tmp_reg = operands [ 0 ] ; rtx addis_value = operands [ 1 ] ; rtx orig_mem = operands [ 2 ] ; rtx src = operands [ 3 ] ; rtx new_addr , new_mem , orig_addr , offset , set , clobber , insn , new_src ; enum rtx_code plus_or_lo_sum ; machine_mode target_mode = GET_MODE ( orig_mem ) ; machine_mode ptr_mode = Pmode ; gcc_assert ( MEM_P ( orig_mem ) ) ; orig_addr = XEXP ( orig_mem , 0 ) ; plus_or_lo_sum = GET_CODE ( orig_addr ) ; gcc_assert ( plus_or_lo_sum == PLUS || plus_or_lo_sum == LO_SUM ) ; offset = XEXP ( orig_addr , 1 ) ; new_addr = gen_rtx_fmt_ee ( plus_or_lo_sum , ptr_mode , addis_value , offset ) ; new_mem = replace_equiv_address_nv ( orig_mem , new_addr , false ) ; new_src = gen_rtx_UNSPEC ( target_mode , gen_rtvec ( 1 , src ) , UNSPEC_FUSION_P9 ) ; set = gen_rtx_SET ( new_mem , new_src ) ; clobber = gen_rtx_CLOBBER ( VOIDmode , tmp_reg ) ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , set , clobber ) ) ; emit_insn ( insn ) ; return ; } </s>

During the peephole2 pass , adjust and expand the insns for an extended fusion store sequence . The operands are : operands [ 0 ] register set with addis operands [ 1 ] value set via addis operands [ 2 ] target D-form memory being stored to operands [ 3 ] register being stored This is similar to the fusion introduced with power8 , except it scales to both loads/stores and does not require the result register to be the same as the base register . At the moment , we only do this if register set with addis is dead .


"{comclr|cmpclr},%B2 %%r0,%1,%%r0\n\tb %3\n\tmtsar %r1"

Return the output template for emitting a dbra type insn . Note it may perform some output operations on its own before returning the final output string .


<s> void mmix_init_expanders ( ) { init_machine_status = mmix_init_machine_status ; } </s>


<s> void AMDGPUPreLegalizerCombiner :: getAnalysisUsage ( AnalysisUsage & AU ) const { AU . addRequired < TargetPassConfig > ( ) ; AU . setPreservesCFG ( ) ; getSelectionDAGFallbackAnalysisUsage ( AU ) ; AU . addRequired < GISelKnownBitsAnalysis > ( ) ; AU . addPreserved < GISelKnownBitsAnalysis > ( ) ; if ( ! IsOptNone ) { AU . addRequired < MachineDominatorTree > ( ) ; AU . addPreserved < MachineDominatorTree > ( ) ; } MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


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

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


<s> static bool mep_store_data_bypass_1 ( rtx_insn * prev , rtx pat ) { if ( GET_CODE ( pat ) == PARALLEL ) { int i ; for ( i = 0 ; i < XVECLEN ( pat , 0 ) ; i ++ ) if ( mep_store_data_bypass_p ( prev , as_a < rtx_insn * > ( XVECEXP ( pat , 0 , i ) ) ) ) return true ; return false ; } if ( GET_CODE ( pat ) != SET || GET_CODE ( SET_DEST ( pat ) ) != MEM ) return false ; if ( GET_CODE ( SET_SRC ( pat ) ) == UNSPEC ) { rtx src ; int i ; src = SET_SRC ( pat ) ; for ( i = 1 ; i < XVECLEN ( src , 0 ) ; i ++ ) if ( mep_store_find_set ( XVECEXP ( src , 0 , i ) , prev ) ) return false ; return true ; } return ! mep_store_find_set ( SET_DEST ( pat ) , prev ) ; } </s>

Like mep_store_bypass_p , but takes a pattern as the second argument , not the containing insn .


<s> static bool isF128SoftLibCall ( const char * CallSym ) { const char * const LibCalls [ ] = { "__addtf3" , "__divtf3" , "__eqtf2" , "__extenddftf2" , "__extendsftf2" , "__fixtfdi" , "__fixtfsi" , "__fixtfti" , "__fixunstfdi" , "__fixunstfsi" , "__fixunstfti" , "__floatditf" , "__floatsitf" , "__floattitf" , "__floatunditf" , "__floatunsitf" , "__floatuntitf" , "__getf2" , "__gttf2" , "__letf2" , "__lttf2" , "__multf3" , "__netf2" , "__powitf2" , "__subtf3" , "__trunctfdf2" , "__trunctfsf2" , "__unordtf2" , "ceill" , "copysignl" , "cosl" , "exp2l" , "expl" , "floorl" , "fmal" , "fmodl" , "log10l" , "log2l" , "logl" , "nearbyintl" , "powl" , "rintl" , "sinl" , "sqrtl" , "truncl" } ; const char * const * End = LibCalls + array_lengthof ( LibCalls ) ; MipsTargetLowering :: LTStr Comp ; for ( const char * const * I = LibCalls ; I < End - 1 ; ++ I ) assert ( Comp ( * I , * ( I + 1 ) ) ) ; return std :: binary_search ( LibCalls , End , CallSym , Comp ) ; } </s>

This function returns true if CallSym is a long double emulation routine .


<s> void MipsCallLowering :: splitToValueTypes ( const DataLayout & DL , const ArgInfo & OrigArg , unsigned OriginalIndex , SmallVectorImpl < ArgInfo > & SplitArgs , SmallVectorImpl < unsigned > & SplitArgsOrigIndices ) const { SmallVector < EVT , 4 > SplitEVTs ; SmallVector < Register , 4 > SplitVRegs ; const MipsTargetLowering & TLI = * getTLI < MipsTargetLowering > ( ) ; LLVMContext & Ctx = OrigArg . Ty -> getContext ( ) ; ComputeValueVTs ( TLI , DL , OrigArg . Ty , SplitEVTs ) ; for ( unsigned i = 0 ; i < SplitEVTs . size ( ) ; ++ i ) { ArgInfo Info = ArgInfo { OrigArg . Regs [ i ] , SplitEVTs [ i ] . getTypeForEVT ( Ctx ) } ; Info . Flags = OrigArg . Flags ; SplitArgs . push_back ( Info ) ; SplitArgsOrigIndices . push_back ( OriginalIndex ) ; } } </s>

Break OrigArgInfo into one or more pieces the calling convention can process , returned in SplitArgs .


<s>
void
ARMTTIImpl
::
getUnrollingPreferences
(
Loop
*
L
,
ScalarEvolution
&
SE
,
TTI
::
UnrollingPreferences
&
UP
)
{
if
(
!
ST
->
isMClass
(
)
)
return
BasicTTIImplBase
::
getUnrollingPreferences
(
L
,
SE
,
UP
)
;
UP
.
OptSizeThreshold
=
0
;
UP
.
PartialOptSizeThreshold
=
0
;
if
(
L
->
getHeader
(
)
->
getParent
(
)
->
hasOptSize
(
)
)
return
;
if
(
!
ST
->
isThumb2
(
)
)
return
;
SmallVector
<
BasicBlock
*
,
4
>
ExitingBlocks
;
L
->
getExitingBlocks
(
ExitingBlocks
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"Loop has:\n"
<<
"Blocks: "
<<
L
->
getNumBlocks
(
)
<<
"\n"
<<
"Exit blocks: "
<<
ExitingBlocks
.
size
(
)
<<
"\n"
)
;
if
(
ExitingBlocks
.
size
(
)
>
2
)
return
;
if
(
ST
->
hasBranchPredictor
(
)
&&
L
->
getNumBlocks
(
)
>
4
)
return
;
if
(
getBooleanLoopAttribute
(
L
,
"llvm.loop.isvectorized"
)
)
return
;
unsigned
Cost
=
0
;
for
(
auto
*
BB
:
L
->
getBlocks
(
)
)
{
for
(
auto
&
I
:
*
BB
)
{
if
(
I
.
getType
(
)
->
isVectorTy
(
)
)
return
;
if
(
isa
<
CallInst
>
(
I
)
||
isa
<
InvokeInst
>
(
I
)
)
{
if
(
const
Function
*
F
=
cast
<
CallBase
>
(
I
)
.
getCalledFunction
(
)
)
{
if
(
!
isLoweredToCall
(
F
)
)
continue
;
}
return
;
}
SmallVector
<
const
Value
*
,
4
>
Operands
(
I
.
operand_values
(
)
)
;
Cost
+=
getUserCost
(
&
I
,
Operands
,
TargetTransformInfo
::
TCK_SizeAndLatency
)
;
}
}
LLVM_DEBUG
(
dbgs
(
)
<<
"Cost of loop: "
<<
Cost
<<
"\n"
)
;
UP
.
Partial
=
true
;
UP
.
Runtime
=
true
;
UP
.
UpperBound
=
true
;
UP
.
UnrollRemainder
=
true
;
UP
.
DefaultUnrollRuntimeCount
=
4
;
UP
.
UnrollAndJam
=
true
;
UP
.
UnrollAndJamInnerLoopThreshold
=
60
;
if
(
Cost
<
12
)
UP
.
Force
=
true
;
}
</s>

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


<s> bool X86FrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , MutableArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; if ( MI != MBB . end ( ) && isFuncletReturnInstr ( * MI ) && STI . isOSWindows ( ) ) { if ( STI . is32Bit ( ) ) return true ; if ( MI -> getOpcode ( ) == X86 :: CATCHRET ) { const Function & F = MBB . getParent ( ) -> getFunction ( ) ; bool IsSEH = isAsynchronousEHPersonality ( classifyEHPersonality ( F . getPersonalityFn ( ) ) ) ; if ( IsSEH ) return true ; } } DebugLoc DL = MBB . findDebugLoc ( MI ) ; for ( const CalleeSavedInfo & I : CSI ) { unsigned Reg = I . getReg ( ) ; if ( X86 :: GR64RegClass . contains ( Reg ) || X86 :: GR32RegClass . contains ( Reg ) ) continue ; MVT VT = MVT :: Other ; if ( X86 :: VK16RegClass . contains ( Reg ) ) VT = STI . hasBWI ( ) ? MVT :: v64i1 : MVT :: v16i1 ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg , VT ) ; TII . loadRegFromStackSlot ( MBB , MI , Reg , I . getFrameIdx ( ) , RC , TRI ) ; } unsigned Opc = STI . is64Bit ( ) ? X86 :: POP64r : X86 :: POP32r ; for ( const CalleeSavedInfo & I : CSI ) { unsigned Reg = I . getReg ( ) ; if ( ! X86 :: GR64RegClass . contains ( Reg ) && ! X86 :: GR32RegClass . contains ( Reg ) ) continue ; BuildMI ( MBB , MI , DL , TII . get ( Opc ) , Reg ) . setMIFlag ( MachineInstr :: FrameDestroy ) ; } return true ; } </s>

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


<s>
static
void
aarch64_print_hint_for_core_or_arch
(
const
char
*
str
,
bool
arch
)
{
auto_vec
<
const
char
*
>
candidates
;
const
struct
processor
*
entry
=
arch
all_architectures
:
all_cores
;
for
(
;
entry
->
name
!=
;
entry
++
)
candidates
.
safe_push
(
entry
->
name
)
;
if
(
arch
)
candidates
.
safe_push
(
"native"
)
;
char
*
s
;
const
char
*
hint
=
candidates_list_and_hint
(
str
,
s
,
candidates
)
;
if
(
hint
)
inform
(
input_location
,
"valid arguments are: %s;"
" did you mean %qs?"
,
s
,
hint
)
;
else
inform
(
input_location
,
"valid arguments are: %s"
,
s
)
;
XDELETEVEC
(
s
)
;
}
</s>

Print a hint with a suggestion for a core or architecture name that most closely resembles what the user passed in STR . ARCH is true if the user is asking for an architecture name . ARCH is false if the user is asking for a core name .

aarch64
"native"
"valid arguments are: %s;"
" did you mean %qs?"
"valid arguments are: %s"


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

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

mproc
mproc
"Unknown target flag on GV operand"
0


<s> void NVPTXPassConfig :: addIRPasses ( ) { disablePass ( & PrologEpilogCodeInserterID ) ; disablePass ( & MachineCopyPropagationID ) ; disablePass ( & TailDuplicateID ) ; disablePass ( & StackMapLivenessID ) ; disablePass ( & LiveDebugValuesID ) ; disablePass ( & PostRAMachineSinkingID ) ; disablePass ( & PostRASchedulerID ) ; disablePass ( & FuncletLayoutID ) ; disablePass ( & PatchableFunctionID ) ; disablePass ( & ShrinkWrapID ) ; const NVPTXSubtarget & ST = * getTM < NVPTXTargetMachine > ( ) . getSubtargetImpl ( ) ; addPass ( createNVVMReflectPass ( ST . getSmVersion ( ) ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createNVPTXImageOptimizerPass ( ) ) ; addPass ( createNVPTXAssignValidGlobalNamesPass ( ) ) ; addPass ( createGenericToNVVMPass ( ) ) ; addPass ( createNVPTXLowerArgsPass ( & getNVPTXTargetMachine ( ) ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addAddressSpaceInferencePasses ( ) ; addStraightLineScalarOptimizationPasses ( ) ; } TargetPassConfig :: addIRPasses ( ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addEarlyCSEOrGVNPass ( ) ; if ( ! DisableLoadStoreVectorizer ) addPass ( createLoadStoreVectorizerPass ( ) ) ; } } </s>

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

NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX


<s> static rtx zero_all_vector_registers ( HARD_REG_SET need_zeroed_hardregs ) { if ( ! TARGET_AVX ) return NULL ; for ( unsigned int regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ( LEGACY_SSE_REGNO_P ( regno ) || ( TARGET_64BIT && ( REX_SSE_REGNO_P ( regno ) || ( TARGET_AVX512F && EXT_REX_SSE_REGNO_P ( regno ) ) ) ) ) && ! TEST_HARD_REG_BIT ( need_zeroed_hardregs , regno ) ) return NULL ; return gen_avx_vzeroall ( ) ; } </s>

Generate a rtx to zero all vector registers together if possible , otherwise , return NULL .


<s>
const
MCPhysReg
*
X86RegisterInfo
::
getCalleeSavedRegs
(
const
MachineFunction
*
MF
)
const
{
assert
(
MF
&&
"MachineFunction required"
)
;
const
X86Subtarget
&
Subtarget
=
MF
->
getSubtarget
<
X86Subtarget
>
(
)
;
bool
HasSSE
=
Subtarget
.
hasSSE1
(
)
;
bool
HasAVX
=
Subtarget
.
hasAVX
(
)
;
bool
HasAVX512
=
Subtarget
.
hasAVX512
(
)
;
bool
CallsEHReturn
=
MF
->
callsEHReturn
(
)
;
switch
(
MF
->
getFunction
(
)
->
getCallingConv
(
)
)
{
case
CallingConv
::
GHC
:
case
CallingConv
::
HiPE
:
return
CSR_NoRegs_SaveList
;
case
CallingConv
::
AnyReg
:
if
(
HasAVX
)
return
CSR_64_AllRegs_AVX_SaveList
;
return
CSR_64_AllRegs_SaveList
;
case
CallingConv
::
PreserveMost
:
return
CSR_64_RT_MostRegs_SaveList
;
case
CallingConv
::
PreserveAll
:
if
(
HasAVX
)
return
CSR_64_RT_AllRegs_AVX_SaveList
;
return
CSR_64_RT_AllRegs_SaveList
;
case
CallingConv
::
CXX_FAST_TLS
:
if
(
Is64Bit
)
return
MF
->
getInfo
<
X86MachineFunctionInfo
>
(
)
->
isSplitCSR
(
)
CSR_64_CXX_TLS_Darwin_PE_SaveList
:
CSR_64_TLS_Darwin_SaveList
;
break
;
case
CallingConv
::
Intel_OCL_BI
:
{
if
(
HasAVX512
&&
IsWin64
)
return
CSR_Win64_Intel_OCL_BI_AVX512_SaveList
;
if
(
HasAVX512
&&
Is64Bit
)
return
CSR_64_Intel_OCL_BI_AVX512_SaveList
;
if
(
HasAVX
&&
IsWin64
)
return
CSR_Win64_Intel_OCL_BI_AVX_SaveList
;
if
(
HasAVX
&&
Is64Bit
)
return
CSR_64_Intel_OCL_BI_AVX_SaveList
;
if
(
!
HasAVX
&&
!
IsWin64
&&
Is64Bit
)
return
CSR_64_Intel_OCL_BI_SaveList
;
break
;
}
case
CallingConv
::
HHVM
:
return
CSR_64_HHVM_SaveList
;
case
CallingConv
::
X86_RegCall
:
if
(
Is64Bit
)
{
if
(
IsWin64
)
{
return
(
HasSSE
CSR_Win64_RegCall_SaveList
:
CSR_Win64_RegCall_NoSSE_SaveList
)
;
}
else
{
return
(
HasSSE
CSR_SysV64_RegCall_SaveList
:
CSR_SysV64_RegCall_NoSSE_SaveList
)
;
}
}
else
{
return
(
HasSSE
CSR_32_RegCall_SaveList
:
CSR_32_RegCall_NoSSE_SaveList
)
;
}
case
CallingConv
::
Cold
:
if
(
Is64Bit
)
return
CSR_64_MostRegs_SaveList
;
break
;
case
CallingConv
::
X86_64_Win64
:
if
(
!
HasSSE
)
return
CSR_Win64_NoSSE_SaveList
;
return
CSR_Win64_SaveList
;
case
CallingConv
::
X86_64_SysV
:
if
(
CallsEHReturn
)
return
CSR_64EHRet_SaveList
;
return
CSR_64_SaveList
;
case
CallingConv
::
X86_INTR
:
if
(
Is64Bit
)
{
if
(
HasAVX512
)
return
CSR_64_AllRegs_AVX512_SaveList
;
if
(
HasAVX
)
return
CSR_64_AllRegs_AVX_SaveList
;
if
(
HasSSE
)
return
CSR_64_AllRegs_SaveList
;
return
CSR_64_AllRegs_NoSSE_SaveList
;
}
else
{
if
(
HasAVX512
)
return
CSR_32_AllRegs_AVX512_SaveList
;
if
(
HasAVX
)
return
CSR_32_AllRegs_AVX_SaveList
;
if
(
HasSSE
)
return
CSR_32_AllRegs_SSE_SaveList
;
return
CSR_32_AllRegs_SaveList
;
}
default
:
break
;
}
if
(
Is64Bit
)
{
if
(
IsWin64
)
{
if
(
!
HasSSE
)
return
CSR_Win64_NoSSE_SaveList
;
return
CSR_Win64_SaveList
;
}
if
(
CallsEHReturn
)
return
CSR_64EHRet_SaveList
;
if
(
Subtarget
.
getTargetLowering
(
)
->
supportSwiftError
(
)
&&
MF
->
getFunction
(
)
->
getAttributes
(
)
.
hasAttrSomewhere
(
Attribute
::
SwiftError
)
)
return
CSR_64_SwiftError_SaveList
;
return
CSR_64_SaveList
;
}
if
(
CallsEHReturn
)
return
CSR_32EHRet_SaveList
;
return
CSR_32_SaveList
;
}
</s>


<s> bool RISCVTargetLowering :: isZExtFree ( SDValue Val , EVT VT2 ) const { if ( auto * LD = dyn_cast < LoadSDNode > ( Val ) ) { EVT MemVT = LD -> getMemoryVT ( ) ; if ( ( MemVT == MVT :: i8 || MemVT == MVT :: i16 || ( Subtarget . is64Bit ( ) && MemVT == MVT :: i32 ) ) && ( LD -> getExtensionType ( ) == ISD :: NON_EXTLOAD || LD -> getExtensionType ( ) == ISD :: ZEXTLOAD ) ) return true ; } return TargetLowering :: isZExtFree ( Val , VT2 ) ; } </s>

Return true if zero-extending the specific node Val to type VT2 is free ( either because it 's implicitly zero-extended such as ARM ldrb / ldrh or because it 's folded such as X86 zero-extending loads ) .


<s> static bool ix86_vector_mode_supported_p ( machine_mode mode ) { if ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) return true ; if ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) return true ; if ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) return true ; if ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) return true ; if ( TARGET_MMX && VALID_MMX_REG_MODE ( mode ) ) return true ; if ( TARGET_3DNOW && VALID_MMX_REG_MODE_3DNOW ( mode ) ) return true ; return false ; } </s>

Implements target hook vector_mode_supported_p .


<s> static rtx gen_rx_store_vector ( unsigned int low , unsigned int high ) { unsigned int i ; unsigned int count = ( high - low ) + 2 ; rtx vector ; vector = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count ) ) ; XVECEXP ( vector , 0 , 0 ) = gen_rtx_SET ( stack_pointer_rtx , gen_rtx_MINUS ( SImode , stack_pointer_rtx , GEN_INT ( ( count - 1 ) * UNITS_PER_WORD ) ) ) ; for ( i = 0 ; i < count - 1 ; i ++ ) XVECEXP ( vector , 0 , i + 1 ) = gen_rtx_SET ( gen_rtx_MEM ( SImode , gen_rtx_MINUS ( SImode , stack_pointer_rtx , GEN_INT ( ( i + 1 ) * UNITS_PER_WORD ) ) ) , gen_rtx_REG ( SImode , high - i ) ) ; return vector ; } </s>

Generate a PARALLEL that will pass the rx_store_multiple_vector predicate .


<s> bool PPCPassConfig :: addPreISel ( ) { if ( ! DisablePreIncPrep && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCLoopPreIncPrepPass ( getPPCTargetMachine ( ) ) ) ; if ( ! DisableCTRLoops && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createHardwareLoopsPass ( ) ) ; return false ; } </s>


<s> bool shouldConvertConstantLoadToIntImm ( const APInt & Imm , Type * Ty ) const override { return true ; } </s>

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


<s> bool ThumbRegisterInfo :: saveScavengerRegister ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , MachineBasicBlock :: iterator & UseMI , const TargetRegisterClass * RC , unsigned Reg ) const { const ARMSubtarget & STI = MBB . getParent ( ) -> getSubtarget < ARMSubtarget > ( ) ; if ( ! STI . isThumb1Only ( ) ) return ARMBaseRegisterInfo :: saveScavengerRegister ( MBB , I , UseMI , RC , Reg ) ; const TargetInstrInfo & TII = * STI . getInstrInfo ( ) ; DebugLoc DL ; BuildMI ( MBB , I , DL , TII . get ( ARM :: tMOVr ) ) . addReg ( ARM :: R12 , RegState :: Define ) . addReg ( Reg , RegState :: Kill ) . add ( predOps ( ARMCC :: AL ) ) ; bool done = false ; for ( MachineBasicBlock :: iterator II = I ; ! done && II != UseMI ; ++ II ) { if ( II -> isDebugInstr ( ) ) continue ; for ( unsigned i = 0 , e = II -> getNumOperands ( ) ; i != e ; ++ i ) { const MachineOperand & MO = II -> getOperand ( i ) ; if ( MO . isRegMask ( ) && MO . clobbersPhysReg ( ARM :: R12 ) ) { UseMI = II ; done = true ; break ; } if ( ! MO . isReg ( ) || MO . isUndef ( ) || ! MO . getReg ( ) || TargetRegisterInfo :: isVirtualRegister ( MO . getReg ( ) ) ) continue ; if ( MO . getReg ( ) == ARM :: R12 ) { UseMI = II ; done = true ; break ; } } } BuildMI ( MBB , UseMI , DL , TII . get ( ARM :: tMOVr ) ) . addReg ( Reg , RegState :: Define ) . addReg ( ARM :: R12 , RegState :: Kill ) . add ( predOps ( ARMCC :: AL ) ) ; return true ; } </s>

Spill the register so it can be used by the register scavenger .


<s> void xstormy16_expand_arith ( machine_mode mode , enum rtx_code code , rtx dest , rtx src0 , rtx src1 ) { int num_words = GET_MODE_BITSIZE ( mode ) / BITS_PER_WORD ; int i ; int firstloop = 1 ; if ( code == NEG ) emit_move_insn ( src0 , const0_rtx ) ; for ( i = 0 ; i < num_words ; i ++ ) { rtx w_src0 , w_src1 , w_dest ; rtx insn ; w_src0 = simplify_gen_subreg ( word_mode , src0 , mode , i * UNITS_PER_WORD ) ; w_src1 = simplify_gen_subreg ( word_mode , src1 , mode , i * UNITS_PER_WORD ) ; w_dest = simplify_gen_subreg ( word_mode , dest , mode , i * UNITS_PER_WORD ) ; switch ( code ) { case PLUS : if ( firstloop && CONST_INT_P ( w_src1 ) && INTVAL ( w_src1 ) == 0 ) continue ; if ( firstloop ) insn = gen_addchi4 ( w_dest , w_src0 , w_src1 ) ; else insn = gen_addchi5 ( w_dest , w_src0 , w_src1 ) ; break ; case NEG : case MINUS : case COMPARE : if ( code == COMPARE && i == num_words - 1 ) { rtx branch , sub , clobber , sub_1 ; sub_1 = gen_rtx_MINUS ( HImode , w_src0 , gen_rtx_ZERO_EXTEND ( HImode , gen_rtx_REG ( BImode , CARRY_REGNUM ) ) ) ; sub = gen_rtx_SET ( w_dest , gen_rtx_MINUS ( HImode , sub_1 , w_src1 ) ) ; clobber = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( BImode , CARRY_REGNUM ) ) ; branch = gen_rtx_SET ( pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_EQ ( HImode , sub_1 , w_src1 ) , pc_rtx , pc_rtx ) ) ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 3 , branch , sub , clobber ) ) ; } else if ( firstloop && code != COMPARE && CONST_INT_P ( w_src1 ) && INTVAL ( w_src1 ) == 0 ) continue ; else if ( firstloop ) insn = gen_subchi4 ( w_dest , w_src0 , w_src1 ) ; else insn = gen_subchi5 ( w_dest , w_src0 , w_src1 ) ; break ; case IOR : case XOR : case AND : if ( CONST_INT_P ( w_src1 ) && INTVAL ( w_src1 ) == - ( code == AND ) ) continue ; insn = gen_rtx_SET ( w_dest , gen_rtx_fmt_ee ( code , mode , w_src0 , w_src1 ) ) ; break ; case NOT : insn = gen_rtx_SET ( w_dest , gen_rtx_NOT ( mode , w_src0 ) ) ; break ; default : gcc_unreachable ( ) ; } firstloop = 0 ; emit ( insn ) ; } if ( firstloop ) emit ( gen_nop ( ) ) ; } </s>

Expander for arithmetic operations ; emit insns to compute ( set DEST ( CODE : MODE SRC0 SRC1 ) ) using CARRY as a temporary . When CODE is COMPARE , a branch template is generated ( this saves duplicating code in xstormy16_split_cbranch ) .


<s> InstructionCost PPCTTIImpl :: getIntrinsicInstrCost ( const IntrinsicCostAttributes & ICA , TTI :: TargetCostKind CostKind ) { return BaseT :: getIntrinsicInstrCost ( ICA , CostKind ) ; } </s>


<s> unsigned XCoreInstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { int Opcode = MI -> getOpcode ( ) ; if ( Opcode == XCore :: STWFI ) { if ( ( MI -> getOperand ( 1 ) . isFI ( ) ) && ( MI -> getOperand ( 2 ) . isImm ( ) ) && ( isZeroImm ( MI -> getOperand ( 2 ) ) ) ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

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


<s> void loongarch_emit_binary ( enum rtx_code code , rtx target , rtx op0 , rtx op1 ) { emit_insn ( gen_rtx_SET ( target , gen_rtx_fmt_ee ( code , GET_MODE ( target ) , op0 , op1 ) ) ) ; } </s>

Emit an instruction of the form ( set TARGET ( CODE OP0 OP1 ) ) .


"Not all fixup kinds added to Infos array"


"insertBranch must not be told to insert a fallthrough"

"VE branch conditions should have three component!"

"Unconditional branch with multiple successors!"

Insert branch code into the end of the specified MachineBasicBlock .


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


<s> bool MipsAsmParser :: ParseDirective ( AsmToken DirectiveID ) { if ( DirectiveID . getString ( ) == ".ent" ) { Parser . Lex ( ) ; return false ; } if ( DirectiveID . getString ( ) == ".end" ) { Parser . Lex ( ) ; return false ; } if ( DirectiveID . getString ( ) == ".frame" ) { Parser . EatToEndOfStatement ( ) ; return false ; } if ( DirectiveID . getString ( ) == ".set" ) { Parser . EatToEndOfStatement ( ) ; return false ; } if ( DirectiveID . getString ( ) == ".fmask" ) { Parser . EatToEndOfStatement ( ) ; return false ; } if ( DirectiveID . getString ( ) == ".mask" ) { Parser . EatToEndOfStatement ( ) ; return false ; } if ( DirectiveID . getString ( ) == ".gpword" ) { Parser . EatToEndOfStatement ( ) ; return false ; } return true ; } </s>

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


"64-bit code requested on a subtarget that doesn't support it!"

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


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"AMDGPU Promote Alloca"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool loongarch_12bit_offset_address_p ( rtx x , machine_mode mode ) { struct loongarch_address_info addr ; return ( loongarch_classify_address ( & addr , x , mode , false ) && ( ( addr . type == ADDRESS_REG && CONST_INT_P ( addr . offset ) && LARCH_12BIT_OFFSET_P ( INTVAL ( addr . offset ) ) ) || addr . type == ADDRESS_LO_SUM ) ) ; } </s>

Return true if X is a legitimate address with a 12-bit offset or addr.type is ADDRESS_LO_SUM . MODE is the mode of the value being accessed .


<s> static bool must_save_p ( bool is_inthandler , unsigned regno ) { if ( D_REGNO_P ( regno ) ) { bool is_eh_return_reg = false ; if ( crtl -> calls_eh_return ) { unsigned j ; for ( j = 0 ; ; j ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( j ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) is_eh_return_reg = true ; } } return ( is_eh_return_reg || ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ( is_inthandler || ! call_used_regs [ regno ] ) ) ) ; } else if ( P_REGNO_P ( regno ) ) { return ( ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ( is_inthandler || ! call_used_regs [ regno ] ) ) || ( is_inthandler && ( ENABLE_WA_05000283 || ENABLE_WA_05000315 ) && regno == REG_P5 ) || ( ! TARGET_FDPIC && regno == PIC_OFFSET_TABLE_REGNUM && ( crtl -> uses_pic_offset_table || ( TARGET_ID_SHARED_LIBRARY && ! crtl -> is_leaf ) ) ) ) ; } else return ( ( is_inthandler || ! call_used_regs [ regno ] ) && ( df_regs_ever_live_p ( regno ) || ( ! leaf_function_p ( ) && call_used_regs [ regno ] ) ) ) ; } </s>

For a given REGNO , determine whether it must be saved in the function prologue . IS_INTHANDLER specifies whether we 're generating a normal prologue or an interrupt/exception one .


<s> static void sparc_asm_function_epilogue ( FILE * file , HOST_WIDE_INT size ATTRIBUTE_UNUSED ) { rtx_insn * insn = get_last_insn ( ) ; rtx last_real_insn = prev_real_insn ( insn ) ; if ( last_real_insn && NONJUMP_INSN_P ( last_real_insn ) && GET_CODE ( PATTERN ( last_real_insn ) ) == SEQUENCE ) last_real_insn = XVECEXP ( PATTERN ( last_real_insn ) , 0 , 0 ) ; if ( last_real_insn && CALL_P ( last_real_insn ) && ! SIBLING_CALL_P ( last_real_insn ) ) fputs ( "\tnop\n" , file ) ; sparc_output_deferred_case_vectors ( ) ; } </s>

This function generates the assembly code for function exit .


<s> bool AArch64TargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT ) const { if ( Imm . isPosZero ( ) && ( VT == MVT :: f64 || VT == MVT :: f32 ) ) return true ; if ( VT == MVT :: f64 ) return AArch64_AM :: getFP64Imm ( Imm ) != - 1 ; else if ( VT == MVT :: f32 ) return AArch64_AM :: getFP32Imm ( Imm ) != - 1 ; return false ; } </s>

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


<s> bool aarch64_move_imm ( HOST_WIDE_INT val , machine_mode mode ) { if ( aarch64_movw_imm ( val , mode ) || aarch64_movw_imm ( ~ val , mode ) ) return 1 ; return aarch64_bitmask_imm ( val , mode ) ; } </s>

Return true if val is an immediate that can be loaded into a register in a single instruction .


<s> static inline bool offset_6bit_unsigned_scaled_p ( machine_mode mode , poly_int64 offset ) { HOST_WIDE_INT multiple ; return ( constant_multiple_p ( offset , GET_MODE_SIZE ( mode ) , & multiple ) && IN_RANGE ( multiple , 0 , 63 ) ) ; } </s>

Return true if OFFSET is an unsigned 6-bit value multiplied by the size of MODE .


<s> bool m68k_epilogue_uses ( int regno ATTRIBUTE_UNUSED ) { return ( reload_completed && ( m68k_get_function_kind ( current_function_decl ) == m68k_fk_interrupt_handler ) ) ; } </s>

Implements EPILOGUE_USES . All registers are live on exit from an interrupt routine .


<s> const TargetRegisterClass * ARM64RegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return & ARM64 :: GPR64RegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s> const SchedDFSResult * getDFSResult ( ) const { return DFSResult ; } </s>

Return a non-null DFS result if the scheduling strategy initialized it .


"WebAssembly does not use MCFixupKindInfo flags"

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


<s> static void tilegx_option_override ( void ) { if ( OPTION_SET_P ( tilegx_cmodel ) ) { switch ( tilegx_cmodel ) { case CM_SMALL : case CM_SMALL_PIC : if ( flag_pic ) tilegx_cmodel = CM_SMALL_PIC ; break ; case CM_LARGE : case CM_LARGE_PIC : if ( flag_pic ) tilegx_cmodel = CM_LARGE_PIC ; break ; default : gcc_unreachable ( ) ; } } else tilegx_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL ; if ( flag_modulo_sched ) flag_resched_modulo_sched = 1 ; } </s>


<s>
void
MOSAsmPrinter
::
lowerOperand
(
const
MachineOperand
&
MO
,
MCOperand
&
MCOp
)
{
if
(
!
InstLowering
.
lowerOperand
(
MO
,
MCOp
)
)
llvm_unreachable
(
"Failed to lower operand."
)
;
}
</s>

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


<s> bool SIInstrInfo :: isLegalRegOperand ( const MachineRegisterInfo & MRI , const MCOperandInfo & OpInfo , const MachineOperand & MO ) const { if ( ! MO . isReg ( ) ) return false ; unsigned Reg = MO . getReg ( ) ; const TargetRegisterClass * RC = TargetRegisterInfo :: isVirtualRegister ( Reg ) ? MRI . getRegClass ( Reg ) : RI . getPhysRegClass ( Reg ) ; const SIRegisterInfo * TRI = static_cast < const SIRegisterInfo * > ( MRI . getTargetRegisterInfo ( ) ) ; RC = TRI -> getSubRegClass ( RC , MO . getSubReg ( ) ) ; return RI . getCommonSubClass ( RC , RI . getRegClass ( OpInfo . RegClass ) ) == RC ; } </s>

Check if MO ( a register operand ) is a legal register for the given operand description .


<s>
bool
ARMBaseInstrInfo
::
analyzeBranch
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
*
&
TBB
,
MachineBasicBlock
*
&
FBB
,
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
bool
AllowModify
)
const
{
TBB
=
nullptr
;
FBB
=
nullptr
;
MachineBasicBlock
::
instr_iterator
I
=
MBB
.
instr_end
(
)
;
if
(
I
==
MBB
.
instr_begin
(
)
)
return
false
;
I
;
while
(
isPredicated
(
*
I
)
||
I
->
isTerminator
(
)
||
I
->
isDebugValue
(
)
)
{
bool
CantAnalyze
=
false
;
while
(
I
->
isDebugInstr
(
)
||
!
I
->
isTerminator
(
)
||
isSpeculationBarrierEndBBOpcode
(
I
->
getOpcode
(
)
)
)
{
if
(
I
==
MBB
.
instr_begin
(
)
)
return
false
;
I
;
}
if
(
isIndirectBranchOpcode
(
I
->
getOpcode
(
)
)
||
isJumpTableBranchOpcode
(
I
->
getOpcode
(
)
)
)
{
CantAnalyze
=
true
;
}
else
if
(
isUncondBranchOpcode
(
I
->
getOpcode
(
)
)
)
{
TBB
=
I
->
getOperand
(
0
)
.
getMBB
(
)
;
}
else
if
(
isCondBranchOpcode
(
I
->
getOpcode
(
)
)
)
{
if
(
!
Cond
.
empty
(
)
)
return
true
;
assert
(
!
FBB
&&
"FBB should have been null."
)
;
FBB
=
TBB
;
TBB
=
I
->
getOperand
(
0
)
.
getMBB
(
)
;
Cond
.
push_back
(
I
->
getOperand
(
1
)
)
;
Cond
.
push_back
(
I
->
getOperand
(
2
)
)
;
}
else
if
(
I
->
isReturn
(
)
)
{
CantAnalyze
=
true
;
}
else
{
return
true
;
}
if
(
!
isPredicated
(
*
I
)
&&
(
isUncondBranchOpcode
(
I
->
getOpcode
(
)
)
||
isIndirectBranchOpcode
(
I
->
getOpcode
(
)
)
||
isJumpTableBranchOpcode
(
I
->
getOpcode
(
)
)
||
I
->
isReturn
(
)
)
)
{
Cond
.
clear
(
)
;
FBB
=
nullptr
;
if
(
AllowModify
)
{
MachineBasicBlock
::
iterator
DI
=
std
::
next
(
I
)
;
while
(
DI
!=
MBB
.
instr_end
(
)
)
{
MachineInstr
&
InstToDelete
=
*
DI
;
++
DI
;
if
(
isSpeculationBarrierEndBBOpcode
(
InstToDelete
.
getOpcode
(
)
)
)
continue
;
InstToDelete
.
eraseFromParent
(
)
;
}
}
}
if
(
CantAnalyze
)
{
if
(
AllowModify
&&
!
isPredicated
(
MBB
.
back
(
)
)
&&
isUncondBranchOpcode
(
MBB
.
back
(
)
.
getOpcode
(
)
)
&&
TBB
&&
MBB
.
isLayoutSuccessor
(
TBB
)
)
removeBranch
(
MBB
)
;
return
true
;
}
if
(
I
==
MBB
.
instr_begin
(
)
)
return
false
;
I
;
}
return
false
;
}
</s>

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


<s> unsigned ARMFastISel :: fastEmitInst_r ( unsigned MachineInstOpcode , const TargetRegisterClass * RC , unsigned Op0 ) { Register ResultReg = createResultReg ( RC ) ; const MCInstrDesc & II = TII . get ( MachineInstOpcode ) ; Op0 = constrainOperandRegClass ( II , Op0 , 1 ) ; if ( II . getNumDefs ( ) >= 1 ) { AddOptionalDefs ( BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , II , ResultReg ) . addReg ( Op0 ) ) ; } else { AddOptionalDefs ( BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , II ) . addReg ( Op0 ) ) ; AddOptionalDefs ( BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( TargetOpcode :: COPY ) , ResultReg ) . addReg ( II . ImplicitDefs [ 0 ] ) ) ; } return ResultReg ; } </s>

Emit a MachineInstr with one register operand and a result register in the given register class .


<s> Cpu0TargetLowering :: ConstraintType Cpu0TargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'c' : return C_RegisterClass ; case 'R' : return C_Memory ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s>
static
rtx
avr_addr_space_convert
(
rtx
src
,
tree
type_from
,
tree
type_to
)
{
addr_space_t
as_from
=
TYPE_ADDR_SPACE
(
TREE_TYPE
(
type_from
)
)
;
addr_space_t
as_to
=
TYPE_ADDR_SPACE
(
TREE_TYPE
(
type_to
)
)
;
if
(
avr_log
.
progmem
)
avr_edump
(
"\n%!: op = %r\nfrom = %t\nto = %t\n"
,
src
,
type_from
,
type_to
)
;
if
(
as_from
!=
ADDR_SPACE_MEMX
&&
as_to
==
ADDR_SPACE_MEMX
)
{
int
msb
;
rtx
sym
=
src
;
rtx
reg
=
gen_reg_rtx
(
PSImode
)
;
while
(
CONST
==
GET_CODE
(
sym
)
||
PLUS
==
GET_CODE
(
sym
)
)
sym
=
XEXP
(
sym
,
0
)
;
if
(
SYMBOL_REF
==
GET_CODE
(
sym
)
&&
ADDR_SPACE_FLASH
==
AVR_SYMBOL_GET_ADDR_SPACE
(
sym
)
)
{
as_from
=
ADDR_SPACE_FLASH
;
}
msb
=
ADDR_SPACE_GENERIC_P
(
as_from
)
0x80
:
avr_addrspace
[
as_from
]
.
segment
;
src
=
force_reg
(
Pmode
,
src
)
;
emit_insn
(
msb
==
0
gen_zero_extendhipsi2
(
reg
,
src
)
:
gen_n_extendhipsi2
(
reg
,
gen_int_mode
(
msb
,
QImode
)
,
src
)
)
;
return
reg
;
}
if
(
as_from
==
ADDR_SPACE_MEMX
&&
as_to
!=
ADDR_SPACE_MEMX
)
{
rtx
new_src
=
gen_reg_rtx
(
Pmode
)
;
src
=
force_reg
(
PSImode
,
src
)
;
emit_move_insn
(
new_src
,
simplify_gen_subreg
(
Pmode
,
src
,
PSImode
,
0
)
)
;
return
new_src
;
}
return
src
;
}
</s>

Implement ` TARGET_ADDR_SPACE_CONVERT ' .


<s>
void
X86DAGToDAGISel
::
PreprocessISelDAG
(
)
{
OptForSize
=
MF
->
getFunction
(
)
->
optForSize
(
)
;
OptForMinSize
=
MF
->
getFunction
(
)
->
optForMinSize
(
)
;
assert
(
(
!
OptForMinSize
||
OptForSize
)
&&
"OptForMinSize implies OptForSize"
)
;
for
(
SelectionDAG
::
allnodes_iterator
I
=
CurDAG
->
allnodes_begin
(
)
,
E
=
CurDAG
->
allnodes_end
(
)
;
I
!=
E
;
)
{
SDNode
*
N
=
&
*
I
++
;
if
(
OptLevel
!=
CodeGenOpt
::
&&
(
(
N
->
getOpcode
(
)
==
X86ISD
::
CALL
&&
!
Subtarget
->
callRegIndirect
(
)
)
||
(
N
->
getOpcode
(
)
==
X86ISD
::
TC_RETURN
&&
(
Subtarget
->
is64Bit
(
)
||
!
getTargetMachine
(
)
.
isPositionIndependent
(
)
)
)
)
)
{
bool
HasCallSeq
=
N
->
getOpcode
(
)
==
X86ISD
::
CALL
;
SDValue
Chain
=
N
->
getOperand
(
0
)
;
SDValue
Load
=
N
->
getOperand
(
1
)
;
if
(
!
isCalleeLoad
(
Load
,
Chain
,
HasCallSeq
)
)
continue
;
moveBelowOrigChain
(
CurDAG
,
Load
,
SDValue
(
N
,
0
)
,
Chain
)
;
++
NumLoadMoved
;
continue
;
}
if
(
N
->
getOpcode
(
)
!=
ISD
::
FP_ROUND
&&
N
->
getOpcode
(
)
!=
ISD
::
FP_EXTEND
)
continue
;
MVT
SrcVT
=
N
->
getOperand
(
0
)
.
getSimpleValueType
(
)
;
MVT
DstVT
=
N
->
getSimpleValueType
(
0
)
;
if
(
SrcVT
.
isVector
(
)
||
DstVT
.
isVector
(
)
)
continue
;
const
X86TargetLowering
*
X86Lowering
=
static_cast
<
const
X86TargetLowering
*
>
(
TLI
)
;
bool
SrcIsSSE
=
X86Lowering
->
isScalarFPTypeInSSEReg
(
SrcVT
)
;
bool
DstIsSSE
=
X86Lowering
->
isScalarFPTypeInSSEReg
(
DstVT
)
;
if
(
SrcIsSSE
&&
DstIsSSE
)
continue
;
if
(
!
SrcIsSSE
&&
!
DstIsSSE
)
{
if
(
N
->
getOpcode
(
)
==
ISD
::
FP_EXTEND
)
continue
;
if
(
N
->
getConstantOperandVal
(
1
)
)
continue
;
}
MVT
MemVT
;
if
(
N
->
getOpcode
(
)
==
ISD
::
FP_ROUND
)
MemVT
=
DstVT
;
else
MemVT
=
SrcIsSSE
SrcVT
:
DstVT
;
SDValue
MemTmp
=
CurDAG
->
CreateStackTemporary
(
MemVT
)
;
SDLoc
dl
(
N
)
;
SDValue
Store
=
CurDAG
->
getTruncStore
(
CurDAG
->
getEntryNode
(
)
,
dl
,
N
->
getOperand
(
0
)
,
MemTmp
,
MachinePointerInfo
(
)
,
MemVT
,
false
,
false
,
0
)
;
SDValue
Result
=
CurDAG
->
getExtLoad
(
ISD
::
EXTLOAD
,
dl
,
DstVT
,
Store
,
MemTmp
,
MachinePointerInfo
(
)
,
MemVT
,
false
,
false
,
false
,
0
)
;
I
;
CurDAG
->
ReplaceAllUsesOfValueWith
(
SDValue
(
N
,
0
)
,
Result
)
;
++
I
;
CurDAG
->
DeleteNode
(
N
)
;
}
}
</s>

PreprocessISelDAG - This hook allows targets to hack on the graph before instruction selection starts .


<s> bool AArch64TargetLowering :: enableAggressiveFMAFusion ( EVT VT ) const { return Subtarget -> hasAggressiveFMA ( ) && VT . isFloatingPoint ( ) ; } </s>

Return true if target always benefits from combining into FMA for a given value type .


<s> const char * SPUTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { if ( node_names . empty ( ) ) { node_names [ ( unsigned ) SPUISD :: RET_FLAG ] = "SPUISD::RET_FLAG" ; node_names [ ( unsigned ) SPUISD :: Hi ] = "SPUISD::Hi" ; node_names [ ( unsigned ) SPUISD :: Lo ] = "SPUISD::Lo" ; node_names [ ( unsigned ) SPUISD :: PCRelAddr ] = "SPUISD::PCRelAddr" ; node_names [ ( unsigned ) SPUISD :: AFormAddr ] = "SPUISD::AFormAddr" ; node_names [ ( unsigned ) SPUISD :: IndirectAddr ] = "SPUISD::IndirectAddr" ; node_names [ ( unsigned ) SPUISD :: LDRESULT ] = "SPUISD::LDRESULT" ; node_names [ ( unsigned ) SPUISD :: CALL ] = "SPUISD::CALL" ; node_names [ ( unsigned ) SPUISD :: SHUFB ] = "SPUISD::SHUFB" ; node_names [ ( unsigned ) SPUISD :: SHUFFLE_MASK ] = "SPUISD::SHUFFLE_MASK" ; node_names [ ( unsigned ) SPUISD :: CNTB ] = "SPUISD::CNTB" ; node_names [ ( unsigned ) SPUISD :: PREFSLOT2VEC ] = "SPUISD::PREFSLOT2VEC" ; node_names [ ( unsigned ) SPUISD :: VEC2PREFSLOT ] = "SPUISD::VEC2PREFSLOT" ; node_names [ ( unsigned ) SPUISD :: SHL_BITS ] = "SPUISD::SHL_BITS" ; node_names [ ( unsigned ) SPUISD :: SHL_BYTES ] = "SPUISD::SHL_BYTES" ; node_names [ ( unsigned ) SPUISD :: VEC_ROTL ] = "SPUISD::VEC_ROTL" ; node_names [ ( unsigned ) SPUISD :: VEC_ROTR ] = "SPUISD::VEC_ROTR" ; node_names [ ( unsigned ) SPUISD :: ROTBYTES_LEFT ] = "SPUISD::ROTBYTES_LEFT" ; node_names [ ( unsigned ) SPUISD :: ROTBYTES_LEFT_BITS ] = "SPUISD::ROTBYTES_LEFT_BITS" ; node_names [ ( unsigned ) SPUISD :: SELECT_MASK ] = "SPUISD::SELECT_MASK" ; node_names [ ( unsigned ) SPUISD :: SELB ] = "SPUISD::SELB" ; node_names [ ( unsigned ) SPUISD :: ADD64_MARKER ] = "SPUISD::ADD64_MARKER" ; node_names [ ( unsigned ) SPUISD :: SUB64_MARKER ] = "SPUISD::SUB64_MARKER" ; node_names [ ( unsigned ) SPUISD :: MUL64_MARKER ] = "SPUISD::MUL64_MARKER" ; } std :: map < unsigned , const char * > :: iterator i = node_names . find ( Opcode ) ; return ( ( i != node_names . end ( ) ) ? i -> second : 0 ) ; } </s>

getTargetNodeName - This method returns the name of a target specific


<s> void rl78_split_movsi ( rtx * operands , machine_mode omode ) { rtx op00 , op02 , op10 , op12 ; op00 = rl78_subreg ( HImode , operands [ 0 ] , omode , 0 ) ; op02 = rl78_subreg ( HImode , operands [ 0 ] , omode , 2 ) ; if ( GET_CODE ( operands [ 1 ] ) == CONST || GET_CODE ( operands [ 1 ] ) == SYMBOL_REF ) { op10 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ 1 ] , GEN_INT ( 16 ) , GEN_INT ( 0 ) ) ; op10 = gen_rtx_CONST ( HImode , op10 ) ; op12 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ 1 ] , GEN_INT ( 16 ) , GEN_INT ( 16 ) ) ; op12 = gen_rtx_CONST ( HImode , op12 ) ; } else { op10 = rl78_subreg ( HImode , operands [ 1 ] , omode , 0 ) ; op12 = rl78_subreg ( HImode , operands [ 1 ] , omode , 2 ) ; } if ( rtx_equal_p ( operands [ 0 ] , operands [ 1 ] ) ) ; else if ( rtx_equal_p ( op00 , op12 ) ) { operands [ 2 ] = op02 ; operands [ 4 ] = op12 ; operands [ 3 ] = op00 ; operands [ 5 ] = op10 ; } else { operands [ 2 ] = op00 ; operands [ 4 ] = op10 ; operands [ 3 ] = op02 ; operands [ 5 ] = op12 ; } } </s>


runOnMachineFunction - Emit the function body .


<s> Align getStackAlignment ( ) const { return stackAlignment ; } </s>

Returns the minimum alignment known to hold of the stack frame on entry to the function and which must be maintained by every function for this subtarget .


<s>
const
char
*
getPassName
(
)
const
override
{
return
"X86 Atom LEA Fixup"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> static rtx function_arg_union_value ( int size , enum machine_mode mode , int slotno , int regno ) { int nwords = ROUND_ADVANCE ( size ) , i ; rtx regs ; if ( nwords == 0 ) return gen_rtx_REG ( mode , regno ) ; if ( slotno == SPARC_INT_ARG_MAX - 1 ) nwords = 1 ; regs = gen_rtx_PARALLEL ( mode , rtvec_alloc ( nwords ) ) ; for ( i = 0 ; i < nwords ; i ++ ) { XVECEXP ( regs , 0 , i ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( word_mode , regno ) , GEN_INT ( UNITS_PER_WORD * i ) ) ; regno ++ ; } return regs ; } </s>

Used by function_arg and sparc_function_value_1 to implement the conventions of the 64-bit ABI for passing and returning unions . Return an expression valid as a return value for the FUNCTION_ARG and TARGET_FUNCTION_VALUE . SIZE is the size in bytes of the union . MODE is the argument 's machine mode . REGNO is the hard register the union will be passed in .


<s> EVT ARMTargetLowering :: getSetCCResultType ( EVT VT ) const { if ( ! VT . isVector ( ) ) return getPointerTy ( ) ; return VT . changeVectorElementTypeToInteger ( ) ; } </s>

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


<s> bool AMDGPUPromoteAlloca :: runOnFunction ( Function & F ) { if ( skipFunction ( F ) ) return false ; if ( auto * TPC = getAnalysisIfAvailable < TargetPassConfig > ( ) ) TM = & TPC -> getTM < TargetMachine > ( ) ; else return false ; const Triple & TT = TM -> getTargetTriple ( ) ; IsAMDGCN = TT . getArch ( ) == Triple :: amdgcn ; IsAMDHSA = TT . getOS ( ) == Triple :: AMDHSA ; const AMDGPUSubtarget & ST = AMDGPUSubtarget :: get ( * TM , F ) ; if ( ! ST . isPromoteAllocaEnabled ( ) ) return false ; bool SufficientLDS = hasSufficientLocalMem ( F ) ; bool Changed = false ; BasicBlock & EntryBB = * F . begin ( ) ; for ( auto I = EntryBB . begin ( ) , E = EntryBB . end ( ) ; I != E ; ) { AllocaInst * AI = dyn_cast < AllocaInst > ( I ) ; ++ I ; if ( AI ) Changed |= handleAlloca ( * AI , SufficientLDS ) ; } return Changed ; } </s>

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


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

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


"Can't load this register from stack slot"

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


"sret virtual register not created in entry block"

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


"Not expecting modifiers with immediates"

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


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

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


<s> static inline bool is_interrupt_func ( const_tree decl ) { return has_func_attr ( decl , "interrupt" ) ; } </s>

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


<s> bool mprocFrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { return true ; } </s>

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


<s> bool Mips16TargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned , unsigned , bool * Fast ) const { return false ; } </s>

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


<s> bool arm_fusion_enabled_p ( tune_params :: fuse_ops op ) { return current_tune -> fusible_ops & op ; } </s>

Return true iff the instruction fusion described by OP is enabled .


<s> int mips_class_max_nregs ( enum reg_class rclass , machine_mode mode ) { int size ; HARD_REG_SET left ; size = 0x8000 ; COPY_HARD_REG_SET ( left , reg_class_contents [ ( int ) rclass ] ) ; if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) ST_REGS ] ) ) { if ( HARD_REGNO_MODE_OK ( ST_REG_FIRST , mode ) ) size = MIN ( size , 4 ) ; AND_COMPL_HARD_REG_SET ( left , reg_class_contents [ ( int ) ST_REGS ] ) ; } if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FP_REGS ] ) ) { if ( HARD_REGNO_MODE_OK ( FP_REG_FIRST , mode ) ) { if ( MSA_SUPPORTED_MODE_P ( mode ) ) size = MIN ( size , UNITS_PER_MSA_REG ) ; else size = MIN ( size , UNITS_PER_FPREG ) ; } AND_COMPL_HARD_REG_SET ( left , reg_class_contents [ ( int ) FP_REGS ] ) ; } if ( ! hard_reg_set_empty_p ( left ) ) size = MIN ( size , UNITS_PER_WORD ) ; return ( GET_MODE_SIZE ( mode ) + size - 1 ) / size ; } </s>

Implement CLASS_MAX_NREGS . Usually all registers are word-sized . The only supported exception is -mgp64 -msingle-float , which has 64-bit words but 32-bit float registers . A word-based calculation is correct even in that case , since -msingle-float disallows multi-FPR values . The FP status registers are an exception to this rule . They are always 4 bytes wide as they only hold condition code modes , and CCmode is always considered to be 4 bytes wide .


<s> int i386_pe_reloc_rw_mask ( void ) { return 0 ; } </s>

Local and global relocs can be placed always into readonly memory for memory for PE-COFF targets .


"frame pointer should not have been eliminated"


<s> void SICMCInstLower :: Initialize ( MCContext * C ) { Ctx = C ; } </s>

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


<s> static bool rs6000_use_blocks_for_constant_p ( machine_mode mode , const_rtx x ) { return ! ASM_OUTPUT_SPECIAL_POOL_ENTRY_P ( x , mode ) ; } </s>


<s>
void
ARMTargetLowering
::
ReplaceNodeResults
(
SDNode
*
N
,
SmallVectorImpl
<
SDValue
>
&
Results
,
SelectionDAG
&
DAG
)
const
{
SDValue
Res
;
switch
(
N
->
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Don't know how to custom expand this!"
)
;
case
ISD
::
BITCAST
:
Res
=
ExpandBITCAST
(
N
,
DAG
)
;
break
;
case
ISD
::
SRL
:
case
ISD
::
SRA
:
Res
=
Expand64BitShift
(
N
,
DAG
,
Subtarget
)
;
break
;
case
ISD
::
READCYCLECOUNTER
:
ReplaceREADCYCLECOUNTER
(
N
,
Results
,
DAG
,
Subtarget
)
;
return
;
}
if
(
Res
.
getNode
(
)
)
Results
.
push_back
(
Res
)
;
}
</s>

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

ARM
ARM
"Don't know how to custom expand this!"
ISD::BITCAST
ISD::SRL
ISD::SRA
ISD::READCYCLECOUNTER


<s>
static
int
rs6000_arg_partial_bytes
(
cumulative_args_t
cum_v
,
machine_mode
mode
,
tree
type
,
bool
named
)
{
CUMULATIVE_ARGS
*
cum
=
get_cumulative_args
(
cum_v
)
;
bool
passed_in_gprs
=
true
;
int
ret
=
0
;
int
align_words
;
machine_mode
elt_mode
;
int
n_elts
;
rs6000_discover_homogeneous_aggregate
(
mode
,
type
,
&
elt_mode
,
&
n_elts
)
;
if
(
DEFAULT_ABI
==
ABI_V4
)
return
0
;
if
(
USE_ALTIVEC_FOR_ARG_P
(
cum
,
elt_mode
,
named
)
)
{
if
(
TARGET_64BIT
&&
!
cum
->
prototype
&&
(
!
cum
->
libcall
||
!
FLOAT128_VECTOR_P
(
elt_mode
)
)
)
return
0
;
passed_in_gprs
=
false
;
if
(
cum
->
vregno
+
n_elts
>
ALTIVEC_ARG_MAX_REG
+
1
)
ret
=
(
ALTIVEC_ARG_MAX_REG
+
1
cum
->
vregno
)
*
16
;
}
if
(
TARGET_MACHO
&&
rs6000_darwin64_struct_check_p
(
mode
,
type
)
)
return
0
;
align_words
=
rs6000_parm_start
(
mode
,
type
,
cum
->
words
)
;
if
(
USE_FP_FOR_ARG_P
(
cum
,
elt_mode
)
)
{
unsigned
long
n_fpreg
=
(
GET_MODE_SIZE
(
elt_mode
)
+
7
)
>>
3
;
if
(
type
&&
(
cum
->
nargs_prototype
<=
0
||
(
(
DEFAULT_ABI
==
ABI_AIX
||
DEFAULT_ABI
==
ABI_ELFv2
)
&&
TARGET_XL_COMPAT
&&
align_words
>=
GP_ARG_NUM_REG
)
)
)
return
0
;
passed_in_gprs
=
false
;
if
(
cum
->
fregno
+
n_elts
*
n_fpreg
>
FP_ARG_MAX_REG
+
1
)
{
int
fpr
=
(
(
FP_ARG_MAX_REG
+
1
cum
->
fregno
)
*
MIN
(
8
,
GET_MODE_SIZE
(
elt_mode
)
)
)
;
int
fpr_words
=
fpr
/
(
TARGET_32BIT
4
:
8
)
;
if
(
align_words
+
fpr_words
<
GP_ARG_NUM_REG
)
passed_in_gprs
=
true
;
else
ret
=
fpr
;
}
}
if
(
passed_in_gprs
&&
align_words
<
GP_ARG_NUM_REG
&&
GP_ARG_NUM_REG
<
align_words
+
rs6000_arg_size
(
mode
,
type
)
)
ret
=
(
GP_ARG_NUM_REG
align_words
)
*
(
TARGET_32BIT
4
:
8
)
;
if
(
ret
!=
0
&&
TARGET_DEBUG_ARG
)
fprintf
(
stderr
,
"rs6000_arg_partial_bytes: %d\n"
,
ret
)
;
return
ret
;
}
</s>

For an arg passed partly in registers and partly in memory , this is the number of bytes passed in registers . For args passed entirely in registers or entirely in memory , zero . When an arg is described by a PARALLEL , perhaps using more than one register type , this function returns the number of bytes used by the first element of the PARALLEL .


<s> unsigned char X86Subtarget :: classifyGlobalFunctionReference ( const GlobalValue * GV , const Module & M ) const { if ( TM . shouldAssumeDSOLocal ( M , GV ) ) return X86II :: MO_NO_FLAG ; assert ( ! isTargetCOFF ( ) ) ; const Function * F = dyn_cast_or_null < Function > ( GV ) ; if ( isTargetELF ( ) ) { if ( is64Bit ( ) && F && ( CallingConv :: X86_RegCall == F -> getCallingConv ( ) ) ) return X86II :: MO_GOTPCREL ; return X86II :: MO_PLT ; } if ( is64Bit ( ) ) { if ( F && F -> hasFnAttribute ( Attribute :: NonLazyBind ) ) return X86II :: MO_GOTPCREL ; return X86II :: MO_NO_FLAG ; } return X86II :: MO_NO_FLAG ; } </s>

Classify a global function reference for the current subtarget .


<s> void riscv_expand_prologue ( void ) { struct riscv_frame_info * frame = & cfun -> machine -> frame ; poly_int64 size = frame -> total_size ; unsigned mask = frame -> mask ; rtx insn ; if ( flag_stack_usage_info ) current_function_static_stack_size = constant_lower_bound ( size ) ; if ( cfun -> machine -> naked_p ) return ; if ( riscv_use_save_libcall ( frame ) ) { rtx dwarf = NULL_RTX ; dwarf = riscv_adjust_libcall_cfi_prologue ( ) ; size -= frame -> save_libcall_adjustment ; insn = emit_insn ( riscv_gen_gpr_save_insn ( frame ) ) ; frame -> mask = 0 ; RTX_FRAME_RELATED_P ( insn ) = 1 ; REG_NOTES ( insn ) = dwarf ; } if ( ( frame -> mask | frame -> fmask ) != 0 ) { HOST_WIDE_INT step1 = riscv_first_stack_step ( frame ) ; if ( size . is_constant ( ) ) step1 = MIN ( size . to_constant ( ) , step1 ) ; insn = gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - step1 ) ) ; RTX_FRAME_RELATED_P ( emit_insn ( insn ) ) = 1 ; size -= step1 ; riscv_for_each_saved_reg ( size , riscv_save_reg , false , false ) ; } frame -> mask = mask ; if ( frame_pointer_needed ) { insn = gen_add3_insn ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( ( frame -> hard_frame_pointer_offset - size ) . to_constant ( ) ) ) ; RTX_FRAME_RELATED_P ( emit_insn ( insn ) ) = 1 ; riscv_emit_stack_tie ( ) ; } if ( known_gt ( size , 0 ) ) { poly_int64 scalable_frame ( 0 , 0 ) ; if ( ! size . is_constant ( ) ) { poly_int64 scalable_frame = size ; scalable_frame . coeffs [ 0 ] = size . coeffs [ 1 ] ; riscv_v_adjust_scalable_frame ( stack_pointer_rtx , scalable_frame , false ) ; size -= scalable_frame ; } HOST_WIDE_INT constant_frame = size . to_constant ( ) ; if ( constant_frame == 0 ) return ; if ( SMALL_OPERAND ( - constant_frame ) ) { insn = gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - constant_frame ) ) ; RTX_FRAME_RELATED_P ( emit_insn ( insn ) ) = 1 ; } else { riscv_emit_move ( RISCV_PROLOGUE_TEMP ( Pmode ) , GEN_INT ( - constant_frame ) ) ; emit_insn ( gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , RISCV_PROLOGUE_TEMP ( Pmode ) ) ) ; insn = plus_constant ( Pmode , stack_pointer_rtx , - constant_frame ) ; insn = gen_rtx_SET ( stack_pointer_rtx , insn ) ; riscv_set_frame_expr ( insn ) ; } } } </s>


<s> void X86PassConfig :: addPreEmitPass ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createExecutionDependencyFixPass ( & X86 :: VR128RegClass ) ) ; if ( UseVZeroUpper ) addPass ( createX86IssueVZeroUpperPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86PadShortFunctions ( ) ) ; addPass ( createX86FixupLEAs ( ) ) ; } } </s>

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


<s> static rtx mips16_local_alias ( rtx func ) { if ( mips16_local_aliases == NULL ) mips16_local_aliases = hash_map < rtx , rtx , local_alias_traits > :: create_ggc ( 37 ) ; bool existed ; rtx * slot = & mips16_local_aliases -> get_or_insert ( func , & existed ) ; gcc_assert ( slot != NULL ) ; if ( ! existed ) { const char * func_name , * local_name ; rtx local ; func_name = targetm . strip_name_encoding ( XSTR ( func , 0 ) ) ; local_name = ACONCAT ( ( "__fn_local_" , func_name , NULL ) ) ; local = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( local_name ) ) ; SYMBOL_REF_FLAGS ( local ) = SYMBOL_REF_FLAGS ( func ) | SYMBOL_FLAG_LOCAL ; * slot = local ; } return * slot ; } </s>

FUNC is the symbol for a locally-defined hard-float MIPS16 function . Return a local alias for it , creating a new one if necessary .


<s> static rtx gen_rx_popm_vector ( unsigned int low , unsigned int high ) { unsigned int i ; unsigned int count = ( high - low ) + 2 ; rtx vector ; vector = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count ) ) ; XVECEXP ( vector , 0 , 0 ) = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , ( count - 1 ) * UNITS_PER_WORD ) ) ; for ( i = 0 ; i < count - 1 ; i ++ ) XVECEXP ( vector , 0 , i + 1 ) = gen_rtx_SET ( gen_rtx_REG ( SImode , low + i ) , gen_rtx_MEM ( SImode , i == 0 ? stack_pointer_rtx : plus_constant ( Pmode , stack_pointer_rtx , i * UNITS_PER_WORD ) ) ) ; return vector ; } </s>

Generate a PARALLEL which will satisfy the rx_load_multiple_vector predicate .


<s> bool Nios2PassConfig :: addInstSelector ( ) { addPass ( createNios2ISelDag ( getNios2TargetMachine ( ) , getOptLevel ( ) ) ) ; return false ; } </s>

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


<s> bool ARMAsmBackend :: mayNeedRelaxation ( const MCInst & Inst , const MCSubtargetInfo & STI ) const { if ( getRelaxedOpcode ( Inst . getOpcode ( ) , STI ) != Inst . getOpcode ( ) ) return true ; return false ; } </s>

Check whether the given instruction may need relaxation .


<s> static void m32r_output_function_epilogue ( FILE * ) { current_frame_info = zero_frame_info ; m32r_compute_function_type ( NULL_TREE ) ; } </s>

Do any necessary cleanup after a function to restore stack , frame , and regs .


<s> rtx legitimize_pic_address ( rtx orig , machine_mode mode ATTRIBUTE_UNUSED , rtx reg ) { if ( tls_symbolic_operand ( orig , Pmode ) != TLS_MODEL_NONE ) return orig ; if ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_LOCAL_P ( orig ) ) ) { if ( reg == NULL_RTX ) reg = gen_reg_rtx ( Pmode ) ; if ( TARGET_FDPIC && GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( orig ) ) { if ( SYMBOL_REF_WEAK ( orig ) ) emit_insn ( gen_symGOTFUNCDESC2reg ( reg , orig ) ) ; else emit_insn ( gen_symGOTOFFFUNCDESC2reg ( reg , orig ) ) ; } else if ( TARGET_FDPIC && ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_DECL ( orig ) && ( TREE_READONLY ( SYMBOL_REF_DECL ( orig ) ) || SYMBOL_REF_EXTERNAL_P ( orig ) || DECL_SECTION_NAME ( SYMBOL_REF_DECL ( orig ) ) ) ) ) ) emit_insn ( gen_symGOT2reg ( reg , orig ) ) ; else emit_insn ( gen_symGOTOFF2reg ( reg , orig ) ) ; return reg ; } else if ( GET_CODE ( orig ) == SYMBOL_REF ) { if ( reg == NULL_RTX ) reg = gen_reg_rtx ( Pmode ) ; if ( TARGET_FDPIC && SYMBOL_REF_FUNCTION_P ( orig ) ) emit_insn ( gen_symGOTFUNCDESC2reg ( reg , orig ) ) ; else emit_insn ( gen_symGOT2reg ( reg , orig ) ) ; return reg ; } return orig ; } </s>

Legitimize PIC addresses . If the address is already position-independent , we return ORIG . Newly generated position-independent addresses go into a reg . This is REG if nonzero , otherwise we allocate register ( s ) as necessary .


<s> static bool tryAddingSymbolicOperand ( uint64_t Address , int32_t Value , bool isBranch , uint64_t InstSize , MCInst & MI , const void * Decoder ) { const MCDisassembler * Dis = static_cast < const MCDisassembler * > ( Decoder ) ; return Dis -> tryAddingSymbolicOperand ( MI , ( uint32_t ) Value , Address , isBranch , 0 , InstSize ) ; } </s>

Try to add a symbolic operand instead of Value to the MCInst .


"InsertBranch must not be told to insert a fallthrough"

"M680x0 branch conditions have one component!"

"Unconditional branch with multiple successors!"

Insert branch code into the end of the specified MachineBasicBlock .


<s> enum reg_class s390_secondary_output_reload_class ( enum reg_class class , enum machine_mode mode , rtx out ) { if ( ( TARGET_64BIT ? ( mode == TImode || mode == TFmode ) : ( mode == DImode || mode == DFmode ) ) && reg_classes_intersect_p ( GENERAL_REGS , class ) && GET_CODE ( out ) == MEM && GET_CODE ( XEXP ( out , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( out , 0 ) , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( out , 0 ) , 1 ) ) == CONST_INT && ! DISP_IN_RANGE ( INTVAL ( XEXP ( XEXP ( out , 0 ) , 1 ) ) + GET_MODE_SIZE ( mode ) - 1 ) ) return ADDR_REGS ; if ( reg_classes_intersect_p ( FP_REGS , class ) && mode == TFmode && GET_CODE ( out ) == MEM && GET_CODE ( XEXP ( out , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( out , 0 ) , 1 ) ) == CONST_INT && ! DISP_IN_RANGE ( INTVAL ( XEXP ( XEXP ( out , 0 ) , 1 ) ) + GET_MODE_SIZE ( mode ) - 1 ) ) return ADDR_REGS ; if ( reg_classes_intersect_p ( CC_REGS , class ) ) return GENERAL_REGS ; return NO_REGS ; } </s>

Return the register class of a scratch register needed to store a register of class CLASS in MODE into OUT : We need a temporary when storing a double-word to a non-offsettable memory address .


<s> bool SILowerI1Copies :: runOnMachineFunction ( MachineFunction & TheMF ) { if ( TheMF . getProperties ( ) . hasProperty ( MachineFunctionProperties :: Property :: Selected ) ) return false ; MF = & TheMF ; MRI = & MF -> getRegInfo ( ) ; DT = & getAnalysis < MachineDominatorTree > ( ) ; PDT = & getAnalysis < MachinePostDominatorTree > ( ) ; ST = & MF -> getSubtarget < GCNSubtarget > ( ) ; TII = ST -> getInstrInfo ( ) ; IsWave32 = ST -> isWave32 ( ) ; if ( IsWave32 ) { ExecReg = AMDGPU :: EXEC_LO ; MovOp = AMDGPU :: S_MOV_B32 ; AndOp = AMDGPU :: S_AND_B32 ; OrOp = AMDGPU :: S_OR_B32 ; XorOp = AMDGPU :: S_XOR_B32 ; AndN2Op = AMDGPU :: S_ANDN2_B32 ; OrN2Op = AMDGPU :: S_ORN2_B32 ; } else { ExecReg = AMDGPU :: EXEC ; MovOp = AMDGPU :: S_MOV_B64 ; AndOp = AMDGPU :: S_AND_B64 ; OrOp = AMDGPU :: S_OR_B64 ; XorOp = AMDGPU :: S_XOR_B64 ; AndN2Op = AMDGPU :: S_ANDN2_B64 ; OrN2Op = AMDGPU :: S_ORN2_B64 ; } lowerCopiesFromI1 ( ) ; lowerPhis ( ) ; lowerCopiesToI1 ( ) ; for ( unsigned Reg : ConstrainRegs ) MRI -> constrainRegClass ( Reg , & AMDGPU :: SReg_1_XEXECRegClass ) ; ConstrainRegs . clear ( ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool isImm ( ) const { return Kind == k_Immediate ; } </s>


<s> void R600InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const DebugLoc & DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { unsigned VectorComponents = 0 ; if ( ( AMDGPU :: R600_Reg128RegClass . contains ( DestReg ) || AMDGPU :: R600_Reg128VerticalRegClass . contains ( DestReg ) ) && ( AMDGPU :: R600_Reg128RegClass . contains ( SrcReg ) || AMDGPU :: R600_Reg128VerticalRegClass . contains ( SrcReg ) ) ) { VectorComponents = 4 ; } else if ( ( AMDGPU :: R600_Reg64RegClass . contains ( DestReg ) || AMDGPU :: R600_Reg64VerticalRegClass . contains ( DestReg ) ) && ( AMDGPU :: R600_Reg64RegClass . contains ( SrcReg ) || AMDGPU :: R600_Reg64VerticalRegClass . contains ( SrcReg ) ) ) { VectorComponents = 2 ; } if ( VectorComponents > 0 ) { for ( unsigned I = 0 ; I < VectorComponents ; I ++ ) { unsigned SubRegIndex = RI . getSubRegFromChannel ( I ) ; buildDefaultInstruction ( MBB , MI , AMDGPU :: MOV , RI . getSubReg ( DestReg , SubRegIndex ) , RI . getSubReg ( SrcReg , SubRegIndex ) ) . addReg ( DestReg , RegState :: Define | RegState :: Implicit ) ; } } else { MachineInstr * NewMI = buildDefaultInstruction ( MBB , MI , AMDGPU :: MOV , DestReg , SrcReg ) ; NewMI -> getOperand ( getOperandIdx ( * NewMI , AMDGPU :: OpName :: src0 ) ) . setIsKill ( KillSrc ) ; } } </s>


<s>
bool
ARCFrameLowering
::
assignCalleeSavedSpillSlots
(
MachineFunction
&
MF
,
const
TargetRegisterInfo
*
TRI
,
std
::
vector
<
CalleeSavedInfo
>
&
CSI
)
const
{
int
CurOffset
=
4
;
unsigned
Last
=
determineLastCalleeSave
(
CSI
)
;
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
if
(
hasFP
(
MF
)
)
{
int
StackObj
=
MFI
.
CreateFixedSpillStackObject
(
4
,
CurOffset
,
true
)
;
DEBUG
(
dbgs
(
)
<<
"Creating fixed object ("
<<
StackObj
<<
") for FP at "
<<
CurOffset
<<
"\n"
)
;
(
void
)
StackObj
;
CurOffset
-=
4
;
}
if
(
MFI
.
hasCalls
(
)
||
(
UseSaveRestoreFunclet
&&
Last
>
ARC
::
R14
)
)
{
int
StackObj
=
MFI
.
CreateFixedSpillStackObject
(
4
,
CurOffset
,
true
)
;
DEBUG
(
dbgs
(
)
<<
"Creating fixed object ("
<<
StackObj
<<
") for BLINK at "
<<
CurOffset
<<
"\n"
)
;
(
void
)
StackObj
;
CurOffset
-=
4
;
}
for
(
unsigned
Which
=
Last
;
Which
>
ARC
::
R12
;
Which
)
{
auto
RegI
=
getSavedReg
(
CSI
,
Which
)
;
if
(
RegI
==
CSI
.
end
(
)
||
RegI
->
getFrameIdx
(
)
==
0
)
{
int
FI
=
MFI
.
CreateFixedSpillStackObject
(
4
,
CurOffset
,
true
)
;
if
(
RegI
!=
CSI
.
end
(
)
)
RegI
->
setFrameIdx
(
FI
)
;
}
else
MFI
.
setObjectOffset
(
RegI
->
getFrameIdx
(
)
,
CurOffset
)
;
CurOffset
-=
4
;
}
for
(
auto
&
I
:
CSI
)
{
if
(
I
.
getReg
(
)
>
ARC
::
R12
)
continue
;
if
(
I
.
getFrameIdx
(
)
==
0
)
{
I
.
setFrameIdx
(
MFI
.
CreateFixedSpillStackObject
(
4
,
CurOffset
,
true
)
)
;
DEBUG
(
dbgs
(
)
<<
"Creating fixed object ("
<<
I
.
getFrameIdx
(
)
<<
") for other register at "
<<
CurOffset
<<
"\n"
)
;
}
else
{
MFI
.
setObjectOffset
(
I
.
getFrameIdx
(
)
,
CurOffset
)
;
DEBUG
(
dbgs
(
)
<<
"Updating fixed object ("
<<
I
.
getFrameIdx
(
)
<<
") for other register at "
<<
CurOffset
<<
"\n"
)
;
}
CurOffset
-=
4
;
}
return
true
;
}
</s>

This function will assign callee saved gprs to volatile vector registers for prologue spills when applicable .


<s> int neon_vector_mem_operand ( rtx op , int type , bool strict ) { rtx ind ; if ( strict && ! ( reload_in_progress || reload_completed ) && ( reg_mentioned_p ( frame_pointer_rtx , op ) || reg_mentioned_p ( arg_pointer_rtx , op ) || reg_mentioned_p ( virtual_incoming_args_rtx , op ) || reg_mentioned_p ( virtual_outgoing_args_rtx , op ) || reg_mentioned_p ( virtual_stack_dynamic_rtx , op ) || reg_mentioned_p ( virtual_stack_vars_rtx , op ) ) ) return FALSE ; if ( ! MEM_P ( op ) ) return FALSE ; ind = XEXP ( op , 0 ) ; if ( reload_completed && ( LABEL_REF_P ( ind ) || ( GET_CODE ( ind ) == CONST && GET_CODE ( XEXP ( ind , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( ind , 0 ) , 0 ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( ind , 0 ) , 1 ) ) ) ) ) return TRUE ; if ( REG_P ( ind ) ) return arm_address_register_rtx_p ( ind , 0 ) ; if ( ( type != 1 && GET_CODE ( ind ) == POST_INC ) || ( type == 0 && GET_CODE ( ind ) == PRE_DEC ) ) return arm_address_register_rtx_p ( XEXP ( ind , 0 ) , 0 ) ; if ( type == 2 && GET_CODE ( ind ) == POST_MODIFY && GET_CODE ( XEXP ( ind , 1 ) ) == PLUS && REG_P ( XEXP ( XEXP ( ind , 1 ) , 1 ) ) && REG_P ( XEXP ( ind , 0 ) ) && rtx_equal_p ( XEXP ( ind , 0 ) , XEXP ( XEXP ( ind , 1 ) , 0 ) ) ) return true ; if ( type == 0 && GET_CODE ( ind ) == PLUS && REG_P ( XEXP ( ind , 0 ) ) && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , 0 ) , VOIDmode ) && CONST_INT_P ( XEXP ( ind , 1 ) ) && INTVAL ( XEXP ( ind , 1 ) ) > - 1024 && ( INTVAL ( XEXP ( ind , 1 ) ) < ( VALID_NEON_QREG_MODE ( GET_MODE ( op ) ) ? 1016 : 1024 ) ) && ( INTVAL ( XEXP ( ind , 1 ) ) & 3 ) == 0 ) return TRUE ; return FALSE ; } </s>

Return TRUE if OP is a memory operand which we can load or store a vector to/from . TYPE is one of the following values : 0 - Vector load/stor ( vldr ) 1 - Core registers ( ldm ) 2 - Element/structure loads ( vld1 )


<s> void RISCVFrameLowering :: determineFrameLayout ( MachineFunction & MF ) const { MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const RISCVRegisterInfo * RI = STI . getRegisterInfo ( ) ; uint64_t FrameSize = MFI . getStackSize ( ) ; unsigned StackAlign = getStackAlignment ( ) ; if ( RI -> needsStackRealignment ( MF ) ) { unsigned MaxStackAlign = std :: max ( StackAlign , MFI . getMaxAlignment ( ) ) ; FrameSize += ( MaxStackAlign - StackAlign ) ; StackAlign = MaxStackAlign ; } uint64_t MaxCallSize = alignTo ( MFI . getMaxCallFrameSize ( ) , StackAlign ) ; MFI . setMaxCallFrameSize ( MaxCallSize ) ; FrameSize = alignTo ( FrameSize , StackAlign ) ; MFI . setStackSize ( FrameSize ) ; } </s>

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


<s>
void
print
(
raw_ostream
&
OS
)
const
override
{
switch
(
Kind
)
{
case
Register
:
OS
<<
"<register "
<<
getReg
(
)
<<
" mods: "
<<
Reg
.
Modifiers
<<
'>'
;
break
;
case
Immediate
:
if
(
Imm
.
Type
!=
AMDGPUOperand
::
ImmTyNone
)
OS
<<
getImm
(
)
;
else
OS
<<
'<'
<<
getImm
(
)
<<
" mods: "
<<
Imm
.
Modifiers
<<
'>'
;
break
;
case
Token
:
OS
<<
'\''
<<
getToken
(
)
<<
'\''
;
break
;
case
Expression
:
OS
<<
"<expr "
<<
*
Expr
<<
'>'
;
break
;
}
}
</s>

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

AMDGPU
"<register "
" mods: "
AMDGPU
" mods: "
"<expr "


<s>
void
addExpr
(
MCInst
&
Inst
,
const
MCExpr
*
Expr
)
const
{
assert
(
Expr
&&
"Expr shouldn't be null!"
)
;
if
(
auto
*
CE
=
dyn_cast
<
MCConstantExpr
>
(
Expr
)
)
Inst
.
addOperand
(
MCOperand
::
createImm
(
CE
->
getValue
(
)
)
)
;
else
Inst
.
addOperand
(
MCOperand
::
createExpr
(
Expr
)
)
;
}
</s>


<s> void schedNode ( SUnit * SU , bool IsTopNode ) override { } </s>

ScheduleDAGMI has scheduled an instruction - tell HazardRec about it .


<s> MCELFStreamer & CSKYTargetELFStreamer :: getStreamer ( ) { return static_cast < MCELFStreamer & > ( Streamer ) ; } </s>

Return the output streamer for the assembler .


<s> bool isImm ( ) const override { return Kind == k_Immediate ; } </s>


<s> void AMDGPUPostLegalizerCombiner :: getAnalysisUsage ( AnalysisUsage & AU ) const { AU . addRequired < TargetPassConfig > ( ) ; AU . setPreservesCFG ( ) ; getSelectionDAGFallbackAnalysisUsage ( AU ) ; AU . addRequired < GISelKnownBitsAnalysis > ( ) ; AU . addPreserved < GISelKnownBitsAnalysis > ( ) ; if ( ! IsOptNone ) { AU . addRequired < MachineDominatorTree > ( ) ; AU . addPreserved < MachineDominatorTree > ( ) ; } MachineFunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> bool aarch64_reinterpret_float_as_int ( rtx value , unsigned HOST_WIDE_INT * intval ) { if ( aarch64_float_const_zero_rtx_p ( value ) ) { * intval = 0 ; return true ; } scalar_float_mode mode ; if ( GET_CODE ( value ) != CONST_DOUBLE || ! is_a < scalar_float_mode > ( GET_MODE ( value ) , & mode ) || GET_MODE_BITSIZE ( mode ) > HOST_BITS_PER_WIDE_INT || GET_MODE_BITSIZE ( mode ) > GET_MODE_BITSIZE ( DFmode ) ) return false ; unsigned HOST_WIDE_INT ival = 0 ; long res [ 2 ] ; real_to_target ( res , CONST_DOUBLE_REAL_VALUE ( value ) , REAL_MODE_FORMAT ( mode ) ) ; if ( mode == DFmode ) { int order = BYTES_BIG_ENDIAN ? 1 : 0 ; ival = zext_hwi ( res [ order ] , 32 ) ; ival |= ( zext_hwi ( res [ 1 - order ] , 32 ) << 32 ) ; } else ival = zext_hwi ( res [ 0 ] , 32 ) ; * intval = ival ; return true ; } </s>

Return the binary representation of floating point constant VALUE in INTVAL . If the value can not be converted , return false without setting INTVAL . The conversion is done in the given MODE .


<s> bool SystemZInstrInfo :: canInsertSelect ( const MachineBasicBlock & MBB , ArrayRef < MachineOperand > Pred , unsigned DstReg , unsigned TrueReg , unsigned FalseReg , int & CondCycles , int & TrueCycles , int & FalseCycles ) const { if ( ! STI . hasLoadStoreOnCond ( ) ) return false ; if ( Pred . size ( ) != 2 ) return false ; const MachineRegisterInfo & MRI = MBB . getParent ( ) -> getRegInfo ( ) ; const TargetRegisterClass * RC = RI . getCommonSubClass ( MRI . getRegClass ( TrueReg ) , MRI . getRegClass ( FalseReg ) ) ; if ( ! RC ) return false ; if ( ( STI . hasLoadStoreOnCond2 ( ) && SystemZ :: GRX32BitRegClass . hasSubClassEq ( RC ) ) || SystemZ :: GR32BitRegClass . hasSubClassEq ( RC ) || SystemZ :: GR64BitRegClass . hasSubClassEq ( RC ) ) { CondCycles = 2 ; TrueCycles = 2 ; FalseCycles = 2 ; return true ; } return false ; } </s>

Return true if it is possible to insert a select instruction that chooses between TrueReg and FalseReg based on the condition code in Cond .


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> const char * mips_output_probe_stack_range ( rtx reg1 , rtx reg2 ) { static int labelno = 0 ; char loop_lab [ 32 ] , tmp [ 64 ] ; rtx xops [ 2 ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , "LPSRL" , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ 0 ] = reg1 ; xops [ 1 ] = GEN_INT ( - PROBE_INTERVAL ) ; if ( TARGET_64BIT && TARGET_LONG64 ) output_asm_insn ( "daddiu\t%0,%0,%1" , xops ) ; else output_asm_insn ( "addiu\t%0,%0,%1" , xops ) ; xops [ 1 ] = reg2 ; strcpy ( tmp , "%(%<bne\t%0,%1," ) ; output_asm_insn ( strcat ( tmp , & loop_lab [ 1 ] ) , xops ) ; if ( TARGET_64BIT ) output_asm_insn ( "sd\t$0,0(%0)%)" , xops ) ; else output_asm_insn ( "sw\t$0,0(%0)%)" , xops ) ; return "" ; } </s>

Probe a range of stack addresses from REG1 to REG2 inclusive . These are absolute addresses .


<s> unsigned int m32c_dwarf_frame_regnum ( int n ) { switch ( n ) { case R0_REGNO : return 5 ; case R1_REGNO : return 6 ; case R2_REGNO : return 7 ; case R3_REGNO : return 8 ; case A0_REGNO : return 9 ; case A1_REGNO : return 10 ; case FB_REGNO : return 11 ; case SB_REGNO : return 19 ; case SP_REGNO : return 12 ; case PC_REGNO : return 13 ; default : return DWARF_FRAME_REGISTERS + 1 ; } } </s>

Implements DWARF_FRAME_REGNUM and DEBUGGER_REGNO . Note that the original spec called for dwarf numbers to vary with register width as well , for example , r0l , r0 , and r2r0 would each have different dwarf numbers . GCC does n't support this , and we do n't do it , and gdb seems to like it this way anyway .


<s> static rtx safe_vector_operand ( rtx x , machine_mode mode ) { if ( x != const0_rtx ) return x ; x = gen_reg_rtx ( SImode ) ; emit_insn ( gen_movsi ( x , CONST0_RTX ( SImode ) ) ) ; return gen_lowpart ( mode , x ) ; } </s>

Errors in the source file can cause expand_expr to return const0_rtx where we expect a vector . To avoid crashing , use one of the vector clear instructions .


<s> void aarch64_save_restore_target_globals ( tree new_tree ) { if ( TREE_TARGET_GLOBALS ( new_tree ) ) restore_target_globals ( TREE_TARGET_GLOBALS ( new_tree ) ) ; else if ( new_tree == target_option_default_node ) restore_target_globals ( & default_target_globals ) ; else TREE_TARGET_GLOBALS ( new_tree ) = save_target_globals_default_opts ( ) ; } </s>

Restore or save the TREE_TARGET_GLOBALS from or to NEW_TREE . Used by aarch64_set_current_function and aarch64_pragma_target_parse to make sure optab availability predicates are recomputed when necessary .


<s> void LC2200InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const DebugLoc & DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { BuildMI ( MBB , MI , DL , get ( LC2200 :: ADD ) ) . addReg ( DestReg ) . addReg ( SrcReg ) . addReg ( LC2200 :: zero ) ; } </s>


<s> void LEGRegisterInfo :: eliminateFrameIndex ( MachineBasicBlock :: iterator II , int SPAdj , unsigned FIOperandNum , RegScavenger * RS ) const { MachineInstr & MI = * II ; const MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; const MachineFrameInfo MFI = MF . getFrameInfo ( ) ; MachineOperand & FIOp = MI . getOperand ( FIOperandNum ) ; unsigned FI = FIOp . getIndex ( ) ; unsigned ImmOpIdx = 0 ; switch ( MI . getOpcode ( ) ) { default : return ; case LEG :: LDR : case LEG :: STR : ImmOpIdx = FIOperandNum + 1 ; break ; } MachineOperand & ImmOp = MI . getOperand ( ImmOpIdx ) ; int Offset = MFI . getObjectOffset ( FI ) + MFI . getStackSize ( ) + ImmOp . getImm ( ) ; FIOp . ChangeToRegister ( LEG :: SP , false ) ; ImmOp . setImm ( Offset ) ; } </s>

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


<s> static parallel * nvptx_find_par ( bb_insn_map_t * map , parallel * par , basic_block block ) { if ( block -> flags & BB_VISITED ) return par ; block -> flags |= BB_VISITED ; if ( rtx_insn * * endp = map -> get ( block ) ) { rtx_insn * end = * endp ; switch ( recog_memoized ( end ) ) { case CODE_FOR_return : return par ; case CODE_FOR_nvptx_forked : { unsigned mask = UINTVAL ( XVECEXP ( PATTERN ( end ) , 0 , 0 ) ) ; gcc_assert ( mask ) ; par = new parallel ( par , mask ) ; par -> forked_block = block ; par -> forked_insn = end ; if ( nvptx_needs_shared_bcast ( mask ) ) par -> fork_insn = nvptx_discover_pre ( block , CODE_FOR_nvptx_fork ) ; } break ; case CODE_FOR_nvptx_join : { unsigned mask = UINTVAL ( XVECEXP ( PATTERN ( end ) , 0 , 0 ) ) ; gcc_assert ( par -> mask == mask ) ; gcc_assert ( par -> join_block == NULL ) ; par -> join_block = block ; par -> join_insn = end ; if ( nvptx_needs_shared_bcast ( mask ) ) par -> joining_insn = nvptx_discover_pre ( block , CODE_FOR_nvptx_joining ) ; par = par -> parent ; } break ; default : gcc_unreachable ( ) ; } } if ( par ) par -> blocks . safe_push ( block ) ; else par = new parallel ( 0 , 0 ) ; edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , block -> succs ) nvptx_find_par ( map , par , e -> dest ) ; return par ; } </s>

See also 'gcc/omp-oacc-neuter-broadcast.cc : omp_sese_find_par ' .


<s> void ix86_free_from_memory ( enum machine_mode mode ) { if ( ! TARGET_RED_ZONE ) { int size ; if ( mode == DImode || TARGET_64BIT ) size = 8 ; else size = 4 ; emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( size ) ) ) ) ; } } </s>


<s>
void
PatmosOperand
::
print
(
raw_ostream
&
OS
)
const
{
switch
(
Kind
)
{
case
Immediate
:
getImm
(
)
->
print
(
OS
)
;
break
;
case
Register
:
OS
<<
"<register "
;
OS
<<
PatmosInstPrinter
::
getRegisterName
(
getReg
(
)
)
<<
">"
;
break
;
case
Token
:
OS
<<
"'"
<<
getToken
(
)
<<
"'"
;
break
;
case
Memory
:
{
OS
<<
"<memory "
;
OS
<<
getMemBase
(
)
;
OS
<<
", "
;
OS
<<
getMemOff
(
)
;
OS
<<
">"
;
}
break
;
}
}
</s>

Patmos
Patmos
"<register "
Patmos
">"
"'"
"'"
"<memory "
", "
">"


<s> bool SIRegisterInfo :: requiresFrameIndexScavenging ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; if ( MFI . hasStackObjects ( ) ) return true ; const SIMachineFunctionInfo * Info = MF . getInfo < SIMachineFunctionInfo > ( ) ; return ! Info -> isEntryFunction ( ) ; } </s>

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


<s> SDValue M680x0TargetLowering :: getPICJumpTableRelocBase ( SDValue Table , SelectionDAG & DAG ) const { if ( getJumpTableEncoding ( ) == MachineJumpTableInfo :: EK_Custom32 ) return DAG . getNode ( M680x0ISD :: GlobalBaseReg , SDLoc ( ) , getPointerTy ( DAG . getDataLayout ( ) ) ) ; return Table ; } </s>

Returns relocation base for the given PIC jumptable .


<s> unsigned X86RegisterInfo :: getRARegister ( ) const { if ( Is64Bit ) return X86 :: RIP ; else return X86 :: EIP ; } </s>

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


"Should be handled target independently"

Targets should implement this to emit instructions .


<s> unsigned ARMBaseInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : break ; case ARM :: STRrs : case ARM :: t2STRs : if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 2 ) . isReg ( ) && MI . getOperand ( 3 ) . isImm ( ) && MI . getOperand ( 2 ) . getReg ( ) == 0 && MI . getOperand ( 3 ) . getImm ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: STRi12 : case ARM :: t2STRi12 : case ARM :: tSTRspi : case ARM :: VSTRD : case ARM :: VSTRS : if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 2 ) . isImm ( ) && MI . getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: VSTR_P0_off : if ( MI . getOperand ( 0 ) . isFI ( ) && MI . getOperand ( 1 ) . isImm ( ) && MI . getOperand ( 1 ) . getImm ( ) == 0 ) { FrameIndex = MI . getOperand ( 0 ) . getIndex ( ) ; return ARM :: P0 ; } break ; case ARM :: VST1q64 : case ARM :: VST1d64TPseudo : case ARM :: VST1d64QPseudo : if ( MI . getOperand ( 0 ) . isFI ( ) && MI . getOperand ( 2 ) . getSubReg ( ) == 0 ) { FrameIndex = MI . getOperand ( 0 ) . getIndex ( ) ; return MI . getOperand ( 2 ) . getReg ( ) ; } break ; case ARM :: VSTMQIA : if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 0 ) . getSubReg ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s> MCObjectWriter * MipsAsmBackend :: createObjectWriter ( raw_pwrite_stream & OS ) const { return createMipsELFObjectWriter ( OS , MCELFObjectTargetWriter :: getOSABI ( OSType ) , IsLittle , Is64Bit ) ; } </s>

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


<s> int rs6000_reg_parm_stack_space ( tree fun , bool incoming ) { int reg_parm_stack_space ; switch ( DEFAULT_ABI ) { default : reg_parm_stack_space = 0 ; break ; case ABI_AIX : case ABI_DARWIN : reg_parm_stack_space = TARGET_64BIT ? 64 : 32 ; break ; case ABI_ELFv2 : if ( rs6000_function_parms_need_stack ( fun , incoming ) ) reg_parm_stack_space = TARGET_64BIT ? 64 : 32 ; else reg_parm_stack_space = 0 ; break ; } return reg_parm_stack_space ; } </s>

Return the size of the REG_PARM_STACK_SPACE are for FUN . This is usually a constant depending on the ABI . However , in the ELFv2 ABI the register parameter area is optional when calling a function that has a prototype is scope , has no variable argument list , and passes all parameters in registers .