<s> bool isPPC64 ( ) const { return IsPPC64 ; } </s>

Tests whether the target is 64-bit PowerPC ( little and big endian ) .


<s> void JVMAsmBackend :: applyFixup ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target , MutableArrayRef < char > Data , uint64_t Value , bool IsResolved , const MCSubtargetInfo * STI ) const { return ; } </s>

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


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

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


<s> TargetTransformInfo ARCTargetMachine :: getTargetTransformInfo ( const Function & F ) const { return TargetTransformInfo ( ARCTTIImpl ( this , F ) ) ; } </s>

Get a TargetTransformInfo implementation for the target .


<s>
unsigned
SparcInstrInfo
::
removeBranch
(
MachineBasicBlock
&
MBB
,
int
*
BytesRemoved
)
const
{
assert
(
!
BytesRemoved
&&
"code size not handled"
)
;
MachineBasicBlock
::
iterator
I
=
MBB
.
end
(
)
;
unsigned
Count
=
0
;
while
(
I
!=
MBB
.
begin
(
)
)
{
I
;
if
(
I
->
isDebugValue
(
)
)
continue
;
if
(
I
->
getOpcode
(
)
!=
SP
::
BA
&&
I
->
getOpcode
(
)
!=
SP
::
BCOND
&&
I
->
getOpcode
(
)
!=
SP
::
FBCOND
)
break
;
I
->
eraseFromParent
(
)
;
I
=
MBB
.
end
(
)
;
++
Count
;
}
return
Count
;
}
</s>

Remove the branching code at the end of the specific MBB .

Sparc
Sparc
"code size not handled"
0
SP::BA
SP::BCOND
SP::FBCOND


<s> static int enough_regs_for_param ( CUMULATIVE_ARGS * cum , const_tree type , machine_mode mode ) { int type_size ; int remaining_size ; if ( mode != BLKmode ) type_size = GET_MODE_BITSIZE ( mode ) ; else type_size = int_size_in_bytes ( type ) * BITS_PER_UNIT ; remaining_size = BITS_PER_WORD * ( MAX_REG_FOR_PASSING_ARGS - ( MIN_REG_FOR_PASSING_ARGS + cum -> ints ) + 1 ) ; if ( ( remaining_size >= type_size ) && ( type_size <= 2 * BITS_PER_WORD ) ) return ( type_size + BITS_PER_WORD - 1 ) / BITS_PER_WORD ; return 0 ; } </s>

If enough param regs are available for passing the param of type TYPE return * the number of registers needed else 0 .


<s> unsigned RISCVInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : return 0 ; case RISCV :: SB : case RISCV :: SH : case RISCV :: SW : case RISCV :: FSH : case RISCV :: FSW : case RISCV :: SD : case RISCV :: FSD : case RISCV :: SC_64 : case RISCV :: SC_128 : case RISCV :: CSB : case RISCV :: CSH : case RISCV :: CSW : case RISCV :: CFSW : case RISCV :: CSD : case RISCV :: CFSD : case RISCV :: CSC_64 : case RISCV :: CSC_128 : break ; } if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 2 ) . isImm ( ) && MI . getOperand ( 2 ) . getImm ( ) == 0 ) { 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> DecodeStatus VideocoreDisassembler :: getInstruction ( MCInst & instr , uint64_t & Size , const MemoryObject & Region , uint64_t Address , raw_ostream & vStream , raw_ostream & cStream ) const { DecodeStatus Result ; VideocoreBinaryInstr Insn ( Region , Address ) ; Size = Insn . size ( ) ; if ( Insn . type ( ) == VideocoreBinaryInstr :: Invalid ) return MCDisassembler :: Fail ; const uint8_t * Table ; switch ( Size ) { case 2 : Table = llvm :: DecoderTable16 ; break ; case 4 : Table = llvm :: DecoderTable32 ; break ; case 6 : Table = llvm :: DecoderTable48 ; break ; case 10 : Table = llvm :: DecoderTable80 ; break ; } Result = llvm :: decodeInstruction ( Table , instr , Insn , Address , this , STI ) ; if ( Result != MCDisassembler :: Fail ) { return Result ; } switch ( Insn . type ( ) ) { case VideocoreBinaryInstr :: Scalar16 : instr . setOpcode ( VC :: SCALAR16 ) ; break ; case VideocoreBinaryInstr :: Scalar32 : instr . setOpcode ( VC :: SCALAR32 ) ; break ; case VideocoreBinaryInstr :: Scalar48 : instr . setOpcode ( VC :: SCALAR48 ) ; break ; case VideocoreBinaryInstr :: Vector48 : instr . setOpcode ( VC :: VECTOR48 ) ; break ; case VideocoreBinaryInstr :: Vector80 : instr . setOpcode ( VC :: VECTOR80 ) ; break ; default : return MCDisassembler :: Fail ; } return MCDisassembler :: SoftFail ; } </s>

Returns the disassembly of a single instruction .


<s> int pdp10_stack_pointer_offset ( ) { return 1 ; } </s>

Called by the STACK_POINTER_OFFSET macro .


<s> static int rs6000_hard_regno_mode_ok ( int regno , enum machine_mode mode ) { if ( INT_REGNO_P ( regno ) ) return INT_REGNO_P ( regno + HARD_REGNO_NREGS ( regno , mode ) - 1 ) ; if ( FP_REGNO_P ( regno ) ) return ( GET_MODE_CLASS ( mode ) == MODE_FLOAT && FP_REGNO_P ( regno + HARD_REGNO_NREGS ( regno , mode ) - 1 ) ) || ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) == UNITS_PER_FP_WORD ) ; if ( CR_REGNO_P ( regno ) ) return GET_MODE_CLASS ( mode ) == MODE_CC ; if ( XER_REGNO_P ( regno ) ) return mode == PSImode ; if ( ALTIVEC_REGNO_P ( regno ) ) return ALTIVEC_VECTOR_MODE ( mode ) ; if ( SPE_SIMD_REGNO_P ( regno ) && TARGET_SPE && SPE_VECTOR_MODE ( mode ) ) return 1 ; return GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ; } </s>

Value is 1 if hard register REGNO can hold a value of machine-mode MODE .


<s> void SystemZPostRASchedStrategy :: initPolicy ( MachineBasicBlock :: iterator Begin , MachineBasicBlock :: iterator End , unsigned NumRegionInstrs ) { if ( Begin -> isTerminator ( ) ) return ; advanceTo ( Begin ) ; } </s>


<s> void X86RegisterInfo :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { const TargetFrameLowering * TFI = MF . getTarget ( ) . getFrameLowering ( ) ; bool reseveCallFrame = TFI -> hasReservedCallFrame ( MF ) ; int Opcode = I -> getOpcode ( ) ; bool isDestroy = Opcode == getCallFrameDestroyOpcode ( ) ; DebugLoc DL = I -> getDebugLoc ( ) ; uint64_t Amount = ! reseveCallFrame ? I -> getOperand ( 0 ) . getImm ( ) : 0 ; uint64_t CalleeAmt = isDestroy ? I -> getOperand ( 1 ) . getImm ( ) : 0 ; I = MBB . erase ( I ) ; if ( ! reseveCallFrame ) { if ( Amount == 0 ) return ; Amount = ( Amount + StackAlign - 1 ) / StackAlign * StackAlign ; MachineInstr * New = 0 ; if ( Opcode == getCallFrameSetupOpcode ( ) ) { New = BuildMI ( MF , DL , TII . get ( getSUBriOpcode ( Is64Bit , Amount ) ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } else { assert ( Opcode == getCallFrameDestroyOpcode ( ) ) ; Amount -= CalleeAmt ; if ( Amount ) { unsigned Opc = getADDriOpcode ( Is64Bit , Amount ) ; New = BuildMI ( MF , DL , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } } if ( New ) { New -> getOperand ( 3 ) . setIsDead ( ) ; MBB . insert ( I , New ) ; } return ; } if ( Opcode == getCallFrameDestroyOpcode ( ) && CalleeAmt ) { unsigned Opc = getSUBriOpcode ( Is64Bit , CalleeAmt ) ; MachineInstr * New = BuildMI ( MF , DL , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addImm ( CalleeAmt ) ; New -> getOperand ( 3 ) . setIsDead ( ) ; MBB . insert ( I , New ) ; } } </s>

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


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

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


<s> const char * arithmetic_instr ( rtx op , int shift_first_arg ) { switch ( GET_CODE ( op ) ) { case PLUS : return "add" ; case MINUS : return shift_first_arg ? "rsb" : "sub" ; case IOR : return "orr" ; case XOR : return "eor" ; case AND : return "and" ; default : gcc_unreachable ( ) ; } } </s>

Return the appropriate ARM instruction for the operation code . The returned result should not be overwritten . OP is the rtx of the operation . SHIFT_FIRST_ARG is TRUE if the first argument of the operator was shifted .


<s> std :: pair < unsigned , const TargetRegisterClass * > CAHPTargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'r' : return std :: make_pair ( 0U , & CAHP :: GPRRegClass ) ; default : break ; } } return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> bool aarch64_masks_and_shift_for_bfi_p ( scalar_int_mode mode , unsigned HOST_WIDE_INT mask1 , unsigned HOST_WIDE_INT shft_amnt , unsigned HOST_WIDE_INT mask2 ) { unsigned HOST_WIDE_INT t ; if ( mask1 != ~ mask2 ) return false ; if ( mask2 == 0 || mask2 == HOST_WIDE_INT_M1U ) return false ; gcc_assert ( shft_amnt < GET_MODE_BITSIZE ( mode ) ) ; t = mask2 + ( HOST_WIDE_INT_1U << shft_amnt ) ; return ( t == ( t & - t ) ) ; } </s>

Return true if the masks and a shift amount from an RTX of the form ( ( x & MASK1 ) | ( ( y < < SHIFT_AMNT ) & MASK2 ) ) are valid to combine into a BFI instruction of mode MODE . See * arch64_bfi patterns .


<s> bool X86FastISel :: tryToFoldLoadIntoMI ( MachineInstr * MI , unsigned OpNo , const LoadInst * LI ) { const Value * Ptr = LI -> getPointerOperand ( ) ; X86AddressMode AM ; if ( ! X86SelectAddress ( Ptr , AM ) ) return false ; const X86InstrInfo & XII = ( const X86InstrInfo & ) TII ; unsigned Size = DL . getTypeAllocSize ( LI -> getType ( ) ) ; SmallVector < MachineOperand , 8 > AddrOps ; AM . getFullAddress ( AddrOps ) ; MachineInstr * Result = XII . foldMemoryOperandImpl ( * FuncInfo . MF , * MI , OpNo , AddrOps , FuncInfo . InsertPt , Size , LI -> getAlign ( ) , true ) ; if ( ! Result ) return false ; unsigned OperandNo = 0 ; for ( MachineInstr :: mop_iterator I = Result -> operands_begin ( ) , E = Result -> operands_end ( ) ; I != E ; ++ I , ++ OperandNo ) { MachineOperand & MO = * I ; if ( ! MO . isReg ( ) || MO . isDef ( ) || MO . getReg ( ) != AM . IndexReg ) continue ; unsigned IndexReg = constrainOperandRegClass ( Result -> getDesc ( ) , MO . getReg ( ) , OperandNo ) ; if ( IndexReg == MO . getReg ( ) ) continue ; MO . setReg ( IndexReg ) ; } Result -> addMemOperand ( * FuncInfo . MF , createMachineMemOperandFor ( LI ) ) ; Result -> cloneInstrSymbols ( * FuncInfo . MF , * MI ) ; MachineBasicBlock :: iterator I ( MI ) ; removeDeadCode ( I , std :: next ( I ) ) ; return true ; } </s>

The specified machine instr operand is a vreg , and that vreg is being provided by the specified load instruction .


<s> bool ARMWinCOFFObjectWriter :: recordRelocation ( const MCFixup & Fixup ) const { return static_cast < unsigned > ( Fixup . getKind ( ) ) != ARM :: fixup_t2_movt_hi16 ; } </s>


<s> static rtx ix86_delegitimize_tls_address ( rtx orig_x ) { rtx x = orig_x , unspec ; struct ix86_address addr ; if ( ! TARGET_TLS_DIRECT_SEG_REFS ) return orig_x ; if ( MEM_P ( x ) ) x = XEXP ( x , 0 ) ; if ( GET_CODE ( x ) != PLUS || GET_MODE ( x ) != Pmode ) return orig_x ; if ( ix86_decompose_address ( x , & addr ) == 0 || addr . seg != DEFAULT_TLS_SEG_REG || addr . disp == NULL_RTX || GET_CODE ( addr . disp ) != CONST ) return orig_x ; unspec = XEXP ( addr . disp , 0 ) ; if ( GET_CODE ( unspec ) == PLUS && CONST_INT_P ( XEXP ( unspec , 1 ) ) ) unspec = XEXP ( unspec , 0 ) ; if ( GET_CODE ( unspec ) != UNSPEC || XINT ( unspec , 1 ) != UNSPEC_NTPOFF ) return orig_x ; x = XVECEXP ( unspec , 0 , 0 ) ; gcc_assert ( GET_CODE ( x ) == SYMBOL_REF ) ; if ( unspec != XEXP ( addr . disp , 0 ) ) x = gen_rtx_PLUS ( Pmode , x , XEXP ( XEXP ( addr . disp , 0 ) , 1 ) ) ; if ( addr . index ) { rtx idx = addr . index ; if ( addr . scale != 1 ) idx = gen_rtx_MULT ( Pmode , idx , GEN_INT ( addr . scale ) ) ; x = gen_rtx_PLUS ( Pmode , idx , x ) ; } if ( addr . base ) x = gen_rtx_PLUS ( Pmode , addr . base , x ) ; if ( MEM_P ( orig_x ) ) x = replace_equiv_address_nv ( orig_x , x ) ; return x ; } </s>

Helper function for ix86_delegitimize_address . Attempt to delegitimize TLS local-exec accesses .


<s> static int unspec_cdot ( int rot ) { switch ( rot ) { case 0 : return UNSPEC_CDOT ; case 90 : return UNSPEC_CDOT90 ; case 180 : return UNSPEC_CDOT180 ; case 270 : return UNSPEC_CDOT270 ; default : gcc_unreachable ( ) ; } } </s>

Return the UNSPEC_CDOT * unspec for rotation amount ROT .


<s> static void nvptx_function_arg_advance ( cumulative_args_t cum_v , const function_arg_info & ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; cum -> count ++ ; } </s>


<s> int AMDGPUFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , unsigned & FrameReg ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const AMDGPURegisterInfo * RI = MF . getSubtarget < AMDGPUSubtarget > ( ) . getRegisterInfo ( ) ; FrameReg = RI -> getFrameRegister ( MF ) ; unsigned OffsetBytes = 2 * ( getStackWidth ( MF ) * 4 ) ; int UpperBound = FI == - 1 ? MFI -> getNumObjects ( ) : FI ; for ( int i = MFI -> getObjectIndexBegin ( ) ; i < UpperBound ; ++ i ) { OffsetBytes = alignTo ( OffsetBytes , MFI -> getObjectAlignment ( i ) ) ; OffsetBytes += MFI -> getObjectSize ( i ) ; OffsetBytes = alignTo ( OffsetBytes , 4 ) ; } if ( FI != - 1 ) OffsetBytes = alignTo ( OffsetBytes , MFI -> getObjectAlignment ( FI ) ) ; return OffsetBytes / ( getStackWidth ( MF ) * 4 ) ; } </s>

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


<s> static enum attr_type type_for_anomaly ( rtx_insn * insn ) { rtx pat = PATTERN ( insn ) ; if ( rtx_sequence * seq = dyn_cast < rtx_sequence * > ( pat ) ) { enum attr_type t ; t = get_attr_type ( seq -> insn ( 1 ) ) ; if ( t == TYPE_MCLD ) return t ; t = get_attr_type ( seq -> insn ( 2 ) ) ; if ( t == TYPE_MCLD ) return t ; return TYPE_MCST ; } else return get_attr_type ( insn ) ; } </s>

Return an insn type for INSN that can be used by the caller for anomaly workarounds . This differs from plain get_attr_type in that it handles SEQUENCEs .


<s> bool ARMTargetLowering :: isLegalAddressingMode ( const AddrMode & AM , Type * Ty ) const { EVT VT = getValueType ( Ty , true ) ; if ( ! isLegalAddressImmediate ( AM . BaseOffs , VT , Subtarget ) ) return false ; if ( AM . BaseGV ) return false ; switch ( AM . Scale ) { case 0 : break ; case 1 : if ( Subtarget -> isThumb1Only ( ) ) return false ; default : if ( AM . BaseOffs ) return false ; if ( ! VT . isSimple ( ) ) return false ; if ( Subtarget -> isThumb2 ( ) ) return isLegalT2ScaledAddressingMode ( AM , VT ) ; int Scale = AM . Scale ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { default : return false ; case MVT :: i1 : case MVT :: i8 : case MVT :: i32 : if ( Scale < 0 ) Scale = - Scale ; if ( Scale == 1 ) return true ; return isPowerOf2_32 ( Scale & ~ 1 ) ; case MVT :: i16 : case MVT :: i64 : if ( ( ( unsigned ) AM . HasBaseReg + Scale ) <= 2 ) return true ; return false ; case MVT :: isVoid : if ( Scale & 1 ) return false ; return isPowerOf2_32 ( Scale ) ; } } return true ; } </s>

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


<s> static bool classof ( const MCExpr * E ) { return E -> getKind ( ) == MCExpr :: Target ; } </s>

Methods for support type inquiry through isa , cast , and dyn_cast :


<s> bool HexagonPassConfig :: addPreSched2 ( ) { addPass ( & IfConverterID ) ; return true ; } </s>

This method may be implemented by targets that want to run passes after prolog-epilog insertion and before the second instruction scheduling pass .


<s> int shadd_constant_p ( int val ) { if ( val == 2 || val == 4 || val == 8 ) return 1 ; else return 0 ; } </s>

Return 1 if the given constant is 2 , 4 , or 8 . These are the valid constants for shadd instructions .


<s> static void ix86_dependencies_evaluation_hook ( rtx_insn * head , rtx_insn * tail ) { rtx_insn * insn ; rtx_insn * first_arg = NULL ; if ( reload_completed ) return ; while ( head != tail && DEBUG_INSN_P ( head ) ) head = NEXT_INSN ( head ) ; for ( insn = tail ; insn != head ; insn = PREV_INSN ( insn ) ) if ( INSN_P ( insn ) && CALL_P ( insn ) ) { first_arg = add_parameter_dependencies ( insn , head ) ; if ( first_arg ) { basic_block bb = BLOCK_FOR_INSN ( insn ) ; int rgn = CONTAINING_RGN ( bb -> index ) ; int nr_blks = RGN_NR_BLOCKS ( rgn ) ; if ( nr_blks > 1 && BLOCK_TO_BB ( bb -> index ) != 0 ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , bb -> preds ) { if ( rgn == CONTAINING_RGN ( e -> src -> index ) && BLOCK_TO_BB ( bb -> index ) > BLOCK_TO_BB ( e -> src -> index ) ) add_dependee_for_func_arg ( first_arg , e -> src ) ; } } insn = first_arg ; if ( insn == head ) break ; } } else if ( first_arg ) avoid_func_arg_motion ( first_arg , insn ) ; } </s>

