<s>
void
MipsCodeEmitter
::
emitInstruction
(
const
MachineInstr
&
MI
)
{
DEBUG
(
errs
(
)
<<
"JIT: "
<<
(
void
*
)
MCE
.
getCurrentPCValue
(
)
<<
":\t"
<<
MI
)
;
MCE
.
processDebugLoc
(
MI
.
getDebugLoc
(
)
,
true
)
;
if
(
(
MI
.
getDesc
(
)
.
TSFlags
&
MipsII
::
FormMask
)
==
MipsII
::
Pseudo
)
return
;
switch
(
MI
.
getOpcode
(
)
)
{
case
Mips
::
USW
:
NumEmitted
+=
emitUSW
(
MI
)
;
break
;
case
Mips
::
ULW
:
NumEmitted
+=
emitULW
(
MI
)
;
break
;
case
Mips
::
ULH
:
NumEmitted
+=
emitULH
(
MI
)
;
break
;
case
Mips
::
ULHu
:
NumEmitted
+=
emitULHu
(
MI
)
;
break
;
case
Mips
::
USH
:
NumEmitted
+=
emitUSH
(
MI
)
;
break
;
default
:
emitWordLE
(
getBinaryCodeForInstr
(
MI
)
)
;
++
NumEmitted
;
break
;
}
MCE
.
processDebugLoc
(
MI
.
getDebugLoc
(
)
,
false
)
;
}
</s>

Targets should implement this to emit instructions .

Mips
Mips
"JIT: "
":\t"
MipsII::FormMask
MipsII::Pseudo
Mips::USW
Mips::ULW
Mips::ULH
Mips::ULHu
Mips::USH


"All AArch64 cmps should have 2 operands"

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


<s> SDValue MipsTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { SelectionDAG & DAG = DCI . DAG ; unsigned opc = N -> getOpcode ( ) ; switch ( opc ) { default : break ; case ISD :: ADDE : return PerformADDECombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SUBE : return PerformSUBECombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SDIVREM : case ISD :: UDIVREM : return PerformDivRemCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SELECT : return PerformSELECTCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: AND : return PerformANDCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: OR : return PerformORCombine ( N , DAG , DCI , Subtarget ) ; } return SDValue ( ) ; } </s>

This method will be invoked for all target nodes and for any target-independent nodes that the target has registered with invoke it for .

Mips Mips ISD::ADDE ISD::SUBE ISD::SDIVREM ISD::UDIVREM ISD::SELECT ISD::AND ISD::OR


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


<s> uint64_t flags ( ) const { return 0x0 ; } </s>

Get the flags for this GlobalValue ( see struct GVFlags ) .


<s> bool SelectInlineAsmMemoryOperand ( const SDValue & Op , char ConstraintCode , std :: vector < SDValue > & OutOps ) override { OutOps . push_back ( Op ) ; return false ; } </s>

SelectInlineAsmMemoryOperand - Select the specified address as a target addressing mode , according to the specified constraint .


<s> void PPCPassConfig :: addMachineSSAOptimization ( ) { if ( EnableBranchCoalescing && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCBranchCoalescingPass ( ) ) ; TargetPassConfig :: addMachineSSAOptimization ( ) ; if ( TM -> getTargetTriple ( ) . getArch ( ) == Triple :: ppc64le && ! DisableVSXSwapRemoval ) addPass ( createPPCVSXSwapRemovalPass ( ) ) ; if ( ReduceCRLogical && getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createPPCReduceCRLogicalsPass ( ) ) ; if ( ! DisableMIPeephole ) { addPass ( createPPCMIPeepholePass ( ) ) ; addPass ( & DeadMachineInstructionElimID ) ; } } </s>

Methods with trivial inline returns are convenient points in the common codegen pass pipeline where targets may insert passes .


"unimplemented opcode in encodeInstruction()"

Encode the given Inst to bytes and append to CB .


<s> void SystemZPostRASchedStrategy :: releaseTopNode ( SUnit * SU ) { const MCSchedClassDesc * SC = DAG -> getSchedClass ( SU ) ; bool AffectsGrouping = ( SC -> isValid ( ) && ( SC -> BeginGroup || SC -> EndGroup ) ) ; SU -> isScheduleHigh = ( AffectsGrouping || SU -> isUnbuffered ) ; Available . insert ( SU ) ; } </s>

SU has had all predecessor dependencies resolved .


<s>
void
ARMConstantIslands
::
verify
(
)
{
for
(
MachineFunction
::
iterator
MBBI
=
MF
->
begin
(
)
,
E
=
MF
->
end
(
)
;
MBBI
!=
E
;
++
MBBI
)
{
MachineBasicBlock
*
MBB
=
MBBI
;
unsigned
Align
=
MBB
->
getAlignment
(
)
;
unsigned
MBBId
=
MBB
->
getNumber
(
)
;
assert
(
BBInfo
[
MBBId
]
.
Offset
%
(
1u
<<
Align
)
==
0
)
;
assert
(
!
MBBId
||
BBInfo
[
MBBId
1
]
.
postOffset
(
)
<=
BBInfo
[
MBBId
]
.
Offset
)
;
}
for
(
unsigned
i
=
0
,
e
=
CPUsers
.
size
(
)
;
i
!=
e
;
++
i
)
{
CPUser
&
U
=
CPUsers
[
i
]
;
unsigned
UserOffset
=
GetUserOffset
(
U
)
;
assert
(
CPEIsInRange
(
U
.
MI
,
UserOffset
,
U
.
CPEMI
,
U
.
getMaxDisp
(
)
,
U
.
NegOk
)
&&
"Constant pool entry out of range!"
)
;
}
}
</s>


<s> bool ARMBaseInstrInfo :: isFpMLxInstruction ( unsigned Opcode , unsigned & MulOpc , unsigned & AddSubOpc , bool & NegAcc , bool & HasLane ) const { DenseMap < unsigned , unsigned > :: const_iterator I = MLxEntryMap . find ( Opcode ) ; if ( I == MLxEntryMap . end ( ) ) return false ; const ARM_MLxEntry & Entry = ARM_MLxTable [ I -> second ] ; MulOpc = Entry . MulOpc ; AddSubOpc = Entry . AddSubOpc ; NegAcc = Entry . NegAcc ; HasLane = Entry . HasLane ; return true ; } </s>

isFpMLxInstruction - This version also returns the multiply opcode and the addition / subtraction opcode to expand to .


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

This method should install a ( global ) instruction selector pass , which converts possibly generic instructions to fully target-specific instructions , thereby constraining all generic virtual registers to register classes .


<s>
StringRef
getPassName
(
)
const
override
{
return
"Thumb IT blocks insertion pass"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool gpr_or_gpr_p ( rtx op0 , rtx op1 ) { return ( ( REG_P ( op0 ) && INT_REGNO_P ( REGNO ( op0 ) ) ) || ( REG_P ( op1 ) && INT_REGNO_P ( REGNO ( op1 ) ) ) ) ; } </s>

Return true if either operand is a general purpose register .


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

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


<s> unsigned xlogue_layout :: count_stub_managed_regs ( ) { bool hfp = frame_pointer_needed || stack_realign_fp ; unsigned i , count ; unsigned regno ; for ( count = i = MIN_REGS ; i < MAX_REGS ; ++ i ) { regno = REG_ORDER [ i ] ; if ( regno == BP_REG && hfp ) continue ; if ( ! ix86_save_reg ( regno , false , false ) ) break ; ++ count ; } return count ; } </s>

Determine how many clobbered registers can be saved by the stub . Returns the count of registers the stub will save and restore .


<s> unsigned AArch64InstrInfo :: getLoadStoreImmIdx ( unsigned Opc ) { switch ( Opc ) { default : return 2 ; case AArch64 :: LDPXi : case AArch64 :: LDPDi : case AArch64 :: STPXi : case AArch64 :: STPDi : case AArch64 :: LDNPXi : case AArch64 :: LDNPDi : case AArch64 :: STNPXi : case AArch64 :: STNPDi : case AArch64 :: LDPQi : case AArch64 :: STPQi : case AArch64 :: LDNPQi : case AArch64 :: STNPQi : case AArch64 :: LDPWi : case AArch64 :: LDPSi : case AArch64 :: STPWi : case AArch64 :: STPSi : case AArch64 :: LDNPWi : case AArch64 :: LDNPSi : case AArch64 :: STNPWi : case AArch64 :: STNPSi : case AArch64 :: LDG : case AArch64 :: STGPi : case AArch64 :: LD1B_IMM : case AArch64 :: LD1H_IMM : case AArch64 :: LD1W_IMM : case AArch64 :: LD1D_IMM : case AArch64 :: ST1B_IMM : case AArch64 :: ST1H_IMM : case AArch64 :: ST1W_IMM : case AArch64 :: ST1D_IMM : case AArch64 :: LD1B_H_IMM : case AArch64 :: LD1SB_H_IMM : case AArch64 :: LD1H_S_IMM : case AArch64 :: LD1SH_S_IMM : case AArch64 :: LD1W_D_IMM : case AArch64 :: LD1SW_D_IMM : case AArch64 :: ST1B_H_IMM : case AArch64 :: ST1H_S_IMM : case AArch64 :: ST1W_D_IMM : case AArch64 :: LD1B_S_IMM : case AArch64 :: LD1SB_S_IMM : case AArch64 :: LD1H_D_IMM : case AArch64 :: LD1SH_D_IMM : case AArch64 :: ST1B_S_IMM : case AArch64 :: ST1H_D_IMM : case AArch64 :: LD1B_D_IMM : case AArch64 :: LD1SB_D_IMM : case AArch64 :: ST1B_D_IMM : case AArch64 :: LD1RB_IMM : case AArch64 :: LD1RB_H_IMM : case AArch64 :: LD1RB_S_IMM : case AArch64 :: LD1RB_D_IMM : case AArch64 :: LD1RSB_H_IMM : case AArch64 :: LD1RSB_S_IMM : case AArch64 :: LD1RSB_D_IMM : case AArch64 :: LD1RH_IMM : case AArch64 :: LD1RH_S_IMM : case AArch64 :: LD1RH_D_IMM : case AArch64 :: LD1RSH_S_IMM : case AArch64 :: LD1RSH_D_IMM : case AArch64 :: LD1RW_IMM : case AArch64 :: LD1RW_D_IMM : case AArch64 :: LD1RSW_IMM : case AArch64 :: LD1RD_IMM : return 3 ; case AArch64 :: ADDG : case AArch64 :: STGOffset : case AArch64 :: LDR_PXI : case AArch64 :: STR_PXI : return 2 ; } } </s>

Returns the index for the immediate for a given instruction .


<s> const uint32_t * LanaiRegisterInfo :: getCallPreservedMask ( const MachineFunction & MF , CallingConv :: ID CC ) const { return CSR_RegMask ; } </s>

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


<s>
void
addInstruction
(
TagStoreInstr
I
)
{
assert
(
(
TagStores
.
empty
(
)
||
TagStores
.
back
(
)
.
Offset
+
TagStores
.
back
(
)
.
Size
==
I
.
Offset
)
&&
"Non-adjacent tag store instructions."
)
;
TagStores
.
push_back
(
I
)
;
}
</s>

Record pressure difference induced by the given operand list to node with index Idx .


<s> static bool mem_ok_for_ldrd_strd ( rtx mem , rtx * base , rtx * offset , HOST_WIDE_INT * align ) { rtx addr ; gcc_assert ( base != NULL && offset != NULL ) ; if ( side_effects_p ( mem ) ) return false ; if ( GET_CODE ( mem ) == SUBREG ) return false ; gcc_assert ( MEM_P ( mem ) ) ; * offset = const0_rtx ; * align = MEM_ALIGN ( mem ) ; addr = XEXP ( mem , 0 ) ; if ( ! arm_legitimate_address_p ( DImode , addr , reload_in_progress || reload_completed ) ) return false ; if ( REG_P ( addr ) ) { * base = addr ; return true ; } else if ( GET_CODE ( addr ) == PLUS || GET_CODE ( addr ) == MINUS ) { * base = XEXP ( addr , 0 ) ; * offset = XEXP ( addr , 1 ) ; return ( REG_P ( * base ) && CONST_INT_P ( * offset ) ) ; } return false ; } </s>

Helper for gen_operands_ldrd_strd . Returns true iff the memory operand MEM 's address contains an immediate offset from the base register and has no side effects , in which case it sets BASE and OFFSET accordingly .


<s> void ix86_expand_unary_operator ( enum rtx_code code , machine_mode mode , rtx operands [ ] ) { bool matching_memory = false ; rtx src , dst , op , clob ; dst = operands [ 0 ] ; src = operands [ 1 ] ; if ( MEM_P ( dst ) ) { if ( rtx_equal_p ( dst , src ) ) matching_memory = true ; else dst = gen_reg_rtx ( mode ) ; } if ( MEM_P ( src ) && ! matching_memory ) src = force_reg ( mode , src ) ; op = gen_rtx_SET ( VOIDmode , dst , gen_rtx_fmt_e ( code , mode , src ) ) ; if ( reload_in_progress || code == NOT ) { gcc_assert ( code == NOT ) ; emit_insn ( op ) ; } else { clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , op , clob ) ) ) ; } if ( dst != operands [ 0 ] ) emit_move_insn ( operands [ 0 ] , dst ) ; } </s>

Attempt to expand a unary operator . Make the expansion closer to the actual machine , then just general_operand , which will allow 2 separate memory references ( one output , one input ) in a single insn .


