<s> bool arc_branch_size_unknown_p ( void ) { return ! optimize_size && arc_reorg_in_progress ; } </s>

When estimating sizes during arc_reorg , when optimizing for speed , there are three reasons why we need to consider branches to be length 6 : - annull-false delay slot insns are implemented using conditional execution , thus preventing short insn formation where used . - for ARC600 : annul-true delay slot insns are implemented where possible using conditional execution , preventing short insn formation where used . - for ARC700 : likely or somewhat likely taken branches are made long and unaligned if possible to avoid branch penalty .


<s> MCContext & getContext ( ) { return getStreamer ( ) . getContext ( ) ; } </s>

Return the LLVMContext used by the analysis .


<s> static void aarch64_init_builtins ( ) { aarch64_general_init_builtins ( ) ; aarch64_sve :: init_builtins ( ) ; } </s>


<s> unsigned AArch64InstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { switch ( MI -> getOpcode ( ) ) { default : break ; case AArch64 :: STRWui : case AArch64 :: STRXui : case AArch64 :: STRBui : case AArch64 :: STRHui : case AArch64 :: STRSui : case AArch64 :: STRDui : case AArch64 :: STRQui : if ( MI -> getOperand ( 0 ) . getSubReg ( ) == 0 && MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isImm ( ) && MI -> getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s>
void
AMDGPUTTIImpl
::
getUnrollingPreferences
(
Loop
*
L
,
TTI
::
UnrollingPreferences
&
UP
)
{
UP
.
Threshold
=
300
;
UP
.
MaxCount
=
UINT_MAX
;
UP
.
Partial
=
true
;
const
unsigned
MaxAlloca
=
(
256
16
)
*
4
;
unsigned
ThresholdPrivate
=
UnrollThresholdPrivate
;
unsigned
ThresholdLocal
=
UnrollThresholdLocal
;
unsigned
MaxBoost
=
std
::
max
(
ThresholdPrivate
,
ThresholdLocal
)
;
AMDGPUAS
ASST
=
ST
->
getAMDGPUAS
(
)
;
for
(
const
BasicBlock
*
BB
:
L
->
getBlocks
(
)
)
{
const
DataLayout
&
DL
=
BB
->
getModule
(
)
->
getDataLayout
(
)
;
unsigned
LocalGEPsSeen
=
0
;
for
(
const
Instruction
&
I
:
*
BB
)
{
const
GetElementPtrInst
*
GEP
=
dyn_cast
<
GetElementPtrInst
>
(
&
I
)
;
if
(
!
GEP
)
continue
;
unsigned
AS
=
GEP
->
getAddressSpace
(
)
;
unsigned
Threshold
=
0
;
if
(
AS
==
ASST
.
PRIVATE_ADDRESS
)
Threshold
=
ThresholdPrivate
;
else
if
(
AS
==
ASST
.
LOCAL_ADDRESS
)
Threshold
=
ThresholdLocal
;
else
continue
;
if
(
UP
.
Threshold
>=
Threshold
)
continue
;
if
(
AS
==
ASST
.
PRIVATE_ADDRESS
)
{
const
Value
*
Ptr
=
GEP
->
getPointerOperand
(
)
;
const
AllocaInst
*
Alloca
=
dyn_cast
<
AllocaInst
>
(
GetUnderlyingObject
(
Ptr
,
DL
)
)
;
if
(
!
Alloca
||
!
Alloca
->
isStaticAlloca
(
)
)
continue
;
Type
*
Ty
=
Alloca
->
getAllocatedType
(
)
;
unsigned
AllocaSize
=
Ty
->
isSized
(
)
DL
.
getTypeAllocSize
(
Ty
)
:
0
;
if
(
AllocaSize
>
MaxAlloca
)
continue
;
}
else
if
(
AS
==
ASST
.
LOCAL_ADDRESS
)
{
LocalGEPsSeen
++
;
if
(
LocalGEPsSeen
>
1
||
L
->
getLoopDepth
(
)
>
2
||
(
!
isa
<
GlobalVariable
>
(
GEP
->
getPointerOperand
(
)
)
&&
!
isa
<
Argument
>
(
GEP
->
getPointerOperand
(
)
)
)
)
continue
;
}
bool
HasLoopDef
=
false
;
for
(
const
Value
*
Op
:
GEP
->
operands
(
)
)
{
const
Instruction
*
Inst
=
dyn_cast
<
Instruction
>
(
Op
)
;
if
(
!
Inst
||
L
->
isLoopInvariant
(
Op
)
)
continue
;
if
(
any_of
(
L
->
getSubLoops
(
)
,
[
Inst
]
(
const
Loop
*
SubLoop
)
{
return
SubLoop
->
contains
(
Inst
)
;
}
)
)
continue
;
HasLoopDef
=
true
;
break
;
}
if
(
!
HasLoopDef
)
continue
;
UP
.
Threshold
=
Threshold
;
DEBUG
(
dbgs
(
)
<<
"Set unroll threshold "
<<
Threshold
<<
" for loop:\n"
<<
*
L
<<
" due to "
<<
*
GEP
<<
'\n'
)
;
if
(
UP
.
Threshold
==
MaxBoost
)
return
;
}
}
}
</s>

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


<s>
MachineBasicBlock
*
CSKYTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
&
MI
,
MachineBasicBlock
*
BB
)
const
{
switch
(
MI
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Unexpected instr type to insert"
)
;
case
CSKY
::
ISEL32
:
return
emitSelectPseudo
(
MI
,
BB
,
CSKY
::
BT32
)
;
case
CSKY
::
ISEL16
:
return
emitSelectPseudo
(
MI
,
BB
,
CSKY
::
BT16
)
;
}
}
</s>

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


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

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


<s> static bool avr_scalar_mode_supported_p ( machine_mode mode ) { if ( ALL_FIXED_POINT_MODE_P ( mode ) ) return true ; if ( PSImode == mode ) return true ; return default_scalar_mode_supported_p ( mode ) ; } </s>

Implement ` TARGET_SCALAR_MODE_SUPPORTED_P ' .


<s> void Thumb2InstrInfo :: ReplaceTailWithBranchTo ( MachineBasicBlock :: iterator Tail , MachineBasicBlock * NewDest ) const { MachineBasicBlock * MBB = Tail -> getParent ( ) ; ARMFunctionInfo * AFI = MBB -> getParent ( ) -> getInfo < ARMFunctionInfo > ( ) ; if ( ! AFI -> hasITBlocks ( ) ) { TargetInstrInfo :: ReplaceTailWithBranchTo ( Tail , NewDest ) ; return ; } unsigned PredReg = 0 ; ARMCC :: CondCodes CC = getInstrPredicate ( Tail , PredReg ) ; MachineBasicBlock :: iterator MBBI = Tail ; if ( CC != ARMCC :: AL ) -- MBBI ; TargetInstrInfo :: ReplaceTailWithBranchTo ( Tail , NewDest ) ; if ( CC != ARMCC :: AL ) { MachineBasicBlock :: iterator E = MBB -> begin ( ) ; unsigned Count = 4 ; while ( Count && MBBI != E ) { if ( MBBI -> isDebugValue ( ) ) { -- MBBI ; continue ; } if ( MBBI -> getOpcode ( ) == ARM :: t2IT ) { unsigned Mask = MBBI -> getOperand ( 1 ) . getImm ( ) ; if ( Count == 4 ) MBBI -> eraseFromParent ( ) ; else { unsigned MaskOn = 1 << Count ; unsigned MaskOff = ~ ( MaskOn - 1 ) ; MBBI -> getOperand ( 1 ) . setImm ( ( Mask & MaskOff ) | MaskOn ) ; } return ; } -- MBBI ; -- Count ; } } } </s>

Delete the instruction OldInst and everything after it , replacing it with an unconditional branch to NewDest .


<s> static void ix86_avx256_split_vector_move_misalign ( rtx op0 , rtx op1 ) { rtx m ; rtx ( * extract ) ( rtx , rtx , rtx ) ; machine_mode mode ; if ( ( MEM_P ( op1 ) && ! TARGET_AVX256_SPLIT_UNALIGNED_LOAD ) || ( MEM_P ( op0 ) && ! TARGET_AVX256_SPLIT_UNALIGNED_STORE ) ) { emit_insn ( gen_rtx_SET ( op0 , op1 ) ) ; return ; } rtx orig_op0 = NULL_RTX ; mode = GET_MODE ( op0 ) ; switch ( GET_MODE_CLASS ( mode ) ) { case MODE_VECTOR_INT : case MODE_INT : if ( mode != V32QImode ) { if ( ! MEM_P ( op0 ) ) { orig_op0 = op0 ; op0 = gen_reg_rtx ( V32QImode ) ; } else op0 = gen_lowpart ( V32QImode , op0 ) ; op1 = gen_lowpart ( V32QImode , op1 ) ; mode = V32QImode ; } break ; case MODE_VECTOR_FLOAT : break ; default : gcc_unreachable ( ) ; } switch ( mode ) { default : gcc_unreachable ( ) ; case E_V32QImode : extract = gen_avx_vextractf128v32qi ; mode = V16QImode ; break ; case E_V16BFmode : extract = gen_avx_vextractf128v16bf ; mode = V8BFmode ; break ; case E_V16HFmode : extract = gen_avx_vextractf128v16hf ; mode = V8HFmode ; break ; case E_V8SFmode : extract = gen_avx_vextractf128v8sf ; mode = V4SFmode ; break ; case E_V4DFmode : extract = gen_avx_vextractf128v4df ; mode = V2DFmode ; break ; } if ( MEM_P ( op1 ) ) { rtx r = gen_reg_rtx ( mode ) ; m = adjust_address ( op1 , mode , 0 ) ; emit_move_insn ( r , m ) ; m = adjust_address ( op1 , mode , 16 ) ; r = gen_rtx_VEC_CONCAT ( GET_MODE ( op0 ) , r , m ) ; emit_move_insn ( op0 , r ) ; } else if ( MEM_P ( op0 ) ) { m = adjust_address ( op0 , mode , 0 ) ; emit_insn ( extract ( m , op1 , const0_rtx ) ) ; m = adjust_address ( op0 , mode , 16 ) ; emit_insn ( extract ( m , copy_rtx ( op1 ) , const1_rtx ) ) ; } else gcc_unreachable ( ) ; if ( orig_op0 ) emit_move_insn ( orig_op0 , gen_lowpart ( GET_MODE ( orig_op0 ) , op0 ) ) ; } </s>

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


"eliminateCallFramePseudoInstr size too big: "

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


<s> HOST_WIDE_INT sparc_compute_frame_size ( HOST_WIDE_INT size , int leaf_function_p ) { int outgoing_args_size = ( current_function_outgoing_args_size + REG_PARM_STACK_SPACE ( current_function_decl ) ) ; int n_regs = 0 ; int i ; if ( TARGET_ARCH64 ) { for ( i = 0 ; i < 8 ; i ++ ) if ( regs_ever_live [ i ] && ! call_used_regs [ i ] ) n_regs += 2 ; } else { for ( i = 0 ; i < 8 ; i += 2 ) if ( ( regs_ever_live [ i ] && ! call_used_regs [ i ] ) || ( regs_ever_live [ i + 1 ] && ! call_used_regs [ i + 1 ] ) ) n_regs += 2 ; } for ( i = 32 ; i < ( TARGET_V9 ? 96 : 64 ) ; i += 2 ) if ( ( regs_ever_live [ i ] && ! call_used_regs [ i ] ) || ( regs_ever_live [ i + 1 ] && ! call_used_regs [ i + 1 ] ) ) n_regs += 2 ; num_gfregs = n_regs ; if ( leaf_function_p && n_regs == 0 && size == 0 && current_function_outgoing_args_size == 0 ) actual_fsize = apparent_fsize = 0 ; else { apparent_fsize = ( size - STARTING_FRAME_OFFSET + 7 ) & - 8 ; apparent_fsize += n_regs * 4 ; actual_fsize = apparent_fsize + ( ( outgoing_args_size + 7 ) & - 8 ) ; } if ( ! leaf_function_p || size > 0 ) actual_fsize += FIRST_PARM_OFFSET ( current_function_decl ) ; return SPARC_STACK_ALIGN ( actual_fsize ) ; } </s>

Compute the frame size required by the function . This function is called during the reload pass and also by sparc_expand_prologue .


<s> const uint32_t * RISCVRegisterInfo :: getNoPreservedMask ( ) const { return CSR_NoRegs_RegMask ; } </s>

Return a register mask that clobbers everything .


<s> SDValue AMDGPUTargetLowering :: loadStackInputValue ( SelectionDAG & DAG , EVT VT , const SDLoc & SL , int64_t Offset ) const { MachineFunction & MF = DAG . getMachineFunction ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; int FI = MFI . CreateFixedObject ( VT . getStoreSize ( ) , Offset , true ) ; auto SrcPtrInfo = MachinePointerInfo :: getStack ( MF , Offset ) ; SDValue Ptr = DAG . getFrameIndex ( FI , MVT :: i32 ) ; return DAG . getLoad ( VT , SL , DAG . getEntryNode ( ) , Ptr , SrcPtrInfo , 4 , MachineMemOperand :: MODereferenceable | MachineMemOperand :: MOInvariant ) ; } </s>

Similar to CreateLiveInRegister , except value maybe loaded from a stack slot rather than passed in a register .


<s> bool ARMTargetLowering :: isUsedByReturnOnly ( SDNode * N , SDValue & Chain ) const { if ( N -> getNumValues ( ) != 1 ) return false ; if ( ! N -> hasNUsesOfValue ( 1 , 0 ) ) return false ; SDValue TCChain = Chain ; SDNode * Copy = * N -> use_begin ( ) ; if ( Copy -> getOpcode ( ) == ISD :: CopyToReg ) { if ( Copy -> getOperand ( Copy -> getNumOperands ( ) - 1 ) . getValueType ( ) == MVT :: Glue ) return false ; TCChain = Copy -> getOperand ( 0 ) ; } else if ( Copy -> getOpcode ( ) == ARMISD :: VMOVRRD ) { SDNode * VMov = Copy ; SmallPtrSet < SDNode * , 2 > Copies ; for ( SDNode :: use_iterator UI = VMov -> use_begin ( ) , UE = VMov -> use_end ( ) ; UI != UE ; ++ UI ) { if ( UI -> getOpcode ( ) != ISD :: CopyToReg ) return false ; Copies . insert ( * UI ) ; } if ( Copies . size ( ) > 2 ) return false ; for ( SDNode :: use_iterator UI = VMov -> use_begin ( ) , UE = VMov -> use_end ( ) ; UI != UE ; ++ UI ) { SDValue UseChain = UI -> getOperand ( 0 ) ; if ( Copies . count ( UseChain . getNode ( ) ) ) Copy = * UI ; else TCChain = UseChain ; } } else if ( Copy -> getOpcode ( ) == ISD :: BITCAST ) { if ( ! Copy -> hasOneUse ( ) ) return false ; Copy = * Copy -> use_begin ( ) ; if ( Copy -> getOpcode ( ) != ISD :: CopyToReg || ! Copy -> hasNUsesOfValue ( 1 , 0 ) ) return false ; TCChain = Copy -> getOperand ( 0 ) ; } else { return false ; } bool HasRet = false ; for ( SDNode :: use_iterator UI = Copy -> use_begin ( ) , UE = Copy -> use_end ( ) ; UI != UE ; ++ UI ) { if ( UI -> getOpcode ( ) != ARMISD :: RET_FLAG ) return false ; HasRet = true ; } if ( ! HasRet ) return false ; Chain = TCChain ; return true ; } </s>

Return true if result of the specified node is used by a return node only .


<s> int sh_loop_align ( rtx_insn * label ) { rtx_insn * next = label ; if ( ! optimize || optimize_size ) return 0 ; do next = next_nonnote_insn ( next ) ; while ( next && LABEL_P ( next ) ) ; if ( ! next || ! INSN_P ( next ) || recog_memoized ( next ) == CODE_FOR_consttable_2 ) return 0 ; return align_loops . levels [ 0 ] . log ; } </s>

If we are inside a phony loop , almost any kind of label can turn up as the first one in the loop . Aligning a braf label causes incorrect switch destination addresses ; we can detect braf labels because they are followed by a BARRIER . Applying loop alignment to small constant or switch tables is a waste of space , so we suppress this too .


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

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


<s> static unsigned parse_env_var ( const char * str , char * * * pvalues ) { const char * curval , * nextval ; char * * values ; unsigned num = 1 , i ; curval = strchr ( str , ':' ) ; while ( curval ) { num ++ ; curval = strchr ( curval + 1 , ':' ) ; } values = ( char * * ) xmalloc ( num * sizeof ( char * ) ) ; curval = str ; nextval = strchr ( curval , ':' ) ; if ( nextval == NULL ) nextval = strchr ( curval , '\0' ) ; for ( i = 0 ; i < num ; i ++ ) { int l = nextval - curval ; values [ i ] = ( char * ) xmalloc ( l + 1 ) ; memcpy ( values [ i ] , curval , l ) ; values [ i ] [ l ] = 0 ; curval = nextval + 1 ; nextval = strchr ( curval , ':' ) ; if ( nextval == NULL ) nextval = strchr ( curval , '\0' ) ; } * pvalues = values ; return num ; } </s>

Parse STR , saving found tokens into PVALUES and return their number . Tokens are assumed to be delimited by ' : ' .


"Cannot relax short instruction fixups!"

Simple predicate for targets where ! Resolved implies requiring relaxation .


<s> bool llvm :: getAlign ( const CallInst & I , unsigned index , unsigned & align ) { if ( MDNode * alignNode = I . getMetadata ( "callalign" ) ) { for ( int i = 0 , n = alignNode -> getNumOperands ( ) ; i < n ; i ++ ) { if ( const ConstantInt * CI = dyn_cast < ConstantInt > ( alignNode -> getOperand ( i ) ) ) { unsigned v = CI -> getZExtValue ( ) ; if ( ( v >> 16 ) == index ) { align = v & 0xFFFF ; return true ; } if ( ( v >> 16 ) > index ) { return false ; } } } } return false ; } </s>

Return the minimum known alignment in bytes of the actual memory reference .


<s> void init_builtins ( ) { sve_switcher sve ; register_builtin_types ( ) ; if ( in_lto_p ) handle_arm_sve_h ( ) ; } </s>

Initialize all compiler built-ins related to RVV that should be defined at start-up .


<s> void GCNHazardRecognizer :: AdvanceCycle ( ) { if ( ! CurrCycleInstr ) { EmittedInstrs . push_front ( nullptr ) ; return ; } if ( CurrCycleInstr -> isImplicitDef ( ) || CurrCycleInstr -> isDebugInstr ( ) || CurrCycleInstr -> isKill ( ) ) { CurrCycleInstr = nullptr ; return ; } if ( CurrCycleInstr -> isBundle ( ) ) { processBundle ( ) ; return ; } unsigned NumWaitStates = TII . getNumWaitStates ( * CurrCycleInstr ) ; EmittedInstrs . push_front ( CurrCycleInstr ) ; for ( unsigned i = 1 , e = std :: min ( NumWaitStates , getMaxLookAhead ( ) ) ; i < e ; ++ i ) { EmittedInstrs . push_front ( nullptr ) ; } EmittedInstrs . resize ( getMaxLookAhead ( ) ) ; CurrCycleInstr = nullptr ; } </s>

AdvanceCycle - This callback is invoked whenever the next top-down instruction to be scheduled can not issue in the current cycle , either because of latency or resource conflicts .


<s> void ix86_print_patchable_function_entry ( FILE * file , unsigned HOST_WIDE_INT patch_area_size , bool record_p ) { if ( cfun -> machine -> function_label_emitted ) { return ; } default_print_patchable_function_entry ( file , patch_area_size , record_p ) ; } </s>


<s> static char * mips16e_add_register_range ( char * s , unsigned int min_reg , unsigned int max_reg ) { if ( min_reg != max_reg ) s += sprintf ( s , ",%s-%s" , reg_names [ min_reg ] , reg_names [ max_reg ] ) ; else s += sprintf ( s , ",%s" , reg_names [ min_reg ] ) ; return s ; } </s>

Add a MIPS16e SAVE or RESTORE register-range argument to string S for the register range [ MIN_REG , MAX_REG ] . Return a pointer to the null terminator .


<s> static rtx sched_get_reg_operand ( rtx_insn * insn , bool opx_p ) { rtx op = NULL ; if ( opx_p ) { if ( get_attr_opx_type ( insn ) == OPX_TYPE_RN ) { op = sched_get_operand ( insn , true ) ; gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } } else { if ( get_attr_opy_type ( insn ) == OPY_TYPE_RN ) { op = sched_get_operand ( insn , false ) ; gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } } return op ; } </s>

Return X or Y ( depending on OPX_P ) operand of INSN , if it is an integer register , or NULL overwise .


<s> bool X86AsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & MF . getSubtarget < X86Subtarget > ( ) ; SMShadowTracker . startFunction ( MF ) ; CodeEmitter . reset ( TM . getTarget ( ) . createMCCodeEmitter ( * MF . getSubtarget ( ) . getInstrInfo ( ) , * MF . getSubtarget ( ) . getRegisterInfo ( ) , MF . getContext ( ) ) ) ; SetupMachineFunction ( MF ) ; if ( Subtarget -> isTargetCOFF ( ) ) { 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 ( ) ; } EmitFunctionBody ( ) ; EmitXRayTable ( ) ; return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> static rtx emit_csky_regs_push ( unsigned long mask ) { int num_regs = 0 ; int i , j ; rtx par ; rtx dwarf ; rtx tmp ; int dwarf_par_index ; for ( i = 0 ; i < CSKY_NGPR_REGS ; i ++ ) { if ( mask & ( 1 << i ) ) num_regs ++ ; } gcc_assert ( num_regs && num_regs <= 12 ) ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs ) ) ; dwarf = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( num_regs + 1 ) ) ; dwarf_par_index = 1 ; for ( i = 0 ; i < CSKY_NGPR_REGS ; i ++ ) if ( mask & ( 1 << i ) ) { rtx reg = gen_rtx_REG ( SImode , i ) ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , - 4 * num_regs ) ; tmp = gen_frame_mem ( BLKmode , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , addr ) ) ; XVECEXP ( par , 0 , 0 ) = gen_rtx_SET ( tmp , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( 1 , reg ) , UNSPEC_PUSHPOP_MULT ) ) ; tmp = gen_rtx_SET ( gen_frame_mem ( SImode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = 1 ; XVECEXP ( dwarf , 0 , dwarf_par_index ++ ) = tmp ; break ; } for ( j = 1 , i ++ ; j < num_regs ; i ++ ) if ( mask & ( 1 << i ) ) { rtx reg = gen_rtx_REG ( SImode , i ) ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , 4 * j ) ; tmp = gen_rtx_SET ( gen_frame_mem ( SImode , addr ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = 1 ; XVECEXP ( par , 0 , j ) = gen_rtx_USE ( VOIDmode , reg ) ; XVECEXP ( dwarf , 0 , dwarf_par_index ++ ) = tmp ; j ++ ; } par = emit_insn ( par ) ; tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - 4 * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = 1 ; XVECEXP ( dwarf , 0 , 0 ) = tmp ; add_reg_note ( par , REG_FRAME_RELATED_EXPR , dwarf ) ; RTX_FRAME_RELATED_P ( par ) = 1 ; return par ; } </s>

Generate and emit an insn that we will recognize as a push_multi . Unfortunately , since this insn does not reflect very well the actual semantics of the operation , we need to annotate the insn for the benefit of DWARF2 frame unwind information . DWARF_REGS_MASK is a subset of MASK for registers that should be annotated for DWARF2 frame unwind information .


"sret virtual register not created in the entry block"

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


<s> bool ARMBaseTargetMachine :: addPreISel ( PassManagerBase & PM ) { if ( getOptLevel ( ) != CodeGenOpt :: None && EnableGlobalMerge ) PM . add ( createGlobalMergePass ( getTargetLowering ( ) ) ) ; return false ; } </s>


"Can only insert epilog into returning blocks"


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> bool fusion_gpr_load_p ( rtx addis_reg , rtx addis_value , rtx target , rtx mem ) { rtx addr ; rtx base_reg ; if ( ! base_reg_operand ( addis_reg , GET_MODE ( addis_reg ) ) ) return false ; if ( ! base_reg_operand ( target , GET_MODE ( target ) ) ) return false ; if ( ! fusion_gpr_addis ( addis_value , GET_MODE ( addis_value ) ) ) return false ; if ( GET_CODE ( mem ) == ZERO_EXTEND || ( GET_CODE ( mem ) == SIGN_EXTEND && TARGET_P8_FUSION_SIGN ) ) mem = XEXP ( mem , 0 ) ; if ( ! MEM_P ( mem ) ) return false ; if ( ! fusion_gpr_mem_load ( mem , GET_MODE ( mem ) ) ) return false ; addr = XEXP ( mem , 0 ) ; if ( GET_CODE ( addr ) != PLUS && GET_CODE ( addr ) != LO_SUM ) return false ; if ( REGNO ( addis_reg ) != REGNO ( target ) ) { if ( reg_mentioned_p ( target , mem ) ) return false ; if ( ! peep2_reg_dead_p ( 2 , addis_reg ) ) return false ; if ( REG_P ( target ) && REGNO ( target ) == STACK_POINTER_REGNUM ) return false ; } base_reg = XEXP ( addr , 0 ) ; return REGNO ( addis_reg ) == REGNO ( base_reg ) ; } </s>

Return true if the peephole2 can combine a load involving a combination of an addis instruction and a load with an offset that can be fused together on a power8 .


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

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


<s> SDValue MipsTargetLowering :: LowerCallResult ( SDValue Chain , SDValue InFlag , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , DebugLoc dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , getTargetMachine ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallResult ( Ins , RetCC_Mips ) ; for ( unsigned i = 0 ; i != RVLocs . size ( ) ; ++ i ) { Chain = DAG . getCopyFromReg ( Chain , dl , RVLocs [ i ] . getLocReg ( ) , RVLocs [ i ] . getValVT ( ) , InFlag ) . getValue ( 1 ) ; InFlag = Chain . getValue ( 2 ) ; InVals . push_back ( Chain . getValue ( 0 ) ) ; } return Chain ; } </s>

LowerCallResult - Lower the result values of an ISD : :CALL into the appropriate copies out of appropriate physical registers .


<s> bool NVPTXPassConfig :: addInstSelector ( ) { const NVPTXSubtarget & ST = getTM < NVPTXTargetMachine > ( ) . getSubtarget < NVPTXSubtarget > ( ) ; addPass ( createLowerAggrCopies ( ) ) ; addPass ( createAllocaHoisting ( ) ) ; addPass ( createNVPTXISelDag ( getNVPTXTargetMachine ( ) , getOptLevel ( ) ) ) ; if ( ! ST . hasImageHandles ( ) ) addPass ( createNVPTXReplaceImageHandlesPass ( ) ) ; return false ; } </s>

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

NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX


<s> void Mips16FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { if ( ! hasReservedCallFrame ( MF ) ) { int64_t Amount = I -> getOperand ( 0 ) . getImm ( ) ; if ( I -> getOpcode ( ) == Mips :: ADJCALLSTACKDOWN ) Amount = - Amount ; const Mips16InstrInfo & TII = * static_cast < const Mips16InstrInfo * > ( STI . getInstrInfo ( ) ) ; TII . adjustStackPtr ( Mips :: SP , Amount , MBB , I ) ; } MBB . erase ( I ) ; } </s>

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

Mips Mips 0 Mips::ADJCALLSTACKDOWN Mips Mips Mips::SP


<s> static bool ia64_vectorize_vec_perm_const_ok ( machine_mode vmode , const unsigned char * sel ) { struct expand_vec_perm_d d ; unsigned int i , nelt , which ; bool ret ; d . vmode = vmode ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . testing_p = true ; memcpy ( d . perm , sel , nelt ) ; for ( i = which = 0 ; i < nelt ; ++ i ) { unsigned char e = d . perm [ i ] ; gcc_assert ( e < 2 * nelt ) ; which |= ( e < nelt ? 1 : 2 ) ; } if ( which == 2 ) for ( i = 0 ; i < nelt ; ++ i ) d . perm [ i ] -= nelt ; d . one_operand_p = ( which != 3 ) ; d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 1 ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 2 ) ; if ( ! d . one_operand_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 3 ) ; start_sequence ( ) ; ret = ia64_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ret ; } </s>


<s> bool FPGATTIImpl :: hasBranchDivergence ( ) { return true ; } </s>

Return true if branch divergence exists .


<s> void emitPrologue ( MachineFunction & MF , MachineBasicBlock & MBB ) const override { } </s>

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


<s> const TargetRegisterInfo & getRegisterInfo ( ) const { return TRI ; } </s>

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


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

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


<s> bool AMDGPUPassConfig :: addGCPasses ( ) { return false ; } </s>

addGCPasses - Add late codegen passes that analyze code for garbage collection .


<s>
void
ARMTargetLowering
::
ReplaceNodeResults
(
SDNode
*
N
,
SmallVectorImpl
<
SDValue
>
&
Results
,
SelectionDAG
&
DAG
)
const
{
SDValue
Res
;
switch
(
N
->
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Don't know how to custom expand this!"
)
;
case
ISD
::
BITCAST
:
Res
=
ExpandBITCAST
(
N
,
DAG
)
;
break
;
case
ISD
::
SIGN_EXTEND
:
case
ISD
::
ZERO_EXTEND
:
Res
=
ExpandVectorExtension
(
N
,
DAG
)
;
break
;
case
ISD
::
SRL
:
case
ISD
::
SRA
:
Res
=
Expand64BitShift
(
N
,
DAG
,
Subtarget
)
;
break
;
case
ISD
::
READCYCLECOUNTER
:
ReplaceREADCYCLECOUNTER
(
N
,
Results
,
DAG
,
Subtarget
)
;
return
;
case
ISD
::
ATOMIC_LOAD_ADD
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMADD64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_AND
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMAND64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_NAND
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMNAND64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_OR
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMOR64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_SUB
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMSUB64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_XOR
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMXOR64_DAG
)
;
return
;
case
ISD
::
ATOMIC_SWAP
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMSWAP64_DAG
)
;
return
;
case
ISD
::
ATOMIC_CMP_SWAP
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMCMPXCHG64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_MIN
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMMIN64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_UMIN
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMUMIN64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_MAX
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMMAX64_DAG
)
;
return
;
case
ISD
::
ATOMIC_LOAD_UMAX
:
ReplaceATOMIC_OP_64
(
N
,
Results
,
DAG
,
ARMISD
::
ATOMUMAX64_DAG
)
;
return
;
}
if
(
Res
.
getNode
(
)
)
Results
.
push_back
(
Res
)
;
}
</s>

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


"Branch with unknown extendable field type"

immediateExtend - Changes the instruction in place to one using an immediate extender .


<s> MCSymbol * AArch64AsmPrinter :: GetCPISymbol ( unsigned CPID ) const { if ( getDataLayout ( ) . getLinkerPrivateGlobalPrefix ( ) [ 0 ] ) return OutContext . GetOrCreateSymbol ( Twine ( getDataLayout ( ) . getLinkerPrivateGlobalPrefix ( ) ) + "CPI" + Twine ( getFunctionNumber ( ) ) + "_" + Twine ( CPID ) ) ; return OutContext . GetOrCreateSymbol ( Twine ( getDataLayout ( ) . getPrivateGlobalPrefix ( ) ) + "CPI" + Twine ( getFunctionNumber ( ) ) + "_" + Twine ( CPID ) ) ; } </s>

Return the symbol for the specified constant pool entry .


<s> void GCNPassConfig :: addPreEmitPass ( ) { addPass ( createSIMemoryLegalizerPass ( ) ) ; addPass ( createSIInsertWaitcntsPass ( ) ) ; addPass ( createSIModeRegisterPass ( ) ) ; if ( getOptLevel ( ) > CodeGenOpt :: None ) addPass ( & SIInsertHardClausesID ) ; addPass ( & SILateBranchLoweringPassID ) ; if ( getOptLevel ( ) > CodeGenOpt :: None ) addPass ( & SIPreEmitPeepholeID ) ; addPass ( & PostRAHazardRecognizerID ) ; addPass ( & BranchRelaxationPassID ) ; } </s>

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


<s> bool isMicroMips ( const MCSubtargetInfo & STI ) const { return STI . getFeatureBits ( ) & Mips :: FeatureMicroMips ; } </s>

Check whether a given symbol has been flagged with MICROMIPS flag .


<s> bool Z80PassConfig :: addPreISel ( ) { return false ; } </s>


<s> unsigned MBlazeRegisterInfo :: getPICCallReg ( ) { return MBlaze :: R20 ; } </s>


<s>
void
SIRegisterInfo
::
resolveFrameIndex
(
MachineInstr
&
MI
,
unsigned
BaseReg
,
int64_t
Offset
)
const
{
MachineBasicBlock
*
MBB
=
MI
.
getParent
(
)
;
MachineFunction
*
MF
=
MBB
->
getParent
(
)
;
const
AMDGPUSubtarget
&
Subtarget
=
MF
->
getSubtarget
<
AMDGPUSubtarget
>
(
)
;
const
SIInstrInfo
*
TII
=
static_cast
<
const
SIInstrInfo
*
>
(
Subtarget
.
getInstrInfo
(
)
)
;
bool
SeenFI
=
false
;
for
(
const
MachineOperand
&
MO
:
MI
.
operands
(
)
)
{
if
(
MO
.
isFI
(
)
)
{
if
(
SeenFI
)
llvm_unreachable
(
"should not see multiple frame indices"
)
;
SeenFI
=
true
;
}
}
MachineOperand
*
FIOp
=
TII
->
getNamedOperand
(
MI
,
AMDGPU
::
OpName
::
vaddr
)
;
assert
(
FIOp
&&
FIOp
->
isFI
(
)
&&
"frame index must be address operand"
)
;
assert
(
TII
->
isMUBUF
(
MI
)
)
;
MachineOperand
*
OffsetOp
=
TII
->
getNamedOperand
(
MI
,
AMDGPU
::
OpName
::
offset
)
;
int64_t
NewOffset
=
OffsetOp
->
getImm
(
)
+
Offset
;
if
(
isUInt
<
12
>
(
NewOffset
)
)
{
FIOp
->
ChangeToRegister
(
BaseReg
,
false
)
;
OffsetOp
->
setImm
(
NewOffset
)
;
return
;
}
MachineRegisterInfo
&
MRI
=
MF
->
getRegInfo
(
)
;
unsigned
NewReg
=
MRI
.
createVirtualRegister
(
&
AMDGPU
::
VGPR_32RegClass
)
;
DebugLoc
DL
=
MI
.
getDebugLoc
(
)
;
assert
(
Offset
!=
0
&&
"Non-zero offset expected"
)
;
unsigned
UnusedCarry
=
MRI
.
createVirtualRegister
(
&
AMDGPU
::
SReg_64RegClass
)
;
BuildMI
(
*
MBB
,
MI
,
DL
,
TII
->
get
(
AMDGPU
::
V_ADD_I32_e64
)
,
NewReg
)
.
addReg
(
UnusedCarry
,
RegState
::
Define
|
RegState
::
Dead
)
.
addImm
(
Offset
)
.
addReg
(
BaseReg
)
;
FIOp
->
ChangeToRegister
(
NewReg
,
false
)
;
}
</s>

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

AMDGPU
SI
AMDGPU
AMDGPU
SI
SI
"should not see multiple frame indices"
AMDGPU::OpName
"frame index must be address operand"
AMDGPU::OpName
12
AMDGPU::VGPR_32RegClass
0
"Non-zero offset expected"
AMDGPU::SReg_64RegClass
AMDGPU::V_ADD_I32_e64


<s> const DataLayout * getDataLayout ( ) const override { return & DL ; } </s>

Return the DataLayout associated with the module this SCEV instance is operating on .


<s> int xtensa_emit_move_sequence ( rtx * operands , machine_mode mode ) { rtx src = operands [ 1 ] ; if ( CONSTANT_P ( src ) && ( GET_CODE ( src ) != CONST_INT || ! xtensa_simm12b ( INTVAL ( src ) ) ) ) { rtx dst = operands [ 0 ] ; if ( xtensa_tls_referenced_p ( src ) ) { rtx addend = NULL ; if ( GET_CODE ( src ) == CONST && GET_CODE ( XEXP ( src , 0 ) ) == PLUS ) { addend = XEXP ( XEXP ( src , 0 ) , 1 ) ; src = XEXP ( XEXP ( src , 0 ) , 0 ) ; } src = xtensa_legitimize_tls_address ( src ) ; if ( addend ) { src = gen_rtx_PLUS ( mode , src , addend ) ; src = force_operand ( src , dst ) ; } emit_move_insn ( dst , src ) ; return 1 ; } if ( ! TARGET_CONST16 ) { src = force_const_mem ( SImode , src ) ; operands [ 1 ] = src ; } if ( mode != SImode ) { if ( register_operand ( dst , mode ) ) { emit_move_insn ( simplify_gen_subreg ( SImode , dst , mode , 0 ) , src ) ; return 1 ; } else { src = force_reg ( SImode , src ) ; src = gen_lowpart_SUBREG ( mode , src ) ; operands [ 1 ] = src ; } } } if ( ! ( reload_in_progress | reload_completed ) && ! xtensa_valid_move ( mode , operands ) ) operands [ 1 ] = force_reg ( mode , operands [ 1 ] ) ; operands [ 1 ] = xtensa_copy_incoming_a7 ( operands [ 1 ] ) ; if ( reload_in_progress ) { operands [ 0 ] = fixup_subreg_mem ( operands [ 0 ] ) ; operands [ 1 ] = fixup_subreg_mem ( operands [ 1 ] ) ; } return 0 ; } </s>

Emit insns to move operands [ 1 ] into operands [ 0 ] . Return 1 if we have written out everything that needs to be done to do the move . Otherwise , return 0 and the caller will emit the move normally .


"ERROR: Unknown type of MachineOperand: "

getMachineOpValue - Return binary encoding of operand .


<s> static rtx mips16e_build_save_restore ( bool restore_p , unsigned int * mask_ptr , HOST_WIDE_INT * offset_ptr , unsigned int nargs , HOST_WIDE_INT size ) { rtx pattern , set ; HOST_WIDE_INT offset , top_offset ; unsigned int i , regno ; int n ; gcc_assert ( cfun -> machine -> frame . num_fp == 0 ) ; n = 1 + nargs ; for ( i = 0 ; i < ARRAY_SIZE ( mips16e_save_restore_regs ) ; i ++ ) if ( BITSET_P ( * mask_ptr , mips16e_save_restore_regs [ i ] ) ) n ++ ; pattern = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( n ) ) ; n = 0 ; set = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , restore_p ? size : - size ) ) ; RTX_FRAME_RELATED_P ( set ) = 1 ; XVECEXP ( pattern , 0 , n ++ ) = set ; top_offset = restore_p ? size : 0 ; for ( i = 0 ; i < nargs ; i ++ ) { offset = top_offset + i * UNITS_PER_WORD ; set = mips16e_save_restore_reg ( restore_p , true , offset , GP_ARG_FIRST + i ) ; XVECEXP ( pattern , 0 , n ++ ) = set ; } offset = top_offset ; for ( i = 0 ; i < ARRAY_SIZE ( mips16e_save_restore_regs ) ; i ++ ) { regno = mips16e_save_restore_regs [ i ] ; if ( BITSET_P ( * mask_ptr , regno ) ) { offset -= UNITS_PER_WORD ; set = mips16e_save_restore_reg ( restore_p , false , offset , regno ) ; XVECEXP ( pattern , 0 , n ++ ) = set ; * mask_ptr &= ~ ( 1 << regno ) ; } } * offset_ptr = size + ( offset - top_offset ) ; gcc_assert ( n == XVECLEN ( pattern , 0 ) ) ; return pattern ; } </s>

Return RTL for a MIPS16e SAVE or RESTORE instruction ; RESTORE_P says which . The instruction must : - Allocate or deallocate SIZE bytes in total ; SIZE is known to be nonzero . - Save or restore as many registers in * MASK_PTR as possible . The instruction saves the first registers at the top of the allocated area , with the other registers below it . - Save NARGS argument registers above the allocated area . ( NARGS is always zero if RESTORE_P . ) The SAVE and RESTORE instructions can not save and restore all general registers , so there may be some registers left over for the caller to handle . Destructively modify * MASK_PTR so that it contains the registers that still need to be saved or restored . The caller can save these registers in the memory immediately below * OFFSET_PTR , which is a byte offset from the bottom of the allocated stack area .


<s> unsigned getEUsPerCU ( ) const { return AMDGPU :: IsaInfo :: getEUsPerCU ( this ) ; } </s>

Number of SIMDs/EUs ( execution units ) per `` CU '' ( `` compute unit '' ) , where the `` CU '' is the unit onto which workgroups are mapped .


<s> bool SystemZPostRewrite :: runOnMachineFunction ( MachineFunction & MF ) { TII = static_cast < const SystemZInstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; bool Modified = false ; for ( auto & MBB : MF ) Modified |= selectMBB ( MBB ) ; return Modified ; } </s>

runOnMachineFunction - Emit the function body .


WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly


<s> bool aarch64_mov128_immediate ( rtx imm ) { if ( CONST_INT_P ( imm ) ) return true ; gcc_assert ( CONST_WIDE_INT_NUNITS ( imm ) == 2 ) ; rtx lo = GEN_INT ( CONST_WIDE_INT_ELT ( imm , 0 ) ) ; rtx hi = GEN_INT ( CONST_WIDE_INT_ELT ( imm , 1 ) ) ; return aarch64_internal_mov_immediate ( NULL_RTX , lo , false , DImode ) + aarch64_internal_mov_immediate ( NULL_RTX , hi , false , DImode ) <= 4 ; } </s>

Return whether imm is a 128-bit immediate which is simple enough to expand inline .


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

Simple predicate for targets where ! Resolved implies requiring relaxation .


<s> static unsigned int ix86_minimum_incoming_stack_boundary ( bool sibcall ) { unsigned int incoming_stack_boundary ; if ( ix86_user_incoming_stack_boundary ) incoming_stack_boundary = ix86_user_incoming_stack_boundary ; else if ( ! sibcall && ix86_force_align_arg_pointer && crtl -> stack_alignment_estimated == 128 ) incoming_stack_boundary = MIN_STACK_BOUNDARY ; else incoming_stack_boundary = ix86_default_incoming_stack_boundary ; if ( incoming_stack_boundary > MIN_STACK_BOUNDARY && lookup_attribute ( ix86_force_align_arg_pointer_string , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) incoming_stack_boundary = MIN_STACK_BOUNDARY ; if ( incoming_stack_boundary < crtl -> parm_stack_boundary ) incoming_stack_boundary = crtl -> parm_stack_boundary ; if ( incoming_stack_boundary > MAIN_STACK_BOUNDARY && DECL_NAME ( current_function_decl ) && MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) && DECL_FILE_SCOPE_P ( current_function_decl ) ) incoming_stack_boundary = MAIN_STACK_BOUNDARY ; return incoming_stack_boundary ; } </s>

Return minimum incoming stack alignment .


<s> static bool ix86_addr_space_zero_address_valid ( addr_space_t as ) { return as != ADDR_SPACE_GENERIC ; } </s>

All use of segmentation is assumed to make address 0 valid .


<s> virtual unsigned int execute ( function * ) { return visium_reorg ( ) ; } </s>


<s> MCObjectWriter * RISCVAsmBackend :: createObjectWriter ( raw_pwrite_stream & OS ) const { return createRISCVELFObjectWriter ( OS , OSABI , Is64Bit ) ; } </s>

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


<s> bool AMDGPUCtorDtorLowering :: runOnModule ( Module & M ) { bool Modified = false ; Modified |= createInitOrFiniKernel ( M , M . getGlobalVariable ( "llvm.global_ctors" ) , true ) ; Modified |= createInitOrFiniKernel ( M , M . getGlobalVariable ( "llvm.global_dtors" ) , false ) ; return Modified ; } </s>

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


<s> bool X86TTIImpl :: areInlineCompatible ( const Function * Caller , const Function * Callee ) const { const TargetMachine & TM = getTLI ( ) -> getTargetMachine ( ) ; const FeatureBitset & CallerBits = TM . getSubtargetImpl ( * Caller ) -> getFeatureBits ( ) ; const FeatureBitset & CalleeBits = TM . getSubtargetImpl ( * Callee ) -> getFeatureBits ( ) ; return ( CallerBits & CalleeBits ) == CalleeBits ; } </s>

Determine whether a callee with the given TLI can be inlined into caller with this TLI , based on 'nobuiltin ' attributes .


"can only insert epilog into returning blocks"


<s> void ix86_split_copysign_var ( rtx operands [ ] ) { machine_mode mode , vmode ; rtx dest , scratch , op0 , op1 , mask , nmask , x ; dest = operands [ 0 ] ; scratch = operands [ 1 ] ; op0 = operands [ 2 ] ; op1 = operands [ 3 ] ; nmask = operands [ 4 ] ; mask = operands [ 5 ] ; mode = GET_MODE ( dest ) ; vmode = GET_MODE ( mask ) ; if ( rtx_equal_p ( op0 , op1 ) ) { emit_move_insn ( dest , op0 ) ; return ; } if ( REG_P ( mask ) && REGNO ( dest ) == REGNO ( mask ) ) { gcc_assert ( REGNO ( op1 ) == REGNO ( scratch ) ) ; x = gen_rtx_AND ( vmode , scratch , mask ) ; emit_insn ( gen_rtx_SET ( scratch , x ) ) ; dest = mask ; op0 = simplify_gen_subreg ( vmode , op0 , mode , 0 ) ; x = gen_rtx_NOT ( vmode , dest ) ; x = gen_rtx_AND ( vmode , x , op0 ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; } else { if ( REGNO ( op1 ) == REGNO ( scratch ) ) { x = gen_rtx_AND ( vmode , scratch , mask ) ; } else { gcc_assert ( REGNO ( mask ) == REGNO ( scratch ) ) ; op1 = simplify_gen_subreg ( vmode , op1 , mode , 0 ) ; x = gen_rtx_AND ( vmode , scratch , op1 ) ; } emit_insn ( gen_rtx_SET ( scratch , x ) ) ; if ( REGNO ( op0 ) == REGNO ( dest ) ) { dest = simplify_gen_subreg ( vmode , op0 , mode , 0 ) ; x = gen_rtx_AND ( vmode , dest , nmask ) ; } else { gcc_assert ( REGNO ( nmask ) == REGNO ( dest ) ) ; dest = nmask ; op0 = simplify_gen_subreg ( vmode , op0 , mode , 0 ) ; x = gen_rtx_AND ( vmode , dest , op0 ) ; } emit_insn ( gen_rtx_SET ( dest , x ) ) ; } x = gen_rtx_IOR ( vmode , dest , scratch ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; } </s>

Deconstruct a copysign operation into bit masks . Operand 0 is variable , so we have to do two masks .


"Unsupported atomic operations, please use 32/64 bit version"

"Unsupported atomic operations, please use 64 bit version"

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


"built-in function %qE not supported for MIPS16"

Expand builtin functions . This is called from TARGET_EXPAND_BUILTIN .


<s> static rtx Fpa ( rtx par ) { int len = XVECLEN ( par , 0 ) ; int i ; for ( i = 0 ; i < len ; i ++ ) RTX_FRAME_RELATED_P ( XVECEXP ( par , 0 , i ) ) = 1 ; return par ; } </s>

Mark all the subexpressions of the PARALLEL rtx PAR as frame-related . Return PAR . dwarf2out.cc : dwarf2out_frame_debug_expr ignores sub-expressions of a PARALLEL rtx other than the first if they do not have the FRAME_RELATED flag set on them .


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

Get a TargetTransformInfo implementation for the target .


<s>
bool
AArch64AddressTypePromotion
::
runOnFunction
(
Function
&
F
)
{
if
(
skipFunction
(
F
)
)
return
false
;
if
(
F
.
isDeclaration
(
)
)
return
false
;
Func
=
&
F
;
ConsideredSExtType
=
Type
::
getInt64Ty
(
Func
->
getContext
(
)
)
;
DEBUG
(
dbgs
(
)
<<
"*** "
<<
getPassName
(
)
<<
": "
<<
Func
->
getName
(
)
<<
'\n'
)
;
Instructions
SExtInsts
;
analyzeSExtension
(
SExtInsts
)
;
return
propagateSignExtension
(
SExtInsts
)
;
}
</s>

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


<s> const TargetRegisterClass * AVRRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return & AVR :: PTRDISPREGSRegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


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

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


"loadRegFromStackSlot didn't insert any code!"

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


<s> bool TVMMoveMaterializable :: processInstruction ( MachineInstr & MI ) { bool Changed = false ; auto Uses = reverse ( MI . uses ( ) ) ; MachineInstr * InsertBefore = & MI ; MachineBasicBlock * MBB = MI . getParent ( ) ; for ( MachineOperand & Use : Uses ) { if ( Use . isReg ( ) ) { unsigned Reg = Use . getReg ( ) ; MachineInstr * Def = GetVRegDef ( Reg , & MI , * MRI , * LIS ) ; if ( Def ) { if ( HasOneUse ( Reg , Def , * MRI , * MDT , * LIS ) && Def -> getParent ( ) == MBB && Def -> getDesc ( ) . isRematerializable ( ) && ! TVM :: isArgument ( * Def ) && ! TVM :: isArgument ( * InsertBefore ) ) { MBB -> splice ( InsertBefore , MBB , Def ) ; InsertBefore = Def ; } Changed = true ; } else if ( Use . isUndef ( ) ) { const ConstantInt * Value ; if ( TVM :: isConstInt ( * InsertBefore ) ) Value = InsertBefore -> getOperand ( 1 ) . getCImm ( ) ; else Value = cimm ( * C , 0 ) ; unsigned RegConst = MRI -> createVirtualRegister ( & TVM :: I257RegClass ) ; InsertBefore = BuildMI ( * MBB , * InsertBefore , InsertBefore -> getDebugLoc ( ) , TII -> get ( TVM :: CONST_I257 ) , RegConst ) . addCImm ( Value ) ; Use . ChangeToRegister ( RegConst , false , false , true ) ; Changed = true ; } } } return Changed ; } </s>

Process a single instruction and collect debug info anchors .


<s> static rtx sh_function_arg ( cumulative_args_t ca_v , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; if ( mode == VOIDmode ) return ca -> renesas_abi ? const1_rtx : const0_rtx ; if ( sh_pass_in_reg_p ( * ca , mode , type ) && ( named || ! ( TARGET_HITACHI || ca -> renesas_abi ) ) ) { int regno ; if ( mode == SCmode && TARGET_SH4 && TARGET_LITTLE_ENDIAN && ( ! FUNCTION_ARG_SCmode_WART || ( sh_round_reg ( * ca , mode ) & 1 ) ) ) { rtx r1 = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( SFmode , BASE_ARG_REG ( mode ) + ( sh_round_reg ( * ca , mode ) ^ 1 ) ) , const0_rtx ) ; rtx r2 = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( SFmode , BASE_ARG_REG ( mode ) + ( ( sh_round_reg ( * ca , mode ) + 1 ) ^ 1 ) ) , GEN_INT ( 4 ) ) ; return gen_rtx_PARALLEL ( SCmode , gen_rtvec ( 2 , r1 , r2 ) ) ; } if ( ( TARGET_HITACHI || ca -> renesas_abi ) && ca -> free_single_fp_reg && mode == SFmode ) return gen_rtx_REG ( mode , ca -> free_single_fp_reg ) ; regno = ( BASE_ARG_REG ( mode ) + sh_round_reg ( * ca , mode ) ) ^ ( mode == SFmode && TARGET_SH4 && TARGET_LITTLE_ENDIAN && ! TARGET_HITACHI && ! ca -> renesas_abi ) ; return gen_rtx_REG ( mode , regno ) ; } return NULL_RTX ; } </s>

Define where to put the arguments to a function . Value is zero to push the argument on the stack , or a hard register in which to store the argument . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) . On SH the first args are normally in registers and the rest are pushed . Any arg that starts within the first NPARM_REGS words is at least partially passed in a register unless its data type forbids .


<s> static void pa_output_function_epilogue ( FILE * file , HOST_WIDE_INT size ATTRIBUTE_UNUSED ) { rtx insn = get_last_insn ( ) ; last_address = 0 ; if ( GET_CODE ( insn ) == NOTE ) insn = prev_real_insn ( insn ) ; if ( insn && GET_CODE ( insn ) == INSN && GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) insn = XVECEXP ( PATTERN ( insn ) , 0 , 0 ) ; if ( insn && GET_CODE ( insn ) == CALL_INSN ) { fputs ( "\tnop\n" , file ) ; last_address += 4 ; } fputs ( "\t.EXIT\n\t.PROCEND\n" , file ) ; if ( TARGET_SOM && TARGET_GAS ) { forget_section ( ) ; } if ( INSN_ADDRESSES_SET_P ( ) ) { insn = get_last_nonnote_insn ( ) ; last_address += INSN_ADDRESSES ( INSN_UID ( insn ) ) ; if ( INSN_P ( insn ) ) last_address += insn_default_length ( insn ) ; last_address = ( ( last_address + FUNCTION_BOUNDARY / BITS_PER_UNIT - 1 ) & ~ ( FUNCTION_BOUNDARY / BITS_PER_UNIT - 1 ) ) ; } update_total_code_bytes ( last_address ) ; } </s>

This function generates the assembly code for function exit . Args are as for output_function_prologue ( ) . The function epilogue should not depend on the current stack pointer ! It should use the frame pointer only . This is mandatory because of alloca ; we also take advantage of it to omit stack adjustments before returning .


<s> unsigned MipsTargetLowering :: getVectorTypeBreakdownForCallingConv ( LLVMContext & Context , CallingConv :: ID CC , EVT VT , EVT & IntermediateVT , unsigned & NumIntermediates , MVT & RegisterVT ) const { RegisterVT = getRegisterTypeForCallingConv ( Context , CC , VT ) ; IntermediateVT = RegisterVT ; NumIntermediates = VT . getFixedSizeInBits ( ) < RegisterVT . getFixedSizeInBits ( ) ? VT . getVectorNumElements ( ) : divideCeil ( VT . getSizeInBits ( ) , RegisterVT . getSizeInBits ( ) ) ; return NumIntermediates ; } </s>

Certain targets such as MIPS require that some types such as vectors are always broken down into scalars in some contexts .


<s> static bool rs6000_expand_vec_perm_const_1 ( rtx target , rtx op0 , rtx op1 , unsigned char perm0 , unsigned char perm1 ) { rtx x ; if ( ( perm0 & 2 ) == ( perm1 & 2 ) ) { if ( perm0 & 2 ) op0 = op1 ; else op1 = op0 ; } if ( rtx_equal_p ( op0 , op1 ) ) { perm0 = perm0 & 1 ; perm1 = ( perm1 & 1 ) + 2 ; } else if ( perm0 & 2 ) { if ( perm1 & 2 ) return false ; perm0 -= 2 ; perm1 += 2 ; std :: swap ( op0 , op1 ) ; } else if ( ( perm1 & 2 ) == 0 ) return false ; if ( target != NULL ) { machine_mode vmode , dmode ; rtvec v ; vmode = GET_MODE ( target ) ; gcc_assert ( GET_MODE_NUNITS ( vmode ) == 2 ) ; dmode = mode_for_vector ( GET_MODE_INNER ( vmode ) , 4 ) . require ( ) ; x = gen_rtx_VEC_CONCAT ( dmode , op0 , op1 ) ; v = gen_rtvec ( 2 , GEN_INT ( perm0 ) , GEN_INT ( perm1 ) ) ; x = gen_rtx_VEC_SELECT ( vmode , x , gen_rtx_PARALLEL ( VOIDmode , v ) ) ; emit_insn ( gen_rtx_SET ( target , x ) ) ; } return true ; } </s>

Expand a Paired Single or VSX Permute Doubleword constant permutation . Return true if we match an efficient implementation .


<s> void dimode_scalar_chain :: convert_registers ( ) { bitmap_iterator bi ; unsigned id ; EXECUTE_IF_SET_IN_BITMAP ( defs , 0 , id , bi ) convert_reg ( id ) ; EXECUTE_IF_AND_COMPL_IN_BITMAP ( defs_conv , defs , 0 , id , bi ) make_vector_copies ( id ) ; } </s>

Generate copies from defs used by the chain but not defined therein . Also populates defs_map which is used later by convert_insn .


<s> void spu_expand_atomic_op ( enum rtx_code code , rtx mem , rtx val , rtx orig_before , rtx orig_after ) { machine_mode mode = GET_MODE ( mem ) ; rtx before = orig_before , after = orig_after ; if ( before == NULL_RTX ) before = gen_reg_rtx ( mode ) ; emit_move_insn ( before , mem ) ; if ( code == MULT ) { rtx x = expand_simple_binop ( mode , AND , before , val , NULL_RTX , 1 , OPTAB_LIB_WIDEN ) ; after = expand_simple_unop ( mode , NOT , x , after , 1 ) ; } else { after = expand_simple_binop ( mode , code , before , val , after , 1 , OPTAB_LIB_WIDEN ) ; } emit_move_insn ( mem , after ) ; if ( orig_after && after != orig_after ) emit_move_insn ( orig_after , after ) ; } </s>

Expand an atomic fetch-and-operate pattern . CODE is the binary operation to perform . MEM is the memory on which to operate . VAL is the second operand of the binary operator . BEFORE and AFTER are optional locations to return the value of MEM either before of after the operation .


<s> int VEFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , unsigned & FrameReg ) const { const VESubtarget & Subtarget = MF . getSubtarget < VESubtarget > ( ) ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const VERegisterInfo * RegInfo = Subtarget . getRegisterInfo ( ) ; const VEMachineFunctionInfo * FuncInfo = MF . getInfo < VEMachineFunctionInfo > ( ) ; bool isFixed = MFI . isFixedObjectIndex ( FI ) ; bool UseFP = true ; if ( FuncInfo -> isLeafProc ( ) ) { UseFP = false ; } else if ( isFixed ) { UseFP = true ; } else if ( RegInfo -> needsStackRealignment ( MF ) ) { UseFP = false ; } int64_t FrameOffset = MF . getFrameInfo ( ) . getObjectOffset ( FI ) ; if ( UseFP ) { FrameReg = RegInfo -> getFrameRegister ( MF ) ; return FrameOffset ; } FrameReg = VE :: SX11 ; return FrameOffset + MF . getFrameInfo ( ) . getStackSize ( ) ; } </s>

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


<s> BitVector MOSRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = getFrameLowering ( MF ) ; BitVector Reserved = this -> Reserved ; if ( TFI -> hasFP ( MF ) ) reserveAllSubregs ( & Reserved , getFrameRegister ( MF ) ) ; 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> static void predict_jump ( int prob ) { rtx insn = get_last_insn ( ) ; gcc_assert ( JUMP_P ( insn ) ) ; add_int_reg_note ( insn , REG_BR_PROB , prob ) ; } </s>

Predict just emitted jump instruction to be taken with probability PROB .


"pointer offset from symbol maybe incorrect"


<s> int ix86_data_alignment ( tree type , int align ) { if ( AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && ( TREE_INT_CST_LOW ( TYPE_SIZE ( type ) ) >= 256 || TREE_INT_CST_HIGH ( TYPE_SIZE ( type ) ) ) && align < 256 ) return 256 ; if ( TARGET_64BIT ) { if ( AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && ( TREE_INT_CST_LOW ( TYPE_SIZE ( type ) ) >= 128 || TREE_INT_CST_HIGH ( TYPE_SIZE ( type ) ) ) && align < 128 ) return 128 ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < 64 ) return 64 ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < 128 ) return 128 ; } else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < 64 ) return 64 ; if ( TYPE_MODE ( type ) == XCmode && align < 128 ) return 128 ; } else if ( ( TREE_CODE ( type ) == RECORD_TYPE || TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == QUAL_UNION_TYPE ) && TYPE_FIELDS ( type ) ) { if ( DECL_MODE ( TYPE_FIELDS ( type ) ) == DFmode && align < 64 ) return 64 ; if ( ALIGN_MODE_128 ( DECL_MODE ( TYPE_FIELDS ( type ) ) ) && align < 128 ) return 128 ; } else if ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == VECTOR_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) { if ( TYPE_MODE ( type ) == DFmode && align < 64 ) return 64 ; if ( ALIGN_MODE_128 ( TYPE_MODE ( type ) ) && align < 128 ) return 128 ; } return align ; } </s>

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


<s> void EmitInstruction ( const MachineInstr * MI ) { printInstruction ( MI ) ; OutStreamer . AddBlankLine ( ) ; } </s>

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


<s> ARMSubtarget :: ARMSubtarget ( const std :: string & TT , const std :: string & CPU , const std :: string & FS ) : ARMGenSubtargetInfo ( TT , CPU , FS ) , ARMProcFamily ( Others ) , HasV4TOps ( false ) , HasV5TOps ( false ) , HasV5TEOps ( false ) , HasV6Ops ( false ) , HasV6T2Ops ( false ) , HasV7Ops ( false ) , HasVFPv2 ( false ) , HasVFPv3 ( false ) , HasVFPv4 ( false ) , HasNEON ( false ) , UseNEONForSinglePrecisionFP ( false ) , SlowFPVMLx ( false ) , HasVMLxForwarding ( false ) , SlowFPBrcc ( false ) , InThumbMode ( false ) , HasThumb2 ( false ) , IsMClass ( false ) , NoARM ( false ) , PostRAScheduler ( false ) , IsR9Reserved ( ReserveR9 ) , UseMovt ( false ) , SupportsTailCall ( false ) , HasFP16 ( false ) , HasD16 ( false ) , HasHardwareDivide ( false ) , HasT2ExtractPack ( false ) , HasDataBarrier ( false ) , Pref32BitThumb ( false ) , AvoidCPSRPartialUpdate ( false ) , HasMPExtension ( false ) , FPOnlySP ( false ) , AllowsUnalignedMem ( false ) , Thumb2DSP ( false ) , stackAlignment ( 4 ) , CPUString ( CPU ) , TargetTriple ( TT ) , TargetABI ( ARM_ABI_APCS ) { if ( CPUString . empty ( ) ) CPUString = "generic" ; std :: string ArchFS = ARM_MC :: ParseARMTriple ( TT ) ; if ( ! FS . empty ( ) ) { if ( ! ArchFS . empty ( ) ) ArchFS = ArchFS + "," + FS ; else ArchFS = FS ; } ParseSubtargetFeatures ( CPUString , ArchFS ) ; if ( ! HasV6T2Ops && hasThumb2 ( ) ) HasV4TOps = HasV5TOps = HasV5TEOps = HasV6Ops = HasV6T2Ops = true ; InstrItins = getInstrItineraryForCPU ( CPUString ) ; computeIssueWidth ( ) ; if ( TT . find ( "eabi" ) != std :: string :: npos ) TargetABI = ARM_ABI_AAPCS ; if ( isAAPCS_ABI ( ) ) stackAlignment = 8 ; if ( ! isTargetIOS ( ) ) UseMovt = hasV6T2Ops ( ) ; else { IsR9Reserved = ReserveR9 | ! HasV6Ops ; UseMovt = DarwinUseMOVT && hasV6T2Ops ( ) ; SupportsTailCall = ! getTargetTriple ( ) . isOSVersionLT ( 5 , 0 ) ; } if ( ! isThumb ( ) || hasThumb2 ( ) ) PostRAScheduler = true ; if ( ! StrictAlign && hasV6Ops ( ) && isTargetDarwin ( ) ) AllowsUnalignedMem = true ; } </s>

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

ARM ARM ARM ARM ARM ARM 4 ARM "generic" ARM ARM "," "eabi" ARM 8 5 0


<s>
void
X86InstrInfo
::
insertSelect
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DstReg
,
const
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
unsigned
TrueReg
,
unsigned
FalseReg
)
const
{
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
assert
(
Cond
.
size
(
)
==
1
&&
"Invalid Cond array"
)
;
unsigned
Opc
=
getCMovFromCond
(
(
X86
::
CondCode
)
Cond
[
0
]
.
getImm
(
)
,
MRI
.
getRegClass
(
DstReg
)
->
getSize
(
)
/
8
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
FalseReg
)
.
addReg
(
TrueReg
)
;
}
</s>

Insert a select instruction into MBB before I that will copy TrueReg to DstReg when Cond is true , and FalseReg to DstReg when Cond is false .


<s>
static
const
char
*
shift_op
(
rtx
op
,
HOST_WIDE_INT
*
amountp
)
{
const
char
*
mnem
;
enum
rtx_code
code
=
GET_CODE
(
op
)
;
switch
(
code
)
{
case
ROTATE
:
if
(
!
CONST_INT_P
(
XEXP
(
op
,
1
)
)
)
{
output_operand_lossage
(
"invalid shift operand"
)
;
return
;
}
code
=
ROTATERT
;
*
amountp
=
32
INTVAL
(
XEXP
(
op
,
1
)
)
;
mnem
=
"ror"
;
break
;
case
ASHIFT
:
case
ASHIFTRT
:
case
LSHIFTRT
:
case
ROTATERT
:
mnem
=
arm_shift_nmem
(
code
)
;
if
(
CONST_INT_P
(
XEXP
(
op
,
1
)
)
)
{
*
amountp
=
INTVAL
(
XEXP
(
op
,
1
)
)
;
}
else
if
(
REG_P
(
XEXP
(
op
,
1
)
)
)
{
*
amountp
=
1
;
return
mnem
;
}
else
{
output_operand_lossage
(
"invalid shift operand"
)
;
return
;
}
break
;
case
MULT
:
if
(
!
CONST_INT_P
(
XEXP
(
op
,
1
)
)
)
{
output_operand_lossage
(
"invalid shift operand"
)
;
return
;
}
*
amountp
=
INTVAL
(
XEXP
(
op
,
1
)
)
&
0xFFFFFFFF
;
if
(
*
amountp
&
(
*
amountp
1
)
)
{
output_operand_lossage
(
"invalid shift operand"
)
;
return
;
}
*
amountp
=
exact_log2
(
*
amountp
)
;
gcc_assert
(
IN_RANGE
(
*
amountp
,
0
,
31
)
)
;
return
ARM_LSL_NAME
;
default
:
output_operand_lossage
(
"invalid shift operand"
)
;
return
;
}
if
(
code
==
ROTATERT
)
*
amountp
&=
31
;
else
if
(
*
amountp
!=
(
*
amountp
&
31
)
)
{
if
(
code
==
ASHIFT
)
mnem
=
"lsr"
;
*
amountp
=
32
;
}
if
(
*
amountp
==
0
)
return
;
return
mnem
;
}
</s>

Ensure valid constant shifts and return the appropriate shift mnemonic for the operation code . The returned result should not be overwritten . OP is the rtx code of the shift . On exit , * AMOUNTP will be -1 if the shift is by a register , or a constant shift .


<s> static bool ix86_expand_vector_init_duplicate ( bool mmx_ok , enum machine_mode mode , rtx target , rtx val ) { enum machine_mode smode , wsmode , wvmode ; rtx x ; switch ( mode ) { case V2SImode : case V2SFmode : if ( ! mmx_ok && ! TARGET_SSE ) return false ; case V2DFmode : case V2DImode : case V4SFmode : case V4SImode : val = force_reg ( GET_MODE_INNER ( mode ) , val ) ; x = gen_rtx_VEC_DUPLICATE ( mode , val ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , x ) ) ; return true ; case V4HImode : if ( ! mmx_ok ) return false ; if ( TARGET_SSE || TARGET_3DNOW_A ) { val = gen_lowpart ( SImode , val ) ; x = gen_rtx_TRUNCATE ( HImode , val ) ; x = gen_rtx_VEC_DUPLICATE ( mode , x ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , x ) ) ; return true ; } else { smode = HImode ; wsmode = SImode ; wvmode = V2SImode ; goto widen ; } case V8QImode : if ( ! mmx_ok ) return false ; smode = QImode ; wsmode = HImode ; wvmode = V4HImode ; goto widen ; case V8HImode : smode = HImode ; wsmode = SImode ; wvmode = V4SImode ; goto widen ; case V16QImode : smode = QImode ; wsmode = HImode ; wvmode = V8HImode ; goto widen ; widen : val = convert_modes ( wsmode , smode , val , true ) ; x = expand_simple_binop ( wsmode , ASHIFT , val , GEN_INT ( GET_MODE_BITSIZE ( smode ) ) , NULL_RTX , 1 , OPTAB_LIB_WIDEN ) ; val = expand_simple_binop ( wsmode , IOR , val , x , x , 1 , OPTAB_LIB_WIDEN ) ; x = gen_reg_rtx ( wvmode ) ; if ( ! ix86_expand_vector_init_duplicate ( mmx_ok , wvmode , x , val ) ) gcc_unreachable ( ) ; emit_move_insn ( target , gen_lowpart ( mode , x ) ) ; return true ; default : return false ; } } </s>

A subroutine of ix86_expand_vector_init . Store into TARGET a vector with all elements equal to VAR . Return true if successful .


<s> MVT getScalarShiftAmountTy ( const DataLayout & , EVT ) const override { return MVT :: i8 ; } </s>

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


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

PowerPC PPC PPC "ppc-plt" "ppc-pic" "ppc-pcrel" "ppc-got" "ppc-opt-pcrel" "ppc-tlsgd" "ppc-tlsld" "ppc-tprel" "ppc-tlsgdm" "ppc-got-tlsgd-pcrel" "ppc-got-tlsld-pcrel" "ppc-got-tprel-pcrel"


<s> static int symbolic_expression_p ( rtx x ) { if ( GET_CODE ( x ) == SYMBOL_REF ) return 1 ; if ( GET_CODE ( x ) == CONST ) return symbolic_expression_p ( XEXP ( x , 0 ) ) ; if ( UNARY_P ( x ) ) return symbolic_expression_p ( XEXP ( x , 0 ) ) ; if ( ARITHMETIC_P ( x ) ) return ( symbolic_expression_p ( XEXP ( x , 0 ) ) || symbolic_expression_p ( XEXP ( x , 1 ) ) ) ; return 0 ; } </s>

Return 1 if X contains a symbolic expression . We know these expressions will have one of a few well defined forms , so we need only check those forms .


<s> bool DXILTranslateMetadata :: runOnModule ( Module & M ) { if ( MDNode * ValVerMD = cast_or_null < MDNode > ( M . getModuleFlag ( ValVerKey ) ) ) { auto ValVer = loadDXILValidatorVersion ( ValVerMD ) ; if ( ! ValVer . empty ( ) ) ValidatorVer = ValVer ; } emitDXILValidatorVersion ( M , ValidatorVer ) ; cleanModule ( M ) ; return false ; } </s>

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


<s> int NVPTXTTIImpl :: getArithmeticInstrCost ( unsigned Opcode , Type * Ty , TTI :: OperandValueKind Opd1Info , TTI :: OperandValueKind Opd2Info , TTI :: OperandValueProperties Opd1PropInfo , TTI :: OperandValueProperties Opd2PropInfo , ArrayRef < const Value * > Args , const Instruction * CxtI ) { std :: pair < int , MVT > LT = TLI -> getTypeLegalizationCost ( DL , Ty ) ; int ISD = TLI -> InstructionOpcodeToISD ( Opcode ) ; switch ( ISD ) { default : return BaseT :: getArithmeticInstrCost ( Opcode , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; case ISD :: ADD : case ISD :: MUL : case ISD :: XOR : case ISD :: OR : case ISD :: AND : if ( LT . second . SimpleTy == MVT :: i64 ) return 2 * LT . first ; return BaseT :: getArithmeticInstrCost ( Opcode , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; } } </s>

This is an approximation of reciprocal throughput of a math/logic op .

NVPTX NVPTX ISD::ADD ISD::MUL ISD::XOR ISD::OR ISD::AND MVT::i64 2


"sret virtual register not created in the entry block"

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


<s> bool X86InstrInfo :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL = MBB . findDebugLoc ( MI ) ; MachineFunction & MF = * MBB . getParent ( ) ; unsigned FPReg = RI . getFrameRegister ( MF ) ; bool is64Bit = TM . getSubtarget < X86Subtarget > ( ) . is64Bit ( ) ; bool isWin64 = TM . getSubtarget < X86Subtarget > ( ) . isTargetWin64 ( ) ; unsigned Opc = is64Bit ? X86 :: POP64r : X86 :: POP32r ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( Reg == FPReg ) continue ; if ( ! X86 :: VR128RegClass . contains ( Reg ) && ! isWin64 ) { BuildMI ( MBB , MI , DL , get ( Opc ) , Reg ) ; } else { const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; loadRegFromStackSlot ( MBB , MI , Reg , CSI [ i ] . getFrameIdx ( ) , RC , & RI ) ; } } return true ; } </s>

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


<s> static int sh_round_reg ( const CUMULATIVE_ARGS & cum , machine_mode mode ) { return ( ( ( TARGET_ALIGN_DOUBLE || ( ( TARGET_SH4 || TARGET_SH2A_DOUBLE ) && ( mode == DFmode || mode == DCmode ) && cum . arg_count [ ( int ) SH_ARG_FLOAT ] < NPARM_REGS ( mode ) ) ) && GET_MODE_UNIT_SIZE ( mode ) > UNITS_PER_WORD ) ? ( cum . arg_count [ ( int ) GET_SH_ARG_CLASS ( mode ) ] + ( cum . arg_count [ ( int ) GET_SH_ARG_CLASS ( mode ) ] & 1 ) ) : cum . arg_count [ ( int ) GET_SH_ARG_CLASS ( mode ) ] ) ; } </s>

Round a register number up to a proper boundary for an arg of mode MODE . The SH does n't care about double alignment , so we only round doubles to even regs when asked to explicitly .


<s> int mmix_valid_comparison ( RTX_CODE code , enum machine_mode mode , rtx op ) { if ( mode == VOIDmode && op != NULL_RTX ) mode = GET_MODE ( op ) ; if ( mode == CCmode || mode == CC_UNSmode || mode == DImode ) return 1 ; if ( ( mode == CC_FPmode || mode == DFmode ) && ( code == GT || code == LT ) ) return 1 ; if ( ( mode == CC_FPEQmode || mode == DFmode ) && ( code == EQ || code == NE ) ) return 1 ; if ( ( mode == CC_FUNmode || mode == DFmode ) && ( code == ORDERED || code == UNORDERED ) ) return 1 ; return 0 ; } </s>

Returns zero if code and mode is not a valid condition from a compare-type insn . Nonzero if it is . The parameter op , if non-NULL , is the comparison of mode is CC-somethingmode .


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

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

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


<s>
bool
SIInstrInfo
::
isInlineConstant
(
const
MachineOperand
&
MO
,
uint8_t
OperandType
)
const
{
if
(
!
MO
.
isImm
(
)
||
OperandType
<
MCOI
::
OPERAND_FIRST_TARGET
)
return
false
;
int64_t
Imm
=
MO
.
getImm
(
)
;
switch
(
operandBitWidth
(
OperandType
)
)
{
case
32
:
{
int32_t
Trunc
=
static_cast
<
int32_t
>
(
Imm
)
;
return
Trunc
==
Imm
&&
AMDGPU
::
isInlinableLiteral32
(
Trunc
,
ST
.
hasInv2PiInlineImm
(
)
)
;
}
case
64
:
{
return
AMDGPU
::
isInlinableLiteral64
(
MO
.
getImm
(
)
,
ST
.
hasInv2PiInlineImm
(
)
)
;
}
case
16
:
{
if
(
isInt
<
16
>
(
Imm
)
||
isUInt
<
16
>
(
Imm
)
)
{
int16_t
Trunc
=
static_cast
<
int16_t
>
(
Imm
)
;
return
ST
.
has16BitInsts
(
)
&&
AMDGPU
::
isInlinableLiteral16
(
Trunc
,
ST
.
hasInv2PiInlineImm
(
)
)
;
}
return
false
;
}
default
:
llvm_unreachable
(
"invalid bitwidth"
)
;
}
}
</s>

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


<s> void applyFixup ( const MCFixup & Fixup , char * Data , unsigned DataSize , uint64_t Value ) const { MCFixupKind Kind = Fixup . getKind ( ) ; Value = adjustFixupValue ( ( unsigned ) Kind , Value ) ; if ( ! Value ) return ; unsigned Offset = Fixup . getOffset ( ) ; unsigned NumBytes = ( getFixupKindInfo ( Kind ) . TargetSize + 7 ) / 8 ; unsigned FullSize ; switch ( ( unsigned ) Kind ) { case Mips :: fixup_Mips_16 : FullSize = 2 ; break ; case Mips :: fixup_Mips_64 : FullSize = 8 ; break ; default : FullSize = 4 ; break ; } uint64_t CurVal = 0 ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = IsLittle ? i : ( FullSize - 1 - i ) ; CurVal |= ( uint64_t ) ( ( uint8_t ) Data [ Offset + Idx ] ) << ( i * 8 ) ; } uint64_t Mask = ( ( uint64_t ) ( - 1 ) >> ( 64 - getFixupKindInfo ( Kind ) . TargetSize ) ) ; CurVal |= Value & Mask ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = IsLittle ? i : ( FullSize - 1 - i ) ; Data [ Offset + Idx ] = ( uint8_t ) ( ( CurVal >> ( i * 8 ) ) & 0xff ) ; } } </s>

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


<s> const MCPhysReg * PPCRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { const PPCSubtarget & Subtarget = MF -> getSubtarget < PPCSubtarget > ( ) ; if ( MF -> getFunction ( ) . getCallingConv ( ) == CallingConv :: AnyReg ) { if ( Subtarget . hasVSX ( ) ) return CSR_64_AllRegs_VSX_SaveList ; if ( Subtarget . hasAltivec ( ) ) return CSR_64_AllRegs_Altivec_SaveList ; return CSR_64_AllRegs_SaveList ; } if ( TM . isPPC64 ( ) && MF -> getInfo < PPCFunctionInfo > ( ) -> isSplitCSR ( ) ) return CSR_SRV464_TLS_PE_SaveList ; bool SaveR2 = MF -> getRegInfo ( ) . isAllocatable ( PPC :: X2 ) && ! Subtarget . isUsingPCRelativeCalls ( ) ; if ( MF -> getFunction ( ) . getCallingConv ( ) == CallingConv :: Cold ) { if ( TM . isPPC64 ( ) ) { if ( Subtarget . hasAltivec ( ) ) return SaveR2 ? CSR_SVR64_ColdCC_R2_Altivec_SaveList : CSR_SVR64_ColdCC_Altivec_SaveList ; return SaveR2 ? CSR_SVR64_ColdCC_R2_SaveList : CSR_SVR64_ColdCC_SaveList ; } if ( Subtarget . hasAltivec ( ) ) return CSR_SVR32_ColdCC_Altivec_SaveList ; else if ( Subtarget . hasSPE ( ) ) return CSR_SVR32_ColdCC_SPE_SaveList ; return CSR_SVR32_ColdCC_SaveList ; } if ( TM . isPPC64 ( ) ) { if ( Subtarget . hasAltivec ( ) ) return SaveR2 ? CSR_PPC64_R2_Altivec_SaveList : CSR_PPC64_Altivec_SaveList ; return SaveR2 ? CSR_PPC64_R2_SaveList : CSR_PPC64_SaveList ; } if ( Subtarget . hasAltivec ( ) ) return CSR_SVR432_Altivec_SaveList ; else if ( Subtarget . hasSPE ( ) ) return CSR_SVR432_SPE_SaveList ; return CSR_SVR432_SaveList ; } </s>

PowerPC PPC PPC PPC PPC PPC PPC::X2 PPC PPC PPC PPC PPC PPC


<s> bool isIntrinsic ( ) const { return ( Attributes & Intrinsic ) != 0 ; } </s>

Returns true iff the group of FMA opcodes holds intrinsic opcodes .


runOnMachineFunction - Emit the function body .


<s> bool PPCLowerMASSVEntries :: runOnModule ( Module & M ) { bool Changed = false ; auto * TPC = getAnalysisIfAvailable < TargetPassConfig > ( ) ; if ( ! TPC ) return Changed ; auto & TM = TPC -> getTM < PPCTargetMachine > ( ) ; const PPCSubtarget * Subtarget ; for ( Function & Func : M ) { if ( ! Func . isDeclaration ( ) ) continue ; if ( ! isMASSVFunc ( Func . getName ( ) ) ) continue ; SmallVector < User * , 4 > MASSVUsers ; for ( auto * User : Func . users ( ) ) MASSVUsers . push_back ( User ) ; for ( auto * User : MASSVUsers ) { auto * CI = dyn_cast < CallInst > ( User ) ; if ( ! CI ) continue ; Subtarget = & TM . getSubtarget < PPCSubtarget > ( * CI -> getParent ( ) -> getParent ( ) ) ; Changed |= lowerMASSVCall ( CI , Func , M , Subtarget ) ; } } return Changed ; } </s>


<s> unsigned RISCVInstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { return isSimpleMove ( MI , FrameIndex , RISCVII :: SimpleStore ) ; } </s>

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


aarch64
"%*sselected tune = %s\n"
""
"%*sselected arch = %s%s\n"
""


<s> static rtx frame_emit_store ( int regno , int regno_note , rtx addr , rtx cfa , int cfa_offset ) { rtx reg = gen_rtx_REG ( Pmode , regno ) ; rtx mem = gen_frame_mem ( Pmode , addr ) ; rtx mov = gen_movsi ( mem , reg ) ; rtx reg_note = gen_rtx_REG ( Pmode , regno_note ) ; rtx cfa_relative_addr = gen_rtx_PLUS ( Pmode , cfa , gen_int_si ( cfa_offset ) ) ; rtx cfa_relative_mem = gen_frame_mem ( Pmode , cfa_relative_addr ) ; rtx real = gen_rtx_SET ( cfa_relative_mem , reg_note ) ; add_reg_note ( mov , REG_CFA_OFFSET , real ) ; return emit_insn ( mov ) ; } </s>

Emit a store in the stack frame to save REGNO at address ADDR , and emit the corresponding REG_CFA_OFFSET note described by CFA and CFA_OFFSET . Return the emitted insn .


<s>
Value
*
PPCTargetLowering
::
emitMaskedAtomicRMWIntrinsic
(
IRBuilderBase
&
Builder
,
AtomicRMWInst
*
AI
,
Value
*
AlignedAddr
,
Value
*
Incr
,
Value
*
Mask
,
Value
*
ShiftAmt
,
AtomicOrdering
Ord
)
const
{
assert
(
shouldInlineQuadwordAtomics
(
)
&&
"Only support quadword now"
)
;
Module
*
M
=
Builder
.
GetInsertBlock
(
)
->
getParent
(
)
->
getParent
(
)
;
Type
*
ValTy
=
Incr
->
getType
(
)
;
assert
(
ValTy
->
getPrimitiveSizeInBits
(
)
==
128
)
;
Function
*
RMW
=
Intrinsic
::
getDeclaration
(
M
,
getIntrinsicForAtomicRMWBinOp128
(
AI
->
getOperation
(
)
)
)
;
Type
*
Int64Ty
=
Type
::
getInt64Ty
(
M
->
getContext
(
)
)
;
Value
*
IncrLo
=
Builder
.
CreateTrunc
(
Incr
,
Int64Ty
,
"incr_lo"
)
;
Value
*
IncrHi
=
Builder
.
CreateTrunc
(
Builder
.
CreateLShr
(
Incr
,
64
)
,
Int64Ty
,
"incr_hi"
)
;
Value
*
Addr
=
Builder
.
CreateBitCast
(
AlignedAddr
,
Type
::
getInt8PtrTy
(
M
->
getContext
(
)
)
)
;
Value
*
LoHi
=
Builder
.
CreateCall
(
RMW
,
{
Addr
,
IncrLo
,
IncrHi
}
)
;
Value
*
Lo
=
Builder
.
CreateExtractValue
(
LoHi
,
0
,
"lo"
)
;
Value
*
Hi
=
Builder
.
CreateExtractValue
(
LoHi
,
1
,
"hi"
)
;
Lo
=
Builder
.
CreateZExt
(
Lo
,
ValTy
,
"lo64"
)
;
Hi
=
Builder
.
CreateZExt
(
Hi
,
ValTy
,
"hi64"
)
;
return
Builder
.
CreateOr
(
Lo
,
Builder
.
CreateShl
(
Hi
,
ConstantInt
::
get
(
ValTy
,
64
)
)
,
"val64"
)
;
}
</s>

Perform a masked atomicrmw using a target-specific intrinsic .


<s> inline bool function_base :: apply_tail_policy_p ( ) const { return true ; } </s>

We choose to apply tail policy operand by default since most of the intrinsics has tail policy operand .


<s> static void pru_elf_asm_constructor ( rtx symbol , int priority ) { char buf [ 23 ] ; section * s ; if ( priority == DEFAULT_INIT_PRIORITY ) snprintf ( buf , sizeof ( buf ) , ".init_array" ) ; else { snprintf ( buf , sizeof ( buf ) , ".init_array.%.5u" , priority ) ; } s = get_section ( buf , SECTION_WRITE | SECTION_NOTYPE , NULL ) ; switch_to_section ( s ) ; assemble_aligned_integer ( INIT_ARRAY_ENTRY_BYTES , symbol ) ; } </s>


<s> static rtx s390_emit_ccraw_jump ( HOST_WIDE_INT mask , enum rtx_code comparison , rtx label ) { rtx temp ; gcc_assert ( comparison == EQ || comparison == NE ) ; gcc_assert ( mask > 0 && mask < 15 ) ; temp = gen_rtx_fmt_ee ( comparison , VOIDmode , gen_rtx_REG ( CCRAWmode , CC_REGNUM ) , GEN_INT ( mask ) ) ; temp = gen_rtx_IF_THEN_ELSE ( VOIDmode , temp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; temp = gen_rtx_SET ( pc_rtx , temp ) ; return emit_jump_insn ( temp ) ; } </s>

Emit a conditional jump to LABEL for condition code mask MASK using comparsion operator COMPARISON . Return the emitted jump insn .


<s> Register ARCRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const ARCFrameLowering * TFI = getFrameLowering ( MF ) ; return TFI -> hasFP ( MF ) ? ARC :: FP : ARC :: SP ; } </s>


<s> rtx expand ( function_expander & e ) const OVERRIDE { for ( unsigned int i = 0 ; i < 2 ; ++ i ) e . args [ i ] = e . convert_to_pmode ( e . args [ i ] ) ; return e . use_exact_insn ( code_for_while ( m_unspec , Pmode , e . gp_mode ( 0 ) ) ) ; } </s>


<s> bool X86TargetLowering :: isIntDivCheap ( EVT VT , AttributeList Attr ) const { bool OptSize = Attr . hasFnAttribute ( Attribute :: MinSize ) ; return OptSize && ! VT . isVector ( ) ; } </s>

Return true if integer divide is usually cheaper than a sequence of several shifts , adds , and multiplies for this target .


<s> unsigned X86AsmParser :: checkTargetMatchPredicate ( MCInst & Inst ) { unsigned Opc = Inst . getOpcode ( ) ; const MCInstrDesc & MCID = MII . get ( Opc ) ; if ( ForcedVEXEncoding == VEXEncoding_EVEX && ( MCID . TSFlags & X86II :: EncodingMask ) != X86II :: EVEX ) return Match_Unsupported ; if ( ( ForcedVEXEncoding == VEXEncoding_VEX2 || ForcedVEXEncoding == VEXEncoding_VEX3 ) && ( MCID . TSFlags & X86II :: EncodingMask ) != X86II :: VEX ) return Match_Unsupported ; switch ( Opc ) { case X86 :: VCVTSD2SIZrm_Int : case X86 :: VCVTSD2SI64Zrm_Int : case X86 :: VCVTSS2SIZrm_Int : case X86 :: VCVTSS2SI64Zrm_Int : case X86 :: VCVTTSD2SIZrm : case X86 :: VCVTTSD2SIZrm_Int : case X86 :: VCVTTSD2SI64Zrm : case X86 :: VCVTTSD2SI64Zrm_Int : case X86 :: VCVTTSS2SIZrm : case X86 :: VCVTTSS2SIZrm_Int : case X86 :: VCVTTSS2SI64Zrm : case X86 :: VCVTTSS2SI64Zrm_Int : if ( ForcedVEXEncoding != VEXEncoding_EVEX ) return Match_Unsupported ; } return Match_Success ; } </s>

checkTargetMatchPredicate - Validate the instruction match against any complex target predicates not expressible via match classes .


<s> static void avr_output_bss_section_asm_op ( const char * data ) { avr_need_clear_bss_p = true ; output_section_asm_op ( data ) ; } </s>

Unnamed section callback for bss_section to track need of __do_clear_bss .


<s> static bool riscv_valid_offset_p ( rtx x , machine_mode mode ) { if ( ! const_arith_operand ( x , Pmode ) ) return false ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && ! SMALL_OPERAND ( INTVAL ( x ) + GET_MODE_SIZE ( mode ) - UNITS_PER_WORD ) ) return false ; return true ; } </s>

Return true if , for every base register BASE_REG , ( plus BASE_REG X ) can address a value of mode MODE .


<s> void AMDGPUHSATargetObjectFile :: Initialize ( MCContext & Ctx , const TargetMachine & TM ) { TargetLoweringObjectFileELF :: Initialize ( Ctx , TM ) ; InitializeELF ( TM . Options . UseInitArray ) ; TextSection = AMDGPU :: getHSATextSection ( Ctx ) ; DataGlobalAgentSection = AMDGPU :: getHSADataGlobalAgentSection ( Ctx ) ; DataGlobalProgramSection = AMDGPU :: getHSADataGlobalProgramSection ( Ctx ) ; RodataReadonlyAgentSection = AMDGPU :: getHSARodataReadonlyAgentSection ( Ctx ) ; } </s>

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


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

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


<s> int HexagonMCInstrInfo :: getMinValue ( MCInstrInfo const & MCII , MCInst const & MCI ) { assert ( HexagonMCInstrInfo :: isExtendable ( MCII , MCI ) || HexagonMCInstrInfo :: isExtended ( MCII , MCI ) ) ; if ( HexagonMCInstrInfo :: isExtentSigned ( MCII , MCI ) ) return - ( 1 << ( HexagonMCInstrInfo :: getExtentBits ( MCII , MCI ) - 1 ) ) ; return 0 ; } </s>

Return the minimal unsigned value possible given these KnownBits .

Hexagon Hexagon Hexagon Hexagon Hexagon 1 Hexagon 1 0


<s> MachineInstr * ARMBaseInstrInfo :: duplicate ( MachineInstr * Orig , MachineFunction & MF ) const { MachineInstr * MI = TargetInstrInfo :: duplicate ( Orig , MF ) ; switch ( Orig -> getOpcode ( ) ) { case ARM :: tLDRpci_pic : case ARM :: t2LDRpci_pic : { unsigned CPI = Orig -> getOperand ( 1 ) . getIndex ( ) ; unsigned PCLabelId = duplicateCPV ( MF , CPI ) ; Orig -> getOperand ( 1 ) . setIndex ( CPI ) ; Orig -> getOperand ( 2 ) . setImm ( PCLabelId ) ; break ; } } return MI ; } </s>

Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore .


<s> bool SIInstrInfo :: isReallyTriviallyReMaterializable ( const MachineInstr * MI , AliasAnalysis * AA ) const { switch ( MI -> getOpcode ( ) ) { case AMDGPU :: V_MOV_B32_e32 : case AMDGPU :: V_MOV_B32_e64 : case AMDGPU :: V_MOV_B64_PSEUDO : return true ; default : return false ; } } </s>

For instructions with opcodes for which the M_REMATERIALIZABLE flag is set , this hook lets the target specify whether the instruction is actually trivially rematerializable , taking into consideration its operands .


<s> bool alpha_emit_setcc ( rtx operands [ ] , machine_mode cmp_mode ) { enum rtx_code cmp_code ; enum rtx_code code = GET_CODE ( operands [ 1 ] ) ; rtx op0 = operands [ 2 ] , op1 = operands [ 3 ] ; rtx tmp ; if ( cmp_mode == TFmode ) { op0 = alpha_emit_xfloating_compare ( & code , op0 , op1 ) ; op1 = const0_rtx ; cmp_mode = DImode ; } if ( cmp_mode == DFmode && ! TARGET_FIX ) return 0 ; cmp_code = UNKNOWN ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; break ; case NE : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; case ORDERED : cmp_code = reverse_condition ( code ) ; code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( cmp_mode == DImode ) { if ( ! register_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( cmp_code != UNKNOWN ) { tmp = gen_reg_rtx ( cmp_mode ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_fmt_ee ( cmp_code , cmp_mode , op0 , op1 ) ) ) ; op0 = cmp_mode != DImode ? gen_lowpart ( DImode , tmp ) : tmp ; op1 = const0_rtx ; } emit_insn ( gen_rtx_SET ( operands [ 0 ] , gen_rtx_fmt_ee ( code , DImode , op0 , op1 ) ) ) ; return true ; } </s>

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


<s> int dimode_scalar_chain :: vector_const_cost ( rtx exp ) { gcc_assert ( CONST_INT_P ( exp ) ) ; if ( standard_sse_constant_p ( exp , V2DImode ) ) return COSTS_N_INSNS ( 1 ) ; return ix86_cost -> sse_load [ 1 ] ; } </s>

Return a cost of building a vector costant instead of using a scalar one .


<s> InstructionCost GCNTTIImpl :: getArithmeticReductionCost ( unsigned Opcode , VectorType * Ty , bool IsPairwise , TTI :: TargetCostKind CostKind ) { EVT OrigTy = TLI -> getValueType ( DL , Ty ) ; if ( IsPairwise || ! ST -> hasVOP3PInsts ( ) || OrigTy . getScalarSizeInBits ( ) != 16 ) return BaseT :: getArithmeticReductionCost ( Opcode , Ty , IsPairwise , CostKind ) ; std :: pair < InstructionCost , MVT > LT = TLI -> getTypeLegalizationCost ( DL , Ty ) ; return LT . first * getFullRateInstrCost ( ) ; } </s>

Calculate the cost of vector reduction intrinsics .


<s> bool avr_has_nibble_0xf ( rtx ival ) { unsigned int map = UINTVAL ( ival ) & GET_MODE_MASK ( SImode ) ; return 0 != avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) ; } </s>

Return true if IVAL has a 0xf in its hexadecimal representation and false , otherwise . Only nibbles 0 .. 7 are taken into account . Used as constraint helper for C0f and Cxf .


<s> inline bool vgpr_vector_mode_p ( machine_mode mode ) { return VECTOR_MODE_P ( mode ) ; } </s>

Return true if MODE can be handled directly by VGPR operations .


<s> const SystemZInstrInfo * getInstrInfo ( ) const { return getTargetMachine ( ) . getSubtargetImpl ( ) -> getInstrInfo ( ) ; } </s>


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { return true ; } </s>

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


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\n"

Given a library name NAME , i.e . foo , Look for libfoo.lib and then libfoo.a in the set of directories we are allowed to search in . May return NULL if the library can be discarded .


<s> bool func_fma_steering :: put_node ( fma_node * node ) { return this -> m_insn_fma_head_map -> put ( node -> get_insn ( ) , node ) ; } </s>

Memorize the mapping of this instruction to its fma_node object and return whether such a mapping existed .


<s>
static
const
char
*
output_move_const_into_data_reg
(
rtx
*
operands
)
{
HOST_WIDE_INT
i
;
i
=
INTVAL
(
operands
[
1
]
)
;
switch
(
m68k_const_method
(
i
)
)
{
case
MVZ
:
return
"mvzw %1,%0"
;
case
MVS
:
return
"mvsw %1,%0"
;
case
MOVQ
:
return
"moveq %1,%0"
;
case
NOTB
:
CC_STATUS_INIT
;
operands
[
1
]
=
GEN_INT
(
i
^
0xff
)
;
return
"moveq %1,%0\n\tnot%.b %0"
;
case
NOTW
:
CC_STATUS_INIT
;
operands
[
1
]
=
GEN_INT
(
i
^
0xffff
)
;
return
"moveq %1,%0\n\tnot%.w %0"
;
case
NEGW
:
CC_STATUS_INIT
;
return
"moveq #-128,%0\n\tneg%.w %0"
;
case
SWAP
:
{
unsigned
u
=
i
;
operands
[
1
]
=
GEN_INT
(
(
u
<<
16
)
|
(
u
>>
16
)
)
;
return
"moveq %1,%0\n\tswap %0"
;
}
case
MOVL
:
return
"move%.l %1,%0"
;
default
:
gcc_unreachable
(
)
;
}
}
</s>

Return an instruction to move CONST_INT OPERANDS [ 1 ] into data register OPERANDS [ 0 ] .


<s>
SDValue
XCoreTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
case
ISD
::
EH_RETURN
:
return
LowerEH_RETURN
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
LowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
ConstantPool
:
return
LowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
BR_JT
:
return
LowerBR_JT
(
Op
,
DAG
)
;
case
ISD
::
LOAD
:
return
LowerLOAD
(
Op
,
DAG
)
;
case
ISD
::
STORE
:
return
LowerSTORE
(
Op
,
DAG
)
;
case
ISD
::
VAARG
:
return
LowerVAARG
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
)
;
case
ISD
::
SMUL_LOHI
:
return
LowerSMUL_LOHI
(
Op
,
DAG
)
;
case
ISD
::
UMUL_LOHI
:
return
LowerUMUL_LOHI
(
Op
,
DAG
)
;
case
ISD
::
ADD
:
case
ISD
::
SUB
:
return
ExpandADDSUB
(
Op
.
getNode
(
)
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
)
;
case
ISD
::
FRAME_TO_ARGS_OFFSET
:
return
LowerFRAME_TO_ARGS_OFFSET
(
Op
,
DAG
)
;
case
ISD
::
INIT_TRAMPOLINE
:
return
LowerINIT_TRAMPOLINE
(
Op
,
DAG
)
;
case
ISD
::
ADJUST_TRAMPOLINE
:
return
LowerADJUST_TRAMPOLINE
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_FENCE
:
return
LowerATOMIC_FENCE
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_LOAD
:
return
LowerATOMIC_LOAD
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_STORE
:
return
LowerATOMIC_STORE
(
Op
,
DAG
)
;
default
:
llvm_unreachable
(
"unimplemented operand"
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


Choose the order in which to allocate hard registers for pseudo-registers local to a basic block . Store the desired register order in the array ` reg_alloc_order ' . Element 0 should be the register to allocate first ; element 1 , the next register ; and so on .


<s> MachineInstr * AlphaInstrInfo :: foldMemoryOperandImpl ( MachineFunction & MF , MachineInstr * MI , const SmallVectorImpl < unsigned > & Ops , int FrameIndex ) const { if ( Ops . size ( ) != 1 ) return NULL ; unsigned Opc = MI -> getOpcode ( ) ; MachineInstr * NewMI = NULL ; switch ( Opc ) { default : break ; case Alpha :: BISr : case Alpha :: CPYSS : case Alpha :: CPYST : if ( MI -> getOperand ( 1 ) . getReg ( ) == MI -> getOperand ( 2 ) . getReg ( ) ) { if ( Ops [ 0 ] == 0 ) { unsigned InReg = MI -> getOperand ( 1 ) . getReg ( ) ; bool isKill = MI -> getOperand ( 1 ) . isKill ( ) ; bool isUndef = MI -> getOperand ( 1 ) . isUndef ( ) ; Opc = ( Opc == Alpha :: BISr ) ? Alpha :: STQ : ( ( Opc == Alpha :: CPYSS ) ? Alpha :: STS : Alpha :: STT ) ; NewMI = BuildMI ( MF , MI -> getDebugLoc ( ) , get ( Opc ) ) . addReg ( InReg , getKillRegState ( isKill ) | getUndefRegState ( isUndef ) ) . addFrameIndex ( FrameIndex ) . addReg ( Alpha :: F31 ) ; } else { unsigned OutReg = MI -> getOperand ( 0 ) . getReg ( ) ; bool isDead = MI -> getOperand ( 0 ) . isDead ( ) ; bool isUndef = MI -> getOperand ( 0 ) . isUndef ( ) ; Opc = ( Opc == Alpha :: BISr ) ? Alpha :: LDQ : ( ( Opc == Alpha :: CPYSS ) ? Alpha :: LDS : Alpha :: LDT ) ; NewMI = BuildMI ( MF , MI -> getDebugLoc ( ) , get ( Opc ) ) . addReg ( OutReg , RegState :: Define | getDeadRegState ( isDead ) | getUndefRegState ( isUndef ) ) . addFrameIndex ( FrameIndex ) . addReg ( Alpha :: F31 ) ; } } break ; } return NewMI ; } </s>

foldMemoryOperand - Same as the previous version except it allows folding of any load and store from / to any address , not just from a specific stack slot .


<s> static void output_stack_adjust ( int direction , int size ) { if ( direction < 0 && size > mcore_stack_increment && mcore_stack_increment > 0 ) { rtx tmp = gen_rtx_REG ( SImode , 1 ) ; rtx memref ; emit_insn ( gen_movsi ( tmp , GEN_INT ( mcore_stack_increment ) ) ) ; do { emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; memref = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; MEM_VOLATILE_P ( memref ) = 1 ; emit_insn ( gen_movsi ( memref , stack_pointer_rtx ) ) ; size -= mcore_stack_increment ; } while ( size > mcore_stack_increment ) ; } if ( size ) { rtx insn ; rtx val = GEN_INT ( size ) ; if ( size > 32 ) { rtx nval = gen_rtx_REG ( SImode , 1 ) ; emit_insn ( gen_movsi ( nval , val ) ) ; val = nval ; } if ( direction > 0 ) insn = gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , val ) ; else insn = gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , val ) ; emit_insn ( insn ) ; } } </s>