Hook for pre-reload schedule - avoid motion of function arguments passed in likely spilled HW registers .


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> bool TPCHazardRecognizer :: atIssueLimit ( ) const { return ( CurrentPacket . size ( ) == 4 ) ; } </s>

atIssueLimit - Return true if no more instructions may be issued in this cycle .


"\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\n"

Worker function for TARGET_SETUP_INCOMING_VARARGS .


<s> const DLXSubtarget * getSubtargetImpl ( const llvm :: Function & ) const override { return & Subtarget ; } </s>

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


"passing %wd to argument %d of %qE, which expects"

Report that LOCATION has a call to FNDECL in which argument ARGNO has the value ACTUAL , whereas the function requires either VALUE0 or VALUE1 . ARGNO counts from zero .


<s> unsigned MSP430InstrInfo :: getInstSizeInBytes ( const MachineInstr & MI ) const { const MCInstrDesc & Desc = MI . getDesc ( ) ; switch ( Desc . getOpcode ( ) ) { case TargetOpcode :: CFI_INSTRUCTION : case TargetOpcode :: EH_LABEL : case TargetOpcode :: IMPLICIT_DEF : case TargetOpcode :: KILL : case TargetOpcode :: DBG_VALUE : return 0 ; case TargetOpcode :: INLINEASM : case TargetOpcode :: INLINEASM_BR : { const MachineFunction * MF = MI . getParent ( ) -> getParent ( ) ; const TargetInstrInfo & TII = * MF -> getSubtarget ( ) . getInstrInfo ( ) ; return TII . getInlineAsmLength ( MI . getOperand ( 0 ) . getSymbolName ( ) , * MF -> getTarget ( ) . getMCAsmInfo ( ) ) ; } } return Desc . getSize ( ) ; } </s>

Returns the size in bytes of the specified MachineInstr , or ~0U when this function is not implemented by a target .


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

runOnMachineFunction - Emit the function body .


<s> bool ARMInstrInfo :: PredicateInstruction ( MachineInstr * MI , const SmallVectorImpl < MachineOperand > & Pred ) const { unsigned Opc = MI -> getOpcode ( ) ; if ( Opc == ARM :: B || Opc == ARM :: tB ) { MI -> setDesc ( get ( Opc == ARM :: B ? ARM :: Bcc : ARM :: tBcc ) ) ; MI -> addOperand ( MachineOperand :: CreateImm ( Pred [ 0 ] . getImm ( ) ) ) ; MI -> addOperand ( MachineOperand :: CreateReg ( Pred [ 1 ] . getReg ( ) , false ) ) ; return true ; } int PIdx = MI -> findFirstPredOperandIdx ( ) ; if ( PIdx != - 1 ) { MachineOperand & PMO = MI -> getOperand ( PIdx ) ; PMO . setImm ( Pred [ 0 ] . getImm ( ) ) ; MI -> getOperand ( PIdx + 1 ) . setReg ( Pred [ 1 ] . getReg ( ) ) ; return true ; } return false ; } </s>

Convert the instruction into a predicated instruction .


<s>
void
SIInstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
Register
SrcReg
,
bool
isKill
,
int
FrameIndex
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
MachineFunction
*
MF
=
MBB
.
getParent
(
)
;
SIMachineFunctionInfo
*
MFI
=
MF
->
getInfo
<
SIMachineFunctionInfo
>
(
)
;
MachineFrameInfo
&
FrameInfo
=
MF
->
getFrameInfo
(
)
;
const
DebugLoc
&
DL
=
MBB
.
findDebugLoc
(
MI
)
;
MachinePointerInfo
PtrInfo
=
MachinePointerInfo
::
getFixedStack
(
*
MF
,
FrameIndex
)
;
MachineMemOperand
*
MMO
=
MF
->
getMachineMemOperand
(
PtrInfo
,
MachineMemOperand
::
MOStore
,
FrameInfo
.
getObjectSize
(
FrameIndex
)
,
FrameInfo
.
getObjectAlign
(
FrameIndex
)
)
;
unsigned
SpillSize
=
TRI
->
getSpillSize
(
*
RC
)
;
if
(
RI
.
isSGPRClass
(
RC
)
)
{
MFI
->
setHasSpilledSGPRs
(
)
;
assert
(
SrcReg
!=
AMDGPU
::
M0
&&
"m0 should not be spilled"
)
;
assert
(
SrcReg
!=
AMDGPU
::
EXEC_LO
&&
SrcReg
!=
AMDGPU
::
EXEC_HI
&&
SrcReg
!=
AMDGPU
::
EXEC
&&
"exec should not be spilled"
)
;
const
MCInstrDesc
&
OpDesc
=
get
(
getSGPRSpillSaveOpcode
(
SpillSize
)
)
;
if
(
SrcReg
.
isVirtual
(
)
&&
SpillSize
==
4
)
{
MachineRegisterInfo
&
MRI
=
MF
->
getRegInfo
(
)
;
MRI
.
constrainRegClass
(
SrcReg
,
&
AMDGPU
::
SReg_32_XM0_XEXECRegClass
)
;
}
BuildMI
(
MBB
,
MI
,
DL
,
OpDesc
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FrameIndex
)
.
addMemOperand
(
MMO
)
.
addReg
(
MFI
->
getStackPtrOffsetReg
(
)
,
RegState
::
Implicit
)
;
if
(
RI
.
spillSGPRToVGPR
(
)
)
FrameInfo
.
setStackID
(
FrameIndex
,
TargetStackID
::
SGPRSpill
)
;
return
;
}
unsigned
Opcode
=
RI
.
isAGPRClass
(
RC
)
getAGPRSpillSaveOpcode
(
SpillSize
)
:
getVGPRSpillSaveOpcode
(
SpillSize
)
;
MFI
->
setHasSpilledVGPRs
(
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opcode
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FrameIndex
)
.
addReg
(
MFI
->
getStackPtrOffsetReg
(
)
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
;
}
</s>

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


"%qE attribute only applies to functions"

Handle an `` trap_exit '' attribute ; arguments as in struct attribute_spec.handler .


<s> bool SparcRegisterInfo :: canRealignStack ( const MachineFunction & MF ) const { if ( ! TargetRegisterInfo :: canRealignStack ( MF ) ) return false ; if ( getFrameLowering ( MF ) -> hasReservedCallFrame ( MF ) ) return true ; return false ; } </s>

True if the stack can be realigned for the target .


<s> std :: pair < SDValue , SDValue > AMDGPUTargetLowering :: split64BitValue ( SDValue Op , SelectionDAG & DAG ) const { SDLoc SL ( Op ) ; SDValue Vec = DAG . getNode ( ISD :: BITCAST , SL , MVT :: v2i32 , Op ) ; const SDValue Zero = DAG . getConstant ( 0 , SL , MVT :: i32 ) ; const SDValue One = DAG . getConstant ( 1 , SL , MVT :: i32 ) ; SDValue Lo = DAG . getNode ( ISD :: EXTRACT_VECTOR_ELT , SL , MVT :: i32 , Vec , Zero ) ; SDValue Hi = DAG . getNode ( ISD :: EXTRACT_VECTOR_ELT , SL , MVT :: i32 , Vec , One ) ; return std :: make_pair ( Lo , Hi ) ; } </s>

Return 64-bit value Op as two 32-bit integers .


<s> void ia64_expand_vecint_cmov ( rtx operands [ ] ) { machine_mode mode = GET_MODE ( operands [ 0 ] ) ; enum rtx_code code = GET_CODE ( operands [ 3 ] ) ; bool negate ; rtx cmp , x , ot , of ; cmp = gen_reg_rtx ( mode ) ; negate = ia64_expand_vecint_compare ( code , mode , cmp , operands [ 4 ] , operands [ 5 ] ) ; ot = operands [ 1 + negate ] ; of = operands [ 2 - negate ] ; if ( ot == CONST0_RTX ( mode ) ) { if ( of == CONST0_RTX ( mode ) ) { emit_move_insn ( operands [ 0 ] , ot ) ; return ; } x = gen_rtx_NOT ( mode , cmp ) ; x = gen_rtx_AND ( mode , x , of ) ; emit_insn ( gen_rtx_SET ( operands [ 0 ] , x ) ) ; } else if ( of == CONST0_RTX ( mode ) ) { x = gen_rtx_AND ( mode , cmp , ot ) ; emit_insn ( gen_rtx_SET ( operands [ 0 ] , x ) ) ; } else { rtx t , f ; t = gen_reg_rtx ( mode ) ; x = gen_rtx_AND ( mode , cmp , operands [ 1 + negate ] ) ; emit_insn ( gen_rtx_SET ( t , x ) ) ; f = gen_reg_rtx ( mode ) ; x = gen_rtx_NOT ( mode , cmp ) ; x = gen_rtx_AND ( mode , x , operands [ 2 - negate ] ) ; emit_insn ( gen_rtx_SET ( f , x ) ) ; x = gen_rtx_IOR ( mode , t , f ) ; emit_insn ( gen_rtx_SET ( operands [ 0 ] , x ) ) ; } } </s>

Emit an integral vector conditional move .


<s> static tree arm_promoted_type ( const_tree t ) { if ( SCALAR_FLOAT_TYPE_P ( t ) && TYPE_PRECISION ( t ) == 16 && TYPE_MAIN_VARIANT ( t ) == arm_fp16_type_node ) return float_type_node ; return NULL_TREE ; } </s>


<s> bool mayNeedRelaxation ( const MCInst & Inst ) const override { return false ; } </s>

Check whether the given instruction may need relaxation .