<s> bool X86AsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { SetupMachineFunction ( MF ) ; if ( Subtarget -> isTargetCOFF ( ) && ! Subtarget -> isTargetEnvMacho ( ) ) { bool Intrn = MF . getFunction ( ) -> hasInternalLinkage ( ) ; OutStreamer . BeginCOFFSymbolDef ( CurrentFnSym ) ; OutStreamer . EmitCOFFSymbolStorageClass ( Intrn ? COFF :: IMAGE_SYM_CLASS_STATIC : COFF :: IMAGE_SYM_CLASS_EXTERNAL ) ; OutStreamer . EmitCOFFSymbolType ( COFF :: IMAGE_SYM_DTYPE_FUNCTION << COFF :: SCT_COMPLEX_TYPE_SHIFT ) ; OutStreamer . EndCOFFSymbolDef ( ) ; } EmitFunctionHeader ( ) ; EmitFunctionBody ( ) ; return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool aarch64_prepare_sve_cond_int_fma ( rtx * operands , rtx_code code ) { machine_mode mode = GET_MODE ( operands [ 0 ] ) ; if ( rtx shifts = aarch64_convert_mult_to_shift ( operands [ 3 ] , code ) ) { rtx product = expand_binop ( mode , vashl_optab , operands [ 2 ] , shifts , NULL_RTX , true , OPTAB_DIRECT ) ; emit_insn ( gen_cond ( code , mode , operands [ 0 ] , operands [ 1 ] , operands [ 4 ] , product , operands [ 5 ] ) ) ; return true ; } operands [ 3 ] = force_reg ( mode , operands [ 3 ] ) ; return false ; } </s>

Likewise , but for a conditional pattern .


<s> void PPCPassConfig :: addIRPasses ( ) { addPass ( createAtomicExpandPass ( & getPPCTargetMachine ( ) ) ) ; bool UsePrefetching = Triple ( TM -> getTargetTriple ( ) ) . getVendor ( ) == Triple :: BGQ && getOptLevel ( ) != CodeGenOpt :: None ; if ( EnablePrefetch . getNumOccurrences ( ) > 0 ) UsePrefetching = EnablePrefetch ; if ( UsePrefetching ) addPass ( createPPCLoopDataPrefetchPass ( ) ) ; if ( TM -> getOptLevel ( ) == CodeGenOpt :: Aggressive && EnableGEPOpt ) { addPass ( createSeparateConstOffsetFromGEPPass ( TM , true ) ) ; addPass ( createEarlyCSEPass ( ) ) ; addPass ( createLICMPass ( ) ) ; } TargetPassConfig :: addIRPasses ( ) ; } </s>

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


<s> static bool vr4130_swap_insns_p ( rtx insn1 , rtx insn2 ) { rtx dep ; for ( dep = INSN_DEPEND ( insn1 ) ; dep != 0 ; dep = XEXP ( dep , 1 ) ) if ( REG_NOTE_KIND ( dep ) == REG_DEP_ANTI && INSN_PRIORITY ( XEXP ( dep , 0 ) ) > INSN_PRIORITY ( insn2 ) && recog_memoized ( XEXP ( dep , 0 ) ) >= 0 && get_attr_vr4130_class ( XEXP ( dep , 0 ) ) == VR4130_CLASS_ALU ) return false ; if ( vr4130_last_insn != 0 && recog_memoized ( insn1 ) >= 0 && recog_memoized ( insn2 ) >= 0 ) { enum attr_vr4130_class class1 = get_attr_vr4130_class ( insn1 ) ; enum attr_vr4130_class class2 = get_attr_vr4130_class ( insn2 ) ; if ( class1 != class2 || class1 == VR4130_CLASS_ALU ) { bool dep1 = vr4130_true_reg_dependence_p ( insn1 ) ; bool dep2 = vr4130_true_reg_dependence_p ( insn2 ) ; if ( dep1 != dep2 ) return dep1 ; if ( class1 != VR4130_CLASS_ALU && recog_memoized ( vr4130_last_insn ) >= 0 && class1 == get_attr_vr4130_class ( vr4130_last_insn ) ) return true ; } } return false ; } </s>

A TUNE_MIPS4130 helper function . Given that INSN1 is at the head of the ready queue and that INSN2 is the instruction after it , return true if it is worth promoting INSN2 ahead of INSN1 . Look for cases in which INSN1 and INSN2 can probably issue in parallel , but for which ( INSN2 , INSN1 ) should be less sensitive to instruction alignment than ( INSN1 , INSN2 ) . See 4130.md for more details .


<s> bool isVirtualSection ( const MCSection & Section ) const { const MCSectionMachO & SMO = static_cast < const MCSectionMachO & > ( Section ) ; return ( SMO . getType ( ) == MCSectionMachO :: S_ZEROFILL || SMO . getType ( ) == MCSectionMachO :: S_GB_ZEROFILL ) ; } </s>

Check whether this section is `` virtual '' , that is has no actual object file contents .


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

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


<s>
static
void
thumb_pushpop
(
FILE
*
f
,
unsigned
long
mask
,
int
push
,
int
*
cfa_offset
,
unsigned
long
real_regs
)
{
int
regno
;
int
lo_mask
=
mask
&
0xFF
;
int
pushed_words
=
0
;
gcc_assert
(
mask
)
;
if
(
lo_mask
==
0
&&
!
push
&&
(
mask
&
(
1
<<
PC_REGNUM
)
)
)
{
thumb_exit
(
f
,
1
)
;
return
;
}
if
(
ARM_EABI_UNWIND_TABLES
&&
push
)
{
fprintf
(
f
,
"\t.save\t{"
)
;
for
(
regno
=
0
;
regno
<
15
;
regno
++
)
{
if
(
real_regs
&
(
1
<<
regno
)
)
{
if
(
real_regs
&
(
(
1
<<
regno
)
1
)
)
fprintf
(
f
,
", "
)
;
asm_fprintf
(
f
,
"%r"
,
regno
)
;
}
}
fprintf
(
f
,
"}\n"
)
;
}
fprintf
(
f
,
"\t%s\t{"
,
push
"push"
:
"pop"
)
;
for
(
regno
=
0
;
regno
<=
LAST_LO_REGNUM
;
regno
++
,
lo_mask
>>=
1
)
{
if
(
lo_mask
&
1
)
{
asm_fprintf
(
f
,
"%r"
,
regno
)
;
if
(
(
lo_mask
&
~
1
)
!=
0
)
fprintf
(
f
,
", "
)
;
pushed_words
++
;
}
}
if
(
push
&&
(
mask
&
(
1
<<
LR_REGNUM
)
)
)
{
if
(
mask
&
0xFF
)
fprintf
(
f
,
", "
)
;
asm_fprintf
(
f
,
"%r"
,
LR_REGNUM
)
;
pushed_words
++
;
}
else
if
(
!
push
&&
(
mask
&
(
1
<<
PC_REGNUM
)
)
)
{
if
(
TARGET_INTERWORK
||
TARGET_BACKTRACE
||
current_function_calls_eh_return
)
{
fprintf
(
f
,
"}\n"
)
;
thumb_exit
(
f
,
1
)
;
return
;
}
else
{
if
(
mask
&
0xFF
)
fprintf
(
f
,
", "
)
;
asm_fprintf
(
f
,
"%r"
,
PC_REGNUM
)
;
}
}
fprintf
(
f
,
"}\n"
)
;
if
(
push
&&
pushed_words
&&
dwarf2out_do_frame
(
)
)
{
char
*
l
=
dwarf2out_cfi_label
(
)
;
int
pushed_mask
=
real_regs
;
*
cfa_offset
+=
pushed_words
*
4
;
dwarf2out_def_cfa
(
l
,
SP_REGNUM
,
*
cfa_offset
)
;
pushed_words
=
0
;
pushed_mask
=
real_regs
;
for
(
regno
=
0
;
regno
<=
14
;
regno
++
,
pushed_mask
>>=
1
)
{
if
(
pushed_mask
&
1
)
dwarf2out_reg_save
(
l
,
regno
,
4
*
pushed_words
++
*
cfa_offset
)
;
}
}
}
</s>

Emit code to push or pop registers to or from the stack . F is the assembly file . MASK is the registers to push or pop . PUSH is nonzero if we should push , and zero if we should pop . For debugging output , if pushing , adjust CFA_OFFSET by the amount of space added to the stack . REAL_REGS should have the same number of bits set as MASK , and will be used instead ( in the same order ) to describe which registers were saved - this is used to mark the save slots when we push high registers after moving them to low registers .


<s> bool MipsLongBranch :: runOnMachineFunction ( MachineFunction & F ) { if ( ( TM . getRelocationModel ( ) == Reloc :: PIC_ ) && TM . getSubtarget < MipsSubtarget > ( ) . isABI_O32 ( ) && F . getInfo < MipsFunctionInfo > ( ) -> globalBaseRegSet ( ) ) emitGPDisp ( F , TII ) ; if ( SkipLongBranch ) return true ; MF = & F ; initMBBInfo ( ) ; bool IsPIC = ( TM . getRelocationModel ( ) == Reloc :: PIC_ ) ; SmallVector < MBBInfo , 16 > :: iterator I , E = MBBInfos . end ( ) ; bool EverMadeChange = false , MadeChange = true ; while ( MadeChange ) { MadeChange = false ; for ( I = MBBInfos . begin ( ) ; I != E ; ++ I ) { if ( ! I -> Br || I -> HasLongBranch ) continue ; if ( ! ForceLongBranch ) { int64_t Offset = computeOffset ( I -> Br ) ; if ( ( I -> Br -> isConditionalBranch ( ) || IsPIC ) && isInt < 16 > ( Offset / 4 ) ) continue ; if ( I -> Br -> isUnconditionalBranch ( ) && ! IsPIC && isInt < 26 > ( Offset / 4 ) ) continue ; } expandToLongBranch ( * I ) ; ++ LongBranches ; EverMadeChange = MadeChange = true ; } } if ( EverMadeChange ) MF -> RenumberBlocks ( ) ; return true ; } </s>


<s> void PPCTargetLowering :: insertSSPDeclarations ( Module & M ) const { if ( Subtarget . isAIXABI ( ) ) { M . getOrInsertGlobal ( AIXSSPCanaryWordName , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ; return ; } if ( ! Subtarget . isTargetLinux ( ) ) return TargetLowering :: insertSSPDeclarations ( M ) ; } </s>

Inserts necessary declarations for SSP ( stack protection ) purpose .


<s> static inline tree def_builtin_const2 ( HOST_WIDE_INT mask , const char * name , enum ix86_builtin_func_type tcode , enum ix86_builtins code ) { tree decl = def_builtin2 ( mask , name , tcode , code ) ; if ( decl ) TREE_READONLY ( decl ) = 1 ; else ix86_builtins_isa [ ( int ) code ] . const_p = true ; return decl ; } </s>

Like def_builtin , but also marks the function decl `` const '' .


<s>
bool
ARMBaseInstrInfo
::
analyzeSelect
(
const
MachineInstr
*
MI
,
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
unsigned
&
TrueOp
,
unsigned
&
FalseOp
,
bool
&
Optimizable
)
const
{
assert
(
(
MI
->
getOpcode
(
)
==
ARM
::
MOVCCr
||
MI
->
getOpcode
(
)
==
ARM
::
t2MOVCCr
)
&&
"Unknown select instruction"
)
;
TrueOp
=
1
;
FalseOp
=
2
;
Cond
.
push_back
(
MI
->
getOperand
(
3
)
)
;
Cond
.
push_back
(
MI
->
getOperand
(
4
)
)
;
Optimizable
=
true
;
return
false
;
}
</s>

Analyze the given select instruction , returning true if it can not be understood .


<s> static int unspec_cmla ( int rot ) { switch ( rot ) { case 0 : return UNSPEC_CMLA ; case 90 : return UNSPEC_CMLA90 ; case 180 : return UNSPEC_CMLA180 ; case 270 : return UNSPEC_CMLA270 ; default : gcc_unreachable ( ) ; } } </s>

Return the UNSPEC_CMLA * unspec for rotation amount ROT .


<s> static bool csky_class_likely_spilled_p ( reg_class_t rclass ) { if ( ( TARGET_MINI_REGISTERS && rclass == MINI_REGS ) || rclass == C_REGS ) return true ; return false ; } </s>

Implement TARGET_CLASS_LIKELY_SPILLED_P . We need to define this for MINI_REGS when we only use r0 - r7 . Otherwise we can end up using r0-r4 for function arguments , and do n't have enough left over to do doubleword arithmetic .


<s> BitVector TOYRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( TOY :: SP ) ; Reserved . set ( TOY :: LR ) ; return Reserved ; } </s>

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


"internal error: builtin function %s already processed"

Add a SPARC builtin function with NAME , ICODE , CODE and TYPE . Return the function decl or NULL_TREE if the builtin was not added .


<s> bool isLittleEndian ( ) const { return IsLittleEndian ; } </s>

Tests whether the target triple is little endian .


<s> static int ix86_set_reg_reg_cost ( machine_mode mode ) { unsigned int units = UNITS_PER_WORD ; switch ( GET_MODE_CLASS ( mode ) ) { default : break ; case MODE_CC : units = GET_MODE_SIZE ( CCmode ) ; break ; case MODE_FLOAT : if ( ( TARGET_SSE && mode == TFmode ) || ( TARGET_80387 && mode == XFmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DFmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SFmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_COMPLEX_FLOAT : if ( ( TARGET_SSE && mode == TCmode ) || ( TARGET_80387 && mode == XCmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DCmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SCmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_VECTOR_INT : case MODE_VECTOR_FLOAT : if ( ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) || ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) || ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) || ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) || ( ( TARGET_MMX || TARGET_MMX_WITH_SSE ) && VALID_MMX_REG_MODE ( mode ) ) ) units = GET_MODE_SIZE ( mode ) ; } return COSTS_N_INSNS ( CEIL ( GET_MODE_SIZE ( mode ) , units ) ) ; } </s>

Return the cost of moving between two registers of mode MODE .


<s> bool ARMBaseInstrInfo :: hasHighOperandLatency ( const InstrItineraryData * ItinData , const MachineRegisterInfo * MRI , const MachineInstr * DefMI , unsigned DefIdx , const MachineInstr * UseMI , unsigned UseIdx ) const { unsigned DDomain = DefMI -> getDesc ( ) . TSFlags & ARMII :: DomainMask ; unsigned UDomain = UseMI -> getDesc ( ) . TSFlags & ARMII :: DomainMask ; if ( Subtarget . isCortexA8 ( ) && ( DDomain == ARMII :: DomainVFP || UDomain == ARMII :: DomainVFP ) ) return true ; int Latency = computeOperandLatency ( ItinData , DefMI , DefIdx , UseMI , UseIdx , false ) ; if ( Latency < 0 ) Latency = getInstrLatency ( ItinData , DefMI ) ; if ( Latency <= 3 ) return false ; return DDomain == ARMII :: DomainVFP || DDomain == ARMII :: DomainNEON || UDomain == ARMII :: DomainVFP || UDomain == ARMII :: DomainNEON ; } </s>

Compute operand latency between a def of 'Reg ' and a use in the current loop .

ARM ARM ARMII::DomainMask ARMII::DomainMask ARMII::DomainVFP ARMII::DomainVFP 0 3 ARMII::DomainVFP ARMII::DomainNEON ARMII::DomainVFP ARMII::DomainNEON


<s> static void mips16_copy_fpr_return_value ( void ) { rtx fn , insn , retval ; tree return_type ; machine_mode return_mode ; const char * name ; return_type = DECL_RESULT ( current_function_decl ) ; return_mode = DECL_MODE ( return_type ) ; name = ACONCAT ( ( "__mips16_ret_" , mips16_call_stub_mode_suffix ( return_mode ) , NULL ) ) ; fn = mips16_stub_function ( name ) ; SYMBOL_REF_FLAGS ( fn ) |= SYMBOL_FLAG_BIND_NOW ; retval = gen_rtx_REG ( return_mode , GP_RETURN ) ; insn = mips_expand_call ( MIPS_CALL_EPILOGUE , retval , fn , const0_rtx , NULL_RTX , false ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , retval ) ; } </s>

The current function is a MIPS16 function that returns a value in an FPR . Copy the return value from its soft-float to its hard-float location . libgcc2 has special non-MIPS16 helper functions for each case .


"Instr doesn't have FrameIndex operand!"

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


<s>
void
MipsInstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
SrcReg
,
bool
isKill
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
MachineMemOperand
*
MMO
=
GetMemOperand
(
MBB
,
FI
,
MachineMemOperand
::
MOStore
)
;
unsigned
Opc
=
0
;
if
(
Mips
::
CPURegsRegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
SW_P8
:
Mips
::
SW
;
else
if
(
Mips
::
CPU64RegsRegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
SD_P8
:
Mips
::
SD
;
else
if
(
Mips
::
FGR32RegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
SWC1_P8
:
Mips
::
SWC1
;
else
if
(
Mips
::
AFGR64RegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
Mips
::
SDC1
;
else
if
(
Mips
::
FGR64RegClass
.
hasSubClassEq
(
RC
)
)
Opc
=
IsN64
Mips
::
SDC164_P8
:
Mips
::
SDC164
;
assert
(
Opc
&&
"Register class not handled!"
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
;
}
</s>

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


<s> static void mips_conditional_register_usage ( void ) { if ( ISA_HAS_DSP ) { global_regs [ CCDSP_PO_REGNUM ] = 1 ; global_regs [ CCDSP_SC_REGNUM ] = 1 ; } else accessible_reg_set &= ~ reg_class_contents [ DSP_ACC_REGS ] ; if ( ! ISA_HAS_HILO ) accessible_reg_set &= ~ reg_class_contents [ MD_REGS ] ; if ( ! TARGET_HARD_FLOAT ) accessible_reg_set &= ~ ( reg_class_contents [ FP_REGS ] | reg_class_contents [ ST_REGS ] ) ; else if ( ! ISA_HAS_8CC ) { accessible_reg_set &= ~ reg_class_contents [ ST_REGS ] ; if ( ! ISA_HAS_CCF ) SET_HARD_REG_BIT ( accessible_reg_set , FPSW_REGNUM ) ; fixed_regs [ FPSW_REGNUM ] = 1 ; } if ( TARGET_MIPS16 ) { fixed_regs [ 18 ] = 1 ; fixed_regs [ 19 ] = 1 ; fixed_regs [ 20 ] = 1 ; fixed_regs [ 21 ] = 1 ; fixed_regs [ 22 ] = 1 ; fixed_regs [ 23 ] = 1 ; fixed_regs [ 26 ] = 1 ; fixed_regs [ 27 ] = 1 ; fixed_regs [ 30 ] = 1 ; if ( optimize_size ) { fixed_regs [ 8 ] = 1 ; fixed_regs [ 9 ] = 1 ; fixed_regs [ 10 ] = 1 ; fixed_regs [ 11 ] = 1 ; fixed_regs [ 12 ] = 1 ; fixed_regs [ 13 ] = 1 ; fixed_regs [ 14 ] = 1 ; fixed_regs [ 15 ] = 1 ; } operand_reg_set &= ~ reg_class_contents [ MD_REGS ] ; } if ( mips_abi == ABI_64 ) { int regno ; for ( regno = FP_REG_FIRST + 20 ; regno < FP_REG_FIRST + 24 ; regno ++ ) call_used_regs [ regno ] = 1 ; } if ( mips_abi == ABI_N32 || ( mips_abi == ABI_32 && TARGET_FLOAT64 ) ) { int regno ; for ( regno = FP_REG_FIRST + 21 ; regno <= FP_REG_FIRST + 31 ; regno += 2 ) call_used_regs [ regno ] = 1 ; } if ( TARGET_LITTLE_ENDIAN ) { unsigned int regno ; mips_swap_registers ( MD_REG_FIRST ) ; for ( regno = DSP_ACC_REG_FIRST ; regno <= DSP_ACC_REG_LAST ; regno += 2 ) mips_swap_registers ( regno ) ; } } </s>


<s> static const char * detect_processor_aix ( void ) { switch ( _system_configuration . implementation ) { case 0x0008 : return "601" ; case 0x0020 : return "603" ; case 0x0010 : return "604" ; case 0x0040 : return "620" ; case 0x0080 : return "630" ; case 0x0100 : case 0x0200 : case 0x0400 : return "rs64" ; case 0x0800 : return "power4" ; case 0x2000 : if ( _system_configuration . version == 0x0F0000 ) return "power5" ; else return "power5+" ; case 0x4000 : return "power6" ; case 0x8000 : return "power7" ; case 0x10000 : return "power8" ; default : return "powerpc" ; } } </s>

Returns the processor implementation on AIX .


<s> static rtx lxvrse_expand_builtin ( rtx target , insn_code icode , rtx * op , machine_mode tmode , machine_mode smode ) { rtx pat , addr ; op [ 1 ] = copy_to_mode_reg ( Pmode , op [ 1 ] ) ; if ( op [ 0 ] == const0_rtx ) addr = gen_rtx_MEM ( tmode , op [ 1 ] ) ; else { op [ 0 ] = copy_to_mode_reg ( Pmode , op [ 0 ] ) ; addr = gen_rtx_MEM ( smode , gen_rtx_PLUS ( Pmode , op [ 1 ] , op [ 0 ] ) ) ; } rtx discratch = gen_reg_rtx ( V2DImode ) ; rtx tiscratch = gen_reg_rtx ( TImode ) ; pat = GEN_FCN ( icode ) ( tiscratch , addr ) ; if ( ! pat ) return 0 ; emit_insn ( pat ) ; rtx temp1 ; if ( icode == CODE_FOR_vsx_lxvrbx ) { temp1 = simplify_gen_subreg ( V16QImode , tiscratch , TImode , 0 ) ; emit_insn ( gen_vsx_sign_extend_v16qi_v2di ( discratch , temp1 ) ) ; } else if ( icode == CODE_FOR_vsx_lxvrhx ) { temp1 = simplify_gen_subreg ( V8HImode , tiscratch , TImode , 0 ) ; emit_insn ( gen_vsx_sign_extend_v8hi_v2di ( discratch , temp1 ) ) ; } else if ( icode == CODE_FOR_vsx_lxvrwx ) { temp1 = simplify_gen_subreg ( V4SImode , tiscratch , TImode , 0 ) ; emit_insn ( gen_vsx_sign_extend_v4si_v2di ( discratch , temp1 ) ) ; } else if ( icode == CODE_FOR_vsx_lxvrdx ) discratch = simplify_gen_subreg ( V2DImode , tiscratch , TImode , 0 ) ; else gcc_unreachable ( ) ; rtx temp2 = simplify_gen_subreg ( TImode , discratch , V2DImode , 0 ) ; emit_insn ( gen_extendditi2_vector ( target , temp2 ) ) ; return target ; } </s>

Expand a builtin function that loads a scalar into a vector register with sign extension , and return the expanded rtx .


<s>
void
print
(
raw_ostream
&
OS
)
const
override
{
switch
(
Kind
)
{
case
Immediate
:
OS
<<
*
getImm
(
)
;
break
;
case
Register
:
OS
<<
"<register x"
;
OS
<<
getReg
(
)
<<
">"
;
break
;
case
Token
:
OS
<<
"'"
<<
getToken
(
)
<<
"'"
;
break
;
}
}
</s>

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


<s> void altivec_expand_vec_perm_le ( rtx operands [ 4 ] ) { rtx notx , iorx , unspec ; rtx target = operands [ 0 ] ; rtx op0 = operands [ 1 ] ; rtx op1 = operands [ 2 ] ; rtx sel = operands [ 3 ] ; rtx tmp = target ; rtx norreg = gen_reg_rtx ( V16QImode ) ; machine_mode mode = GET_MODE ( target ) ; if ( ! REG_P ( op0 ) ) op0 = force_reg ( mode , op0 ) ; if ( ! REG_P ( op1 ) ) op1 = force_reg ( mode , op1 ) ; if ( ! REG_P ( sel ) ) sel = force_reg ( V16QImode , sel ) ; if ( ! REG_P ( target ) ) tmp = gen_reg_rtx ( mode ) ; notx = gen_rtx_NOT ( V16QImode , sel ) ; iorx = ( TARGET_P8_VECTOR ? gen_rtx_IOR ( V16QImode , notx , notx ) : gen_rtx_AND ( V16QImode , notx , notx ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , norreg , iorx ) ) ; unspec = gen_rtx_UNSPEC ( mode , gen_rtvec ( 3 , op1 , op0 , norreg ) , UNSPEC_VPERM ) ; if ( ! REG_P ( target ) ) { emit_move_insn ( tmp , unspec ) ; unspec = tmp ; } emit_move_insn ( target , unspec ) ; } </s>

Similarly to altivec_expand_vec_perm_const_le , we must adjust the permute control vector . But here it 's not a constant , so we must generate a vector NAND or NOR to do the adjustment .


<s> bool AArch64InstrInfo :: isStridedAccess ( const MachineInstr & MI ) { return llvm :: any_of ( MI . memoperands ( ) , [ ] ( MachineMemOperand * MMO ) { return MMO -> getFlags ( ) & MOStridedAccess ; } ) ; } </s>

Return true if the given load or store is a strided memory access .


"MMIX Internal: Last named vararg would not fit in a register"


<s> EVT ARMTargetLowering :: getOptimalMemOpType ( const MemOp & Op , const AttributeList & FuncAttributes ) const { if ( ( Op . isMemcpy ( ) || Op . isZeroMemset ( ) ) && Subtarget -> hasNEON ( ) && ! FuncAttributes . hasFnAttribute ( Attribute :: NoImplicitFloat ) ) { bool Fast ; if ( Op . size ( ) >= 16 && ( Op . isAligned ( Align ( 16 ) ) || ( allowsMisalignedMemoryAccesses ( MVT :: v2f64 , 0 , 1 , MachineMemOperand :: MONone , & Fast ) && Fast ) ) ) { return MVT :: v2f64 ; } else if ( Op . size ( ) >= 8 && ( Op . isAligned ( Align ( 8 ) ) || ( allowsMisalignedMemoryAccesses ( MVT :: f64 , 0 , 1 , MachineMemOperand :: MONone , & Fast ) && Fast ) ) ) { return MVT :: f64 ; } } return MVT :: Other ; } </s>

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


<s> int mep_register_move_cost ( machine_mode mode , enum reg_class from , enum reg_class to ) { if ( mep_have_copro_copro_moves_p && reg_class_subset_p ( from , CR_REGS ) && reg_class_subset_p ( to , CR_REGS ) ) { if ( TARGET_32BIT_CR_REGS && GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return 4 ; return 2 ; } if ( reg_class_subset_p ( from , CR_REGS ) && reg_class_subset_p ( to , CR_REGS ) ) { if ( TARGET_32BIT_CR_REGS && GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return 8 ; return 4 ; } if ( reg_class_subset_p ( from , CR_REGS ) || reg_class_subset_p ( to , CR_REGS ) ) { if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return 4 ; return 2 ; } if ( mep_secondary_memory_needed ( from , to , mode ) ) return 1000 ; if ( MEP_NONGENERAL_CLASS ( from ) && MEP_NONGENERAL_CLASS ( to ) ) return 1000 ; if ( GET_MODE_SIZE ( mode ) > 4 ) return 4 ; return 2 ; } </s>

Implement REGISTER_MOVE_COST . Return 2 for direct single-register moves , 4 for direct double-register moves , and 1000 for anything that requires a temporary register or temporary stack slot .


<s>
static
bool
rs6000_predict_doloop_p
(
struct
loop
*
loop
)
{
gcc_assert
(
loop
)
;
if
(
loop
->
inner
!=
)
{
if
(
dump_file
&&
(
dump_flags
&
TDF_DETAILS
)
)
fprintf
(
dump_file
,
"Predict doloop failure due to"
" loop nesting.\n"
)
;
return
false
;
}
return
true
;
}
</s>

Predict whether the given loop in gimple will be transformed in the RTL doloop_optimize pass .

rs6000
"Predict doloop failure due to"
" loop nesting.\n"


<s> AArch64Subtarget :: AArch64Subtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const TargetMachine & TM , bool LittleEndian ) : AArch64GenSubtargetInfo ( TT , CPU , FS ) , ReserveX18 ( TT . isOSDarwin ( ) ) , IsLittle ( LittleEndian ) , CPUString ( CPU ) , TargetTriple ( TT ) , FrameLowering ( ) , InstrInfo ( initializeSubtargetDependencies ( FS ) ) , TSInfo ( ) , TLInfo ( TM , * this ) , GISel ( ) { } </s>

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


<s>
StringRef
getPassName
(
)
const
override
{
return
"X86 Atom pad short functions"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s>
bool
fixupNeedsRelaxation
(
const
MCFixup
&
Fixup
,
uint64_t
Value
,
const
MCRelaxableFragment
*
DF
,
const
MCAsmLayout
&
Layout
)
const
{
assert
(
0
&&
"fixupNeedsRelaxation() unimplemented"
)
;
return
false
;
}
</s>

Simple predicate for targets where ! Resolved implies requiring relaxation .

Sparc
0
"fixupNeedsRelaxation() unimplemented"


<s> rtx function_expander :: map_to_unspecs ( int unspec_for_sint , int unspec_for_uint , int unspec_for_fp , unsigned int merge_argno ) { machine_mode mode = vector_mode ( 0 ) ; int unspec = ( ! type_suffix ( 0 ) . integer_p ? unspec_for_fp : type_suffix ( 0 ) . unsigned_p ? unspec_for_uint : unspec_for_sint ) ; if ( pred == PRED_x ) { insn_code icode = maybe_code_for_aarch64_pred ( unspec , mode ) ; if ( icode != CODE_FOR_nothing ) return use_pred_x_insn ( icode ) ; } if ( pred == PRED_none || pred == PRED_x ) { insn_code icode = maybe_code_for_aarch64_sve ( unspec , mode ) ; if ( icode != CODE_FOR_nothing ) return use_unpred_insn ( icode ) ; } insn_code icode = code_for_cond ( unspec , vector_mode ( 0 ) ) ; return use_cond_insn ( icode , merge_argno ) ; } </s>

Implement the call using one of the following strategies , chosen in order : ( 1 ) `` aarch64_pred_ < optab > < mode > '' for PRED_x functions ; this is a predicated pattern ( 2 ) `` aarch64_sve_ < optab > < mode > '' for PRED_none and PRED_x functions ; this is an unpredicated pattern ( 3 ) `` cond_ < optab > < mode > '' otherwise where < optab > corresponds to : - UNSPEC_FOR_SINT for signed integers - UNSPEC_FOR_UINT for unsigned integers - UNSPEC_FOR_FP for floating-point values MERGE_ARGNO is the argument that provides the values of inactive lanes for _m functions , or DEFAULT_MERGE_ARGNO if we should apply the usual rules .


<s> SDNode * PPCDAGToDAGISel :: getGlobalBaseReg ( ) { if ( ! GlobalBaseReg ) { const TargetInstrInfo & TII = * PPCSubTarget -> getInstrInfo ( ) ; MachineBasicBlock & FirstMBB = MF -> front ( ) ; MachineBasicBlock :: iterator MBBI = FirstMBB . begin ( ) ; const Module * M = MF -> getFunction ( ) -> getParent ( ) ; DebugLoc dl ; if ( PPCLowering -> getPointerTy ( ) == MVT :: i32 ) { if ( PPCSubTarget -> isTargetELF ( ) ) { GlobalBaseReg = PPC :: R30 ; if ( M -> getPICLevel ( ) == PICLevel :: Small ) { BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MoveGOTtoLR ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; MF -> getInfo < PPCFunctionInfo > ( ) -> setUsesPICBase ( true ) ; } else { BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; unsigned TempReg = RegInfo -> createVirtualRegister ( & PPC :: GPRCRegClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: UpdateGBR ) ) . addReg ( GlobalBaseReg ) . addReg ( TempReg , RegState :: Define ) . addReg ( GlobalBaseReg ) ; MF -> getInfo < PPCFunctionInfo > ( ) -> setUsesPICBase ( true ) ; } } else { GlobalBaseReg = RegInfo -> createVirtualRegister ( & PPC :: GPRC_NOR0RegClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR ) , GlobalBaseReg ) ; } } else { GlobalBaseReg = RegInfo -> createVirtualRegister ( & PPC :: G8RC_NOX0RegClass ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MovePCtoLR8 ) ) ; BuildMI ( FirstMBB , MBBI , dl , TII . get ( PPC :: MFLR8 ) , GlobalBaseReg ) ; } } return CurDAG -> getRegister ( GlobalBaseReg , PPCLowering -> getPointerTy ( ) ) . getNode ( ) ; } </s>

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

PowerPC PPC PPC PPC MVT::i32 PPC PPC::R30 PPC::MoveGOTtoLR PPC::MFLR PPC PPC::MovePCtoLR PPC::MFLR PPC::GPRCRegClass PPC::UpdateGBR PPC PPC::GPRC_NOR0RegClass PPC::MovePCtoLR PPC::MFLR PPC::G8RC_NOX0RegClass PPC::MovePCtoLR8 PPC::MFLR8 PPC


<s> bool mips_get_pic_call_symbol ( rtx * operands , int args_size_opno ) { rtx args_size , symbol ; if ( ! TARGET_RELAX_PIC_CALLS || args_size_opno == - 1 ) return false ; args_size = operands [ args_size_opno ] ; if ( GET_CODE ( args_size ) != UNSPEC ) return false ; gcc_assert ( XINT ( args_size , 1 ) == UNSPEC_CALL_ATTR ) ; symbol = XVECEXP ( args_size , 0 , 1 ) ; gcc_assert ( GET_CODE ( symbol ) == SYMBOL_REF ) ; operands [ args_size_opno ] = symbol ; return true ; } </s>

OPERANDS [ ARGS_SIZE_OPNO ] is the arg_size operand of a CALL expression . See if instead of the arg_size argument it contains the call attributes . If yes return true along with setting OPERANDS [ ARGS_SIZE_OPNO ] to the function symbol from the call attributes . Also return false if ARGS_SIZE_OPNO is -1 .


<s> void X86FrameLowering :: BuildCFI ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , const DebugLoc & DL , const MCCFIInstruction & CFIInst , MachineInstr :: MIFlag Flag ) const { MachineFunction & MF = * MBB . getParent ( ) ; unsigned CFIIndex = MF . addFrameInst ( CFIInst ) ; BuildMI ( MBB , MBBI , DL , TII . get ( TargetOpcode :: CFI_INSTRUCTION ) ) . addCFIIndex ( CFIIndex ) . setMIFlag ( Flag ) ; } </s>

Wraps up getting a CFI index and building a MachineInstr for it .


<s> const uint16_t * ARMBaseRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { const uint16_t * RegList = ( STI . isTargetIOS ( ) && ! STI . isAAPCS_ABI ( ) ) ? CSR_iOS_SaveList : CSR_AAPCS_SaveList ; if ( ! MF ) return RegList ; const Function * F = MF -> getFunction ( ) ; if ( F -> getCallingConv ( ) == CallingConv :: GHC ) { return CSR_NoRegs_SaveList ; } else if ( F -> hasFnAttribute ( "interrupt" ) ) { if ( STI . isMClass ( ) ) { return CSR_AAPCS_SaveList ; } else if ( F -> getFnAttribute ( "interrupt" ) . getValueAsString ( ) == "FIQ" ) { return CSR_FIQ_SaveList ; } else { return CSR_GenericInt_SaveList ; } } return RegList ; } </s>


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

Returns true if the target requires ( and can make use of ) the register scavenger .


<s> rtx nds32_legitimize_ict_address ( rtx x ) { rtx symbol = x ; rtx addr = x ; rtx reg = gen_reg_rtx ( Pmode ) ; gcc_assert ( GET_CODE ( x ) == SYMBOL_REF && nds32_indirect_call_referenced_p ( x ) ) ; addr = gen_rtx_UNSPEC ( SImode , gen_rtvec ( 1 , symbol ) , UNSPEC_ICT ) ; addr = gen_rtx_CONST ( SImode , addr ) ; emit_insn ( gen_sethi ( reg , addr ) ) ; x = gen_const_mem ( SImode , gen_rtx_LO_SUM ( Pmode , reg , addr ) ) ; return x ; } </s>

Expand ICT symbol . Example for @ ICT and ICT model=large : la $ r0 , symbol @ ICT - > sethi $ rt , hi20 ( symbol @ ICT ) lwi $ r0 , [ $ rt + lo12 ( symbol @ ICT ) ]


<s> InstructionCost SystemZTTIImpl :: getIntImmCost ( const APInt & Imm , Type * Ty , TTI :: TargetCostKind CostKind ) { assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 ) return TTI :: TCC_Free ; if ( BitSize > 64 ) return TTI :: TCC_Free ; if ( Imm == 0 ) return TTI :: TCC_Free ; if ( Imm . getBitWidth ( ) <= 64 ) { if ( isInt < 32 > ( Imm . getSExtValue ( ) ) ) return TTI :: TCC_Basic ; if ( isUInt < 32 > ( Imm . getZExtValue ( ) ) ) return TTI :: TCC_Basic ; if ( ( Imm . getZExtValue ( ) & 0xffffffff ) == 0 ) return TTI :: TCC_Basic ; return 2 * TTI :: TCC_Basic ; } return 4 * TTI :: TCC_Basic ; } </s>

Calculate the cost of materializing a 64-bit value .


<s> int mmix_starting_frame_offset ( void ) { return ( - 8 + ( MMIX_CFUN_HAS_LANDING_PAD ? - 16 : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? - 8 : 0 ) ) ) ; } </s>


<s> const MipsSubtarget * MipsTargetMachine :: getSubtargetImpl ( const Function & F ) const { Attribute CPUAttr = F . getFnAttribute ( "target-cpu" ) ; Attribute FSAttr = F . getFnAttribute ( "target-features" ) ; std :: string CPU = ! CPUAttr . hasAttribute ( Attribute :: None ) ? CPUAttr . getValueAsString ( ) . str ( ) : TargetCPU ; std :: string FS = ! FSAttr . hasAttribute ( Attribute :: None ) ? FSAttr . getValueAsString ( ) . str ( ) : TargetFS ; bool hasMips16Attr = ! F . getFnAttribute ( "mips16" ) . hasAttribute ( Attribute :: None ) ; bool hasNoMips16Attr = ! F . getFnAttribute ( "nomips16" ) . hasAttribute ( Attribute :: None ) ; bool HasMicroMipsAttr = ! F . getFnAttribute ( "micromips" ) . hasAttribute ( Attribute :: None ) ; bool HasNoMicroMipsAttr = ! F . getFnAttribute ( "nomicromips" ) . hasAttribute ( Attribute :: None ) ; bool softFloat = F . hasFnAttribute ( "use-soft-float" ) && F . getFnAttribute ( "use-soft-float" ) . getValueAsString ( ) == "true" ; if ( hasMips16Attr ) FS += FS . empty ( ) ? "+mips16" : ",+mips16" ; else if ( hasNoMips16Attr ) FS += FS . empty ( ) ? "-mips16" : ",-mips16" ; if ( HasMicroMipsAttr ) FS += FS . empty ( ) ? "+micromips" : ",+micromips" ; else if ( HasNoMicroMipsAttr ) FS += FS . empty ( ) ? "-micromips" : ",-micromips" ; if ( softFloat ) FS += FS . empty ( ) ? "+soft-float" : ",+soft-float" ; auto & I = SubtargetMap [ CPU + FS ] ; if ( ! I ) { resetTargetOptions ( F ) ; I = llvm :: make_unique < MipsSubtarget > ( TargetTriple , CPU , FS , isLittle , * this , Options . StackAlignmentOverride ) ; } return I . get ( ) ; } </s>

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

Mips Mips Mips "target-cpu" "target-features" Mips "mips16" Mips "nomips16" Mips "micromips" Mips "nomicromips" "use-soft-float" "use-soft-float" "true" Mips "+mips16" ",+mips16" Mips "-mips16" ",-mips16" Mips "+micromips" ",+micromips" Mips "-micromips" ",-micromips" "+soft-float" ",+soft-float" Mips


<s> static inline tree def_builtin_pure2 ( HOST_WIDE_INT mask , const char * name , enum ix86_builtin_func_type tcode , enum ix86_builtins code ) { tree decl = def_builtin2 ( mask , name , tcode , code ) ; if ( decl ) DECL_PURE_P ( decl ) = 1 ; else ix86_builtins_isa [ ( int ) code ] . pure_p = true ; return decl ; } </s>

Like def_builtin , but also marks the function decl `` pure '' .


<s> static rtx dump_constants_1 ( enum machine_mode mode , rtx value , rtx insn ) { switch ( GET_MODE_CLASS ( mode ) ) { case MODE_INT : { rtx size = GEN_INT ( GET_MODE_SIZE ( mode ) ) ; return emit_insn_after ( gen_consttable_int ( value , size ) , insn ) ; } case MODE_FLOAT : return emit_insn_after ( gen_consttable_float ( value ) , insn ) ; case MODE_VECTOR_FLOAT : case MODE_VECTOR_INT : { int i ; for ( i = 0 ; i < CONST_VECTOR_NUNITS ( value ) ; i ++ ) insn = dump_constants_1 ( GET_MODE_INNER ( mode ) , CONST_VECTOR_ELT ( value , i ) , insn ) ; return insn ; } default : gcc_unreachable ( ) ; } } </s>

Output constant VALUE after instruction INSN and return the last instruction emitted . MODE is the mode of the constant .


<s> int SystemZFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { int64_t Offset = TargetFrameLowering :: getFrameIndexReference ( MF , FI , FrameReg ) ; return Offset + SystemZMC :: CallFrameSize ; } </s>

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


<s> const uint32_t * CAHPRegisterInfo :: getCallPreservedMask ( const MachineFunction & , CallingConv :: ID ) const { return CSR_RegMask ; } </s>

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


<s> bool evaluateBranch ( const MCInst & Inst , uint64_t Addr , uint64_t Size , uint64_t & Target ) const { if ( Info -> get ( Inst . getOpcode ( ) ) . OpInfo [ 0 ] . OperandType != MCOI :: OPERAND_PCREL ) return false ; int64_t Imm = Inst . getOperand ( 0 ) . getImm ( ) ; Target = Addr + Imm + 8 ; return true ; } </s>

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


<s> void or1k_expand_atomic_compare_and_swap ( rtx operands [ ] ) { rtx boolval , retval , mem , oldval , newval ; rtx label1 , label2 ; machine_mode mode ; bool is_weak ; boolval = operands [ 0 ] ; retval = operands [ 1 ] ; mem = operands [ 2 ] ; oldval = operands [ 3 ] ; newval = operands [ 4 ] ; is_weak = ( INTVAL ( operands [ 5 ] ) != 0 ) ; mode = GET_MODE ( mem ) ; if ( reg_overlap_mentioned_p ( retval , oldval ) ) oldval = copy_to_reg ( oldval ) ; label1 = NULL_RTX ; if ( ! is_weak ) { label1 = gen_rtx_LABEL_REF ( VOIDmode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , 0 ) ) ; } label2 = gen_rtx_LABEL_REF ( VOIDmode , gen_label_rtx ( ) ) ; emit_load_locked ( mode , retval , mem ) ; emit_compare ( EQ , retval , oldval ) ; emit_unlikely_jump ( EQ , label2 ) ; emit_store_conditional ( mode , mem , newval ) ; if ( ! is_weak ) emit_unlikely_jump ( EQ , label1 ) ; emit_label ( XEXP ( label2 , 0 ) ) ; emit_insn ( gen_sne_sr_f ( boolval ) ) ; } </s>