Adjust the stack and return the number of bytes taken to do it


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> int SIFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { const SIRegisterInfo * RI = MF . getSubtarget < GCNSubtarget > ( ) . getRegisterInfo ( ) ; FrameReg = RI -> getFrameRegister ( MF ) ; return MF . getFrameInfo ( ) . getObjectOffset ( FI ) ; } </s>

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


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


<s> static unsigned int riscv_function_arg_boundary ( enum machine_mode mode , const_tree type ) { unsigned int alignment ; if ( type && ! AGGREGATE_TYPE_P ( type ) ) alignment = TYPE_ALIGN ( TYPE_MAIN_VARIANT ( type ) ) ; else alignment = type ? TYPE_ALIGN ( type ) : GET_MODE_ALIGNMENT ( mode ) ; return MIN ( STACK_BOUNDARY , MAX ( PARM_BOUNDARY , alignment ) ) ; } </s>

Implement TARGET_FUNCTION_ARG_BOUNDARY . Every parameter gets at least PARM_BOUNDARY bits of alignment , but will be given anything up to STACK_BOUNDARY bits if the type requires it .


<s> enum reg_class s390_secondary_input_reload_class ( enum reg_class class , enum machine_mode mode , rtx in ) { if ( s390_plus_operand ( in , mode ) ) return ADDR_REGS ; if ( reg_classes_intersect_p ( FP_REGS , class ) && mode == TFmode && GET_CODE ( in ) == MEM && GET_CODE ( XEXP ( in , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( in , 0 ) , 1 ) ) == CONST_INT && ! DISP_IN_RANGE ( INTVAL ( XEXP ( XEXP ( in , 0 ) , 1 ) ) + GET_MODE_SIZE ( mode ) - 1 ) ) return ADDR_REGS ; if ( reg_classes_intersect_p ( CC_REGS , class ) ) return GENERAL_REGS ; return NO_REGS ; } </s>