<s>
X86TargetMachine
::
X86TargetMachine
(
const
Target
&
T
,
const
std
::
string
&
TT
,
const
std
::
string
&
FS
,
bool
is64Bit
)
:
LLVMTargetMachine
(
T
,
TT
)
,
Subtarget
(
TT
,
FS
,
is64Bit
)
,
DataLayout
(
Subtarget
.
getDataLayout
(
)
)
,
FrameInfo
(
TargetFrameInfo
::
StackGrowsDown
,
Subtarget
.
getStackAlignment
(
)
,
(
Subtarget
.
isTargetWin64
(
)
40
:
(
Subtarget
.
is64Bit
(
)
8
:
4
)
)
)
,
InstrInfo
(
*
this
)
,
JITInfo
(
*
this
)
,
TLInfo
(
*
this
)
,
TSInfo
(
*
this
)
,
ELFWriterInfo
(
*
this
)
{
DefRelocModel
=
getRelocationModel
(
)
;
if
(
getRelocationModel
(
)
==
Reloc
::
Default
)
{
if
(
Subtarget
.
isTargetDarwin
(
)
)
{
if
(
Subtarget
.
is64Bit
(
)
)
setRelocationModel
(
Reloc
::
PIC_
)
;
else
setRelocationModel
(
Reloc
::
DynamicNoPIC
)
;
}
else
if
(
Subtarget
.
isTargetWin64
(
)
)
setRelocationModel
(
Reloc
::
PIC_
)
;
else
setRelocationModel
(
Reloc
::
Static
)
;
}
assert
(
getRelocationModel
(
)
!=
Reloc
::
Default
&&
"Relocation mode not picked"
)
;
if
(
getRelocationModel
(
)
==
Reloc
::
DynamicNoPIC
)
{
if
(
is64Bit
)
setRelocationModel
(
Reloc
::
PIC_
)
;
else
if
(
!
Subtarget
.
isTargetDarwin
(
)
)
setRelocationModel
(
Reloc
::
Static
)
;
}
if
(
getRelocationModel
(
)
==
Reloc
::
Static
&&
Subtarget
.
isTargetDarwin
(
)
&&
is64Bit
)
setRelocationModel
(
Reloc
::
PIC_
)
;
if
(
getRelocationModel
(
)
==
Reloc
::
Static
)
{
Subtarget
.
setPICStyle
(
PICStyles
::
)
;
}
else
if
(
Subtarget
.
is64Bit
(
)
)
{
Subtarget
.
setPICStyle
(
PICStyles
::
RIPRel
)
;
}
else
if
(
Subtarget
.
isTargetCygMing
(
)
)
{
Subtarget
.
setPICStyle
(
PICStyles
::
)
;
}
else
if
(
Subtarget
.
isTargetDarwin
(
)
)
{
if
(
getRelocationModel
(
)
==
Reloc
::
PIC_
)
Subtarget
.
setPICStyle
(
PICStyles
::
StubPIC
)
;
else
{
assert
(
getRelocationModel
(
)
==
Reloc
::
DynamicNoPIC
)
;
Subtarget
.
setPICStyle
(
PICStyles
::
StubDynamicNoPIC
)
;
}
}
else
if
(
Subtarget
.
isTargetELF
(
)
)
{
Subtarget
.
setPICStyle
(
PICStyles
::
GOT
)
;
}
if
(
Subtarget
.
getPICStyle
(
)
==
PICStyles
::
)
setRelocationModel
(
Reloc
::
Static
)
;
}
</s>


<s> TargetTransformInfo GCNTargetMachine :: getTargetTransformInfo ( const Function & F ) { return TargetTransformInfo ( GCNTTIImpl ( this , F ) ) ; } </s>

Get a TargetTransformInfo implementation for the target .


"Instr doesn't have FrameIndex operand!"

Resolve a frame index operand of an instruction to reference the indicated base register plus offset instead .


<s>
unsigned
Cpu0SEInstrInfo
::
getOppositeBranchOpc
(
unsigned
Opc
)
const
{
switch
(
Opc
)
{
default
:
llvm_unreachable
(
"Illegal opcode!"
)
;
case
Cpu0
::
BEQ
:
return
Cpu0
::
BNE
;
case
Cpu0
::
BNE
:
return
Cpu0
::
BEQ
;
}
}
</s>

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


<s>
SDNode
*
SystemZDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
DEBUG
(
errs
(
)
<<
"Selecting: "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
if
(
Node
->
isMachineOpcode
(
)
)
{
DEBUG
(
errs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
return
0
;
}
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
SDNode
*
ResNode
=
0
;
switch
(
Opcode
)
{
case
ISD
::
OR
:
case
ISD
::
XOR
:
if
(
Node
->
getValueType
(
0
)
==
MVT
::
i64
)
if
(
ConstantSDNode
*
Op1
=
dyn_cast
<
ConstantSDNode
>
(
Node
->
getOperand
(
1
)
)
)
{
uint64_t
Val
=
Op1
->
getZExtValue
(
)
;
if
(
!
SystemZ
::
isImmLF
(
Val
)
&&
!
SystemZ
::
isImmHF
(
Val
)
)
Node
=
splitLargeImmediate
(
Opcode
,
Node
,
Node
->
getOperand
(
0
)
,
Val
uint32_t
(
Val
)
,
uint32_t
(
Val
)
)
;
}
break
;
case
ISD
::
AND
:
ResNode
=
tryRISBGForAND
(
Node
)
;
break
;
case
ISD
::
Constant
:
if
(
Node
->
getValueType
(
0
)
==
MVT
::
i64
)
{
uint64_t
Val
=
cast
<
ConstantSDNode
>
(
Node
)
->
getZExtValue
(
)
;
if
(
!
SystemZ
::
isImmLF
(
Val
)
&&
!
SystemZ
::
isImmHF
(
Val
)
&&
!
isInt
<
32
>
(
Val
)
)
Node
=
splitLargeImmediate
(
ISD
::
OR
,
Node
,
SDValue
(
)
,
Val
uint32_t
(
Val
)
,
uint32_t
(
Val
)
)
;
}
break
;
case
ISD
::
ATOMIC_LOAD_SUB
:
if
(
ConstantSDNode
*
Op2
=
dyn_cast
<
ConstantSDNode
>
(
Node
->
getOperand
(
2
)
)
)
{
uint64_t
Value
=
Op2
->
getZExtValue
(
)
;
EVT
VT
=
Node
->
getValueType
(
0
)
;
if
(
VT
==
MVT
::
i32
||
isInt
<
32
>
(
Value
)
)
{
SDValue
Ops
[
]
=
{
Node
->
getOperand
(
0
)
,
Node
->
getOperand
(
1
)
,
CurDAG
->
getConstant
(
int32_t
(
Value
)
,
VT
)
}
;
Node
=
CurDAG
->
MorphNodeTo
(
Node
,
ISD
::
ATOMIC_LOAD_ADD
,
Node
->
getVTList
(
)
,
Ops
,
array_lengthof
(
Ops
)
)
;
}
}
break
;
}
if
(
!
ResNode
)
ResNode
=
SelectCode
(
Node
)
;
DEBUG
(
errs
(
)
<<
"=> "
;
if
(
ResNode
==
||
ResNode
==
Node
)
Node
->
dump
(
CurDAG
)
;
else
ResNode
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
;
)
;
return
ResNode
;
}
</s>

Main hook for targets to transform nodes into machine nodes .


<s> static bool riscv_pass_by_reference ( cumulative_args_t cum_v , const function_arg_info & arg ) { HOST_WIDE_INT size = arg . type_size_in_bytes ( ) ; struct riscv_arg_info info ; CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( cum != NULL ) { riscv_get_arg_info ( & info , cum , arg . mode , arg . type , arg . named , false ) ; if ( info . num_fprs ) return false ; } return ! IN_RANGE ( size , 0 , 2 * UNITS_PER_WORD ) ; } </s>


"Do not know how to return this many arguments!"

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


<s> const RegisterBankInfo :: InstructionMapping & M68kRegisterBankInfo :: getInstrMapping ( const MachineInstr & MI ) const { auto Opc = MI . getOpcode ( ) ; if ( ! isPreISelGenericOpcode ( Opc ) ) { const InstructionMapping & Mapping = getInstrMappingImpl ( MI ) ; if ( Mapping . isValid ( ) ) return Mapping ; } using namespace TargetOpcode ; unsigned NumOperands = MI . getNumOperands ( ) ; const ValueMapping * OperandsMapping = & M68k :: ValueMappings [ M68k :: GPR3OpsIdx ] ; switch ( Opc ) { case G_ADD : case G_SUB : case G_MUL : case G_SDIV : case G_UDIV : case G_LOAD : case G_STORE : { OperandsMapping = & M68k :: ValueMappings [ M68k :: GPR3OpsIdx ] ; break ; } case G_CONSTANT : case G_FRAME_INDEX : OperandsMapping = getOperandsMapping ( { & M68k :: ValueMappings [ M68k :: GPR3OpsIdx ] , nullptr } ) ; break ; default : return getInvalidInstructionMapping ( ) ; } return getInstructionMapping ( DefaultMappingID , 1 , OperandsMapping , NumOperands ) ; } </s>

Get the mapping of the different operands of MI on the register bank .


<s> static void alpha_expand_unaligned_store_words ( rtx * data_regs , rtx dmem , HOST_WIDE_INT words , HOST_WIDE_INT ofs ) { rtx const im8 = GEN_INT ( - 8 ) ; rtx ins_tmps [ MAX_MOVE_WORDS ] ; rtx st_tmp_1 , st_tmp_2 , dreg ; rtx st_addr_1 , st_addr_2 , dmema ; HOST_WIDE_INT i ; dmema = XEXP ( dmem , 0 ) ; if ( GET_CODE ( dmema ) == LO_SUM ) dmema = force_reg ( Pmode , dmema ) ; if ( data_regs != NULL ) for ( i = 0 ; i < words ; ++ i ) ins_tmps [ i ] = gen_reg_rtx ( DImode ) ; st_tmp_1 = gen_reg_rtx ( DImode ) ; st_tmp_2 = gen_reg_rtx ( DImode ) ; if ( ofs != 0 ) dmem = adjust_address ( dmem , GET_MODE ( dmem ) , ofs ) ; st_addr_2 = change_address ( dmem , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , dmema , words * 8 - 1 ) , im8 ) ) ; set_mem_alias_set ( st_addr_2 , 0 ) ; st_addr_1 = change_address ( dmem , DImode , gen_rtx_AND ( DImode , dmema , im8 ) ) ; set_mem_alias_set ( st_addr_1 , 0 ) ; emit_move_insn ( st_tmp_2 , st_addr_2 ) ; emit_move_insn ( st_tmp_1 , st_addr_1 ) ; dreg = copy_addr_to_reg ( dmema ) ; if ( data_regs != NULL ) { for ( i = words - 1 ; i >= 0 ; -- i ) { emit_insn ( gen_insqh ( ins_tmps [ i ] , data_regs [ i ] , dreg ) ) ; emit_insn ( gen_insql ( data_regs [ i ] , data_regs [ i ] , dreg ) ) ; } for ( i = words - 1 ; i > 0 ; -- i ) { ins_tmps [ i - 1 ] = expand_binop ( DImode , ior_optab , data_regs [ i ] , ins_tmps [ i - 1 ] , ins_tmps [ i - 1 ] , 1 , OPTAB_WIDEN ) ; } } emit_insn ( gen_mskqh ( st_tmp_2 , st_tmp_2 , dreg ) ) ; emit_insn ( gen_mskql ( st_tmp_1 , st_tmp_1 , dreg ) ) ; if ( data_regs != NULL ) { st_tmp_2 = expand_binop ( DImode , ior_optab , st_tmp_2 , ins_tmps [ words - 1 ] , st_tmp_2 , 1 , OPTAB_WIDEN ) ; st_tmp_1 = expand_binop ( DImode , ior_optab , st_tmp_1 , data_regs [ 0 ] , st_tmp_1 , 1 , OPTAB_WIDEN ) ; } emit_move_insn ( st_addr_2 , st_tmp_2 ) ; for ( i = words - 1 ; i > 0 ; -- i ) { rtx tmp = change_address ( dmem , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , dmema , i * 8 ) , im8 ) ) ; set_mem_alias_set ( tmp , 0 ) ; emit_move_insn ( tmp , data_regs ? ins_tmps [ i - 1 ] : const0_rtx ) ; } emit_move_insn ( st_addr_1 , st_tmp_1 ) ; } </s>

Store an integral number of consecutive unaligned quadwords . DATA_REGS may be NULL to store zeros .


<s> void applyFixup ( const MCFixup & Fixup , char * Data , unsigned DataSize , uint64_t Value , bool IsPCRel ) const { Value = adjustFixupValue ( Fixup . getKind ( ) , Value ) ; if ( ! Value ) return ; unsigned Offset = Fixup . getOffset ( ) ; unsigned NumBytes = getFixupKindNumBytes ( Fixup . getKind ( ) ) ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = IsLittleEndian ? i : ( NumBytes - 1 - i ) ; Data [ Offset + i ] |= uint8_t ( ( Value >> ( Idx * 8 ) ) & 0xff ) ; } } </s>

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


<s> static rtx arc_legitimize_tls_address ( rtx addr , enum tls_model model ) { rtx tmp ; if ( ! flag_pic && model == TLS_MODEL_LOCAL_DYNAMIC ) model = TLS_MODEL_LOCAL_EXEC ; gcc_assert ( arc_tp_regno != - 1 ) ; switch ( model ) { case TLS_MODEL_GLOBAL_DYNAMIC : tmp = gen_reg_rtx ( Pmode ) ; emit_move_insn ( tmp , arc_unspec_offset ( addr , UNSPEC_TLS_GD ) ) ; return arc_call_tls_get_addr ( tmp ) ; case TLS_MODEL_LOCAL_DYNAMIC : rtx base ; tree decl ; const char * base_name ; decl = SYMBOL_REF_DECL ( addr ) ; base_name = DTPOFF_ZERO_SYM ; if ( decl && bss_initializer_p ( decl ) ) base_name = ".tbss" ; base = gen_rtx_SYMBOL_REF ( Pmode , base_name ) ; tmp = gen_reg_rtx ( Pmode ) ; emit_move_insn ( tmp , arc_unspec_offset ( base , UNSPEC_TLS_GD ) ) ; base = arc_call_tls_get_addr ( tmp ) ; return gen_rtx_PLUS ( Pmode , force_reg ( Pmode , base ) , arc_unspec_offset ( addr , UNSPEC_TLS_OFF ) ) ; case TLS_MODEL_INITIAL_EXEC : addr = arc_unspec_offset ( addr , UNSPEC_TLS_IE ) ; addr = copy_to_mode_reg ( Pmode , gen_const_mem ( Pmode , addr ) ) ; return gen_rtx_PLUS ( Pmode , gen_rtx_REG ( Pmode , arc_tp_regno ) , addr ) ; case TLS_MODEL_LOCAL_EXEC : addr = arc_unspec_offset ( addr , UNSPEC_TLS_OFF ) ; return gen_rtx_PLUS ( Pmode , gen_rtx_REG ( Pmode , arc_tp_regno ) , addr ) ; default : gcc_unreachable ( ) ; } } </s>

Return a legitimized address for ADDR , which is a SYMBOL_REF with tls_model MODEL .


<s> bool ARMPreAllocLoadStoreOpt :: runOnMachineFunction ( MachineFunction & Fn ) { TD = & Fn . getDataLayout ( ) ; STI = & static_cast < const ARMSubtarget & > ( Fn . getSubtarget ( ) ) ; TII = STI -> getInstrInfo ( ) ; TRI = STI -> getRegisterInfo ( ) ; MRI = & Fn . getRegInfo ( ) ; MF = & Fn ; bool Modified = false ; for ( MachineFunction :: iterator MFI = Fn . begin ( ) , E = Fn . end ( ) ; MFI != E ; ++ MFI ) Modified |= RescheduleLoadStoreInstrs ( MFI ) ; return Modified ; } </s>

runOnMachineFunction - Emit the function body .


<s> int call_address_operand ( rtx op , enum machine_mode mode ) { return ( symbolic_operand ( op , mode ) || ( GET_CODE ( op ) == CONST_INT && LEGITIMATE_CONSTANT_P ( op ) ) || ( GET_CODE ( op ) == REG ) ) ; } </s>