Expand an atomic compare and swap operation . Emits the RTX to perform a compare and swap operation . This function takes 8 RTX arguments in the OPERANDS array . The compare and swap operation loads a value from memory ( OPERANDS [ 2 ] ) and compares it with an expected value ( OPERANDS [ 3 ] ) , if the values are equal it stores a new value ( OPERANDS [ 4 ] ) to memory . The argument OPERANDS [ 0 ] represents a boolean result which will be set to true if the operation succeeds . A return value ( OPERANDS [ 1 ] ) will be set to what was loaded from memory . The argument OPERAND [ 5 ] is used to indicate if the compare and swap is to be treated as weak . OpenRISC does not use OPERANDS [ 5 ] or OPERANDS [ 6 ] which provide memory model details . For OpenRISC this emits RTX which will translate to assembly using the ' l.lwa ' ( load word atomic ) and ' l.swa ' ( store word atomic ) instructions .


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

Return true if the target supports swifterror attribute .


<s> bool X86FrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const MachineModuleInfo & MMI = MF . getMMI ( ) ; const TargetRegisterInfo * RI = TM . getRegisterInfo ( ) ; return ( DisableFramePointerElim ( MF ) || RI -> needsStackRealignment ( MF ) || MFI -> hasVarSizedObjects ( ) || MFI -> isFrameAddressTaken ( ) || MF . getInfo < X86MachineFunctionInfo > ( ) -> getForceFramePointer ( ) || MMI . callsUnwindInit ( ) ) ; } </s>

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