Return the register class of a scratch register needed to load IN into a register of class CLASS in MODE . We need a temporary when loading a PLUS expression which is not a legitimate operand of the LOAD ADDRESS instruction .


<s>
bool
AArch64TargetLowering
::
SimplifyDemandedBitsForTargetNode
(
SDValue
Op
,
const
APInt
&
OriginalDemandedBits
,
const
APInt
&
OriginalDemandedElts
,
KnownBits
&
Known
,
TargetLoweringOpt
&
TLO
,
unsigned
Depth
)
const
{
unsigned
Opc
=
Op
.
getOpcode
(
)
;
switch
(
Opc
)
{
case
AArch64ISD
::
VSHL
:
{
SDValue
ShiftL
=
Op
;
SDValue
ShiftR
=
Op
->
getOperand
(
0
)
;
if
(
ShiftR
->
getOpcode
(
)
!=
AArch64ISD
::
VLSHR
)
return
false
;
if
(
!
ShiftL
.
hasOneUse
(
)
||
!
ShiftR
.
hasOneUse
(
)
)
return
false
;
unsigned
ShiftLBits
=
ShiftL
->
getConstantOperandVal
(
1
)
;
unsigned
ShiftRBits
=
ShiftR
->
getConstantOperandVal
(
1
)
;
if
(
ShiftRBits
!=
ShiftLBits
)
return
false
;
unsigned
ScalarSize
=
Op
.
getScalarValueSizeInBits
(
)
;
assert
(
ScalarSize
>
ShiftLBits
&&
"Invalid shift imm"
)
;
APInt
ZeroBits
=
APInt
::
getLowBitsSet
(
ScalarSize
,
ShiftLBits
)
;
APInt
UnusedBits
=
~
OriginalDemandedBits
;
if
(
(
ZeroBits
&
UnusedBits
)
!=
ZeroBits
)
return
false
;
return
TLO
.
CombineTo
(
Op
,
ShiftR
->
getOperand
(
0
)
)
;
}
}
return
TargetLowering
::
SimplifyDemandedBitsForTargetNode
(
Op
,
OriginalDemandedBits
,
OriginalDemandedElts
,
Known
,
TLO
,
Depth
)
;
}
</s>