Return true if OP is a valid call operand .


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"TLCS900 Branch Selector"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool PPCAIXAsmPrinter :: doFinalization ( Module & M ) { for ( MCSymbol * Sym : ExtSymSDNodeSymbols ) OutStreamer -> emitSymbolAttribute ( Sym , MCSA_Extern ) ; return PPCAsmPrinter :: doFinalization ( M ) ; } </s>

doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes have run .


<s> SDValue Nios2TargetLowering :: LowerReturn ( SDValue Chain , CallingConv :: ID CallConv , bool IsVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , const SmallVectorImpl < SDValue > & OutVals , const SDLoc & DL , SelectionDAG & DAG ) const { SmallVector < SDValue , 4 > RetOps ( 1 , Chain ) ; return DAG . getNode ( Nios2ISD :: Ret , DL , MVT :: Other , RetOps ) ; } </s>


<s> unsigned PPCRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; if ( ! Subtarget . isPPC64 ( ) ) return TFI -> hasFP ( MF ) ? PPC :: R31 : PPC :: R1 ; else return TFI -> hasFP ( MF ) ? PPC :: X31 : PPC :: X1 ; } </s>


<s> ARMCC :: CondCodes getPredicate ( const MachineInstr * MI ) const { int PIdx = MI -> findFirstPredOperandIdx ( ) ; return PIdx != - 1 ? ( ARMCC :: CondCodes ) MI -> getOperand ( PIdx ) . getImm ( ) : ARMCC :: AL ; } </s>

Returns the comparison predicate underlying the intrinsic .

ARM ARMCC::CondCodes 1 ARMCC::CondCodes ARMCC::AL


<s> void h8300_expand_epilogue ( void ) { int regno ; int saved_regs ; int n_regs ; HOST_WIDE_INT frame_size ; bool returned_p ; if ( h8300_os_task_function_p ( current_function_decl ) ) return ; frame_size = round_frame_size ( get_frame_size ( ) ) ; returned_p = false ; h8300_emit_stack_adjustment ( 1 , frame_size ) ; saved_regs = compute_saved_regs ( ) ; for ( regno = FIRST_PSEUDO_REGISTER - 1 ; regno >= 0 ; regno -= n_regs ) { n_regs = 1 ; if ( saved_regs & ( 1 << regno ) ) { if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & 3 ) == 3 ) && ( ( saved_regs << 3 >> regno ) & 0x0f ) == 0x0f ) n_regs = 4 ; else if ( ( TARGET_H8300SX || ( regno & 3 ) == 2 ) && ( ( saved_regs << 2 >> regno ) & 0x07 ) == 0x07 ) n_regs = 3 ; else if ( ( TARGET_H8300SX || ( regno & 1 ) == 1 ) && ( ( saved_regs << 1 >> regno ) & 0x03 ) == 0x03 ) n_regs = 2 ; } if ( TARGET_H8300SX && ! frame_pointer_needed && frame_size == 0 && ( saved_regs & ( ( 1 << ( regno - n_regs + 1 ) ) - 1 ) ) == 0 ) returned_p = true ; h8300_push_pop ( regno - n_regs + 1 , n_regs , 1 , returned_p ) ; } } if ( frame_pointer_needed ) { if ( TARGET_H8300SX ) returned_p = true ; h8300_push_pop ( HARD_FRAME_POINTER_REGNUM , 1 , 1 , returned_p ) ; } if ( ! returned_p ) emit_insn ( gen_rtx_RETURN ( VOIDmode ) ) ; } </s>

Generate RTL code for the function epilogue .


<s> void emitIndIdx ( const MCExpr * ) override { } </s>


<s> static bool ix86_valid_target_attribute_p ( tree fndecl , tree ARG_UNUSED ( name ) , tree args , int ARG_UNUSED ( flags ) ) { struct gcc_options func_options ; tree new_target , new_optimize ; bool ret = true ; if ( TREE_VALUE ( args ) && TREE_CODE ( TREE_VALUE ( args ) ) == STRING_CST && TREE_CHAIN ( args ) == NULL_TREE && strcmp ( TREE_STRING_POINTER ( TREE_VALUE ( args ) ) , "default" ) == 0 ) return true ; tree old_optimize = build_optimization_node ( & global_options ) ; tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) ; if ( ! func_optimize ) func_optimize = old_optimize ; memset ( & func_options , 0 , sizeof ( func_options ) ) ; init_options_struct ( & func_options , NULL ) ; lang_hooks . init_options_struct ( & func_options ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ; cl_target_option_restore ( & func_options , TREE_TARGET_OPTION ( target_option_default_node ) ) ; new_target = ix86_valid_target_attribute_tree ( args , & func_options , & global_options_set ) ; new_optimize = build_optimization_node ( & func_options ) ; if ( new_target == error_mark_node ) ret = false ; else if ( fndecl && new_target ) { DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) = new_target ; if ( old_optimize != new_optimize ) DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) = new_optimize ; } return ret ; } </s>

Hook to validate attribute ( ( target ( `` string '' ) ) ) .


<s> void FixupLEAPass :: processInstruction ( MachineBasicBlock :: iterator & I , MachineFunction :: iterator MFI ) { MachineInstr * MI = I ; const MCInstrDesc & Desc = MI -> getDesc ( ) ; int AddrOffset = X86II :: getMemoryOperandNo ( Desc . TSFlags ) ; if ( AddrOffset >= 0 ) { AddrOffset += X86II :: getOperandBias ( Desc ) ; MachineOperand & p = MI -> getOperand ( AddrOffset + X86 :: AddrBaseReg ) ; if ( p . isReg ( ) && p . getReg ( ) != X86 :: ESP ) { seekLEAFixup ( p , I , MFI ) ; } MachineOperand & q = MI -> getOperand ( AddrOffset + X86 :: AddrIndexReg ) ; if ( q . isReg ( ) && q . getReg ( ) != X86 :: ESP ) { seekLEAFixup ( q , I , MFI ) ; } } } </s>

Process a single instruction and collect debug info anchors .


<s>
static
void
rs6000_xcoff_file_start
(
void
)
{
rs6000_gen_section_name
(
&
xcoff_bss_section_name
,
main_input_filename
,
".bss_"
)
;
rs6000_gen_section_name
(
&
xcoff_private_data_section_name
,
main_input_filename
,
".rw_"
)
;
rs6000_gen_section_name
(
&
xcoff_read_only_section_name
,
main_input_filename
,
".ro_"
)
;
rs6000_gen_section_name
(
&
xcoff_tls_data_section_name
,
main_input_filename
,
".tls_"
)
;
rs6000_gen_section_name
(
&
xcoff_tbss_section_name
,
main_input_filename
,
".tbss_[UL]"
)
;
fputs
(
"\t.file\t"
,
asm_out_file
)
;
output_quoted_string
(
asm_out_file
,
main_input_filename
)
;
fputc
(
'\n'
,
asm_out_file
)
;
if
(
write_symbols
!=
NO_DEBUG
)
switch_to_section
(
private_data_section
)
;
switch_to_section
(
toc_section
)
;
switch_to_section
(
text_section
)
;
if
(
profile_flag
)
fprintf
(
asm_out_file
,
"\t.extern %s\n"
,
RS6000_MCOUNT
)
;
rs6000_file_start
(
)
;
}
</s>

Output at beginning of assembler file . Initialize the section names for the RS/6000 at this point . Specify filename , including full path , to assembler . We want to go into the TOC section so at least one .toc will be emitted . Also , in order to output proper .bs/.es pairs , we need at least one static [ RW ] section emitted . Finally , declare mcount when profiling to make the assembler happy .


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

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


<s> static bool arm_print_operand_punct_valid_p ( unsigned char code ) { return ( code == '@' || code == '|' || code == '.' || code == '(' || code == ')' || code == '#' || ( TARGET_32BIT && ( code == '?' ) ) || ( TARGET_THUMB2 && ( code == '!' ) ) || ( TARGET_THUMB && ( code == '_' ) ) ) ; } </s>

Target hook for indicating whether a punctuation character for TARGET_PRINT_OPERAND is valid .


<s>
bool
AArch64InstrInfo
::
isFPRCopy
(
const
MachineInstr
&
MI
)
{
switch
(
MI
.
getOpcode
(
)
)
{
default
:
break
;
case
TargetOpcode
::
COPY
:
{
Register
DstReg
=
MI
.
getOperand
(
0
)
.
getReg
(
)
;
return
AArch64
::
FPR128RegClass
.
contains
(
DstReg
)
;
}
case
AArch64
::
ORRv16i8
:
if
(
MI
.
getOperand
(
1
)
.
getReg
(
)
==
MI
.
getOperand
(
2
)
.
getReg
(
)
)
{
assert
(
MI
.
getDesc
(
)
.
getNumOperands
(
)
==
3
&&
MI
.
getOperand
(
0
)
.
isReg
(
)
&&
"invalid ORRv16i8 operands"
)
;
return
true
;
}
break
;
}
return
false
;
}
</s>

Does this instruction rename an FPR without modifying bits ?


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

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


<s> void rs6000_expand_vector_set ( rtx target , rtx val , int elt ) { machine_mode mode = GET_MODE ( target ) ; machine_mode inner_mode = GET_MODE_INNER ( mode ) ; rtx reg = gen_reg_rtx ( mode ) ; rtx mask , mem , x ; int width = GET_MODE_SIZE ( inner_mode ) ; int i ; if ( VECTOR_MEM_VSX_P ( mode ) && ( mode == V2DFmode || mode == V2DImode ) ) { rtx ( * set_func ) ( rtx , rtx , rtx , rtx ) = ( ( mode == V2DFmode ) ? gen_vsx_set_v2df : gen_vsx_set_v2di ) ; emit_insn ( set_func ( target , target , val , GEN_INT ( elt ) ) ) ; return ; } if ( GET_MODE_SIZE ( mode ) == GET_MODE_SIZE ( inner_mode ) && elt == 0 ) { emit_move_insn ( target , gen_lowpart ( mode , val ) ) ; return ; } mem = assign_stack_temp ( mode , GET_MODE_SIZE ( inner_mode ) ) ; emit_move_insn ( adjust_address_nv ( mem , inner_mode , 0 ) , val ) ; x = gen_rtx_UNSPEC ( VOIDmode , gen_rtvec ( 1 , const0_rtx ) , UNSPEC_LVE ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , gen_rtx_SET ( VOIDmode , reg , mem ) , x ) ) ) ; mask = gen_rtx_PARALLEL ( V16QImode , rtvec_alloc ( 16 ) ) ; for ( i = 0 ; i < 16 ; ++ i ) XVECEXP ( mask , 0 , i ) = GEN_INT ( i ) ; for ( i = 0 ; i < width ; ++ i ) XVECEXP ( mask , 0 , elt * width + i ) = GEN_INT ( i + 0x10 ) ; x = gen_rtx_CONST_VECTOR ( V16QImode , XVEC ( mask , 0 ) ) ; if ( BYTES_BIG_ENDIAN ) x = gen_rtx_UNSPEC ( mode , gen_rtvec ( 3 , target , reg , force_reg ( V16QImode , x ) ) , UNSPEC_VPERM ) ; else { rtx notx = gen_rtx_NOT ( V16QImode , force_reg ( V16QImode , x ) ) ; rtx iorx = ( TARGET_P8_VECTOR ? gen_rtx_IOR ( V16QImode , notx , notx ) : gen_rtx_AND ( V16QImode , notx , notx ) ) ; rtx tmp = gen_reg_rtx ( V16QImode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp , iorx ) ) ; x = gen_rtx_UNSPEC ( mode , gen_rtvec ( 3 , reg , target , tmp ) , UNSPEC_VPERM ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , target , x ) ) ; } </s>


<s> bool AArch64TargetLowering :: shouldReduceLoadWidth ( SDNode * Load , ISD :: LoadExtType ExtTy , EVT NewVT ) const { if ( ExtTy != ISD :: NON_EXTLOAD ) return true ; MemSDNode * Mem = dyn_cast < MemSDNode > ( Load ) ; assert ( Mem ) ; const SDValue & Base = Mem -> getBasePtr ( ) ; if ( Base . getOpcode ( ) == ISD :: ADD && Base . getOperand ( 1 ) . getOpcode ( ) == ISD :: SHL && Base . getOperand ( 1 ) . hasOneUse ( ) && Base . getOperand ( 1 ) . getOperand ( 1 ) . getOpcode ( ) == ISD :: Constant ) { uint64_t ShiftAmount = Base . getOperand ( 1 ) . getConstantOperandVal ( 1 ) ; uint64_t LoadBytes = Mem -> getMemoryVT ( ) . getSizeInBits ( ) / 8 ; if ( ShiftAmount == Log2_32 ( LoadBytes ) ) return false ; } return true ; } </s>

Return true if we believe it is correct and profitable to reduce the load node to a smaller type .


<s>
StringRef
getPassName
(
)
const
override
{
return
"TVM continuations hoisting pass"
;
}
</s>


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

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


<s> static const char * alpha_mangle_fundamental_type ( tree type ) { if ( TYPE_MAIN_VARIANT ( type ) == long_double_type_node && TARGET_LONG_DOUBLE_128 ) return "g" ; return NULL ; } </s>


<s> int getIntImmCostInst ( unsigned Opc , unsigned Idx , const APInt & Imm , Type * Ty , TTI :: TargetCostKind CostKind , Instruction * Inst = nullptr ) { return getIntImmCost ( Imm , Ty , CostKind ) ; } </s>

Return the expected cost of materialization for the given integer immediate of the specified type for a given instruction .


"Suitable Machine Function for outlining must track liveness"

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


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


<s>
SDNode
*
BPFDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
DEBUG
(
dbgs
(
)
<<
"Selecting: "
;
Node
->
dump
(
CurDAG
)
;
dbgs
(
)
<<
'\n'
)
;
if
(
Node
->
isMachineOpcode
(
)
)
{
DEBUG
(
dbgs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
dbgs
(
)
<<
'\n'
)
;
return
;
}
switch
(
Opcode
)
{
default
:
break
;
case
ISD
::
UNDEF
:
{
errs
(
)
<<
"BUG: "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
'\n'
;
report_fatal_error
(
"shouldn't see UNDEF during Select"
)
;
break
;
}
case
ISD
::
INTRINSIC_W_CHAIN
:
{
unsigned
IntNo
=
cast
<
ConstantSDNode
>
(
Node
->
getOperand
(
1
)
)
->
getZExtValue
(
)
;
switch
(
IntNo
)
{
case
Intrinsic
::
bpf_load_byte
:
case
Intrinsic
::
bpf_load_half
:
case
Intrinsic
::
bpf_load_word
:
{
SDLoc
DL
(
Node
)
;
SDValue
Chain
=
Node
->
getOperand
(
0
)
;
SDValue
N1
=
Node
->
getOperand
(
1
)
;
SDValue
Skb
=
Node
->
getOperand
(
2
)
;
SDValue
N3
=
Node
->
getOperand
(
3
)
;
SDValue
R6Reg
=
CurDAG
->
getRegister
(
BPF
::
R6
,
MVT
::
i64
)
;
Chain
=
CurDAG
->
getCopyToReg
(
Chain
,
DL
,
R6Reg
,
Skb
,
SDValue
(
)
)
;
Node
=
CurDAG
->
UpdateNodeOperands
(
Node
,
Chain
,
N1
,
R6Reg
,
N3
)
;
break
;
}
}
break
;
}
case
ISD
::
FrameIndex
:
{
int
FI
=
cast
<
FrameIndexSDNode
>
(
Node
)
->
getIndex
(
)
;
EVT
VT
=
Node
->
getValueType
(
0
)
;
SDValue
TFI
=
CurDAG
->
getTargetFrameIndex
(
FI
,
VT
)
;
unsigned
Opc
=
BPF
::
MOV_rr
;
if
(
Node
->
hasOneUse
(
)
)
return
CurDAG
->
SelectNodeTo
(
Node
,
Opc
,
VT
,
TFI
)
;
return
CurDAG
->
getMachineNode
(
Opc
,
SDLoc
(
Node
)
,
VT
,
TFI
)
;
}
}
SDNode
*
ResNode
=
SelectCode
(
Node
)
;
DEBUG
(
dbgs
(
)
<<
"=> "
;
if
(
ResNode
==
nullptr
||
ResNode
==
Node
)
Node
->
dump
(
CurDAG
)
;
else
ResNode
->
dump
(
CurDAG
)
;
dbgs
(
)
<<
'\n'
)
;
return
ResNode
;
}
</s>