<s> bool DLXInstrInfo :: areMemAccessesTriviallyDisjoint ( MachineInstr & MIa , MachineInstr & MIb , AliasAnalysis * ) const { return false ; } </s>

Sometimes , it is possible for the target to tell , even without aliasing information , that two MIs access different memory addresses .


<s> void AArch64AsmPrinter :: emitEndOfAsmFile ( Module & M ) { emitHwasanMemaccessSymbols ( M ) ; const Triple & TT = TM . getTargetTriple ( ) ; if ( TT . isOSBinFormatMachO ( ) ) { OutStreamer -> emitAssemblerFlag ( MCAF_SubsectionsViaSymbols ) ; } emitStackMaps ( SM ) ; FM . serializeToFaultMapSection ( ) ; } </s>

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


<s> bool X86PassConfig :: addPreEmitPass ( ) { bool ShouldPrint = false ; if ( getOptLevel ( ) != CodeGenOpt :: None && getX86Subtarget ( ) . hasSSE2 ( ) ) { addPass ( createExecutionDependencyFixPass ( & X86 :: VR128RegClass ) ) ; ShouldPrint = true ; } if ( UseVZeroUpper ) { addPass ( createX86IssueVZeroUpperPass ( ) ) ; ShouldPrint = true ; } if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86PadShortFunctions ( ) ) ; addPass ( createX86FixupLEAs ( ) ) ; ShouldPrint = true ; } return ShouldPrint ; } </s>

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