Attempt to simplify any target nodes based on the demanded bits/elts , returning true on success .


<s>
bool
SILoadStoreOptimizer
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
if
(
skipFunction
(
MF
.
getFunction
(
)
)
)
return
false
;
STM
=
&
MF
.
getSubtarget
<
GCNSubtarget
>
(
)
;
if
(
!
STM
->
loadStoreOptEnabled
(
)
)
return
false
;
TII
=
STM
->
getInstrInfo
(
)
;
TRI
=
&
TII
->
getRegisterInfo
(
)
;
STI
=
&
MF
.
getSubtarget
<
MCSubtargetInfo
>
(
)
;
MRI
=
&
MF
.
getRegInfo
(
)
;
AA
=
&
getAnalysis
<
AAResultsWrapperPass
>
(
)
.
getAAResults
(
)
;
assert
(
MRI
->
isSSA
(
)
&&
"Must be run on SSA"
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"Running SILoadStoreOptimizer\n"
)
;
bool
Modified
=
false
;
for
(
MachineBasicBlock
&
MBB
:
MF
)
{
std
::
list
<
std
::
list
<
CombineInfo
>
>
MergeableInsts
;
Modified
|=
collectMergeableInsts
(
MBB
,
MergeableInsts
)
;
do
{
OptimizeAgain
=
false
;
Modified
|=
optimizeBlock
(
MergeableInsts
)
;
}
while
(
OptimizeAgain
)
;
}
return
Modified
;
}
</s>