Main hook for targets to transform nodes into machine nodes .


<s> static bool arc_can_use_doloop_p ( const widest_int & iterations , const widest_int & , unsigned int loop_depth , bool entered_at_top ) { if ( loop_depth > 1 ) return false ; if ( TARGET_ARC700 && ! entered_at_top && wi :: gtu_p ( iterations , 0 ) && wi :: leu_p ( iterations , flag_pic ? 6 : 3 ) ) return false ; return true ; } </s>


<s> std :: vector < std :: string > pop ( Px a ) { return D ( "pop" , R ( a ) ) ; } </s>


<s>
MCOperand
P2MCInstLower
::
lowerOperand
(
const
MachineOperand
&
MO
,
unsigned
offset
)
const
{
MachineOperandType
MOTy
=
MO
.
getType
(
)
;
switch
(
MOTy
)
{
default
:
LLVM_DEBUG
(
errs
(
)
<<
"Operand type: "
<<
(
int
)
MOTy
<<
"\n"
)
;
llvm_unreachable
(
"MCInstrLower: unknown operand type"
)
;
case
MachineOperand
::
MO_GlobalAddress
:
case
MachineOperand
::
MO_JumpTableIndex
:
case
MachineOperand
::
MO_BlockAddress
:
case
MachineOperand
::
MO_MachineBasicBlock
:
case
MachineOperand
::
MO_ExternalSymbol
:
LLVM_DEBUG
(
errs
(
)
<<
"mcinst lower, MO: "
;
MO
.
dump
(
)
)
;
LLVM_DEBUG
(
errs
(
)
<<
"MO type: "
<<
(
int
)
MOTy
<<
"\n"
)
;
return
LowerSymbolOperand
(
MO
,
MOTy
,
offset
)
;
case
MachineOperand
::
MO_Register
:
if
(
MO
.
isImplicit
(
)
)
break
;
return
MCOperand
::
createReg
(
MO
.
getReg
(
)
)
;
case
MachineOperand
::
MO_Immediate
:
return
MCOperand
::
createImm
(
MO
.
getImm
(
)
+
offset
)
;
case
MachineOperand
::
MO_RegisterMask
:
break
;
}
return
MCOperand
(
)
;
}
</s>

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

P2
P2
"Operand type: "
"\n"
"MCInstrLower: unknown operand type"
"mcinst lower, MO: "
"MO type: "
"\n"


<s> unsigned int call_properties ( const function_instance & ) const OVERRIDE { return 0 ; } </s>

Default implementation of function_base : :call_properties , with conservatively correct behavior for floating-point instructions .


"instructions, but the target does not support ARM mode execution."

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


<s> static void iq2000_setup_incoming_varargs ( CUMULATIVE_ARGS * cum , enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_size , int no_rtl ) { unsigned int iq2000_off = ! cum -> last_arg_fp ; unsigned int iq2000_fp_off = cum -> last_arg_fp ; if ( ( cum -> arg_words < MAX_ARGS_IN_REGISTERS - iq2000_off ) ) { int iq2000_save_gp_regs = MAX_ARGS_IN_REGISTERS - cum -> arg_words - iq2000_off ; int iq2000_save_fp_regs = ( MAX_ARGS_IN_REGISTERS - cum -> fp_arg_words - iq2000_fp_off ) ; if ( iq2000_save_gp_regs < 0 ) iq2000_save_gp_regs = 0 ; if ( iq2000_save_fp_regs < 0 ) iq2000_save_fp_regs = 0 ; * pretend_size = ( ( iq2000_save_gp_regs * UNITS_PER_WORD ) + ( iq2000_save_fp_regs * UNITS_PER_FPREG ) ) ; if ( ! ( no_rtl ) ) { if ( cum -> arg_words < MAX_ARGS_IN_REGISTERS - iq2000_off ) { rtx ptr , mem ; ptr = plus_constant ( virtual_incoming_args_rtx , - ( iq2000_save_gp_regs * UNITS_PER_WORD ) ) ; mem = gen_rtx_MEM ( BLKmode , ptr ) ; move_block_from_reg ( cum -> arg_words + GP_ARG_FIRST + iq2000_off , mem , iq2000_save_gp_regs ) ; } } } } </s>

Worker function for TARGET_SETUP_INCOMING_VARARGS .


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

Return information about object file lowering .


<s> void ARMBaseRegisterInfo :: materializeFrameBaseRegister ( MachineBasicBlock * MBB , unsigned BaseReg , int FrameIdx , int64_t Offset ) const { ARMFunctionInfo * AFI = MBB -> getParent ( ) -> getInfo < ARMFunctionInfo > ( ) ; unsigned ADDriOpc = ! AFI -> isThumbFunction ( ) ? ARM :: ADDri : ( AFI -> isThumb1OnlyFunction ( ) ? ARM :: tADDrSPi : ARM :: t2ADDri ) ; MachineBasicBlock :: iterator Ins = MBB -> begin ( ) ; DebugLoc DL ; if ( Ins != MBB -> end ( ) ) DL = Ins -> getDebugLoc ( ) ; MachineInstrBuilder MIB = BuildMI ( * MBB , Ins , DL , TII . get ( ADDriOpc ) , BaseReg ) . addFrameIndex ( FrameIdx ) . addImm ( Offset ) ; if ( ! AFI -> isThumb1OnlyFunction ( ) ) AddDefaultCC ( AddDefaultPred ( MIB ) ) ; } </s>

Insert defining instruction ( s ) for a pointer to FrameIdx before insertion point I .

ARM ARM ARM ARM ARM::ADDri ARM::tADDrSPi ARM::t2ADDri


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

Execute target specific actions to finalize target lowering .


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> const uint32_t * SIRegisterInfo :: getNoPreservedMask ( ) const { return CSR_AMDGPU_NoRegs_RegMask ; } </s>

Return a register mask that clobbers everything .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Z80 Machine Late Optimization"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> static rtx_insn * mips_epilogue_emit_cfa_restores ( void ) { rtx_insn * insn ; insn = get_last_insn ( ) ; if ( mips_epilogue . cfa_restores ) { gcc_assert ( insn && ! REG_NOTES ( insn ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; REG_NOTES ( insn ) = mips_epilogue . cfa_restores ; mips_epilogue . cfa_restores = 0 ; } return insn ; } </s>

Attach all pending register saves to the previous instruction . Return that instruction .


<s> static void insn_set_clock ( rtx insn , int cycle ) { unsigned uid = INSN_UID ( insn ) ; if ( uid >= INSN_INFO_LENGTH ) insn_info . safe_grow ( uid * 5 / 4 + 10 , true ) ; INSN_INFO_ENTRY ( uid ) . clock = cycle ; INSN_INFO_ENTRY ( uid ) . new_cond = NULL ; INSN_INFO_ENTRY ( uid ) . reservation = 0 ; INSN_INFO_ENTRY ( uid ) . ebb_start = false ; } </s>

Set the clock cycle of INSN to CYCLE . Also clears the insn 's entry in new_conditions .


<s>
SDNode
*
XNCMDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
DEBUG
(
errs
(
)
<<
"Selecting: "
)
;
DEBUG
(
Node
->
dump
(
CurDAG
)
)
;
DEBUG
(
errs
(
)
<<
"\n"
)
;
if
(
Node
->
isMachineOpcode
(
)
)
{
DEBUG
(
errs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
return
;
}
switch
(
Node
->
getOpcode
(
)
)
{
default
:
break
;
}
SDNode
*
ResNode
=
SelectCode
(
Node
)
;
DEBUG
(
errs
(
)
<<
"=> "
)
;
if
(
ResNode
==
||
ResNode
==
Node
)
DEBUG
(
Node
->
dump
(
CurDAG
)
)
;
else
DEBUG
(
ResNode
->
dump
(
CurDAG
)
)
;
DEBUG
(
errs
(
)
<<
"\n"
)
;
return
ResNode
;
}
</s>

XNCM
XNCM
"Selecting: "
"\n"
"== "
"\n"
"=> "
"\n"


<s> static unsigned int pru_section_type_flags ( tree decl , const char * name , int reloc ) { unsigned int flags = default_section_type_flags ( decl , name , reloc ) ; if ( ! strcmp ( name , ".pru_irq_map" ) ) flags = SECTION_DEBUG | SECTION_RETAIN ; return flags ; } </s>


<s> static bool or1k_strict_argument_naming ( cumulative_args_t ) { return true ; } </s>

Worker for TARGET_STRICT_ARGUMENT_NAMING . Return true always as on OpenRISC the last argument in a variatic function is named .


<s> void PPCRegisterInfo :: lowerCRSpilling ( MachineBasicBlock :: iterator II , unsigned FrameIndex , int SPAdj , RegScavenger * RS ) const { MachineInstr & MI = * II ; MachineBasicBlock & MBB = * MI . getParent ( ) ; DebugLoc dl = MI . getDebugLoc ( ) ; const TargetRegisterClass * G8RC = & PPC :: G8RCRegClass ; const TargetRegisterClass * GPRC = & PPC :: GPRCRegClass ; const TargetRegisterClass * RC = Subtarget . isPPC64 ( ) ? G8RC : GPRC ; unsigned Reg = findScratchRegister ( II , RS , RC , SPAdj ) ; unsigned SrcReg = MI . getOperand ( 0 ) . getReg ( ) ; BuildMI ( MBB , II , dl , TII . get ( PPC :: MFCRpseud ) , Reg ) . addReg ( SrcReg , getKillRegState ( MI . getOperand ( 0 ) . isKill ( ) ) ) ; if ( SrcReg != PPC :: CR0 ) BuildMI ( MBB , II , dl , TII . get ( PPC :: RLWINM ) , Reg ) . addReg ( Reg , RegState :: Kill ) . addImm ( PPCRegisterInfo :: getRegisterNumbering ( SrcReg ) * 4 ) . addImm ( 0 ) . addImm ( 31 ) ; addFrameReference ( BuildMI ( MBB , II , dl , TII . get ( PPC :: STW ) ) . addReg ( Reg , getKillRegState ( MI . getOperand ( 1 ) . getImm ( ) ) ) , FrameIndex ) ; MBB . erase ( II ) ; } </s>

lowerCRSpilling - Generate the code for spilling a CR register .


<s> virtual void applyFixup ( const MCFixup & Fixup , char * Data , unsigned DataSize , uint64_t Value ) const { MCFixupKind Kind = Fixup . getKind ( ) ; Value = adjustFixupValue ( Kind , Value ) ; if ( ! Value ) return ; unsigned TargetSize = getFixupKindInfo ( Kind ) . TargetSize ; unsigned TargetOffset = getFixupKindInfo ( Kind ) . TargetOffset ; unsigned Offset = Fixup . getOffset ( ) ; unsigned NumBytes = ( TargetSize + 7 ) / 8 ; unsigned FullSize = ( TargetOffset + TargetSize + 7 ) / 8 ; uint64_t CurVal = 0 ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = ( FullSize - 1 - i ) ; CurVal |= ( uint64_t ) ( ( uint8_t ) Data [ Offset + Idx ] ) << ( i * 8 ) ; } uint64_t Mask = ( ( uint64_t ) ( - 1 ) >> ( 64 - TargetSize ) ) ; unsigned Shift = FullSize * 8 - ( TargetOffset + TargetSize ) ; CurVal |= ( Value & Mask ) << Shift ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = ( FullSize - 1 - i ) ; Data [ Offset + Idx ] = ( uint8_t ) ( ( CurVal >> ( i * 8 ) ) & 0xff ) ; } } </s>

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


<s> bool X86ATTAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , unsigned AsmVariant , const char * ExtraCode ) { if ( ExtraCode && ExtraCode [ 0 ] ) { if ( ExtraCode [ 1 ] != 0 ) return true ; switch ( ExtraCode [ 0 ] ) { default : return true ; case 'c' : printOperand ( MI , OpNo , "mem" , true ) ; return false ; case 'b' : case 'h' : case 'w' : case 'k' : case 'q' : if ( MI -> getOperand ( OpNo ) . isReg ( ) ) return printAsmMRegister ( MI -> getOperand ( OpNo ) , ExtraCode [ 0 ] ) ; printOperand ( MI , OpNo ) ; return false ; case 'P' : printOperand ( MI , OpNo , "mem" ) ; return false ; } } printOperand ( MI , OpNo ) ; return false ; } </s>

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


<s>
void
SIFrameLowering
::
processFunctionBeforeFrameFinalized
(
MachineFunction
&
MF
,
RegScavenger
*
RS
)
const
{
MachineFrameInfo
*
MFI
=
MF
.
getFrameInfo
(
)
;
bool
MayNeedScavengingEmergencySlot
=
MFI
->
hasStackObjects
(
)
;
assert
(
(
RS
||
!
MayNeedScavengingEmergencySlot
)
&&
"RegScavenger required if spilling"
)
;
if
(
MayNeedScavengingEmergencySlot
)
{
int
ScavengeFI
=
MFI
->
CreateSpillStackObject
(
AMDGPU
::
SGPR_32RegClass
.
getSize
(
)
,
AMDGPU
::
SGPR_32RegClass
.
getAlignment
(
)
)
;
RS
->
addScavengingFrameIndex
(
ScavengeFI
)
;
}
}
</s>

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