<s>
void
SparcInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
if
(
SP
::
IntRegsRegClass
.
contains
(
DestReg
,
SrcReg
)
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
SP
::
ORrr
)
,
DestReg
)
.
addReg
(
SP
::
G0
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
else
if
(
SP
::
FPRegsRegClass
.
contains
(
DestReg
,
SrcReg
)
)
BuildMI
(
MBB
,
I
,
DL
,
get
(
SP
::
FMOVS
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
else
if
(
SP
::
DFPRegsRegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
if
(
Subtarget
.
isV9
(
)
)
{
BuildMI
(
MBB
,
I
,
DL
,
get
(
SP
::
FMOVD
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
{
const
TargetRegisterInfo
*
TRI
=
&
getRegisterInfo
(
)
;
MachineInstr
*
MovMI
=
0
;
unsigned
subRegIdx
[
]
=
{
SP
::
sub_even
,
SP
::
sub_odd
}
;
for
(
unsigned
i
=
0
;
i
!=
2
;
++
i
)
{
unsigned
Dst
=
TRI
->
getSubReg
(
DestReg
,
subRegIdx
[
i
]
)
;
unsigned
Src
=
TRI
->
getSubReg
(
SrcReg
,
subRegIdx
[
i
]
)
;
assert
(
Dst
&&
Src
&&
"Bad sub-register"
)
;
MovMI
=
BuildMI
(
MBB
,
I
,
DL
,
get
(
SP
::
FMOVS
)
,
Dst
)
.
addReg
(
Src
)
;
}
MovMI
->
addRegisterDefined
(
DestReg
,
TRI
)
;
if
(
KillSrc
)
MovMI
->
addRegisterKilled
(
SrcReg
,
TRI
)
;
}
}
else
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
</s>


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


<s> static enum rs6000_reg_type register_to_reg_type ( rtx reg , bool * is_altivec ) { HOST_WIDE_INT regno ; enum reg_class rclass ; if ( GET_CODE ( reg ) == SUBREG ) reg = SUBREG_REG ( reg ) ; if ( ! REG_P ( reg ) ) return NO_REG_TYPE ; regno = REGNO ( reg ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) { if ( ! lra_in_progress && ! reload_in_progress && ! reload_completed ) return PSEUDO_REG_TYPE ; regno = true_regnum ( reg ) ; if ( regno < 0 || regno >= FIRST_PSEUDO_REGISTER ) return PSEUDO_REG_TYPE ; } gcc_assert ( regno >= 0 ) ; if ( is_altivec && ALTIVEC_REGNO_P ( regno ) ) * is_altivec = true ; rclass = rs6000_regno_regclass [ regno ] ; return reg_class_to_reg_type [ ( int ) rclass ] ; } </s>

Classify a register type . Because the FMRGOW/FMRGEW instructions only work on traditional floating point registers , and the VMRGOW/VMRGEW instructions only work on the traditional altivec registers , note if an altivec register was chosen .


<s> bool isBarrier ( ) const { return Kind == k_Barrier ; } </s>

Tests if this is an Order dependence that is marked as a barrier .


<s> bool PPCFunctionInfo :: isLiveInZExt ( unsigned VReg ) const { for ( const std :: pair < unsigned , ISD :: ArgFlagsTy > & LiveIn : LiveInAttrs ) if ( LiveIn . first == VReg ) return LiveIn . second . isZExt ( ) ; return false ; } </s>

This function returns true if the specified vreg is a live-in register and zero-extended .


<s> bool direct_move_p ( rtx op0 , rtx op1 ) { int regno0 , regno1 ; if ( ! REG_P ( op0 ) || ! REG_P ( op1 ) ) return false ; if ( ! TARGET_DIRECT_MOVE && ! TARGET_MFPGPR ) return false ; regno0 = REGNO ( op0 ) ; regno1 = REGNO ( op1 ) ; if ( ! HARD_REGISTER_NUM_P ( regno0 ) || ! HARD_REGISTER_NUM_P ( regno1 ) ) return false ; if ( INT_REGNO_P ( regno0 ) ) return ( TARGET_DIRECT_MOVE ) ? VSX_REGNO_P ( regno1 ) : FP_REGNO_P ( regno1 ) ; else if ( INT_REGNO_P ( regno1 ) ) { if ( TARGET_MFPGPR && FP_REGNO_P ( regno0 ) ) return true ; else if ( TARGET_DIRECT_MOVE && VSX_REGNO_P ( regno0 ) ) return true ; } return false ; } </s>

Return true if this is a move direct operation between GPR registers and floating point/VSX registers .


<s> Register ARMBaseRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const ARMSubtarget & STI = MF . getSubtarget < ARMSubtarget > ( ) ; const ARMFrameLowering * TFI = getFrameLowering ( MF ) ; if ( TFI -> hasFP ( MF ) ) return getFramePointerReg ( STI ) ; return ARM :: SP ; } </s>


<s> RCPair ARMTargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'l' : if ( Subtarget -> isThumb ( ) ) return RCPair ( 0U , & ARM :: tGPRRegClass ) ; return RCPair ( 0U , & ARM :: GPRRegClass ) ; case 'h' : if ( Subtarget -> isThumb ( ) ) return RCPair ( 0U , & ARM :: hGPRRegClass ) ; break ; case 'r' : return RCPair ( 0U , & ARM :: GPRRegClass ) ; case 'w' : if ( VT == MVT :: Other ) break ; if ( VT == MVT :: f32 ) return RCPair ( 0U , & ARM :: SPRRegClass ) ; if ( VT . getSizeInBits ( ) == 64 ) return RCPair ( 0U , & ARM :: DPRRegClass ) ; if ( VT . getSizeInBits ( ) == 128 ) return RCPair ( 0U , & ARM :: QPRRegClass ) ; break ; case 'x' : if ( VT == MVT :: Other ) break ; if ( VT == MVT :: f32 ) return RCPair ( 0U , & ARM :: SPR_8RegClass ) ; if ( VT . getSizeInBits ( ) == 64 ) return RCPair ( 0U , & ARM :: DPR_8RegClass ) ; if ( VT . getSizeInBits ( ) == 128 ) return RCPair ( 0U , & ARM :: QPR_8RegClass ) ; break ; case 't' : if ( VT == MVT :: f32 ) return RCPair ( 0U , & ARM :: SPRRegClass ) ; break ; } } if ( StringRef ( "{cc}" ) . equals_lower ( Constraint ) ) return std :: make_pair ( unsigned ( ARM :: CPSR ) , & ARM :: CCRRegClass ) ; return TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> bool CAHPAsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count ) const { if ( ( Count % 2 ) != 0 ) return false ; Count /= 2 ; for ( uint64_t i = 0 ; i < Count ; ++ i ) OS . write ( "\0\0" , 2 ) ; return true ; } </s>

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


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
{
const
static
MCFixupKindInfo
Infos
[
PPC
::
NumTargetFixupKinds
]
=
{
{
"fixup_ppc_br24"
,
6
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_brcond14"
,
16
,
14
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_ppc_lo16"
,
16
,
16
,
0
}
,
{
"fixup_ppc_ha16"
,
16
,
16
,
0
}
,
{
"fixup_ppc_lo14"
,
16
,
14
,
0
}
,
{
"fixup_ppc_toc"
,
0
,
64
,
0
}
,
{
"fixup_ppc_toc16"
,
16
,
16
,
0
}
,
{
"fixup_ppc_toc16_ds"
,
16
,
14
,
0
}
,
{
"fixup_ppc_tlsreg"
,
0
,
0
,
0
}
,
{
"fixup_ppc_nofixup"
,
0
,
0
,
0
}
}
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s> bool PPCFastISel :: fastSelectInstruction ( const Instruction * I ) { switch ( I -> getOpcode ( ) ) { case Instruction :: Load : return SelectLoad ( I ) ; case Instruction :: Store : return SelectStore ( I ) ; case Instruction :: Br : return SelectBranch ( I ) ; case Instruction :: IndirectBr : return SelectIndirectBr ( I ) ; case Instruction :: FPExt : return SelectFPExt ( I ) ; case Instruction :: FPTrunc : return SelectFPTrunc ( I ) ; case Instruction :: SIToFP : return SelectIToFP ( I , true ) ; case Instruction :: UIToFP : return SelectIToFP ( I , false ) ; case Instruction :: FPToSI : return SelectFPToI ( I , true ) ; case Instruction :: FPToUI : return SelectFPToI ( I , false ) ; case Instruction :: Add : return SelectBinaryIntOp ( I , ISD :: ADD ) ; case Instruction :: Or : return SelectBinaryIntOp ( I , ISD :: OR ) ; case Instruction :: Sub : return SelectBinaryIntOp ( I , ISD :: SUB ) ; case Instruction :: Call : if ( TM . getTargetTriple ( ) . isOSAIX ( ) ) break ; return selectCall ( I ) ; case Instruction :: Ret : return SelectRet ( I ) ; case Instruction :: Trunc : return SelectTrunc ( I ) ; case Instruction :: ZExt : case Instruction :: SExt : return SelectIntExt ( I ) ; default : break ; } return false ; } </s>

This method is called by target-independent code when the normal FastISel process fails to select an instruction .


<s> bool rs6000_gimple_fold_builtin ( gimple_stmt_iterator * gsi ) { gimple * stmt = gsi_stmt ( * gsi ) ; tree fndecl = gimple_call_fndecl ( stmt ) ; gcc_checking_assert ( fndecl && DECL_BUILT_IN_CLASS ( fndecl ) == BUILT_IN_MD ) ; enum rs6000_builtins fn_code = ( enum rs6000_builtins ) DECL_FUNCTION_CODE ( fndecl ) ; tree arg0 , arg1 , lhs ; switch ( fn_code ) { case ALTIVEC_BUILTIN_VADDUBM : case ALTIVEC_BUILTIN_VADDUHM : case ALTIVEC_BUILTIN_VADDUWM : case P8V_BUILTIN_VADDUDM : case ALTIVEC_BUILTIN_VADDFP : case VSX_BUILTIN_XVADDDP : { arg0 = gimple_call_arg ( stmt , 0 ) ; arg1 = gimple_call_arg ( stmt , 1 ) ; lhs = gimple_call_lhs ( stmt ) ; gimple * g = gimple_build_assign ( lhs , PLUS_EXPR , arg0 , arg1 ) ; gimple_set_location ( g , gimple_location ( stmt ) ) ; gsi_replace ( gsi , g , true ) ; return true ; } case ALTIVEC_BUILTIN_VSUBUBM : case ALTIVEC_BUILTIN_VSUBUHM : case ALTIVEC_BUILTIN_VSUBUWM : case P8V_BUILTIN_VSUBUDM : case ALTIVEC_BUILTIN_VSUBFP : case VSX_BUILTIN_XVSUBDP : { arg0 = gimple_call_arg ( stmt , 0 ) ; arg1 = gimple_call_arg ( stmt , 1 ) ; lhs = gimple_call_lhs ( stmt ) ; gimple * g = gimple_build_assign ( lhs , MINUS_EXPR , arg0 , arg1 ) ; gimple_set_location ( g , gimple_location ( stmt ) ) ; gsi_replace ( gsi , g , true ) ; return true ; } case ALTIVEC_BUILTIN_VMULESB : case ALTIVEC_BUILTIN_VMULESH : case ALTIVEC_BUILTIN_VMULEUB : case ALTIVEC_BUILTIN_VMULEUH : { arg0 = gimple_call_arg ( stmt , 0 ) ; arg1 = gimple_call_arg ( stmt , 1 ) ; lhs = gimple_call_lhs ( stmt ) ; gimple * g = gimple_build_assign ( lhs , VEC_WIDEN_MULT_EVEN_EXPR , arg0 , arg1 ) ; gimple_set_location ( g , gimple_location ( stmt ) ) ; gsi_replace ( gsi , g , true ) ; return true ; } case ALTIVEC_BUILTIN_VMULOSB : case ALTIVEC_BUILTIN_VMULOSH : case ALTIVEC_BUILTIN_VMULOUB : case ALTIVEC_BUILTIN_VMULOUH : { arg0 = gimple_call_arg ( stmt , 0 ) ; arg1 = gimple_call_arg ( stmt , 1 ) ; lhs = gimple_call_lhs ( stmt ) ; gimple * g = gimple_build_assign ( lhs , VEC_WIDEN_MULT_ODD_EXPR , arg0 , arg1 ) ; gimple_set_location ( g , gimple_location ( stmt ) ) ; gsi_replace ( gsi , g , true ) ; return true ; } default : break ; } return false ; } </s>

Fold a machine-dependent built-in in GIMPLE . ( For folding into a constant , use rs6000_fold_builtin . )


<s> bool ARMAsmParser :: ParseInstruction ( StringRef Name , SMLoc NameLoc , SmallVectorImpl < MCParsedAsmOperand * > & Operands ) { OwningPtr < ARMOperand > Op ; size_t Start = 0 , Next = Name . find ( '.' ) ; StringRef Head = Name . slice ( Start , Next ) ; unsigned CC = StringSwitch < unsigned > ( Head . substr ( Head . size ( ) - 2 ) ) . Case ( "eq" , ARMCC :: EQ ) . Case ( "ne" , ARMCC :: NE ) . Case ( "hs" , ARMCC :: HS ) . Case ( "lo" , ARMCC :: LO ) . Case ( "mi" , ARMCC :: MI ) . Case ( "pl" , ARMCC :: PL ) . Case ( "vs" , ARMCC :: VS ) . Case ( "vc" , ARMCC :: VC ) . Case ( "hi" , ARMCC :: HI ) . Case ( "ls" , ARMCC :: LS ) . Case ( "ge" , ARMCC :: GE ) . Case ( "lt" , ARMCC :: LT ) . Case ( "gt" , ARMCC :: GT ) . Case ( "le" , ARMCC :: LE ) . Case ( "al" , ARMCC :: AL ) . Default ( ~ 0U ) ; if ( CC != ~ 0U ) { Head = Head . slice ( 0 , Head . size ( ) - 2 ) ; } else CC = ARMCC :: AL ; ARMOperand :: CreateToken ( Op , Head , NameLoc ) ; Operands . push_back ( Op . take ( ) ) ; ARMOperand :: CreateCondCode ( Op , ARMCC :: CondCodes ( CC ) , NameLoc ) ; Operands . push_back ( Op . take ( ) ) ; while ( Next != StringRef :: npos ) { Start = Next ; Next = Name . find ( '.' , Start + 1 ) ; Head = Name . slice ( Start , Next ) ; ARMOperand :: CreateToken ( Op , Head , NameLoc ) ; Operands . push_back ( Op . take ( ) ) ; } if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { OwningPtr < ARMOperand > Op ; if ( ParseOperand ( Op ) ) return true ; Operands . push_back ( Op . take ( ) ) ; while ( getLexer ( ) . is ( AsmToken :: Comma ) ) { Parser . Lex ( ) ; if ( ParseOperand ( Op ) ) return true ; Operands . push_back ( Op . take ( ) ) ; } } return false ; } </s>

ParseInstruction - Parse one assembly instruction .

ARM ARM ARM 0 2 "eq" ARMCC::EQ "ne" ARMCC::NE "hs" ARMCC::HS "lo" ARMCC::LO "mi" ARMCC::MI "pl" ARMCC::PL "vs" ARMCC::VS "vc" ARMCC::VC "hi" ARMCC::HI "ls" ARMCC::LS "ge" ARMCC::GE "lt" ARMCC::LT "gt" ARMCC::GT "le" ARMCC::LE "al" ARMCC::AL 0U 0U 0 2 ARMCC::AL ARM ARM ARMCC::CondCodes 1 ARM ARM


<s> void MipsPassConfig :: addPreRegAlloc ( ) { addPass ( createMipsOptimizePICCallPass ( getMipsTargetMachine ( ) ) ) ; } </s>

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


"Instr doesn't have FrameIndex operand!"

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


<s> void OR1KFrameLowering :: determineFrameLayout ( MachineFunction & MF ) const { MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const TargetRegisterInfo * TRI = MF . getTarget ( ) . getRegisterInfo ( ) ; unsigned FrameSize = MFI -> getStackSize ( ) ; unsigned StackAlign = TRI -> needsStackRealignment ( MF ) ? MFI -> getMaxAlignment ( ) : MF . getTarget ( ) . getFrameLowering ( ) -> getStackAlignment ( ) ; unsigned maxCallFrameSize = MFI -> getMaxCallFrameSize ( ) ; if ( MFI -> hasVarSizedObjects ( ) ) maxCallFrameSize = RoundUpToAlignment ( maxCallFrameSize , StackAlign ) ; MFI -> setMaxCallFrameSize ( maxCallFrameSize ) ; if ( ! ( hasReservedCallFrame ( MF ) && MFI -> adjustsStack ( ) ) ) FrameSize += maxCallFrameSize ; FrameSize = RoundUpToAlignment ( FrameSize , StackAlign ) ; MFI -> setStackSize ( FrameSize ) ; } </s>

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


<s> BitVector X86RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; const TargetFrameInfo * TFI = MF . getTarget ( ) . getFrameInfo ( ) ; Reserved . set ( X86 :: RSP ) ; Reserved . set ( X86 :: ESP ) ; Reserved . set ( X86 :: SP ) ; Reserved . set ( X86 :: SPL ) ; Reserved . set ( X86 :: RIP ) ; Reserved . set ( X86 :: EIP ) ; Reserved . set ( X86 :: IP ) ; if ( TFI -> hasFP ( MF ) ) { Reserved . set ( X86 :: RBP ) ; Reserved . set ( X86 :: EBP ) ; Reserved . set ( X86 :: BP ) ; Reserved . set ( X86 :: BPL ) ; } Reserved . set ( X86 :: ST0 ) ; Reserved . set ( X86 :: ST1 ) ; Reserved . set ( X86 :: ST2 ) ; Reserved . set ( X86 :: ST3 ) ; Reserved . set ( X86 :: ST4 ) ; Reserved . set ( X86 :: ST5 ) ; Reserved . set ( X86 :: ST6 ) ; Reserved . set ( X86 :: ST7 ) ; return Reserved ; } </s>

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


<s> const uint16_t * X86RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { bool callsEHReturn = false ; bool ghcCall = false ; if ( MF ) { callsEHReturn = MF -> getMMI ( ) . callsEHReturn ( ) ; const Function * F = MF -> getFunction ( ) ; ghcCall = ( F ? F -> getCallingConv ( ) == CallingConv :: GHC : false ) ; } if ( ghcCall ) return CSR_NoRegs_SaveList ; if ( Is64Bit ) { if ( IsWin64 ) return CSR_Win64_SaveList ; if ( callsEHReturn ) return CSR_64EHRet_SaveList ; return CSR_64_SaveList ; } if ( callsEHReturn ) return CSR_32EHRet_SaveList ; return CSR_32_SaveList ; } </s>


<s> const X86InstrInfo * getInstrInfo ( ) const override { return getSubtargetImpl ( ) -> getInstrInfo ( ) ; } </s>


<s> void SystemZInstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , Register DestReg , int FrameIdx , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; unsigned LoadOpcode , StoreOpcode ; getLoadStoreOpcodes ( RC , LoadOpcode , StoreOpcode ) ; addFrameReference ( BuildMI ( MBB , MBBI , DL , get ( LoadOpcode ) , DestReg ) , FrameIdx ) ; } </s>

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


<s> bool PPCSubtarget :: enableMachineScheduler ( ) const { return needsAggressiveScheduling ( DarwinDirective ) ; } </s>

Enable the MachineScheduler pass for all X86 subtargets .


<s> static void ix86_override_options_after_change ( void ) { ix86_default_align ( & global_options ) ; } </s>

Implement TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE hook .


<s> static HOST_WIDE_INT aarch64_constant_alignment ( const_tree exp , HOST_WIDE_INT align ) { if ( TREE_CODE ( exp ) == STRING_CST && ! optimize_size ) return MAX ( align , BITS_PER_WORD ) ; return align ; } </s>

Implement TARGET_CONSTANT_ALIGNMENT . Make strings word-aligned so that strcpy from constants will be faster .


<s> unsigned ARMTargetLowering :: getMaxSupportedInterleaveFactor ( ) const { if ( Subtarget -> hasNEON ( ) ) return 4 ; if ( Subtarget -> hasMVEIntegerOps ( ) ) return 4 ; return TargetLoweringBase :: getMaxSupportedInterleaveFactor ( ) ; } </s>

Get the maximum supported factor for interleaved memory accesses .


<s>
void
X86InstrInfo
::
storeRegToStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
unsigned
SrcReg
,
bool
isKill
,
int
FrameIdx
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
const
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
assert
(
MF
.
getFrameInfo
(
)
->
getObjectSize
(
FrameIdx
)
>=
(
RC
->
getSize
(
)
/
8
)
&&
"Stack slot too small for store"
)
;
unsigned
Alignment
=
(
RC
->
getSize
(
)
/
8
)
==
32
32
:
16
;
bool
isAligned
=
(
TM
.
getFrameLowering
(
)
->
getStackAlignment
(
)
>=
Alignment
)
||
RI
.
canRealignStack
(
MF
)
;
unsigned
Opc
=
getStoreRegOpcode
(
SrcReg
,
RC
,
isAligned
,
TM
)
;
DebugLoc
DL
=
MBB
.
findDebugLoc
(
MI
)
;
addFrameReference
(
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
)
,
FrameIdx
)
.
addReg
(
SrcReg
,
getKillRegState
(
isKill
)
)
;
}
</s>

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