runOnMachineFunction - Emit the function body .

AMDGPU
SI
"Must be run on SSA"
"Running SILoadStoreOptimizer\n"


<s> unsigned HexagonInstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { switch ( MI -> getOpcode ( ) ) { default : break ; case Hexagon :: LDriw : case Hexagon :: LDrid : case Hexagon :: LDrih : case Hexagon :: LDrib : case Hexagon :: LDriub : if ( MI -> getOperand ( 2 ) . isFI ( ) && MI -> getOperand ( 1 ) . isImm ( ) && ( MI -> getOperand ( 1 ) . getImm ( ) == 0 ) ) { FrameIndex = MI -> getOperand ( 2 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s>
void
R600SchedStrategy
::
initialize
(
ScheduleDAGMI
*
dag
)
{
assert
(
dag
->
hasVRegLiveness
(
)
&&
"R600SchedStrategy needs vreg liveness"
)
;
DAG
=
static_cast
<
ScheduleDAGMILive
*
>
(
dag
)
;
TII
=
static_cast
<
const
R600InstrInfo
*
>
(
DAG
->
TII
)
;
TRI
=
static_cast
<
const
R600RegisterInfo
*
>
(
DAG
->
TRI
)
;
VLIW5
=
!
DAG
->
MF
.
getTarget
(
)
.
getSubtarget
<
AMDGPUSubtarget
>
(
)
.
hasCaymanISA
(
)
;
MRI
=
&
DAG
->
MRI
;
CurInstKind
=
IDOther
;
CurEmitted
=
0
;
OccupedSlotsMask
=
31
;
InstKindLimit
[
IDAlu
]
=
TII
->
getMaxAlusPerClause
(
)
;
InstKindLimit
[
IDOther
]
=
32
;
const
AMDGPUSubtarget
&
ST
=
DAG
->
TM
.
getSubtarget
<
AMDGPUSubtarget
>
(
)
;
InstKindLimit
[
IDFetch
]
=
ST
.
getTexVTXClauseSize
(
)
;
AluInstCount
=
0
;
FetchInstCount
=
0
;
}
</s>

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


<s> bool X86TargetLowering :: isTypeDesirableForOp ( unsigned Opc , EVT VT ) const { if ( ! isTypeLegal ( VT ) ) return false ; if ( VT != MVT :: i16 ) return true ; switch ( Opc ) { default : return true ; case ISD :: LOAD : case ISD :: SIGN_EXTEND : case ISD :: ZERO_EXTEND : case ISD :: ANY_EXTEND : case ISD :: SHL : case ISD :: SRL : case ISD :: SUB : case ISD :: ADD : case ISD :: MUL : case ISD :: AND : case ISD :: OR : case ISD :: XOR : return false ; } } </s>

Return true if the target has native support for the specified value type and it is 'desirable ' to use the type for the given node type .


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