<s> static void release_scratch_register_on_entry ( struct scratch_reg * sr , HOST_WIDE_INT offset , bool release_via_pop ) { if ( sr -> saved ) { if ( release_via_pop ) { struct machine_function * m = cfun -> machine ; rtx x , insn = emit_insn ( gen_pop ( sr -> reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; x = plus_constant ( Pmode , stack_pointer_rtx , UNITS_PER_WORD ) ; x = gen_rtx_SET ( stack_pointer_rtx , x ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , x ) ; m -> fs . sp_offset -= UNITS_PER_WORD ; } else { rtx x = plus_constant ( Pmode , stack_pointer_rtx , offset ) ; x = gen_rtx_SET ( sr -> reg , gen_rtx_MEM ( word_mode , x ) ) ; emit_insn ( x ) ; } } } </s>

Release a scratch register obtained from the preceding function . If RELEASE_VIA_POP is true , we just pop the register off the stack to release it . This is what non-Linux systems use with -fstack-check . Otherwise we use OFFSET to locate the saved register and the allocated stack space becomes part of the local frame and is deallocated by the epilogue .


<s> const char * mips_output_jump ( rtx * operands , int target_opno , int size_opno , bool link_p ) { static char buffer [ 300 ] ; char * s = buffer ; bool reg_p = REG_P ( operands [ target_opno ] ) ; const char * and_link = link_p ? "al" : "" ; const char * reg = reg_p ? "r" : "" ; const char * compact = "" ; const char * nop = "%/" ; const char * short_delay = link_p ? "%!" : "" ; const char * insn_name = TARGET_CB_NEVER || reg_p ? "j" : "b" ; if ( ! final_sequence && ( TARGET_CB_MAYBE || ( ISA_HAS_JRC && ! link_p && reg_p ) ) ) { compact = "c" ; nop = "" ; } if ( TARGET_USE_GOT && ! TARGET_EXPLICIT_RELOCS ) sprintf ( s , "%%*%s%s\t%%%d%%/" , insn_name , and_link , target_opno ) ; else { if ( ! reg_p && TARGET_ABICALLS_PIC2 ) s += sprintf ( s , ".option\tpic0\n\t" ) ; if ( reg_p && mips_get_pic_call_symbol ( operands , size_opno ) ) s += sprintf ( s , "%%*.reloc\t1f,%s,%%%d\n1:\t" , TARGET_MICROMIPS ? "R_MICROMIPS_JALR" : "R_MIPS_JALR" , size_opno ) ; else s += sprintf ( s , "%%*" ) ; s += sprintf ( s , "%s%s%s%s%s\t%%%d%s" , insn_name , and_link , reg , compact , short_delay , target_opno , nop ) ; if ( ! reg_p && TARGET_ABICALLS_PIC2 ) s += sprintf ( s , "\n\t.option\tpic2" ) ; } return buffer ; } </s>

Return the asm template for a call . OPERANDS are the operands , TARGET_OPNO is the operand number of the target . SIZE_OPNO is the operand number of the argument size operand that can optionally hold the call attributes . If SIZE_OPNO is not -1 and the call is indirect , use the function symbol from the call attributes to attach a R_MIPS_JALR relocation to the call . LINK_P indicates whether the jump is a call and needs to set the link register . When generating GOT code without explicit relocation operators , all calls should use assembly macros . Otherwise , all indirect calls should use `` jr '' or `` jalr '' ; we will arrange to restore $ gp afterwards if necessary . Finally , we can only generate direct calls for -mabicalls by temporarily switching to non-PIC mode . For microMIPS jal ( r ) , we try to generate jal ( r ) s when a 16-bit instruction is in the delay slot of jal ( r ) . Where compact branches are available , we try to use them if the delay slot has a NOP ( or equivalently delay slots were not enabled for the instruction anyway ) .


<s> bool m68k_movem_pattern_p ( rtx pattern , rtx automod_base , HOST_WIDE_INT automod_offset , bool store_p ) { rtx base , mem_base , set , mem , reg , last_reg ; HOST_WIDE_INT offset , mem_offset ; int i , first , len ; enum reg_class rclass ; len = XVECLEN ( pattern , 0 ) ; first = ( automod_base != NULL ) ; if ( automod_base ) { if ( store_p != ( automod_offset < 0 ) ) return false ; base = automod_base ; offset = ( automod_offset < 0 ? automod_offset : 0 ) ; } else { base = NULL ; offset = 0 ; } last_reg = NULL ; rclass = NO_REGS ; for ( i = first ; i < len ; i ++ ) { set = XVECEXP ( pattern , 0 , i ) ; if ( GET_CODE ( set ) != SET ) return false ; mem = XEXP ( set , ! store_p ) ; if ( ! MEM_P ( mem ) || ! memory_operand ( mem , VOIDmode ) ) return false ; if ( base == NULL ) { m68k_split_offset ( XEXP ( mem , 0 ) , & base , & offset ) ; if ( TARGET_COLDFIRE && ! m68k_legitimate_base_reg_p ( base , reload_completed ) ) return false ; } else { m68k_split_offset ( XEXP ( mem , 0 ) , & mem_base , & mem_offset ) ; if ( ! rtx_equal_p ( base , mem_base ) || offset != mem_offset ) return false ; } reg = XEXP ( set , store_p ) ; if ( ! REG_P ( reg ) || ! HARD_REGISTER_P ( reg ) || GET_MODE ( reg ) != reg_raw_mode [ REGNO ( reg ) ] ) return false ; if ( last_reg ) { if ( ! TEST_HARD_REG_BIT ( reg_class_contents [ rclass ] , REGNO ( reg ) ) || REGNO ( last_reg ) >= REGNO ( reg ) ) return false ; } else { if ( INT_REGNO_P ( REGNO ( reg ) ) ) rclass = GENERAL_REGS ; else if ( FP_REGNO_P ( REGNO ( reg ) ) ) rclass = FP_REGS ; else return false ; } last_reg = reg ; offset += GET_MODE_SIZE ( GET_MODE ( reg ) ) ; } if ( automod_base && offset != ( automod_offset < 0 ? 0 : automod_offset ) ) return false ; if ( len < first + ( rclass == FP_REGS ? MIN_FMOVEM_REGS : MIN_MOVEM_REGS ) ) return false ; return true ; } </s>

Return true if PATTERN is a PARALLEL suitable for a movem or fmovem instruction . STORE_P says whether the move is a load or store . If the instruction uses post-increment or pre-decrement addressing , AUTOMOD_BASE is the base register and AUTOMOD_OFFSET is the total adjustment . This adjustment will be made by the first element of PARALLEL , with the loads or stores starting at element 1 . If the instruction does not use post-increment or pre-decrement addressing , AUTOMOD_BASE is null , AUTOMOD_OFFSET is 0 , and the loads or stores start at element 0 .


<s> rtx nios2_get_return_address ( int count ) { if ( count != 0 ) return const0_rtx ; return get_hard_reg_initial_val ( Pmode , RA_REGNO ) ; } </s>

Implement RETURN_ADDR_RTX . Note , we do not support moving back to a previous frame .


<s> EVT RISCVTargetLowering :: getSetCCResultType ( const DataLayout & DL , LLVMContext & Context , EVT VT ) const { if ( ! VT . isVector ( ) ) return getPointerTy ( DL , 0 ) ; if ( Subtarget . hasStdExtV ( ) && ( VT . isScalableVector ( ) || Subtarget . useRVVForFixedLengthVectors ( ) ) ) return EVT :: getVectorVT ( Context , MVT :: i1 , VT . getVectorElementCount ( ) ) ; return VT . changeVectorElementTypeToInteger ( ) ; } </s>

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


<s> static int rs6000_hard_regno_mode_ok ( int regno , machine_mode mode ) { int last_regno = regno + rs6000_hard_regno_nregs [ mode ] [ regno ] - 1 ; if ( mode == PTImode ) return ( IN_RANGE ( regno , FIRST_GPR_REGNO , LAST_GPR_REGNO ) && IN_RANGE ( last_regno , FIRST_GPR_REGNO , LAST_GPR_REGNO ) && ( ( regno & 1 ) == 0 ) ) ; if ( TARGET_VSX && VSX_REGNO_P ( regno ) && ( VECTOR_MEM_VSX_P ( mode ) || FLOAT128_VECTOR_P ( mode ) || reg_addr [ mode ] . scalar_in_vmx_p || ( TARGET_VSX_TIMODE && mode == TImode ) || ( TARGET_VADDUQM && mode == V1TImode ) ) ) { if ( FP_REGNO_P ( regno ) ) return FP_REGNO_P ( last_regno ) ; if ( ALTIVEC_REGNO_P ( regno ) ) { if ( GET_MODE_SIZE ( mode ) != 16 && ! reg_addr [ mode ] . scalar_in_vmx_p ) return 0 ; return ALTIVEC_REGNO_P ( last_regno ) ; } } if ( INT_REGNO_P ( regno ) ) return INT_REGNO_P ( last_regno ) ; if ( FP_REGNO_P ( regno ) ) { if ( FLOAT128_VECTOR_P ( mode ) ) return false ; if ( SCALAR_FLOAT_MODE_P ( mode ) && ( mode != TDmode || ( regno % 2 ) == 0 ) && FP_REGNO_P ( last_regno ) ) return 1 ; if ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) == UNITS_PER_FP_WORD ) return 1 ; if ( PAIRED_SIMD_REGNO_P ( regno ) && TARGET_PAIRED_FLOAT && PAIRED_VECTOR_MODE ( mode ) ) return 1 ; return 0 ; } if ( CR_REGNO_P ( regno ) ) return GET_MODE_CLASS ( mode ) == MODE_CC ; if ( CA_REGNO_P ( regno ) ) return mode == Pmode || mode == SImode ; if ( ALTIVEC_REGNO_P ( regno ) ) return ( VECTOR_MEM_ALTIVEC_OR_VSX_P ( mode ) || mode == V1TImode ) ; if ( SPE_SIMD_REGNO_P ( regno ) && TARGET_SPE && SPE_VECTOR_MODE ( mode ) ) return 1 ; return GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ; } </s>

Value is 1 if hard register REGNO can hold a value of machine-mode MODE .


<s> tree arm_valid_target_attribute_tree ( tree args , struct gcc_options * opts , struct gcc_options * opts_set ) { struct cl_target_option cl_opts ; if ( ! arm_valid_target_attribute_rec ( args , opts ) ) return NULL_TREE ; cl_target_option_save ( & cl_opts , opts , opts_set ) ; arm_configure_build_target ( & arm_active_target , & cl_opts , opts_set , false ) ; arm_option_check_internal ( opts ) ; arm_option_reconfigure_globals ( ) ; arm_options_perform_arch_sanity_checks ( ) ; arm_option_override_internal ( opts , opts_set ) ; return build_target_option_node ( opts , opts_set ) ; } </s>

Return a TARGET_OPTION_NODE tree of the target options listed or NULL .


<s> unsigned XCoreRegisterInfo :: getRARegister ( ) const { return XCore :: LR ; } </s>

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


<s> EVT X86TargetLowering :: getOptimalMemOpType ( const MemOp & Op , const AttributeList & FuncAttributes ) const { if ( ! FuncAttributes . hasFnAttr ( Attribute :: NoImplicitFloat ) ) { if ( Op . size ( ) >= 16 && ( ! Subtarget . isUnalignedMem16Slow ( ) || Op . isAligned ( Align ( 16 ) ) ) ) { if ( Op . size ( ) >= 64 && Subtarget . hasAVX512 ( ) && ( Subtarget . getPreferVectorWidth ( ) >= 512 ) ) { return Subtarget . hasBWI ( ) ? MVT :: v64i8 : MVT :: v16i32 ; } if ( Op . size ( ) >= 32 && Subtarget . hasAVX ( ) && ( Subtarget . getPreferVectorWidth ( ) >= 256 ) ) { return MVT :: v32i8 ; } if ( Subtarget . hasSSE2 ( ) && ( Subtarget . getPreferVectorWidth ( ) >= 128 ) ) return MVT :: v16i8 ; if ( Subtarget . hasSSE1 ( ) && ( Subtarget . is64Bit ( ) || Subtarget . hasX87 ( ) ) && ( Subtarget . getPreferVectorWidth ( ) >= 128 ) ) return MVT :: v4f32 ; } else if ( ( ( Op . isMemcpy ( ) && ! Op . isMemcpyStrSrc ( ) ) || Op . isZeroMemset ( ) ) && Op . size ( ) >= 8 && ! Subtarget . is64Bit ( ) && Subtarget . hasSSE2 ( ) ) { return MVT :: f64 ; } } if ( Subtarget . is64Bit ( ) && Op . size ( ) >= 8 ) return MVT :: i64 ; return MVT :: i32 ; } </s>

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


<s> bool riscv_new_address_profitable_p ( rtx memref , rtx_insn * insn , rtx new_addr ) { addr_space_t as = MEM_ADDR_SPACE ( memref ) ; bool speed = optimize_bb_for_speed_p ( BLOCK_FOR_INSN ( insn ) ) ; int old_cost = address_cost ( XEXP ( memref , 0 ) , GET_MODE ( memref ) , as , speed ) ; int new_cost = address_cost ( new_addr , GET_MODE ( memref ) , as , speed ) ; return new_cost <= old_cost ; } </s>


<s> void riscv_init_builtins ( void ) { for ( size_t i = 0 ; i < ARRAY_SIZE ( riscv_builtins ) ; i ++ ) { const struct riscv_builtin_description * d = & riscv_builtins [ i ] ; if ( d -> avail ( ) ) { tree type = riscv_build_function_type ( d -> prototype ) ; riscv_builtin_decls [ i ] = add_builtin_function ( d -> name , type , i , BUILT_IN_MD , NULL , NULL ) ; riscv_builtin_decl_index [ d -> icode ] = i ; } } } </s>


<s> int m32c_extra_memory_constraint ( char c , const char * str ATTRIBUTE_UNUSED ) { return c == 'S' ; } </s>

Implements EXTRA_MEMORY_CONSTRAINT . Currently , we only use strings starting with 'S ' .


<s>
StringRef
getPassName
(
)
const
override
{
return
"M680x0 Assembly Printer"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> static int mips_small_data_pattern_1 ( rtx * loc , void * data ATTRIBUTE_UNUSED ) { if ( GET_CODE ( * loc ) == LO_SUM ) return - 1 ; return mips_rewrite_small_data_p ( * loc ) ; } </s>

A for_each_rtx callback for mips_small_data_pattern_p .


"ARM hazards don't support scoreboard lookahead"

getHazardType - Return the hazard type of emitting this node .


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

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


<s> void EmitInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI ) override { if ( IsThumb ) EmitThumbMappingSymbol ( ) ; else EmitARMMappingSymbol ( ) ; MCELFStreamer :: EmitInstruction ( Inst , STI ) ; } </s>

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


<s> bool RegisterAliasInfo :: covers ( const RegisterSet & RRs , RegisterRef RR ) const { if ( RRs . count ( RR ) ) return true ; if ( TargetRegisterInfo :: isVirtualRegister ( RR . Reg ) ) { if ( RR . Sub != 0 ) return RRs . count ( { RR . Reg , 0 } ) ; return false ; } unsigned Reg = RR . Sub == 0 ? RR . Reg : TRI . getSubReg ( RR . Reg , RR . Sub ) ; for ( MCSuperRegIterator SR ( Reg , & TRI ) ; SR . isValid ( ) ; ++ SR ) if ( RRs . count ( { * SR , 0 } ) ) return true ; return false ; } </s>

Check whether this register bank covers RC .