<s> static rtx_insn * emit_frame_insn ( rtx x ) { rtx_insn * insn = emit_insn ( x ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; return insn ; } </s>

Wrapper around emit_insn that sets RTX_FRAME_RELATED_P on the insn .


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


<s> void rs6000_xcoff_asm_globalize_decl_name ( FILE * stream , tree decl ) { const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , 0 ) , 0 ) ; fputs ( GLOBAL_ASM_OP , stream ) ; RS6000_OUTPUT_BASENAME ( stream , name ) ; fputs ( rs6000_xcoff_visibility ( decl ) , stream ) ; putc ( '\n' , stream ) ; } </s>

Output assembly language to globalize a symbol from a DECL , possibly with visibility .


<s> static void mips_sim_finish_insn ( struct mips_sim * state , rtx_insn * insn ) { if ( JUMP_P ( insn ) ) mips_sim_issue_nop ( state ) ; switch ( GET_CODE ( SEQ_BEGIN ( insn ) ) ) { case CODE_LABEL : case CALL_INSN : mips_sim_reset ( state ) ; break ; case JUMP_INSN : if ( INSN_ANNULLED_BRANCH_P ( SEQ_BEGIN ( insn ) ) ) mips_sim_reset ( state ) ; break ; default : break ; } } </s>

Update simulation state STATE so that it 's ready to accept the instruction after INSN . INSN should be part of the main rtl chain , not a member of a SEQUENCE .


<s> TargetLowering :: AtomicExpansionKind PPCTargetLowering :: shouldExpandAtomicCmpXchgInIR ( AtomicCmpXchgInst * AI ) const { unsigned Size = AI -> getNewValOperand ( ) -> getType ( ) -> getPrimitiveSizeInBits ( ) ; if ( EnableQuadwordAtomics && Subtarget . hasQuadwordAtomics ( ) && Size == 128 ) return AtomicExpansionKind :: MaskedIntrinsic ; return TargetLowering :: shouldExpandAtomicCmpXchgInIR ( AI ) ; } </s>

Returns how the given atomic cmpxchg should be expanded by the IR-level AtomicExpand pass .


"AltiVec argument passed to unprototyped function"

Target hook for invalid_arg_for_unprototyped_fn .