<s> static void nvptx_neuter_pars ( parallel * par , unsigned modes , unsigned outer ) { unsigned me = ( par -> mask & ( GOMP_DIM_MASK ( GOMP_DIM_WORKER ) | GOMP_DIM_MASK ( GOMP_DIM_VECTOR ) ) ) ; unsigned skip_mask = 0 , neuter_mask = 0 ; if ( par -> inner ) nvptx_neuter_pars ( par -> inner , modes , outer | me ) ; for ( unsigned mode = GOMP_DIM_WORKER ; mode <= GOMP_DIM_VECTOR ; mode ++ ) { if ( ( outer | me ) & GOMP_DIM_MASK ( mode ) ) { } else if ( ! ( modes & GOMP_DIM_MASK ( mode ) ) ) { } else if ( par -> inner_mask & GOMP_DIM_MASK ( mode ) || ! par -> forked_insn ) neuter_mask |= GOMP_DIM_MASK ( mode ) ; else if ( ! par -> parent || ! par -> parent -> forked_insn || par -> parent -> inner_mask & GOMP_DIM_MASK ( mode ) ) skip_mask |= GOMP_DIM_MASK ( mode ) ; else { } } if ( neuter_mask ) { int ix , len ; if ( nvptx_optimize ) { bb_pair_vec_t regions ; nvptx_find_sese ( par -> blocks , regions ) ; len = regions . length ( ) ; for ( ix = 0 ; ix != len ; ix ++ ) { basic_block from = regions [ ix ] . first ; basic_block to = regions [ ix ] . second ; if ( from ) nvptx_single ( neuter_mask , from , to ) ; else gcc_assert ( ! to ) ; } } else { len = par -> blocks . length ( ) ; for ( ix = 0 ; ix != len ; ix ++ ) { basic_block block = par -> blocks [ ix ] ; nvptx_single ( neuter_mask , block , block ) ; } } } if ( skip_mask ) nvptx_skip_par ( skip_mask , par ) ; if ( par -> next ) nvptx_neuter_pars ( par -> next , modes , outer ) ; } </s>

Neuter the parallel described by PAR . We recurse in depth-first order . MODES are the partitioning of the execution and OUTER is the partitioning of the parallels we are contained in .


<s> static void rs6000_destroy_cost_data ( void * data ) { free ( data ) ; } </s>


<s> const X86Subtarget * X86TargetMachine :: getSubtargetImpl ( const Function & F ) const { Attribute CPUAttr = F . getFnAttribute ( "target-cpu" ) ; Attribute FSAttr = F . getFnAttribute ( "target-features" ) ; StringRef CPU = ! CPUAttr . hasAttribute ( Attribute :: None ) ? CPUAttr . getValueAsString ( ) : ( StringRef ) TargetCPU ; StringRef FS = ! FSAttr . hasAttribute ( Attribute :: None ) ? FSAttr . getValueAsString ( ) : ( StringRef ) TargetFS ; SmallString < 512 > Key ; Key . reserve ( CPU . size ( ) + FS . size ( ) ) ; Key += CPU ; Key += FS ; bool SoftFloat = F . getFnAttribute ( "use-soft-float" ) . getValueAsString ( ) == "true" ; if ( SoftFloat ) Key += FS . empty ( ) ? "+soft-float" : ",+soft-float" ; unsigned CPUFSWidth = Key . size ( ) ; unsigned PreferVectorWidthOverride = 0 ; if ( F . hasFnAttribute ( "prefer-vector-width" ) ) { StringRef Val = F . getFnAttribute ( "prefer-vector-width" ) . getValueAsString ( ) ; unsigned Width ; if ( ! Val . getAsInteger ( 0 , Width ) ) { Key += ",prefer-vector-width=" ; Key += Val ; PreferVectorWidthOverride = Width ; } } unsigned RequiredVectorWidth = UINT32_MAX ; if ( F . hasFnAttribute ( "min-legal-vector-width" ) ) { StringRef Val = F . getFnAttribute ( "min-legal-vector-width" ) . getValueAsString ( ) ; unsigned Width ; if ( ! Val . getAsInteger ( 0 , Width ) ) { Key += ",min-legal-vector-width=" ; Key += Val ; RequiredVectorWidth = Width ; } } FS = Key . slice ( CPU . size ( ) , CPUFSWidth ) ; auto & I = SubtargetMap [ Key ] ; if ( ! I ) { resetTargetOptions ( F ) ; I = llvm :: make_unique < X86Subtarget > ( TargetTriple , CPU , FS , * this , Options . StackAlignmentOverride , PreferVectorWidthOverride , RequiredVectorWidth ) ; } return I . get ( ) ; } </s>

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


<s> bool ARM64TargetLowering :: CanLowerReturn ( CallingConv :: ID CallConv , MachineFunction & MF , bool isVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , LLVMContext & Context ) const { CCAssignFn * RetCC = CallConv == CallingConv :: WebKit_JS ? RetCC_ARM64_WebKit_JS : RetCC_ARM64_AAPCS ; SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , MF , getTargetMachine ( ) , RVLocs , Context ) ; return CCInfo . CheckReturn ( Outs , RetCC ) ; } </s>

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


<s> static void arm_option_restore ( struct gcc_options * , struct gcc_options * opts_set , struct cl_target_option * ptr ) { arm_configure_build_target ( & arm_active_target , ptr , opts_set , false ) ; } </s>


<s> unsigned PPCFastISel :: fastEmitInst_r ( unsigned MachineInstOpcode , const TargetRegisterClass * RC , unsigned Op0 , bool Op0IsKill ) { const TargetRegisterClass * UseRC = ( RC == & PPC :: GPRCRegClass ? & PPC :: GPRC_and_GPRC_NOR0RegClass : ( RC == & PPC :: G8RCRegClass ? & PPC :: G8RC_and_G8RC_NOX0RegClass : RC ) ) ; return FastISel :: fastEmitInst_r ( MachineInstOpcode , UseRC , Op0 , Op0IsKill ) ; } </s>

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


<s> void X86FrameLowering :: determineCalleeSaves ( MachineFunction & MF , BitVector & SavedRegs , RegScavenger * RS ) const { TargetFrameLowering :: determineCalleeSaves ( MF , SavedRegs , RS ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; X86MachineFunctionInfo * X86FI = MF . getInfo < X86MachineFunctionInfo > ( ) ; int64_t TailCallReturnAddrDelta = X86FI -> getTCReturnAddrDelta ( ) ; if ( TailCallReturnAddrDelta < 0 ) { MFI . CreateFixedObject ( - TailCallReturnAddrDelta , TailCallReturnAddrDelta - SlotSize , true ) ; } if ( TRI -> hasBasePointer ( MF ) ) { SavedRegs . set ( TRI -> getBaseRegister ( ) ) ; if ( MF . getMMI ( ) . hasEHFunclets ( ) ) { int FI = MFI . CreateSpillStackObject ( SlotSize , SlotSize ) ; X86FI -> setHasSEHFramePtrSave ( true ) ; X86FI -> setSEHFramePtrSaveIndex ( FI ) ; } } } </s>

This method determines which of the registers reported by TargetRegisterInfo : :getCalleeSavedRegs ( ) should actually get saved .


<s> bool enableInterleavedAccessVectorization ( ) { return true ; } </s>

Enable matching of interleaved access groups .


<s> static bool expand_vec_perm_broadcast ( struct expand_vec_perm_d * d ) { unsigned i , elt , nelt = d -> nelt ; unsigned char perm2 [ 2 ] ; rtx temp ; bool ok ; if ( ! d -> one_operand_p ) return false ; elt = d -> perm [ 0 ] ; for ( i = 1 ; i < nelt ; ++ i ) if ( d -> perm [ i ] != elt ) return false ; switch ( d -> vmode ) { case V2SImode : case V2SFmode : perm2 [ 0 ] = elt ; perm2 [ 1 ] = elt + 2 ; ok = expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , perm2 , 2 ) ; gcc_assert ( ok ) ; break ; case V8QImode : if ( BYTES_BIG_ENDIAN ) elt = 7 - elt ; elt *= BITS_PER_UNIT ; temp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_extzv ( temp , gen_lowpart ( DImode , d -> op0 ) , GEN_INT ( 8 ) , GEN_INT ( elt ) ) ) ; emit_insn ( gen_mux1_brcst_qi ( d -> target , gen_lowpart ( QImode , temp ) ) ) ; break ; case V4HImode : default : gcc_unreachable ( ) ; } return true ; } </s>


<s> void eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { MBB . erase ( I ) ; } </s>

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


<s> int shift_operator ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { switch ( GET_CODE ( op ) ) { case ASHIFTRT : case LSHIFTRT : case ASHIFT : return 1 ; default : return 0 ; } } </s>


<s> bool shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) override { MCFixupKind Kind = Fixup . getKind ( ) ; switch ( ( unsigned ) Kind ) { default : return Kind >= FirstLiteralRelocationKind ; case PPC :: fixup_ppc_br24 : case PPC :: fixup_ppc_br24abs : case PPC :: fixup_ppc_br24_notoc : if ( const MCSymbolRefExpr * A = Target . getSymA ( ) ) { if ( const auto * S = dyn_cast < MCSymbolELF > ( & A -> getSymbol ( ) ) ) { unsigned Other = S -> getOther ( ) << 2 ; if ( ( Other & ELF :: STO_PPC64_LOCAL_MASK ) != 0 ) return true ; } } return false ; } } </s>

Hook to check if a relocation is needed for some target specific reason .


<s> void GCNPassConfig :: addOptimizedRegAlloc ( FunctionPass * RegAllocPass ) { insertPass ( & MachineSchedulerID , & SIOptimizeExecMaskingPreRAID ) ; insertPass ( & PHIEliminationID , & SILowerControlFlowID , false ) ; insertPass ( & SILowerControlFlowID , & SIFixWWMLivenessID , false ) ; TargetPassConfig :: addOptimizedRegAlloc ( RegAllocPass ) ; } </s>

addOptimizedRegAlloc - Add passes related to register allocation .


<s> std :: pair < const Value * , unsigned > AMDGPUTargetMachine :: getPredicatedAddrSpace ( const Value * V ) const { if ( auto * II = dyn_cast < IntrinsicInst > ( V ) ) { switch ( II -> getIntrinsicID ( ) ) { case Intrinsic :: amdgcn_is_shared : return std :: make_pair ( II -> getArgOperand ( 0 ) , AMDGPUAS :: LOCAL_ADDRESS ) ; case Intrinsic :: amdgcn_is_private : return std :: make_pair ( II -> getArgOperand ( 0 ) , AMDGPUAS :: PRIVATE_ADDRESS ) ; default : break ; } return std :: make_pair ( nullptr , - 1 ) ; } Value * Ptr ; if ( match ( const_cast < Value * > ( V ) , m_c_And ( m_Not ( m_Intrinsic < Intrinsic :: amdgcn_is_shared > ( m_Value ( Ptr ) ) ) , m_Not ( m_Intrinsic < Intrinsic :: amdgcn_is_private > ( m_Deferred ( Ptr ) ) ) ) ) ) return std :: make_pair ( Ptr , AMDGPUAS :: GLOBAL_ADDRESS ) ; return std :: make_pair ( nullptr , - 1 ) ; } </s>

If the specified predicate checks whether a generic pointer falls within a specified address space , return that generic pointer and the address space being queried .


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


<s> void push_back ( Value * V ) { if ( ! S . count ( V ) ) { Q . push_back ( V ) ; S . insert ( V ) ; } } </s>

Insert a node at the back ; never copies .


<s>
void
R600SchedStrategy
::
releaseBottomNode
(
SUnit
*
SU
)
{
DEBUG
(
dbgs
(
)
<<
"Bottom Releasing "
;
SU
->
dump
(
DAG
)
;
)
;
if
(
isPhysicalRegCopy
(
SU
->
getInstr
(
)
)
)
{
PhysicalRegCopy
.
push_back
(
SU
)
;
return
;
}
int
IK
=
getInstKind
(
SU
)
;
if
(
IK
==
IDOther
)
Available
[
IDOther
]
.
push_back
(
SU
)
;
else
Pending
[
IK
]
.
push_back
(
SU
)
;
}
</s>

Currently only scheduling top-down , so this method is empty .


<s> void HexagonDAGToDAGISel :: Select ( SDNode * N ) { if ( N -> isMachineOpcode ( ) ) { N -> setNodeId ( - 1 ) ; return ; } switch ( N -> getOpcode ( ) ) { case ISD :: Constant : SelectConstant ( N ) ; return ; case ISD :: ConstantFP : SelectConstantFP ( N ) ; return ; case ISD :: FrameIndex : SelectFrameIndex ( N ) ; return ; case ISD :: ADD : SelectAdd ( N ) ; return ; case ISD :: SHL : SelectSHL ( N ) ; return ; case ISD :: LOAD : SelectLoad ( N ) ; return ; case ISD :: STORE : SelectStore ( N ) ; return ; case ISD :: MUL : SelectMul ( N ) ; return ; case ISD :: AND : case ISD :: OR : case ISD :: XOR : case ISD :: FABS : case ISD :: FNEG : SelectBitOp ( N ) ; return ; case ISD :: ZERO_EXTEND : SelectZeroExtend ( N ) ; return ; case ISD :: INTRINSIC_W_CHAIN : SelectIntrinsicWChain ( N ) ; return ; case ISD :: INTRINSIC_WO_CHAIN : SelectIntrinsicWOChain ( N ) ; return ; } SelectCode ( N ) ; } </s>

Main hook for targets to transform nodes into machine nodes .

Hexagon Hexagon 1 ISD::Constant ISD::ConstantFP ISD::FrameIndex ISD::ADD ISD::SHL ISD::LOAD ISD::STORE ISD::MUL ISD::AND ISD::OR ISD::XOR ISD::FABS ISD::FNEG ISD::ZERO_EXTEND ISD::INTRINSIC_W_CHAIN ISD::INTRINSIC_WO_CHAIN


<s> rtx arm_function_arg ( CUMULATIVE_ARGS * pcum , enum machine_mode mode , tree type , int named ) { int nregs ; if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( mode ) && pcum -> named_count > pcum -> nargs + 1 ) { if ( pcum -> iwmmxt_nregs <= 9 ) return gen_rtx_REG ( mode , pcum -> iwmmxt_nregs + FIRST_IWMMXT_REGNUM ) ; else { pcum -> can_split = false ; return NULL_RTX ; } } if ( pcum -> nregs & 1 && ARM_DOUBLEWORD_ALIGN && arm_needs_doubleword_align ( mode , type ) ) pcum -> nregs ++ ; if ( mode == VOIDmode ) return GEN_INT ( pcum -> call_cookie ) ; if ( pcum -> can_split ) nregs = 1 ; else nregs = ARM_NUM_REGS2 ( mode , type ) ; if ( ! named || pcum -> nregs + nregs > NUM_ARG_REGS ) return NULL_RTX ; return gen_rtx_REG ( mode , pcum -> nregs ) ; } </s>

Determine where to put an argument to a function . Value is zero to push the argument on the stack , or a hard register in which to store the argument . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) . On the ARM , normally the first 16 bytes are passed in registers r0-r3 ; all other arguments are passed on the stack . If ( NAMED == 0 ) ( which happens only in assign_parms , since TARGET_SETUP_INCOMING_VARARGS is defined ) , say it is passed in the stack ( function_prologue will indeed make it pass in the stack if necessary ) .


<s> static inline bool offset_below_red_zone_p ( HOST_WIDE_INT offset ) { return offset < ( DEFAULT_ABI == ABI_V4 ? 0 : TARGET_32BIT ? - 220 : - 288 ) ; } </s>

Return true if OFFSET from stack pointer can be clobbered by signals . V.4 does n't have any stack cushion , AIX ABIs have 220 or 288 bytes below stack pointer not cloberred by signals .


<s> int arc_return_slot_offset ( ) { struct arc_frame_info * afi = & cfun -> machine -> frame_info ; return ( afi -> save_return_addr ? afi -> total_size - afi -> pretend_size - afi -> extra_size : - 1 ) ; } </s>

Return the offset relative to the stack pointer where the return address is stored , or -1 if it is not stored .


<s>
Value
*
AArch64TargetLowering
::
emitLoadLinked
(
IRBuilderBase
&
Builder
,
Type
*
ValueTy
,
Value
*
Addr
,
AtomicOrdering
Ord
)
const
{
Module
*
M
=
Builder
.
GetInsertBlock
(
)
->
getParent
(
)
->
getParent
(
)
;
bool
IsAcquire
=
isAcquireOrStronger
(
Ord
)
;
if
(
ValueTy
->
getPrimitiveSizeInBits
(
)
==
128
)
{
Intrinsic
::
ID
Int
=
IsAcquire
Intrinsic
::
aarch64_ldaxp
:
Intrinsic
::
aarch64_ldxp
;
Function
*
Ldxr
=
Intrinsic
::
getDeclaration
(
M
,
Int
)
;
Addr
=
Builder
.
CreateBitCast
(
Addr
,
Type
::
getInt8PtrTy
(
M
->
getContext
(
)
)
)
;
Value
*
LoHi
=
Builder
.
CreateCall
(
Ldxr
,
Addr
,
"lohi"
)
;
Value
*
Lo
=
Builder
.
CreateExtractValue
(
LoHi
,
0
,
"lo"
)
;
Value
*
Hi
=
Builder
.
CreateExtractValue
(
LoHi
,
1
,
"hi"
)
;
Lo
=
Builder
.
CreateZExt
(
Lo
,
ValueTy
,
"lo64"
)
;
Hi
=
Builder
.
CreateZExt
(
Hi
,
ValueTy
,
"hi64"
)
;
return
Builder
.
CreateOr
(
Lo
,
Builder
.
CreateShl
(
Hi
,
ConstantInt
::
get
(
ValueTy
,
64
)
)
,
"val64"
)
;
}
const
DataLayout
&
DL
=
M
->
getDataLayout
(
)
;
IntegerType
*
IntEltTy
=
Builder
.
getIntNTy
(
DL
.
getTypeSizeInBits
(
ValueTy
)
)
;
if
(
ValueTy
->
isPointerTy
(
)
)
Addr
=
Builder
.
CreatePointerCast
(
Addr
,
IntEltTy
->
getPointerTo
(
Addr
->
getType
(
)
->
getPointerAddressSpace
(
)
)
)
;
Type
*
Tys
[
]
=
{
Addr
->
getType
(
)
}
;
Intrinsic
::
ID
Int
=
IsAcquire
Intrinsic
::
aarch64_ldaxr
:
Intrinsic
::
aarch64_ldxr
;
Function
*
Ldxr
=
Intrinsic
::
getDeclaration
(
M
,
Int
,
Tys
)
;
Value
*
Trunc
=
Builder
.
CreateTrunc
(
Builder
.
CreateCall
(
Ldxr
,
Addr
)
,
IntEltTy
)
;
assert
(
!
DL
.
isFatPointer
(
ValueTy
)
&&
"Should not be handled here!"
)
;
if
(
ValueTy
->
isPointerTy
(
)
)
return
Builder
.
CreateIntToPtr
(
Trunc
,
ValueTy
)
;
return
Builder
.
CreateBitCast
(
Trunc
,
ValueTy
)
;
}
</s>

Perform a load-linked operation on Addr , returning a `` Value * '' with the corresponding pointee type .


"Huge Stack Frame not yet supported on z/OS"

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


<s>
static
void
recombine_stvx_pattern
(
rtx_insn
*
insn
,
del_info
*
to_delete
)
{
rtx
body
=
PATTERN
(
insn
)
;
gcc_assert
(
GET_CODE
(
body
)
==
SET
&&
GET_CODE
(
SET_DEST
(
body
)
)
==
MEM
&&
GET_CODE
(
SET_SRC
(
body
)
)
==
VEC_SELECT
)
;
rtx
mem
=
SET_DEST
(
body
)
;
rtx
base_reg
=
XEXP
(
mem
,
0
)
;
rtx_insn
*
and_insn
;
rtx
and_operation
=
find_alignment_op
(
insn
,
base_reg
,
&
and_insn
)
;
if
(
and_operation
!=
0
)
{
rtx
src_reg
=
XEXP
(
SET_SRC
(
body
)
,
0
)
;
df_ref
src_use
;
struct
df_insn_info
*
insn_info
=
DF_INSN_INFO_GET
(
insn
)
;
FOR_EACH_INSN_INFO_USE
(
src_use
,
insn_info
)
{
if
(
!
rtx_equal_p
(
DF_REF_REG
(
src_use
)
,
src_reg
)
)
continue
;
struct
df_link
*
link
=
DF_REF_CHAIN
(
src_use
)
;
if
(
!
link
||
link
->
next
)
break
;
rtx_insn
*
swap_insn
=
DF_REF_INSN
(
link
->
ref
)
;
if
(
!
insn_is_swap_p
(
swap_insn
)
||
insn_is_load_p
(
swap_insn
)
||
insn_is_store_p
(
swap_insn
)
)
break
;
to_delete
[
INSN_UID
(
swap_insn
)
]
.
replace
=
true
;
to_delete
[
INSN_UID
(
swap_insn
)
]
.
replace_insn
=
swap_insn
;
rtx
and_base
=
XEXP
(
and_operation
,
0
)
;
rtx
new_reg
=
gen_reg_rtx
(
GET_MODE
(
and_base
)
)
;
rtx
copy
=
gen_rtx_SET
(
new_reg
,
and_base
)
;
rtx_insn
*
new_insn
=
emit_insn_after
(
copy
,
and_insn
)
;
set_block_for_insn
(
new_insn
,
BLOCK_FOR_INSN
(
and_insn
)
)
;
df_insn_rescan
(
new_insn
)
;
XEXP
(
mem
,
0
)
=
gen_rtx_AND
(
GET_MODE
(
and_base
)
,
new_reg
,
XEXP
(
and_operation
,
1
)
)
;
SET_SRC
(
body
)
=
src_reg
;
INSN_CODE
(
insn
)
=
1
;
df_insn_rescan
(
insn
)
;
if
(
dump_file
)
fprintf
(
dump_file
,
"stvx opportunity found at %d\n"
,
INSN_UID
(
insn
)
)
;
}
}
}
</s>

If INSN is the store for an stvx pattern , put it in canonical form .


Emit unwind opcodes for .vsave directives .


Compute the size of the local area and the size to be adjusted by the prologue and epilogue .


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


<s> bool evaluateBranch ( const MCInst & Inst , uint64_t Addr , uint64_t Size , uint64_t & Target ) const override { unsigned OpId ; switch ( Inst . getOpcode ( ) ) { default : OpId = 0 ; if ( Inst . getNumOperands ( ) == 0 ) return false ; break ; case ARM :: MVE_WLSTP_8 : case ARM :: MVE_WLSTP_16 : case ARM :: MVE_WLSTP_32 : case ARM :: MVE_WLSTP_64 : case ARM :: t2WLS : case ARM :: MVE_LETP : case ARM :: t2LEUpdate : OpId = 2 ; break ; case ARM :: t2LE : OpId = 1 ; break ; } if ( Info -> get ( Inst . getOpcode ( ) ) . OpInfo [ OpId ] . OperandType != MCOI :: OPERAND_PCREL ) return false ; Target = Addr + Inst . getOperand ( OpId ) . getImm ( ) + 4 ; return true ; } </s>

Given a branch instruction try to get the address the branch targets .


<s> bool mayNeedRelaxation ( const MCInst & Inst , const MCSubtargetInfo & STI ) const override { return false ; } </s>

Check whether the given instruction may need relaxation .


<s> void mips_va_start ( tree valist , rtx nextarg ) { if ( EABI_FLOAT_VARARGS_P ) { const CUMULATIVE_ARGS * cum ; tree f_ovfl , f_gtop , f_ftop , f_goff , f_foff ; tree ovfl , gtop , ftop , goff , foff ; tree t ; int gpr_save_area_size ; int fpr_save_area_size ; int fpr_offset ; cum = & current_function_args_info ; gpr_save_area_size = ( MAX_ARGS_IN_REGISTERS - cum -> num_gprs ) * UNITS_PER_WORD ; fpr_save_area_size = ( MAX_ARGS_IN_REGISTERS - cum -> num_fprs ) * UNITS_PER_FPREG ; f_ovfl = TYPE_FIELDS ( va_list_type_node ) ; f_gtop = TREE_CHAIN ( f_ovfl ) ; f_ftop = TREE_CHAIN ( f_gtop ) ; f_goff = TREE_CHAIN ( f_ftop ) ; f_foff = TREE_CHAIN ( f_goff ) ; ovfl = build ( COMPONENT_REF , TREE_TYPE ( f_ovfl ) , valist , f_ovfl , NULL_TREE ) ; gtop = build ( COMPONENT_REF , TREE_TYPE ( f_gtop ) , valist , f_gtop , NULL_TREE ) ; ftop = build ( COMPONENT_REF , TREE_TYPE ( f_ftop ) , valist , f_ftop , NULL_TREE ) ; goff = build ( COMPONENT_REF , TREE_TYPE ( f_goff ) , valist , f_goff , NULL_TREE ) ; foff = build ( COMPONENT_REF , TREE_TYPE ( f_foff ) , valist , f_foff , NULL_TREE ) ; t = make_tree ( TREE_TYPE ( ovfl ) , virtual_incoming_args_rtx ) ; if ( cum -> stack_words > 0 ) t = build ( PLUS_EXPR , TREE_TYPE ( ovfl ) , t , build_int_cst ( NULL_TREE , cum -> stack_words * UNITS_PER_WORD ) ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( ovfl ) , ovfl , t ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = make_tree ( TREE_TYPE ( gtop ) , virtual_incoming_args_rtx ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( gtop ) , gtop , t ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = make_tree ( TREE_TYPE ( ftop ) , virtual_incoming_args_rtx ) ; fpr_offset = gpr_save_area_size + UNITS_PER_FPVALUE - 1 ; fpr_offset &= ~ ( UNITS_PER_FPVALUE - 1 ) ; if ( fpr_offset ) t = build ( PLUS_EXPR , TREE_TYPE ( ftop ) , t , build_int_cst ( NULL_TREE , - fpr_offset ) ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( ftop ) , ftop , t ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( goff ) , goff , build_int_cst ( NULL_TREE , gpr_save_area_size ) ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( foff ) , foff , build_int_cst ( NULL_TREE , fpr_save_area_size ) ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } else { nextarg = plus_constant ( nextarg , - cfun -> machine -> varargs_size ) ; std_expand_builtin_va_start ( valist , nextarg ) ; } } </s>


"cpu %s is not based on arch %s, ignoring the arch"

Configure a build target TARGET from the user-specified options OPTS and OPTS_SET .


<s> int i386_pe_dllimport_name_p ( const char * symbol ) { return ( strncmp ( DLL_IMPORT_PREFIX , symbol , strlen ( DLL_IMPORT_PREFIX ) ) == 0 ) ; } </s>

Return nonzero if SYMBOL is marked as being dllimport 'd .


<s> static void s390_expand_cs_tdsi ( machine_mode mode , rtx btarget , rtx vtarget , rtx mem , rtx cmp , rtx new_rtx , bool is_weak ) { rtx output = vtarget ; rtx_code_label * skip_cs_label = NULL ; bool do_const_opt = false ; if ( ! register_operand ( output , mode ) ) output = gen_reg_rtx ( mode ) ; if ( TARGET_Z196 && ( mode == SImode || mode == DImode ) ) do_const_opt = ( is_weak && CONST_INT_P ( cmp ) ) ; if ( do_const_opt ) { const int very_unlikely = REG_BR_PROB_BASE / 100 - 1 ; rtx cc = gen_rtx_REG ( CCZmode , CC_REGNUM ) ; skip_cs_label = gen_label_rtx ( ) ; emit_move_insn ( btarget , const0_rtx ) ; if ( CONST_INT_P ( cmp ) && INTVAL ( cmp ) == 0 ) { rtvec lt = rtvec_alloc ( 2 ) ; RTVEC_ELT ( lt , 0 ) = gen_rtx_SET ( cc , gen_rtx_COMPARE ( CCZmode , mem , cmp ) ) ; RTVEC_ELT ( lt , 1 ) = gen_rtx_SET ( output , mem ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , lt ) ) ; } else { emit_move_insn ( output , mem ) ; emit_insn ( gen_rtx_SET ( cc , gen_rtx_COMPARE ( CCZmode , output , cmp ) ) ) ; } s390_emit_jump ( skip_cs_label , gen_rtx_NE ( VOIDmode , cc , const0_rtx ) ) ; add_int_reg_note ( get_last_insn ( ) , REG_BR_PROB , very_unlikely ) ; cmp = output ; } else cmp = force_reg ( mode , cmp ) ; new_rtx = force_reg ( mode , new_rtx ) ; s390_emit_compare_and_swap ( EQ , output , mem , cmp , new_rtx , ( do_const_opt ) ? CCZmode : CCZ1mode ) ; if ( skip_cs_label != NULL ) emit_label ( skip_cs_label ) ; if ( output != vtarget ) emit_move_insn ( vtarget , output ) ; if ( do_const_opt ) { rtx cc , cond , ite ; cc = gen_rtx_REG ( CCZmode , CC_REGNUM ) ; cond = gen_rtx_EQ ( VOIDmode , cc , const0_rtx ) ; ite = gen_rtx_IF_THEN_ELSE ( SImode , cond , const1_rtx , btarget ) ; emit_insn ( gen_rtx_SET ( btarget , ite ) ) ; } else { rtx cc , cond ; cc = gen_rtx_REG ( CCZ1mode , CC_REGNUM ) ; cond = gen_rtx_EQ ( SImode , cc , const0_rtx ) ; emit_insn ( gen_cstorecc4 ( btarget , cond , cc , const0_rtx ) ) ; } } </s>

Variant of s390_expand_cs for SI , DI and TI modes .


Return an array that contains the bitmask target flag values and their names .


<s> bool X86TTIImpl :: isLegalMaskedGather ( Type * DataTy ) { if ( isa < VectorType > ( DataTy ) && ! isPowerOf2_32 ( DataTy -> getVectorNumElements ( ) ) ) return false ; Type * ScalarTy = DataTy -> getScalarType ( ) ; int DataWidth = ScalarTy -> getPrimitiveSizeInBits ( ) ; return DataWidth >= 32 && ST -> hasAVX512 ( ) ; } </s>

Return true if the target supports masked gather .