<s> bool MipsLongBranch :: runOnMachineFunction ( MachineFunction & F ) { const MipsInstrInfo * TII = static_cast < const MipsInstrInfo * > ( TM . getSubtargetImpl ( ) -> getInstrInfo ( ) ) ; const MipsSubtarget & STI = TM . getSubtarget < MipsSubtarget > ( ) ; if ( STI . inMips16Mode ( ) || ! STI . enableLongBranchPass ( ) ) return false ; if ( ( TM . getRelocationModel ( ) == Reloc :: PIC_ ) && TM . getSubtarget < MipsSubtarget > ( ) . isABI_O32 ( ) && F . getInfo < MipsFunctionInfo > ( ) -> globalBaseRegSet ( ) ) emitGPDisp ( F , TII ) ; if ( SkipLongBranch ) return true ; MF = & F ; initMBBInfo ( ) ; SmallVectorImpl < MBBInfo > :: iterator I , E = MBBInfos . end ( ) ; bool EverMadeChange = false , MadeChange = true ; while ( MadeChange ) { MadeChange = false ; for ( I = MBBInfos . begin ( ) ; I != E ; ++ I ) { if ( ! I -> Br || I -> HasLongBranch ) continue ; int ShVal = TM . getSubtarget < MipsSubtarget > ( ) . inMicroMipsMode ( ) ? 2 : 4 ; int64_t Offset = computeOffset ( I -> Br ) / ShVal ; if ( TM . getSubtarget < MipsSubtarget > ( ) . isTargetNaCl ( ) ) { Offset *= 2 ; } if ( ! ForceLongBranch && isInt < 16 > ( Offset ) ) continue ; I -> HasLongBranch = true ; I -> Size += LongBranchSeqSize * 4 ; ++ LongBranches ; EverMadeChange = MadeChange = true ; } } if ( ! EverMadeChange ) return true ; if ( TM . getRelocationModel ( ) == Reloc :: PIC_ ) { uint64_t Address = 0 ; for ( I = MBBInfos . begin ( ) ; I != E ; Address += I -> Size , ++ I ) I -> Address = Address ; } for ( I = MBBInfos . begin ( ) ; I != E ; ++ I ) if ( I -> HasLongBranch ) expandToLongBranch ( * I ) ; MF -> RenumberBlocks ( ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .

Mips Mips Mips Mips Mips Mips Mips Mips Mips Mips Mips 2 4 Mips 2 16 4 0


<s> static bool expand_vselect ( rtx target , rtx op0 , const unsigned char * perm , unsigned nelt , bool testing_p ) { unsigned int i ; rtx x , save_vconcat ; int icode ; if ( vselect_insn == NULL_RTX ) init_vselect_insn ( ) ; x = XEXP ( SET_SRC ( PATTERN ( vselect_insn ) ) , 1 ) ; PUT_NUM_ELEM ( XVEC ( x , 0 ) , nelt ) ; for ( i = 0 ; i < nelt ; ++ i ) XVECEXP ( x , 0 , i ) = GEN_INT ( perm [ i ] ) ; save_vconcat = XEXP ( SET_SRC ( PATTERN ( vselect_insn ) ) , 0 ) ; XEXP ( SET_SRC ( PATTERN ( vselect_insn ) ) , 0 ) = op0 ; PUT_MODE ( SET_SRC ( PATTERN ( vselect_insn ) ) , GET_MODE ( target ) ) ; SET_DEST ( PATTERN ( vselect_insn ) ) = target ; icode = recog_memoized ( vselect_insn ) ; if ( icode >= 0 && ! testing_p ) emit_insn ( copy_rtx ( PATTERN ( vselect_insn ) ) ) ; SET_DEST ( PATTERN ( vselect_insn ) ) = const0_rtx ; XEXP ( SET_SRC ( PATTERN ( vselect_insn ) ) , 0 ) = save_vconcat ; INSN_CODE ( vselect_insn ) = - 1 ; return icode >= 0 ; } </s>

Construct ( set target ( vec_select op0 ( parallel perm ) ) ) and return true if that 's a valid instruction in the active ISA .


<s> std :: pair < uint16_t , uint16_t > ARMBaseInstrInfo :: getExecutionDomain ( const MachineInstr * MI ) const { if ( MI -> getOpcode ( ) == ARM :: VMOVD && ! isPredicated ( MI ) ) return std :: make_pair ( ExeVFP , ( 1 << ExeVFP ) | ( 1 << ExeNEON ) ) ; unsigned Domain = MI -> getDesc ( ) . TSFlags & ARMII :: DomainMask ; if ( Domain & ARMII :: DomainNEON ) return std :: make_pair ( ExeNEON , 0 ) ; if ( ( Domain & ARMII :: DomainNEONA8 ) && Subtarget . isCortexA8 ( ) ) return std :: make_pair ( ExeNEON , 0 ) ; if ( Domain & ARMII :: DomainVFP ) return std :: make_pair ( ExeVFP , 0 ) ; return std :: make_pair ( ExeGeneric , 0 ) ; } </s>

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


<s>
void
PPCTargetLowering
::
LowerAsmOperandForConstraint
(
SDValue
Op
,
std
::
string
&
Constraint
,
std
::
vector
<
SDValue
>
&
Ops
,
SelectionDAG
&
DAG
)
const
{
SDValue
Result
(
0
,
0
)
;
if
(
Constraint
.
length
(
)
>
1
)
return
;
char
Letter
=
Constraint
[
0
]
;
switch
(
Letter
)
{
default
:
break
;
case
'I'
:
case
'J'
:
case
'K'
:
case
'L'
:
case
'M'
:
case
'N'
:
case
'O'
:
case
'P'
:
{
ConstantSDNode
*
CST
=
dyn_cast
<
ConstantSDNode
>
(
Op
)
;
if
(
!
CST
)
return
;
unsigned
Value
=
CST
->
getZExtValue
(
)
;
switch
(
Letter
)
{
default
:
llvm_unreachable
(
"Unknown constraint letter!"
)
;
case
'I'
:
if
(
(
short
)
Value
==
(
int
)
Value
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'J'
:
case
'L'
:
if
(
(
short
)
Value
==
0
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'K'
:
if
(
(
Value
>>
16
)
==
0
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'M'
:
if
(
Value
>
31
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'N'
:
if
(
(
int
)
Value
>
0
&&
isPowerOf2_32
(
Value
)
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'O'
:
if
(
Value
==
0
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'P'
:
if
(
(
short
)
Value
==
(
int
)
Value
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
}
break
;
}
}
if
(
Result
.
getNode
(
)
)
{
Ops
.
push_back
(
Result
)
;
return
;
}
TargetLowering
::
LowerAsmOperandForConstraint
(
Op
,
Constraint
,
Ops
,
DAG
)
;
}
</s>

Lower the specified operand into the Ops vector .


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

getPassName - Return a nice clean name for a pass .


<s> static bool rs6000_can_eliminate ( const int from , const int to ) { return ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : from == RS6000_PIC_OFFSET_TABLE_REGNUM ? ! TARGET_MINIMAL_TOC || TARGET_NO_TOC || get_pool_size ( ) == 0 : true ) ; } </s>

Given FROM and TO register numbers , say whether this elimination is allowed . Frame pointer elimination is automatically handled . For the RS/6000 , if frame pointer elimination is being done , we would like to convert ap into fp , not sp . We need r30 if -mminimal-toc was specified , and there are constant pool references .


<s>
bool
AArch64AsmPrinter
::
lowerOperand
(
const
MachineOperand
&
MO
,
MCOperand
&
MCOp
)
const
{
switch
(
MO
.
getType
(
)
)
{
default
:
llvm_unreachable
(
"unknown operand type"
)
;
case
MachineOperand
::
MO_Register
:
if
(
MO
.
isImplicit
(
)
)
return
false
;
assert
(
!
MO
.
getSubReg
(
)
&&
"Subregs should be eliminated!"
)
;
MCOp
=
MCOperand
::
CreateReg
(
MO
.
getReg
(
)
)
;
break
;
case
MachineOperand
::
MO_Immediate
:
MCOp
=
MCOperand
::
CreateImm
(
MO
.
getImm
(
)
)
;
break
;
case
MachineOperand
::
MO_FPImmediate
:
{
assert
(
MO
.
getFPImm
(
)
->
isZero
(
)
&&
"Only fp imm 0.0 is supported"
)
;
MCOp
=
MCOperand
::
CreateFPImm
(
0.0
)
;
break
;
}
case
MachineOperand
::
MO_BlockAddress
:
MCOp
=
lowerSymbolOperand
(
MO
,
GetBlockAddressSymbol
(
MO
.
getBlockAddress
(
)
)
)
;
break
;
case
MachineOperand
::
MO_ExternalSymbol
:
MCOp
=
lowerSymbolOperand
(
MO
,
GetExternalSymbolSymbol
(
MO
.
getSymbolName
(
)
)
)
;
break
;
case
MachineOperand
::
MO_GlobalAddress
:
MCOp
=
lowerSymbolOperand
(
MO
,
Mang
->
getSymbol
(
MO
.
getGlobal
(
)
)
)
;
break
;
case
MachineOperand
::
MO_MachineBasicBlock
:
MCOp
=
MCOperand
::
CreateExpr
(
MCSymbolRefExpr
::
Create
(
MO
.
getMBB
(
)
->
getSymbol
(
)
,
OutContext
)
)
;
break
;
case
MachineOperand
::
MO_JumpTableIndex
:
MCOp
=
lowerSymbolOperand
(
MO
,
GetJTISymbol
(
MO
.
getIndex
(
)
)
)
;
break
;
case
MachineOperand
::
MO_ConstantPoolIndex
:
MCOp
=
lowerSymbolOperand
(
MO
,
GetCPISymbol
(
MO
.
getIndex
(
)
)
)
;
break
;
case
MachineOperand
::
MO_RegisterMask
:
return
false
;
}
return
true
;
}
</s>

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


<s> static bool mep_expand_setcc_1 ( enum rtx_code code , rtx dest , rtx op1 , rtx op2 ) { rtx tmp ; switch ( code ) { case GT : case GTU : tmp = op1 , op1 = op2 , op2 = tmp ; code = swap_condition ( code ) ; case LT : case LTU : op1 = force_reg ( SImode , op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , gen_rtx_fmt_ee ( code , SImode , op1 , op2 ) ) ) ; return true ; case EQ : if ( op2 != const0_rtx ) op1 = expand_binop ( SImode , sub_optab , op1 , op2 , NULL , 1 , OPTAB_WIDEN ) ; mep_expand_setcc_1 ( LTU , dest , op1 , const1_rtx ) ; return true ; case NE : if ( optimize_size && op2 != const0_rtx ) return false ; if ( op2 != const0_rtx ) op1 = expand_binop ( SImode , sub_optab , op1 , op2 , NULL , 1 , OPTAB_WIDEN ) ; op2 = gen_reg_rtx ( SImode ) ; mep_expand_setcc_1 ( LTU , op2 , op1 , const1_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , gen_rtx_XOR ( SImode , op2 , const1_rtx ) ) ) ; return true ; case LE : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == 0x7ffffff ) return false ; op2 = GEN_INT ( INTVAL ( op2 ) + 1 ) ; return mep_expand_setcc_1 ( LT , dest , op1 , op2 ) ; case LEU : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == - 1 ) return false ; op2 = GEN_INT ( trunc_int_for_mode ( INTVAL ( op2 ) + 1 , SImode ) ) ; return mep_expand_setcc_1 ( LTU , dest , op1 , op2 ) ; case GE : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == trunc_int_for_mode ( 0x80000000 , SImode ) ) return false ; op2 = GEN_INT ( INTVAL ( op2 ) - 1 ) ; return mep_expand_setcc_1 ( GT , dest , op1 , op2 ) ; case GEU : if ( GET_CODE ( op2 ) != CONST_INT || op2 == const0_rtx ) return false ; op2 = GEN_INT ( trunc_int_for_mode ( INTVAL ( op2 ) - 1 , SImode ) ) ; return mep_expand_setcc_1 ( GTU , dest , op1 , op2 ) ; default : gcc_unreachable ( ) ; } } </s>

Emit a setcc instruction in its entirity .


<s> SparcTargetMachine :: SparcTargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL , bool is64bit ) : LLVMTargetMachine ( T , TT , CPU , FS , Options , RM , CM , OL ) , TLOF ( make_unique < SparcELFTargetObjectFile > ( ) ) , Subtarget ( TT , CPU , FS , * this , is64bit ) { initAsmInfo ( ) ; } </s>


<s> static void ix86_add_new_builtins ( HOST_WIDE_INT isa , HOST_WIDE_INT isa2 ) { isa &= ~ OPTION_MASK_ISA_64BIT ; if ( ( isa & deferred_isa_values ) == 0 && ( isa2 & deferred_isa_values2 ) == 0 ) return ; deferred_isa_values &= ~ isa ; deferred_isa_values2 &= ~ isa2 ; int i ; tree saved_current_target_pragma = current_target_pragma ; current_target_pragma = NULL_TREE ; for ( i = 0 ; i < ( int ) IX86_BUILTIN_MAX ; i ++ ) { if ( ( ( ix86_builtins_isa [ i ] . isa & isa ) != 0 || ( ix86_builtins_isa [ i ] . isa2 & isa2 ) != 0 ) && ix86_builtins_isa [ i ] . set_and_not_built_p ) { tree decl , type ; ix86_builtins_isa [ i ] . set_and_not_built_p = false ; type = ix86_get_builtin_func_type ( ix86_builtins_isa [ i ] . tcode ) ; decl = add_builtin_function_ext_scope ( ix86_builtins_isa [ i ] . name , type , i , BUILT_IN_MD , NULL , NULL_TREE ) ; ix86_builtins [ i ] = decl ; if ( ix86_builtins_isa [ i ] . const_p ) TREE_READONLY ( decl ) = 1 ; } } current_target_pragma = saved_current_target_pragma ; } </s>

Add any new builtin functions for a given ISA that may not have been declared . This saves a bit of space compared to adding all of the declarations to the tree , even if we did n't use them .


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

Returns true if the target requires ( and can make use of ) the register scavenger .


<s> void mips_output_aligned_decl_common ( FILE * stream , tree decl , const char * name , unsigned HOST_WIDE_INT size , unsigned int align ) { if ( TARGET_EMBEDDED_DATA && TARGET_UNINIT_CONST_IN_RODATA && TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ( DECL_INITIAL ( decl ) == 0 || DECL_INITIAL ( decl ) == error_mark_node ) ) { if ( TREE_PUBLIC ( decl ) && DECL_NAME ( decl ) ) targetm . asm_out . globalize_label ( stream , name ) ; switch_to_section ( readonly_data_section ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( align / BITS_PER_UNIT ) ) ; mips_declare_object ( stream , name , "" , ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED "\n" , size ) ; } else mips_declare_common_object ( stream , name , "\n\t.comm\t" , size , align , true ) ; } </s>

Implement ASM_OUTPUT_ALIGNED_DECL_COMMON . This is usually the same as the elfos.h version , but we also need to handle -muninit-const-in-rodata .


<s> const TargetRegisterClass * KudeyarRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return & Kudeyar :: GPRRegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s> void X86ATTInstPrinter :: printInst ( const MCInst * MI , raw_ostream & OS , StringRef Annot , const MCSubtargetInfo & STI ) { const MCInstrDesc & Desc = MII . get ( MI -> getOpcode ( ) ) ; uint64_t TSFlags = Desc . TSFlags ; if ( CommentStream ) HasCustomInstComment = EmitAnyX86InstComments ( MI , * CommentStream , MII , getRegisterName ) ; unsigned Flags = MI -> getFlags ( ) ; if ( ( TSFlags & X86II :: LOCK ) || ( Flags & X86 :: IP_HAS_LOCK ) ) OS << "\tlock\t" ; if ( ( TSFlags & X86II :: NOTRACK ) || ( Flags & X86 :: IP_HAS_NOTRACK ) ) OS << "\tnotrack\t" ; if ( Flags & X86 :: IP_HAS_REPEAT_NE ) OS << "\trepne\t" ; else if ( Flags & X86 :: IP_HAS_REPEAT ) OS << "\trep\t" ; if ( MI -> getOpcode ( ) == X86 :: CALLpcrel32 && ( STI . getFeatureBits ( ) [ X86 :: Mode64Bit ] ) ) { OS << "\tcallq\t" ; printPCRelImm ( MI , 0 , OS ) ; } else if ( MI -> getOpcode ( ) == X86 :: DATA16_PREFIX && ( STI . getFeatureBits ( ) [ X86 :: Mode16Bit ] ) ) { MCInst Data32MI ( * MI ) ; Data32MI . setOpcode ( X86 :: DATA32_PREFIX ) ; printInstruction ( & Data32MI , OS ) ; } else if ( ! printAliasInstr ( MI , OS ) ) printInstruction ( MI , OS ) ; printAnnotation ( OS , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


Implement TARGET_REMOVE_EXTRA_CALL_PRESERVED_REGS . If INSN calls a function that uses the SIMD ABI , take advantage of the extra call-preserved registers that the ABI provides .


<s> static void mips_set_tune ( const struct mips_cpu_info * info ) { if ( info != 0 ) { mips_tune_info = info ; mips_tune = info -> cpu ; } } </s>


<s> static rtx promote_duplicated_reg ( machine_mode mode , rtx val ) { machine_mode valmode = GET_MODE ( val ) ; rtx tmp ; int nops = mode == DImode ? 3 : 2 ; gcc_assert ( mode == SImode || mode == DImode || val == const0_rtx ) ; if ( val == const0_rtx ) return copy_to_mode_reg ( mode , CONST0_RTX ( mode ) ) ; if ( CONST_INT_P ( val ) ) { HOST_WIDE_INT v = INTVAL ( val ) & 255 ; v |= v << 8 ; v |= v << 16 ; if ( mode == DImode ) v |= ( v << 16 ) << 16 ; return copy_to_mode_reg ( mode , gen_int_mode ( v , mode ) ) ; } if ( valmode == VOIDmode ) valmode = QImode ; if ( valmode != QImode ) val = gen_lowpart ( QImode , val ) ; if ( mode == QImode ) return val ; if ( ! TARGET_PARTIAL_REG_STALL ) nops -- ; if ( ix86_cost -> mult_init [ mode == DImode ? 3 : 2 ] + ix86_cost -> mult_bit * ( mode == DImode ? 8 : 4 ) <= ( ix86_cost -> shift_const + ix86_cost -> add ) * nops + ( COSTS_N_INSNS ( TARGET_PARTIAL_REG_STALL == 0 ) ) ) { rtx reg = convert_modes ( mode , QImode , val , true ) ; tmp = promote_duplicated_reg ( mode , const1_rtx ) ; return expand_simple_binop ( mode , MULT , reg , tmp , NULL , 1 , OPTAB_DIRECT ) ; } else { rtx reg = convert_modes ( mode , QImode , val , true ) ; if ( ! TARGET_PARTIAL_REG_STALL ) if ( mode == SImode ) emit_insn ( gen_movsi_insv_1 ( reg , reg ) ) ; else emit_insn ( gen_movdi_insv_1 ( reg , reg ) ) ; else { tmp = expand_simple_binop ( mode , ASHIFT , reg , GEN_INT ( 8 ) , NULL , 1 , OPTAB_DIRECT ) ; reg = expand_simple_binop ( mode , IOR , reg , tmp , reg , 1 , OPTAB_DIRECT ) ; } tmp = expand_simple_binop ( mode , ASHIFT , reg , GEN_INT ( 16 ) , NULL , 1 , OPTAB_DIRECT ) ; reg = expand_simple_binop ( mode , IOR , reg , tmp , reg , 1 , OPTAB_DIRECT ) ; if ( mode == SImode ) return reg ; tmp = expand_simple_binop ( mode , ASHIFT , reg , GEN_INT ( 32 ) , NULL , 1 , OPTAB_DIRECT ) ; reg = expand_simple_binop ( mode , IOR , reg , tmp , reg , 1 , OPTAB_DIRECT ) ; return reg ; } } </s>

Helper function for memcpy . For QImode value 0xXY produce 0xXYXYXYXY of wide specified by MODE . This is essentially a * 0x10101010 , but we can do slightly better than synth_mult by unwinding the sequence by hand on CPUs with slow multiply .


"rs6000_builtin_md_vectorized_function (%s, %s, %s)\n"


<s> bool AArch64TargetLowering :: isFMAFasterThanFMulAndFAdd ( EVT VT ) const { VT = VT . getScalarType ( ) ; if ( ! VT . isSimple ( ) ) return false ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { case MVT :: f16 : case MVT :: f32 : case MVT :: f64 : return true ; case MVT :: f128 : return false ; default : break ; } return false ; } </s>

Return true if an FMA operation is faster than a pair of fmul and fadd instructions .


<s> unsigned X86InstrInfo :: isStoreToStackSlotPostFE ( const MachineInstr & MI , int & FrameIndex ) const { unsigned Dummy ; if ( isFrameStoreOpcode ( MI . getOpcode ( ) , Dummy ) ) { unsigned Reg ; if ( ( Reg = isStoreToStackSlot ( MI , FrameIndex ) ) ) return Reg ; SmallVector < const MachineMemOperand * , 1 > Accesses ; if ( hasStoreToStackSlot ( MI , Accesses ) ) { FrameIndex = cast < FixedStackPseudoSourceValue > ( Accesses . front ( ) -> getPseudoValue ( ) ) -> getFrameIndex ( ) ; return 1 ; } } return 0 ; } </s>

isStoreToStackSlotPostFE - Check for post-frame ptr elimination stack locations as well .


<s> unsigned X86TargetLowering :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { unsigned FPDiff = RegInfo -> hasFP ( MF ) ? 1 : 0 ; switch ( RC -> getID ( ) ) { default : return 0 ; case X86 :: GR32RegClassID : return 4 - FPDiff ; case X86 :: GR64RegClassID : return 8 - FPDiff ; case X86 :: VR128RegClassID : return Subtarget -> is64Bit ( ) ? 10 : 4 ; case X86 :: VR64RegClassID : return 4 ; } } </s>

Return the register pressure `` high water mark '' for the specific register class .


<s> void PPCScoreboardHazardRecognizer :: EmitInstruction ( SUnit * SU ) { const MCInstrDesc * MCID = DAG -> getInstrDesc ( SU ) ; if ( ! MCID ) return ; ScoreboardHazardRecognizer :: EmitInstruction ( SU ) ; } </s>

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


<s> InstructionCost PPCTTIImpl :: getIntImmCostInst ( unsigned Opcode , unsigned Idx , const APInt & Imm , Type * Ty , TTI :: TargetCostKind CostKind , Instruction * Inst ) { if ( DisablePPCConstHoist ) return BaseT :: getIntImmCostInst ( Opcode , Idx , Imm , Ty , CostKind , Inst ) ; assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 ) return ~ 0U ; unsigned ImmIdx = ~ 0U ; bool ShiftedFree = false , RunFree = false , UnsignedFree = false , ZeroFree = false ; switch ( Opcode ) { default : return TTI :: TCC_Free ; case Instruction :: GetElementPtr : if ( Idx == 0 ) return 2 * TTI :: TCC_Basic ; return TTI :: TCC_Free ; case Instruction :: And : RunFree = true ; LLVM_FALLTHROUGH ; case Instruction :: Add : case Instruction :: Or : case Instruction :: Xor : ShiftedFree = true ; LLVM_FALLTHROUGH ; case Instruction :: Sub : case Instruction :: Mul : case Instruction :: Shl : case Instruction :: LShr : case Instruction :: AShr : ImmIdx = 1 ; break ; case Instruction :: ICmp : UnsignedFree = true ; ImmIdx = 1 ; LLVM_FALLTHROUGH ; case Instruction :: Select : ZeroFree = true ; break ; case Instruction :: PHI : case Instruction :: Call : case Instruction :: Ret : case Instruction :: Load : case Instruction :: Store : break ; } if ( ZeroFree && Imm == 0 ) return TTI :: TCC_Free ; if ( Idx == ImmIdx && Imm . getBitWidth ( ) <= 64 ) { if ( isInt < 16 > ( Imm . getSExtValue ( ) ) ) return TTI :: TCC_Free ; if ( RunFree ) { if ( Imm . getBitWidth ( ) <= 32 && ( isShiftedMask_32 ( Imm . getZExtValue ( ) ) || isShiftedMask_32 ( ~ Imm . getZExtValue ( ) ) ) ) return TTI :: TCC_Free ; if ( ST -> isPPC64 ( ) && ( isShiftedMask_64 ( Imm . getZExtValue ( ) ) || isShiftedMask_64 ( ~ Imm . getZExtValue ( ) ) ) ) return TTI :: TCC_Free ; } if ( UnsignedFree && isUInt < 16 > ( Imm . getZExtValue ( ) ) ) return TTI :: TCC_Free ; if ( ShiftedFree && ( Imm . getZExtValue ( ) & 0xFFFF ) == 0 ) return TTI :: TCC_Free ; } return PPCTTIImpl :: getIntImmCost ( Imm , Ty , CostKind ) ; } </s>

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


<s> int getIntImmCost ( Intrinsic :: ID IID , unsigned Idx , const APInt & Imm , Type * Ty ) { return getIntImmCost ( Imm , Ty ) ; } </s>

Calculate the cost of materializing a 64-bit value .


<s> bool X86InstrInfo :: classifyLEAReg ( MachineInstr & MI , const MachineOperand & Src , unsigned Opc , bool AllowSP , unsigned & NewSrc , bool & isKill , bool & isUndef , MachineOperand & ImplicitOp ) const { MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; const TargetRegisterClass * RC ; if ( AllowSP ) { RC = Opc != X86 :: LEA32r ? & X86 :: GR64RegClass : & X86 :: GR32RegClass ; } else { RC = Opc != X86 :: LEA32r ? & X86 :: GR64_NOSPRegClass : & X86 :: GR32_NOSPRegClass ; } unsigned SrcReg = Src . getReg ( ) ; if ( Opc != X86 :: LEA64_32r ) { NewSrc = SrcReg ; isKill = Src . isKill ( ) ; isUndef = Src . isUndef ( ) ; if ( TargetRegisterInfo :: isVirtualRegister ( NewSrc ) && ! MF . getRegInfo ( ) . constrainRegClass ( NewSrc , RC ) ) return false ; return true ; } if ( TargetRegisterInfo :: isPhysicalRegister ( SrcReg ) ) { ImplicitOp = Src ; ImplicitOp . setImplicit ( ) ; NewSrc = getX86SubSuperRegister ( Src . getReg ( ) , 64 ) ; MachineBasicBlock :: LivenessQueryResult LQR = MI . getParent ( ) -> computeRegisterLiveness ( & getRegisterInfo ( ) , NewSrc , MI ) ; switch ( LQR ) { case MachineBasicBlock :: LQR_Unknown : return false ; case MachineBasicBlock :: LQR_Live : isKill = MI . killsRegister ( SrcReg ) ; isUndef = false ; break ; default : isKill = false ; isUndef = true ; break ; } } else { NewSrc = MF . getRegInfo ( ) . createVirtualRegister ( RC ) ; BuildMI ( * MI . getParent ( ) , MI , MI . getDebugLoc ( ) , get ( TargetOpcode :: COPY ) ) . addReg ( NewSrc , RegState :: Define | RegState :: Undef , X86 :: sub_32bit ) . addOperand ( Src ) ; isKill = true ; isUndef = false ; } return true ; } </s>

Given an operand within a MachineInstr , insert preceding code to put it into the right format for a particular kind of LEA instruction .


<s> static void ia64_file_start ( void ) { ia64_flag_var_tracking = flag_var_tracking ; flag_var_tracking = 0 ; default_file_start ( ) ; emit_safe_across_calls ( ) ; } </s>


<s> bool aarch64_move_imm ( HOST_WIDE_INT val , machine_mode mode ) { scalar_int_mode int_mode ; if ( ! is_a < scalar_int_mode > ( mode , & int_mode ) ) return false ; if ( aarch64_movw_imm ( val , int_mode ) || aarch64_movw_imm ( ~ val , int_mode ) ) return 1 ; return aarch64_bitmask_imm ( val , int_mode ) ; } </s>

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


<s>
bool
ARMCallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
unsigned
VReg
)
const
{
assert
(
!
Val
==
!
VReg
&&
"Return value without a vreg"
)
;
auto
Ret
=
AddDefaultPred
(
MIRBuilder
.
buildInstrNoInsert
(
ARM
::
BX_RET
)
)
;
if
(
!
lowerReturnVal
(
MIRBuilder
,
Val
,
VReg
,
Ret
)
)
return
false
;
MIRBuilder
.
insertInstr
(
Ret
)
;
return
true
;
}
</s>

This hook behaves as the extended lowerReturn function , but for targets that do not support swifterror value promotion .

ARM
ARM
"Return value without a vreg"
ARM::BX_RET


<s> void X86InstrInfo :: breakPartialRegDependency ( MachineBasicBlock :: iterator MI , unsigned OpNum , const TargetRegisterInfo * TRI ) const { unsigned Reg = MI -> getOperand ( OpNum ) . getReg ( ) ; if ( MI -> killsRegister ( Reg , TRI ) ) return ; if ( X86 :: VR128RegClass . contains ( Reg ) ) { bool HasAVX = Subtarget . hasAVX ( ) ; unsigned Opc = HasAVX ? X86 :: VXORPSrr : X86 :: XORPSrr ; BuildMI ( * MI -> getParent ( ) , MI , MI -> getDebugLoc ( ) , get ( Opc ) , Reg ) . addReg ( Reg , RegState :: Undef ) . addReg ( Reg , RegState :: Undef ) ; } else if ( X86 :: VR256RegClass . contains ( Reg ) ) { unsigned XReg = TRI -> getSubReg ( Reg , X86 :: sub_xmm ) ; BuildMI ( * MI -> getParent ( ) , MI , MI -> getDebugLoc ( ) , get ( X86 :: VXORPSrr ) , XReg ) . addReg ( XReg , RegState :: Undef ) . addReg ( XReg , RegState :: Undef ) . addReg ( Reg , RegState :: ImplicitDefine ) ; } else return ; MI -> addRegisterKilled ( Reg , TRI , true ) ; } </s>

Insert a dependency-breaking instruction before MI to eliminate an unwanted dependency on OpNum .


<s> static bool ix86_noce_conversion_profitable_p ( rtx_insn * seq , struct noce_if_info * if_info ) { if ( TARGET_ONE_IF_CONV_INSN && if_info -> speed_p ) { int cmov_cnt = 0 ; for ( rtx_insn * insn = seq ; insn ; insn = NEXT_INSN ( insn ) ) { rtx set = single_set ( insn ) ; if ( ! set ) continue ; if ( GET_CODE ( SET_SRC ( set ) ) != IF_THEN_ELSE ) continue ; rtx src = SET_SRC ( set ) ; enum machine_mode mode = GET_MODE ( src ) ; if ( GET_MODE_CLASS ( mode ) != MODE_INT && GET_MODE_CLASS ( mode ) != MODE_FLOAT ) continue ; if ( ( ! REG_P ( XEXP ( src , 1 ) ) && ! MEM_P ( XEXP ( src , 1 ) ) ) || ( ! REG_P ( XEXP ( src , 2 ) ) && ! MEM_P ( XEXP ( src , 2 ) ) ) ) continue ; if ( ++ cmov_cnt > 1 ) return false ; } } return default_noce_conversion_profitable_p ( seq , if_info ) ; } </s>

Return true if SEQ is a good candidate as a replacement for the if-convertible sequence described in IF_INFO .


<s> void SparcTargetLowering :: LowerAsmOperandForConstraint ( SDValue Op , std :: string & Constraint , std :: vector < SDValue > & Ops , SelectionDAG & DAG ) const { SDValue Result ( nullptr , 0 ) ; if ( Constraint . length ( ) > 1 ) return ; char ConstraintLetter = Constraint [ 0 ] ; switch ( ConstraintLetter ) { default : break ; case 'I' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( isInt < 13 > ( C -> getSExtValue ( ) ) ) { Result = DAG . getTargetConstant ( C -> getSExtValue ( ) , Op . getValueType ( ) ) ; break ; } return ; } } if ( Result . getNode ( ) ) { Ops . push_back ( Result ) ; return ; } TargetLowering :: LowerAsmOperandForConstraint ( Op , Constraint , Ops , DAG ) ; } </s>

Lower the specified operand into the Ops vector .


"Code generation for MIPS-I is not implemented"

"Code generation for MIPS-II is not implemented"

"Code generation for MIPS-III is not implemented"

"Code generation for MIPS-V is not implemented"

"MSA requires a 64-bit FPU register file (FR=1 mode). "

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


"switch -mcpu=%s conflicts with -march=%s switch"

"Assembler does not support -mabi=ilp32"


<s> EVT AArch64TargetLowering :: getOptimalMemOpType ( uint64_t Size , unsigned DstAlign , unsigned SrcAlign , bool IsMemset , bool ZeroMemset , bool MemcpyStrSrc , const AttributeList & FuncAttributes ) const { bool CanImplicitFloat = ! FuncAttributes . hasFnAttribute ( Attribute :: NoImplicitFloat ) ; bool CanUseNEON = Subtarget -> hasNEON ( ) && CanImplicitFloat ; bool CanUseFP = Subtarget -> hasFPARMv8 ( ) && CanImplicitFloat ; bool IsSmallMemset = IsMemset && Size < 32 ; auto AlignmentIsAcceptable = [ & ] ( EVT VT , unsigned AlignCheck ) { if ( memOpAlign ( SrcAlign , DstAlign , AlignCheck ) ) return true ; bool Fast ; return allowsMisalignedMemoryAccesses ( VT , 0 , 1 , MachineMemOperand :: MONone , & Fast ) && Fast ; } ; if ( CanUseNEON && IsMemset && ! IsSmallMemset && AlignmentIsAcceptable ( MVT :: v2i64 , 16 ) ) return MVT :: v2i64 ; if ( CanUseFP && ! IsSmallMemset && AlignmentIsAcceptable ( MVT :: f128 , 16 ) ) return MVT :: f128 ; if ( Size >= 8 && AlignmentIsAcceptable ( MVT :: i64 , 8 ) ) return MVT :: i64 ; if ( Size >= 4 && AlignmentIsAcceptable ( MVT :: i32 , 4 ) ) return MVT :: i32 ; return MVT :: Other ; } </s>

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


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> Relocator :: Result unsupported ( Relocation & pReloc , X86_64Relocator & pParent ) { return Relocator :: Unsupported ; } </s>


<s> bool MipsSETargetLowering :: isEligibleForTailCallOptimization ( const CCState & CCInfo , unsigned NextStackOffset , const MipsFunctionInfo & FI ) const { if ( ! EnableMipsTailCalls ) return false ; if ( FI . isISR ( ) ) return false ; if ( CCInfo . getInRegsParamsCount ( ) > 0 || FI . hasByvalArg ( ) ) return false ; return NextStackOffset <= FI . getIncomingArgSize ( ) ; } </s>

Returns true if the call can be lowered as a tail call .