<s> SDValue SITargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { default : return AMDGPUTargetLowering :: PerformDAGCombine ( N , DCI ) ; case ISD :: FADD : return performFAddCombine ( N , DCI ) ; case ISD :: FSUB : return performFSubCombine ( N , DCI ) ; case ISD :: SETCC : return performSetCCCombine ( N , DCI ) ; case ISD :: FMAXNUM : case ISD :: FMINNUM : case ISD :: SMAX : case ISD :: SMIN : case ISD :: UMAX : case ISD :: UMIN : case AMDGPUISD :: FMIN_LEGACY : case AMDGPUISD :: FMAX_LEGACY : { if ( DCI . getDAGCombineLevel ( ) >= AfterLegalizeDAG && N -> getValueType ( 0 ) != MVT :: f64 && getTargetMachine ( ) . getOptLevel ( ) > CodeGenOpt :: None ) return performMinMaxCombine ( N , DCI ) ; break ; } case ISD :: LOAD : case ISD :: STORE : case ISD :: ATOMIC_LOAD : case ISD :: ATOMIC_STORE : case ISD :: ATOMIC_CMP_SWAP : case ISD :: ATOMIC_CMP_SWAP_WITH_SUCCESS : case ISD :: ATOMIC_SWAP : case ISD :: ATOMIC_LOAD_ADD : case ISD :: ATOMIC_LOAD_SUB : case ISD :: ATOMIC_LOAD_AND : case ISD :: ATOMIC_LOAD_OR : case ISD :: ATOMIC_LOAD_XOR : case ISD :: ATOMIC_LOAD_NAND : case ISD :: ATOMIC_LOAD_MIN : case ISD :: ATOMIC_LOAD_MAX : case ISD :: ATOMIC_LOAD_UMIN : case ISD :: ATOMIC_LOAD_UMAX : case AMDGPUISD :: ATOMIC_INC : case AMDGPUISD :: ATOMIC_DEC : { if ( DCI . isBeforeLegalize ( ) ) break ; return performMemSDNodeCombine ( cast < MemSDNode > ( N ) , DCI ) ; } case ISD :: AND : return performAndCombine ( N , DCI ) ; case ISD :: OR : return performOrCombine ( N , DCI ) ; case ISD :: XOR : return performXorCombine ( N , DCI ) ; case AMDGPUISD :: FP_CLASS : return performClassCombine ( N , DCI ) ; case ISD :: FCANONICALIZE : return performFCanonicalizeCombine ( N , DCI ) ; case AMDGPUISD :: FRACT : case AMDGPUISD :: RCP : case AMDGPUISD :: RSQ : case AMDGPUISD :: RCP_LEGACY : case AMDGPUISD :: RSQ_LEGACY : case AMDGPUISD :: RSQ_CLAMP : case AMDGPUISD :: LDEXP : { SDValue Src = N -> getOperand ( 0 ) ; if ( Src . isUndef ( ) ) return Src ; break ; } case ISD :: SINT_TO_FP : case ISD :: UINT_TO_FP : return performUCharToFloatCombine ( N , DCI ) ; case AMDGPUISD :: CVT_F32_UBYTE0 : case AMDGPUISD :: CVT_F32_UBYTE1 : case AMDGPUISD :: CVT_F32_UBYTE2 : case AMDGPUISD :: CVT_F32_UBYTE3 : return performCvtF32UByteNCombine ( N , DCI ) ; } return AMDGPUTargetLowering :: PerformDAGCombine ( N , DCI ) ; } </s>

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


<s> unsigned PPCRegisterInfo :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getTarget ( ) . getFrameLowering ( ) ; const unsigned DefaultSafety = 1 ; switch ( RC -> getID ( ) ) { default : return 0 ; case PPC :: G8RC_NOX0RegClassID : case PPC :: GPRC_NOR0RegClassID : case PPC :: G8RCRegClassID : case PPC :: GPRCRegClassID : { unsigned FP = TFI -> hasFP ( MF ) ? 1 : 0 ; return 32 - FP - DefaultSafety ; } case PPC :: F8RCRegClassID : case PPC :: F4RCRegClassID : case PPC :: VRRCRegClassID : return 32 - DefaultSafety ; case PPC :: CRRCRegClassID : return 8 - DefaultSafety ; } } </s>

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


<s> static short find_set_regmode_weight ( rtx x , machine_mode mode ) { if ( GET_CODE ( x ) == CLOBBER && register_operand ( SET_DEST ( x ) , mode ) ) return 1 ; if ( GET_CODE ( x ) == SET && register_operand ( SET_DEST ( x ) , mode ) ) { if ( REG_P ( SET_DEST ( x ) ) ) { if ( ! reg_mentioned_p ( SET_DEST ( x ) , SET_SRC ( x ) ) ) return 1 ; else return 0 ; } return 1 ; } return 0 ; } </s>


<s>
static
int
spu_sms_res_mii
(
struct
ddg
*
g
)
{
int
i
;
unsigned
t
[
4
]
=
{
0
,
0
,
0
,
0
}
;
for
(
i
=
0
;
i
<
g
->
num_nodes
;
i
++
)
{
rtx_insn
*
insn
=
g
->
nodes
[
i
]
.
insn
;
int
p
=
get_pipe
(
insn
)
+
2
;
gcc_assert
(
p
>=
0
)
;
gcc_assert
(
p
<
4
)
;
t
[
p
]
++
;
if
(
dump_file
&&
INSN_P
(
insn
)
)
fprintf
(
dump_file
,
"i%d %s %d %d\n"
,
INSN_UID
(
insn
)
,
insn_data
[
INSN_CODE
(
insn
)
]
.
name
,
p
,
t
[
p
]
)
;
}
if
(
dump_file
)
fprintf
(
dump_file
,
"%d %d %d %d\n"
,
t
[
0
]
,
t
[
1
]
,
t
[
2
]
,
t
[
3
]
)
;
return
MAX
(
(
t
[
0
]
+
t
[
2
]
+
t
[
3
]
+
1
)
/
2
,
MAX
(
t
[
2
]
,
t
[
3
]
)
)
;
}
</s>

Count the total number of instructions in each pipe and return the maximum , which is used as the Minimum Iteration Interval ( MII ) in the modulo scheduler . get_pipe ( ) will return -2 , -1 , 0 , or 1 . -2 are instructions that can go in pipe0 or pipe1 .


<s> rtx frv_index_memory ( rtx memref , machine_mode mode , int index ) { rtx base = XEXP ( memref , 0 ) ; if ( GET_CODE ( base ) == PRE_MODIFY ) base = XEXP ( base , 0 ) ; return change_address ( memref , mode , plus_constant ( Pmode , base , index * GET_MODE_SIZE ( mode ) ) ) ; } </s>

Given a memory reference MEMREF , interpret the referenced memory as an array of MODE values , and return a reference to the element specified by INDEX . Assume that any pre-modification implicit in MEMREF has already happened . MEMREF must be a legitimate operand for modes larger than SImode . GO_IF_LEGITIMATE_ADDRESS forbids register+register addresses , which this function can not handle .


<s> void arm_output_fn_unwind ( FILE * f , bool prologue ) { if ( arm_except_unwind_info ( & global_options ) != UI_TARGET ) return ; if ( prologue ) fputs ( "\t.fnstart\n" , f ) ; else { if ( ! ( flag_unwind_tables || crtl -> uses_eh_lsda ) && ( TREE_NOTHROW ( current_function_decl ) || crtl -> all_throwers_are_sibcalls ) ) fputs ( "\t.cantunwind\n" , f ) ; fputs ( "\t.fnend\n" , f ) ; } } </s>

Output unwind directives for the start/end of a function .


<s> MachineInstrBuilder R600InstrInfo :: buildIndirectWrite ( MachineBasicBlock * MBB , MachineBasicBlock :: iterator I , unsigned ValueReg , unsigned Address , unsigned OffsetReg ) const { unsigned AddrReg = AMDGPU :: R600_AddrRegClass . getRegister ( Address ) ; MachineInstr * MOVA = buildDefaultInstruction ( * MBB , I , AMDGPU :: MOVA_INT_eg , AMDGPU :: AR_X , OffsetReg ) ; setImmOperand ( MOVA , R600Operands :: WRITE , 0 ) ; MachineInstrBuilder Mov = buildDefaultInstruction ( * MBB , I , AMDGPU :: MOV , AddrReg , ValueReg ) . addReg ( AMDGPU :: AR_X , RegState :: Implicit | RegState :: Kill ) ; setImmOperand ( Mov , R600Operands :: DST_REL , 1 ) ; return Mov ; } </s>

Build instruction ( s ) for an indirect register write .


<s> void X86TargetLowering :: insertSSPDeclarations ( Module & M ) const { if ( Subtarget . getTargetTriple ( ) . isWindowsMSVCEnvironment ( ) || Subtarget . getTargetTriple ( ) . isWindowsItaniumEnvironment ( ) ) { M . getOrInsertGlobal ( "__security_cookie" , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ; FunctionCallee SecurityCheckCookie = M . getOrInsertFunction ( "__security_check_cookie" , Type :: getVoidTy ( M . getContext ( ) ) , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ; if ( Function * F = dyn_cast < Function > ( SecurityCheckCookie . getCallee ( ) ) ) { F -> setCallingConv ( CallingConv :: X86_FastCall ) ; F -> addParamAttr ( 0 , Attribute :: AttrKind :: InReg ) ; } return ; } StringRef GuardMode = M . getStackProtectorGuard ( ) ; if ( ( GuardMode == "tls" || GuardMode . empty ( ) ) && hasStackGuardSlotTLS ( Subtarget . getTargetTriple ( ) ) ) return ; TargetLowering :: insertSSPDeclarations ( M ) ; } </s>

Inserts necessary declarations for SSP ( stack protection ) purpose .


<s> TargetLowering :: ConstraintType XNCMTargetLowering :: getConstraintType ( const std :: string & Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'r' : return C_RegisterClass ; default : break ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s> bool canAddEdge ( const SUnit * Succ , const SUnit * Pred ) const { if ( Pred -> NodeNum < Succ -> NodeNum ) return true ; SmallVector < const SUnit * , 64 > Succs ( { Succ } ) , Preds ( { Pred } ) ; for ( unsigned I = 0 ; I < Succs . size ( ) ; ++ I ) { for ( const SDep & SI : Succs [ I ] -> Succs ) { const SUnit * SU = SI . getSUnit ( ) ; if ( SU != Succs [ I ] && llvm :: find ( Succs , SU ) == Succs . end ( ) ) Succs . push_back ( SU ) ; } } SmallPtrSet < const SUnit * , 32 > Visited ; while ( ! Preds . empty ( ) ) { const SUnit * SU = Preds . pop_back_val ( ) ; if ( llvm :: find ( Succs , SU ) != Succs . end ( ) ) return false ; Visited . insert ( SU ) ; for ( const SDep & SI : SU -> Preds ) if ( SI . getSUnit ( ) != SU && ! Visited . count ( SI . getSUnit ( ) ) ) Preds . push_back ( SI . getSUnit ( ) ) ; } return true ; } </s>

True if an edge can be added from PredSU to SuccSU without creating a cycle .


<s> MVT :: SimpleValueType MipsTargetLowering :: getSetCCResultType ( EVT VT ) const { return MVT :: i32 ; } </s>

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


<s> parallel :: parallel ( parallel * parent_ , unsigned mask_ ) : parent ( parent_ ) , next ( 0 ) , inner ( 0 ) , mask ( mask_ ) , inner_mask ( 0 ) { forked_block = join_block = 0 ; forked_insn = join_insn = 0 ; fork_insn = joining_insn = 0 ; if ( parent ) { next = parent -> inner ; parent -> inner = this ; } } </s>

Constructor links the new parallel into it 's parent 's chain of children .


<s> void relaxInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI , MCInst & Res ) const override { } </s>

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


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

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

powerpcspe "protected" "hidden" "internal" "\t.%s\t%s\n" "\t.%s\t.%s\n"


<s>
SDValue
XCoreTargetLowering
::
LowerReturn
(
SDValue
Chain
,
unsigned
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
DebugLoc
dl
,
SelectionDAG
&
DAG
)
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
getTargetMachine
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_XCore
)
;
if
(
DAG
.
getMachineFunction
(
)
.
getRegInfo
(
)
.
liveout_empty
(
)
)
{
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
if
(
RVLocs
[
i
]
.
isRegLoc
(
)
)
DAG
.
getMachineFunction
(
)
.
getRegInfo
(
)
.
addLiveOut
(
RVLocs
[
i
]
.
getLocReg
(
)
)
;
}
SDValue
Flag
;
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
Outs
[
i
]
.
Val
,
Flag
)
;
Flag
=
Chain
.
getValue
(
1
)
;
}
if
(
Flag
.
getNode
(
)
)
return
DAG
.
getNode
(
XCoreISD
::
RETSP
,
dl
,
MVT
::
Other
,
Chain
,
DAG
.
getConstant
(
0
,
MVT
::
i32
)
,
Flag
)
;
else
return
DAG
.
getNode
(
XCoreISD
::
RETSP
,
dl
,
MVT
::
Other
,
Chain
,
DAG
.
getConstant
(
0
,
MVT
::
i32
)
)
;
}
</s>

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


<s> void assignValueToAddress ( unsigned ValVReg , unsigned Addr , uint64_t Size , MachinePointerInfo & MPO , CCValAssign & VA ) override { auto MMO = MIRBuilder . getMF ( ) . getMachineMemOperand ( MPO , MachineMemOperand :: MOStore , Size , 0 ) ; MIRBuilder . buildStore ( ValVReg , Addr , * MMO ) ; } </s>

An overload which takes an ArgInfo if additional information about the arg is needed .


<s>
static
void
rs6000_xcoff_output_toc_section_asm_op
(
const
void
*
data
ATTRIBUTE_UNUSED
)
{
if
(
TARGET_MINIMAL_TOC
)
{
if
(
!
toc_initialized
)
{
fputs
(
"\t.toc\nLCTOC..1:\n"
,
asm_out_file
)
;
fputs
(
"\t.tc toc_table[TC],toc_table[RW]\n"
,
asm_out_file
)
;
toc_initialized
=
1
;
}
fprintf
(
asm_out_file
,
"\t.csect toc_table[RW]%s\n"
,
(
TARGET_32BIT
""
:
",3"
)
)
;
}
else
fputs
(
"\t.toc\n"
,
asm_out_file
)
;
}
</s>

A get_unnamed_section callback , used for switching to toc_section .


<s> bool PatmosAsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count ) const { if ( ( Count % 4 ) != 0 ) return false ; for ( uint64_t i = 0 ; i < Count ; i += 4 ) support :: endian :: write < uint32_t > ( OS , 0x00400000 , Endian ) ; return true ; } </s>

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


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


<s> static bool rs6000_member_type_forces_blk ( const_tree field , machine_mode mode ) { return ( ( TARGET_SPE && TREE_CODE ( TREE_TYPE ( field ) ) == VECTOR_TYPE ) || ( TARGET_E500_DOUBLE && mode == DFmode ) ) ; } </s>

Return true if a structure , union or array containing FIELD should be accessed using ` BLKMODE ' . For the SPE , simd types are V2SI , and gcc can be tempted to put the entire thing in a DI and use subregs to access the internals . store_bit_field ( ) will force ( subreg : DI ( reg : V2SI x ) ) 's to the back-end . Because a single GPR can hold a V2SI , but not a DI , the best thing to do is set structs to BLKmode and avoid Severe Tire Damage . On e500 v2 , DF and DI modes suffer from the same anomaly . DF can fit into 1 , whereas DI still needs two .


<s>
bool
AArch64AddressTypePromotion
::
runOnFunction
(
Function
&
F
)
{
if
(
!
EnableAddressTypePromotion
||
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> 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> bool riscv_split_64bit_move_p ( rtx dest , rtx src ) { if ( TARGET_64BIT ) return false ; if ( TARGET_DOUBLE_FLOAT && ( ( FP_REG_RTX_P ( src ) && FP_REG_RTX_P ( dest ) ) || ( FP_REG_RTX_P ( dest ) && MEM_P ( src ) ) || ( FP_REG_RTX_P ( src ) && MEM_P ( dest ) ) || ( FP_REG_RTX_P ( dest ) && src == CONST0_RTX ( GET_MODE ( src ) ) ) ) ) return false ; return true ; } </s>

Return true if a 64-bit move from SRC to DEST should be split into two .


<s> void SIMachineFunctionInfo :: removeDeadFrameIndices ( MachineFrameInfo & MFI ) { for ( auto & R : SGPRToVGPRSpills ) { if ( R . first != FramePointerSaveIndex && R . first != BasePointerSaveIndex ) MFI . RemoveStackObject ( R . first ) ; } for ( int i = MFI . getObjectIndexBegin ( ) , e = MFI . getObjectIndexEnd ( ) ; i != e ; ++ i ) if ( i != FramePointerSaveIndex && i != BasePointerSaveIndex ) MFI . setStackID ( i , TargetStackID :: Default ) ; for ( auto & R : VGPRToAGPRSpills ) { if ( R . second . FullyAllocated ) MFI . RemoveStackObject ( R . first ) ; } } </s>

If ResetSGPRSpillStackIDs is true , reset the stack ID from sgpr-spill to the default stack .


<s> static void mt_setup_incoming_varargs ( CUMULATIVE_ARGS * cum , enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_size , int no_rtl ) { int regno ; int regs = MT_NUM_ARG_REGS - * cum ; * pretend_size = regs < 0 ? 0 : GET_MODE_SIZE ( SImode ) * regs ; if ( no_rtl ) return ; for ( regno = * cum ; regno < MT_NUM_ARG_REGS ; regno ++ ) { rtx reg = gen_rtx_REG ( SImode , FIRST_ARG_REGNUM + regno ) ; rtx slot = gen_rtx_PLUS ( Pmode , gen_rtx_REG ( SImode , ARG_POINTER_REGNUM ) , GEN_INT ( UNITS_PER_WORD * regno ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , slot ) , reg ) ; } } </s>

Do what is necessary for ` va_start ' . We look at the current function to determine if stdarg or varargs is used and return the address of the first unnamed parameter .


<s> void aarch64_expand_compare_and_swap ( rtx operands [ ] ) { rtx bval , rval , mem , oldval , newval , is_weak , mod_s , mod_f , x , cc_reg ; machine_mode mode , r_mode ; bval = operands [ 0 ] ; rval = operands [ 1 ] ; mem = operands [ 2 ] ; oldval = operands [ 3 ] ; newval = operands [ 4 ] ; is_weak = operands [ 5 ] ; mod_s = operands [ 6 ] ; mod_f = operands [ 7 ] ; mode = GET_MODE ( mem ) ; if ( is_mm_acquire ( memmodel_from_int ( INTVAL ( mod_f ) ) ) && is_mm_release ( memmodel_from_int ( INTVAL ( mod_s ) ) ) ) mod_s = GEN_INT ( MEMMODEL_ACQ_REL ) ; r_mode = mode ; if ( mode == QImode || mode == HImode ) { r_mode = SImode ; rval = gen_reg_rtx ( r_mode ) ; } if ( TARGET_LSE ) { if ( reg_overlap_mentioned_p ( rval , oldval ) ) rval = copy_to_mode_reg ( r_mode , oldval ) ; else emit_move_insn ( rval , gen_lowpart ( r_mode , oldval ) ) ; emit_insn ( gen_aarch64_compare_and_swap_lse ( mode , rval , mem , newval , mod_s ) ) ; cc_reg = aarch64_gen_compare_reg_maybe_ze ( NE , rval , oldval , mode ) ; } else if ( TARGET_OUTLINE_ATOMICS ) { if ( ! aarch64_plus_operand ( oldval , mode ) ) oldval = force_reg ( mode , oldval ) ; rtx func = aarch64_atomic_ool_func ( mode , mod_s , & aarch64_ool_cas_names ) ; rval = emit_library_call_value ( func , NULL_RTX , LCT_NORMAL , r_mode , oldval , mode , newval , mode , XEXP ( mem , 0 ) , Pmode ) ; cc_reg = aarch64_gen_compare_reg_maybe_ze ( NE , rval , oldval , mode ) ; } else { insn_code code = code_for_aarch64_compare_and_swap ( mode ) ; if ( ! insn_data [ code ] . operand [ 2 ] . predicate ( oldval , mode ) ) oldval = force_reg ( mode , oldval ) ; emit_insn ( GEN_FCN ( code ) ( rval , mem , oldval , newval , is_weak , mod_s , mod_f ) ) ; cc_reg = gen_rtx_REG ( CCmode , CC_REGNUM ) ; } if ( r_mode != mode ) rval = gen_lowpart ( mode , rval ) ; emit_move_insn ( operands [ 1 ] , rval ) ; x = gen_rtx_EQ ( SImode , cc_reg , const0_rtx ) ; emit_insn ( gen_rtx_SET ( bval , x ) ) ; } </s>


"failed to spill SGPR to VGPR when allocated"

runOnMachineFunction - Emit the function body .


<s>
MachineBasicBlock
::
iterator
AAPFrameLowering
::
eliminateCallFramePseudoInstr
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
)
const
{
assert
(
!
hasFP
(
MF
)
&&
"Frame pointer unsupported!"
)
;
return
MBB
.
erase
(
I
)
;
}
</s>

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


<s> static void mips_legitimize_const_move ( machine_mode mode , rtx dest , rtx src ) { rtx base , offset ; if ( splittable_const_int_operand ( src , mode ) ) { mips_move_integer ( dest , dest , INTVAL ( src ) ) ; return ; } if ( mips_split_symbol ( dest , src , MAX_MACHINE_MODE , & src ) ) { emit_insn ( gen_rtx_SET ( dest , src ) ) ; return ; } if ( mips_tls_symbol_p ( src ) ) { mips_emit_move ( dest , mips_legitimize_tls_address ( src ) ) ; return ; } split_const ( src , & base , & offset ) ; if ( offset != const0_rtx && ( targetm . cannot_force_const_mem ( mode , src ) || ( ! TARGET_MIPS16 && can_create_pseudo_p ( ) ) ) ) { base = mips_force_temporary ( dest , base ) ; mips_emit_move ( dest , mips_add_offset ( NULL , base , INTVAL ( offset ) ) ) ; return ; } src = force_const_mem ( mode , src ) ; mips_split_symbol ( dest , XEXP ( src , 0 ) , mode , & XEXP ( src , 0 ) ) ; mips_emit_move ( dest , src ) ; } </s>

Subroutine of mips_legitimize_move . Move constant SRC into register DEST given that SRC satisfies immediate_operand but does n't satisfy move_operand .


<s>
SDValue
BlackfinTargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
const
SmallVectorImpl
<
SDValue
>
&
OutVals
,
DebugLoc
dl
,
SelectionDAG
&
DAG
)
const
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
DAG
.
getMachineFunction
(
)
,
DAG
.
getTarget
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_Blackfin
)
;
if
(
DAG
.
getMachineFunction
(
)
.
getRegInfo
(
)
.
liveout_empty
(
)
)
{
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
DAG
.
getMachineFunction
(
)
.
getRegInfo
(
)
.
addLiveOut
(
RVLocs
[
i
]
.
getLocReg
(
)
)
;
}
SDValue
Flag
;
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
SDValue
Opi
=
OutVals
[
i
]
;
switch
(
VA
.
getLocInfo
(
)
)
{
default
:
llvm_unreachable
(
"Unknown loc info!"
)
;
case
CCValAssign
::
Full
:
break
;
case
CCValAssign
::
SExt
:
Opi
=
DAG
.
getNode
(
ISD
::
SIGN_EXTEND
,
dl
,
VA
.
getLocVT
(
)
,
Opi
)
;
break
;
case
CCValAssign
::
ZExt
:
Opi
=
DAG
.
getNode
(
ISD
::
ZERO_EXTEND
,
dl
,
VA
.
getLocVT
(
)
,
Opi
)
;
break
;
case
CCValAssign
::
AExt
:
Opi
=
DAG
.
getNode
(
ISD
::
ANY_EXTEND
,
dl
,
VA
.
getLocVT
(
)
,
Opi
)
;
break
;
}
Chain
=
DAG
.
getCopyToReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
Opi
,
SDValue
(
)
)
;
Flag
=
Chain
.
getValue
(
1
)
;
}
if
(
Flag
.
getNode
(
)
)
{
return
DAG
.
getNode
(
BFISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
Chain
,
Flag
)
;
}
else
{
return
DAG
.
getNode
(
BFISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
Chain
)
;
}
}
</s>


<s>
void
print
(
)
{
if
(
numSymbols
==
0
)
{
for
(
unsigned
i
=
0
;
i
<
size
;
i
++
)
{
if
(
i
)
O
<<
", "
;
O
<<
(
unsigned
int
)
buffer
[
i
]
;
}
}
else
{
unsigned
int
pos
=
0
;
unsigned
int
nSym
=
0
;
unsigned
int
nextSymbolPos
=
symbolPosInBuffer
[
nSym
]
;
unsigned
int
nBytes
=
4
;
if
(
AP
.
nvptxSubtarget
.
is64Bit
(
)
)
nBytes
=
8
;
for
(
pos
=
0
;
pos
<
size
;
pos
+=
nBytes
)
{
if
(
pos
)
O
<<
", "
;
if
(
pos
==
nextSymbolPos
)
{
const
Value
*
v
=
Symbols
[
nSym
]
;
if
(
const
GlobalValue
*
GVar
=
dyn_cast
<
GlobalValue
>
(
v
)
)
{
MCSymbol
*
Name
=
AP
.
getSymbol
(
GVar
)
;
O
<<
*
Name
;
}
else
if
(
const
ConstantExpr
*
Cexpr
=
dyn_cast
<
ConstantExpr
>
(
v
)
)
{
O
<<
*
nvptx
::
LowerConstant
(
Cexpr
,
AP
)
;
}
else
llvm_unreachable
(
"symbol type unknown"
)
;
nSym
++
;
if
(
nSym
>=
numSymbols
)
nextSymbolPos
=
size
+
1
;
else
nextSymbolPos
=
symbolPosInBuffer
[
nSym
]
;
}
else
if
(
nBytes
==
4
)
O
<<
*
(
unsigned
int
*
)
(
buffer
+
pos
)
;
else
O
<<
*
(
unsigned
long
long
*
)
(
buffer
+
pos
)
;
}
}
}
</s>

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


<s> bool ARMInstrInfo :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI ) const { MachineFunction & MF = * MBB . getParent ( ) ; ARMFunctionInfo * AFI = MF . getInfo < ARMFunctionInfo > ( ) ; if ( ! AFI -> isThumbFunction ( ) || CSI . empty ( ) ) return false ; DebugLoc DL = DebugLoc :: getUnknownLoc ( ) ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineInstrBuilder MIB = BuildMI ( MBB , MI , DL , get ( ARM :: tPUSH ) ) ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; MBB . addLiveIn ( Reg ) ; MIB . addReg ( Reg , RegState :: Kill ) ; } return true ; } </s>

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


<s> bool AArch64AsmBackend :: writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { if ( ( Count & 3 ) != 0 ) { for ( uint64_t i = 0 , e = ( Count & 3 ) ; i != e ; ++ i ) OW -> Write8 ( 0 ) ; } Count /= 4 ; for ( uint64_t i = 0 ; i != Count ; ++ i ) OW -> Write32 ( 0xd503201f ) ; return true ; } </s>


<s> void ix86_emit_swdivsf ( rtx res , rtx a , rtx b , machine_mode mode ) { rtx x0 , x1 , e0 , e1 ; x0 = gen_reg_rtx ( mode ) ; e0 = gen_reg_rtx ( mode ) ; e1 = gen_reg_rtx ( mode ) ; x1 = gen_reg_rtx ( mode ) ; b = force_reg ( mode , b ) ; if ( mode == V16SFmode || mode == V8DFmode ) emit_insn ( gen_rtx_SET ( VOIDmode , x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , b ) , UNSPEC_RCP14 ) ) ) ; else emit_insn ( gen_rtx_SET ( VOIDmode , x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , b ) , UNSPEC_RCP ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , e0 , gen_rtx_MULT ( mode , x0 , b ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , e0 , gen_rtx_MULT ( mode , x0 , e0 ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , e1 , gen_rtx_PLUS ( mode , x0 , x0 ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , x1 , gen_rtx_MINUS ( mode , e1 , e0 ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , res , gen_rtx_MULT ( mode , a , x1 ) ) ) ; } </s>


<s> void SIScheduleBlockScheduler :: addLiveRegs ( std :: set < unsigned > & Regs ) { for ( Register Reg : Regs ) { if ( ! Reg . isVirtual ( ) ) continue ; ( void ) LiveRegs . insert ( Reg ) ; } } </s>

Force liveness of virtual registers or physical register units .


"stack re-alignment, but LLVM couldn't handle it "

"(probably because it has a dynamic alloca)."

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


<s> static void visium_trampoline_init ( rtx m_tramp , tree fndecl , rtx static_chain ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; rtx addr = XEXP ( m_tramp , 0 ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , addr , 0 ) ) , plus_constant ( SImode , expand_shift ( RSHIFT_EXPR , SImode , fnaddr , 16 , NULL_RTX , 1 ) , 0x04a90000 ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , addr , 4 ) ) , plus_constant ( SImode , expand_and ( SImode , fnaddr , GEN_INT ( 0xffff ) , NULL_RTX ) , 0x04890000 ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , addr , 8 ) ) , plus_constant ( SImode , expand_shift ( RSHIFT_EXPR , SImode , static_chain , 16 , NULL_RTX , 1 ) , 0x04b40000 ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , addr , 12 ) ) , gen_int_mode ( 0xff892404 , SImode ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , addr , 16 ) ) , plus_constant ( SImode , expand_and ( SImode , static_chain , GEN_INT ( 0xffff ) , NULL_RTX ) , 0x04940000 ) ) ; emit_library_call ( set_trampoline_parity_libfunc , LCT_NORMAL , VOIDmode , addr , SImode ) ; } </s>

Initialize a trampoline . M_TRAMP is an RTX for the memory block for the trampoline , FNDECL is the FUNCTION_DECL for the nested function and STATIC_CHAIN is an RTX for the static chain value that should be passed to the function when it is called .


<s>
void
AAPInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
const
DebugLoc
&
DL
,
unsigned
DestReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
assert
(
AAP
::
GR64RegClass
.
contains
(
DestReg
)
&&
AAP
::
GR64RegClass
.
contains
(
DestReg
)
&&
"Impossible register-register copy"
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
AAP
::
MOV_r
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
</s>


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


<s> RV16KSubtarget & RV16KSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = CPU ; if ( CPUName . empty ( ) ) CPUName = "generic-rv16k" ; ParseSubtargetFeatures ( CPUName , FS ) ; return * this ; } </s>

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


<s>
SDValue
FISCTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Unimplemented operand"
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
LowerSelectCC
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .

FISC
FISC
"Unimplemented operand"
ISD::GlobalAddress
ISD::SELECT_CC
ISD::VASTART


<s> const char * RISCVTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( ( RISCVISD :: NodeType ) Opcode ) { case RISCVISD :: FIRST_NUMBER : break ; case RISCVISD :: RET_FLAG : return "RISCVISD::RET_FLAG" ; case RISCVISD :: CALL : return "RISCVISD::CALL" ; case RISCVISD :: SELECT_CC : return "RISCVISD::SELECT_CC" ; case RISCVISD :: BuildPairF64 : return "RISCVISD::BuildPairF64" ; case RISCVISD :: SplitF64 : return "RISCVISD::SplitF64" ; } return nullptr ; } </s>

getTargetNodeName - This method returns the name of a target specific


<s> static void riscv_print_operand_reloc ( FILE * file , rtx op , bool hi_reloc ) { const char * reloc ; switch ( riscv_classify_symbolic_expression ( op ) ) { case SYMBOL_ABSOLUTE : reloc = hi_reloc ? "%hi" : "%lo" ; break ; case SYMBOL_PCREL : reloc = hi_reloc ? "%pcrel_hi" : "%pcrel_lo" ; break ; case SYMBOL_TLS_LE : reloc = hi_reloc ? "%tprel_hi" : "%tprel_lo" ; break ; default : gcc_unreachable ( ) ; } fprintf ( file , "%s(" , reloc ) ; output_addr_const ( file , riscv_strip_unspec_address ( op ) ) ; fputc ( ')' , file ) ; } </s>

Print symbolic operand OP , which is part of a HIGH or LO_SUM in context CONTEXT . HI_RELOC indicates a high-part reloc .


<s>
static
uint16_t
name
(
struct
InternalInstruction
*
insn
,
\
OperandType
type
,
\
uint8_t
index
,
\
uint8_t
*
valid
)
{
\
*
valid
=
1
;
\
switch
(
type
)
{
\
default
:
\
debug
(
"Unhandled register type"
)
;
\
*
valid
=
0
;
\
return
0
;
\
case
TYPE_Rv
:
\
return
base
+
index
;
\
case
TYPE_R8
:
\
if
(
insn
->
rexPrefix
&&
\
index
>=
4
&&
index
<=
7
)
{
\
return
prefix
##
_SPL
+
(
index
4
)
;
\
}
else
{
\
return
prefix
##
_AL
+
index
;
\
}
\
case
TYPE_R16
:
\
return
prefix
##
_AX
+
index
;
\
case
TYPE_R32
:
\
return
prefix
##
_EAX
+
index
;
\
case
TYPE_R64
:
\
return
prefix
##
_RAX
+
index
;
\
case
TYPE_XMM512
:
\
return
prefix
##
_ZMM0
+
index
;
\
case
TYPE_XMM256
:
\
return
prefix
##
_YMM0
+
index
;
\
case
TYPE_XMM128
:
\
case
TYPE_XMM64
:
\
case
TYPE_XMM32
:
\
return
prefix
##
_XMM0
+
index
;
\
case
TYPE_VK1
:
\
case
TYPE_VK2
:
\
case
TYPE_VK4
:
\
case
TYPE_VK8
:
\
case
TYPE_VK16
:
\
case
TYPE_VK32
:
\
case
TYPE_VK64
:
\
if
(
index
>
7
)
\
*
valid
=
0
;
\
return
prefix
##
_K0
+
index
;
\
case
TYPE_MM64
:
\
return
prefix
##
_MM0
+
(
index
&
0x7
)
;
\
case
TYPE_SEGMENTREG
:
\
if
(
index
>
5
)
\
*
valid
=
0
;
\
return
prefix
##
_ES
+
index
;
\
case
TYPE_DEBUGREG
:
\
return
prefix
##
_DR0
+
index
;
\
case
TYPE_CONTROLREG
:
\
return
prefix
##
_CR0
+
index
;
\
case
TYPE_BNDR
:
\
if
(
index
>
3
)
\
*
valid
=
0
;
\
return
prefix
##
_BND0
+
index
;
\
}
\
}
</s>

Gets the name of the pass we are mixed into .


"WebAssembly doesn't support non-C calling conventions"

"WebAssembly doesn't support tail call yet"

"WebAssembly doesn't support patch point yet"

"WebAssembly doesn't support struct return yet"

"WebAssembly doesn't support more than 1 returned value yet"

"WebAssembly doesn't support varargs yet"

This hook must be implemented to lower calls into the specified DAG .


<s> bool X86CallLowering :: lowerReturn ( MachineIRBuilder & MIRBuilder , const Value * Val , unsigned VReg ) const { if ( Val ) return false ; ( void ) RetCC_X86 ; MIRBuilder . buildInstr ( X86 :: RET ) . addImm ( 0 ) ; return true ; } </s>

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


<s> RegisterBankInfo :: InstructionMapping AMDGPURegisterBankInfo :: getInstrMapping ( const MachineInstr & MI ) const { RegisterBankInfo :: InstructionMapping Mapping = getInstrMappingImpl ( MI ) ; if ( Mapping . isValid ( ) ) return Mapping ; const MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; const MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; Mapping = InstructionMapping { 1 , 1 , nullptr , MI . getNumOperands ( ) } ; SmallVector < const ValueMapping * , 8 > OpdsMapping ( MI . getNumOperands ( ) ) ; switch ( MI . getOpcode ( ) ) { default : break ; case AMDGPU :: G_CONSTANT : { unsigned Size = MRI . getType ( MI . getOperand ( 0 ) . getReg ( ) ) . getSizeInBits ( ) ; OpdsMapping [ 0 ] = AMDGPU :: getValueMapping ( AMDGPU :: SGPRRegBankID , Size ) ; Mapping . setOperandsMapping ( getOperandsMapping ( OpdsMapping ) ) ; return Mapping ; } case AMDGPU :: G_GEP : { for ( unsigned i = 0 , e = MI . getNumOperands ( ) ; i != e ; ++ i ) { if ( ! MI . getOperand ( i ) . isReg ( ) ) continue ; unsigned Size = MRI . getType ( MI . getOperand ( i ) . getReg ( ) ) . getSizeInBits ( ) ; OpdsMapping [ i ] = AMDGPU :: getValueMapping ( AMDGPU :: SGPRRegBankID , Size ) ; } Mapping . setOperandsMapping ( getOperandsMapping ( OpdsMapping ) ) ; return Mapping ; } case AMDGPU :: G_STORE : { assert ( MI . getOperand ( 0 ) . isReg ( ) ) ; unsigned Size = MRI . getType ( MI . getOperand ( 0 ) . getReg ( ) ) . getSizeInBits ( ) ; const ValueMapping * ValMapping = AMDGPU :: getValueMapping ( AMDGPU :: VGPRRegBankID , Size ) ; const ValueMapping * PtrMapping = AMDGPU :: getValueMapping ( AMDGPU :: VGPRRegBankID , 64 ) ; OpdsMapping [ 0 ] = ValMapping ; OpdsMapping [ 1 ] = PtrMapping ; Mapping . setOperandsMapping ( getOperandsMapping ( OpdsMapping ) ) ; return Mapping ; } case AMDGPU :: G_LOAD : return getInstrMappingForLoad ( MI ) ; } unsigned BankID = AMDGPU :: SGPRRegBankID ; Mapping = InstructionMapping { 1 , 1 , nullptr , MI . getNumOperands ( ) } ; unsigned Size = 0 ; for ( unsigned Idx = 0 ; Idx < MI . getNumOperands ( ) ; ++ Idx ) { if ( MI . getOperand ( Idx ) . isReg ( ) ) Size = getSizeInBits ( MI . getOperand ( Idx ) . getReg ( ) , MRI , * TRI ) ; OpdsMapping . push_back ( AMDGPU :: getValueMapping ( BankID , Size ) ) ; } Mapping . setOperandsMapping ( getOperandsMapping ( OpdsMapping ) ) ; return Mapping ; } </s>

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


<s>
CCAssignFn
*
AArch64TargetLowering
::
CCAssignFnForCall
(
CallingConv
::
ID
CC
,
bool
IsVarArg
)
const
{
switch
(
CC
)
{
default
:
llvm_unreachable
(
"Unsupported calling convention."
)
;
case
CallingConv
::
WebKit_JS
:
return
CC_AArch64_WebKit_JS
;
case
CallingConv
::
GHC
:
return
CC_AArch64_GHC
;
case
CallingConv
::
C
:
case
CallingConv
::
Fast
:
case
CallingConv
::
PreserveMost
:
case
CallingConv
::
CXX_FAST_TLS
:
case
CallingConv
::
Swift
:
if
(
Subtarget
->
isTargetWindows
(
)
&&
IsVarArg
)
return
CC_AArch64_Win64_VarArg
;
if
(
!
Subtarget
->
isTargetDarwin
(
)
)
return
CC_AArch64_AAPCS
;
return
IsVarArg
CC_AArch64_DarwinPCS_VarArg
:
CC_AArch64_DarwinPCS
;
case
CallingConv
::
Win64
:
return
IsVarArg
CC_AArch64_Win64_VarArg
:
CC_AArch64_AAPCS
;
}
}
</s>

Selects the correct CCAssignFn for a given CallingConvention value .


<s> static void pop ( int rn ) { rtx x , sp_reg , reg ; if ( rn == FPUL_REG ) x = gen_pop_fpul ( ) ; else if ( rn == FPSCR_REG ) x = gen_pop_fpscr ( ) ; else if ( ( TARGET_SH4 || TARGET_SH2A_DOUBLE ) && TARGET_FMOVD && ! TARGET_FPU_SINGLE && FP_OR_XD_REGISTER_P ( rn ) ) { if ( FP_REGISTER_P ( rn ) && ( rn - FIRST_FP_REG ) & 1 ) return ; x = gen_pop_4 ( gen_rtx_REG ( DFmode , rn ) ) ; } else if ( TARGET_SH2E && FP_REGISTER_P ( rn ) ) x = gen_pop_e ( gen_rtx_REG ( SFmode , rn ) ) ; else x = gen_pop ( gen_rtx_REG ( SImode , rn ) ) ; x = emit_insn ( x ) ; sp_reg = gen_rtx_REG ( SImode , STACK_POINTER_REGNUM ) ; reg = copy_rtx ( GET_CODE ( PATTERN ( x ) ) == PARALLEL ? SET_DEST ( XVECEXP ( PATTERN ( x ) , 0 , 0 ) ) : SET_DEST ( PATTERN ( x ) ) ) ; add_reg_note ( x , REG_CFA_RESTORE , reg ) ; add_reg_note ( x , REG_CFA_ADJUST_CFA , gen_rtx_SET ( SImode , sp_reg , plus_constant ( SImode , sp_reg , GET_MODE_SIZE ( GET_MODE ( reg ) ) ) ) ) ; add_reg_note ( x , REG_INC , gen_rtx_REG ( SImode , STACK_POINTER_REGNUM ) ) ; RTX_FRAME_RELATED_P ( x ) = 1 ; } </s>

Output RTL to pop register RN from the stack .


<s> static void c6x_asm_init_sections ( void ) { exception_section = get_unnamed_section ( 0 , output_section_asm_op , "\t.handlerdata" ) ; } </s>

Use a special assembly directive rather than a regular setion for unwind table data .


<s> bool HexagonInstrInfo :: analyzeCompare ( const MachineInstr & MI , unsigned & SrcReg , unsigned & SrcReg2 , int & Mask , int & Value ) const { unsigned Opc = MI . getOpcode ( ) ; switch ( Opc ) { case Hexagon :: C2_cmpeq : case Hexagon :: C2_cmpeqp : case Hexagon :: C2_cmpgt : case Hexagon :: C2_cmpgtp : case Hexagon :: C2_cmpgtu : case Hexagon :: C2_cmpgtup : case Hexagon :: C4_cmpneq : case Hexagon :: C4_cmplte : case Hexagon :: C4_cmplteu : case Hexagon :: C2_cmpeqi : case Hexagon :: C2_cmpgti : case Hexagon :: C2_cmpgtui : case Hexagon :: C4_cmpneqi : case Hexagon :: C4_cmplteui : case Hexagon :: C4_cmpltei : SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; Mask = ~ 0 ; break ; case Hexagon :: A4_cmpbeq : case Hexagon :: A4_cmpbgt : case Hexagon :: A4_cmpbgtu : case Hexagon :: A4_cmpbeqi : case Hexagon :: A4_cmpbgti : case Hexagon :: A4_cmpbgtui : SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; Mask = 0xFF ; break ; case Hexagon :: A4_cmpheq : case Hexagon :: A4_cmphgt : case Hexagon :: A4_cmphgtu : case Hexagon :: A4_cmpheqi : case Hexagon :: A4_cmphgti : case Hexagon :: A4_cmphgtui : SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; Mask = 0xFFFF ; break ; } switch ( Opc ) { case Hexagon :: C2_cmpeq : case Hexagon :: C2_cmpeqp : case Hexagon :: C2_cmpgt : case Hexagon :: C2_cmpgtp : case Hexagon :: C2_cmpgtu : case Hexagon :: C2_cmpgtup : case Hexagon :: A4_cmpbeq : case Hexagon :: A4_cmpbgt : case Hexagon :: A4_cmpbgtu : case Hexagon :: A4_cmpheq : case Hexagon :: A4_cmphgt : case Hexagon :: A4_cmphgtu : case Hexagon :: C4_cmpneq : case Hexagon :: C4_cmplte : case Hexagon :: C4_cmplteu : SrcReg2 = MI . getOperand ( 2 ) . getReg ( ) ; return true ; case Hexagon :: C2_cmpeqi : case Hexagon :: C2_cmpgtui : case Hexagon :: C2_cmpgti : case Hexagon :: C4_cmpneqi : case Hexagon :: C4_cmplteui : case Hexagon :: C4_cmpltei : case Hexagon :: A4_cmpbeqi : case Hexagon :: A4_cmpbgti : case Hexagon :: A4_cmpbgtui : case Hexagon :: A4_cmpheqi : case Hexagon :: A4_cmphgti : case Hexagon :: A4_cmphgtui : { SrcReg2 = 0 ; const MachineOperand & Op2 = MI . getOperand ( 2 ) ; if ( ! Op2 . isImm ( ) ) return false ; Value = MI . getOperand ( 2 ) . getImm ( ) ; return true ; } } return false ; } </s>

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


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


"custom\t%d, zero, %%1, %%D1 # fwrx %%1\n\t"

"\n\tcustom\t%d, %%0, zero, zero # frdy %%0"

Emit assembly of custom FPU instructions .


<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 ) , HasRAS ( 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 , CPUString ) ; 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 ) ; if ( ( TT . find ( "eabi" ) != std :: string :: npos ) || ( isTargetIOS ( ) && isMClass ( ) ) ) 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> const char * MBlazeTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { case MBlazeISD :: JmpLink : return "MBlazeISD::JmpLink" ; case MBlazeISD :: GPRel : return "MBlazeISD::GPRel" ; case MBlazeISD :: Wrap : return "MBlazeISD::Wrap" ; case MBlazeISD :: ICmp : return "MBlazeISD::ICmp" ; case MBlazeISD :: Ret : return "MBlazeISD::Ret" ; case MBlazeISD :: Select_CC : return "MBlazeISD::Select_CC" ; default : return NULL ; } } </s>

MBlaze MBlaze MBlazeISD::JmpLink "MBlazeISD::JmpLink" MBlazeISD::GPRel "MBlazeISD::GPRel" MBlazeISD::Wrap "MBlazeISD::Wrap" MBlazeISD::ICmp "MBlazeISD::ICmp" MBlazeISD::Ret "MBlazeISD::Ret" MBlazeISD::Select_CC "MBlazeISD::Select_CC"


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


<s> void SPIRVMCCodeEmitter :: encodeInstruction ( const MCInst & MI , raw_ostream & OS , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { auto Features = computeAvailableFeatures ( STI . getFeatureBits ( ) ) ; verifyInstructionPredicates ( MI , Features ) ; EndianWriter OSE ( OS , support :: little ) ; const uint64_t OpCode = getBinaryCodeForInstr ( MI , Fixups , STI ) ; const uint32_t NumWords = MI . getNumOperands ( ) + 1 ; const uint32_t FirstWord = ( NumWords << 16 ) | OpCode ; OSE . write < uint32_t > ( FirstWord ) ; if ( hasType ( MI , MCII ) ) emitTypedInstrOperands ( MI , OSE ) ; else emitUntypedInstrOperands ( MI , OSE ) ; } </s>

Encode the given Inst to bytes and append to CB .


<s> void aarch64_split_atomic_op ( enum rtx_code code , rtx old_out , rtx new_out , rtx mem , rtx value , rtx model_rtx , rtx cond ) { gcc_assert ( epilogue_completed ) ; machine_mode mode = GET_MODE ( mem ) ; machine_mode wmode = ( mode == DImode ? DImode : SImode ) ; const enum memmodel model = memmodel_from_int ( INTVAL ( model_rtx ) ) ; const bool is_sync = is_mm_sync ( model ) ; rtx_code_label * label ; rtx x ; label = gen_label_rtx ( ) ; emit_label ( label ) ; if ( new_out ) new_out = gen_lowpart ( wmode , new_out ) ; if ( old_out ) old_out = gen_lowpart ( wmode , old_out ) ; else old_out = new_out ; value = simplify_gen_subreg ( wmode , value , mode , 0 ) ; if ( is_sync ) aarch64_emit_load_exclusive ( mode , old_out , mem , GEN_INT ( MEMMODEL_RELAXED ) ) ; else aarch64_emit_load_exclusive ( mode , old_out , mem , model_rtx ) ; switch ( code ) { case SET : new_out = value ; break ; case NOT : x = gen_rtx_AND ( wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; x = gen_rtx_NOT ( wmode , new_out ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( value ) ) { value = GEN_INT ( - INTVAL ( value ) ) ; code = PLUS ; } default : x = gen_rtx_fmt_ee ( code , wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; break ; } aarch64_emit_store_exclusive ( mode , cond , mem , gen_lowpart ( mode , new_out ) , model_rtx ) ; if ( aarch64_track_speculation ) { rtx cc_reg = aarch64_gen_compare_reg ( NE , cond , const0_rtx ) ; x = gen_rtx_NE ( GET_MODE ( cc_reg ) , cc_reg , const0_rtx ) ; } else x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label ) , pc_rtx ) ; aarch64_emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ; if ( is_sync ) aarch64_emit_post_barrier ( model ) ; } </s>


<s> Register getGlobalBaseReg ( ) const { return GlobalBaseReg ; } </s>

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


<s> const TargetRegisterClass * SystemZRegisterInfo :: getCrossCopyRegClass ( const TargetRegisterClass * RC ) const { if ( RC == & SystemZ :: CCRRegClass ) return & SystemZ :: GR32BitRegClass ; return RC ; } </s>

getCrossCopyRegClass - Returns a legal register class to copy a register in the specified class to or from .

SystemZ SystemZ SystemZ::CCRRegClass SystemZ::GR32BitRegClass


<s> bool AMDGPUPassConfig :: addPreISel ( ) { const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; addPass ( createFlattenCFGPass ( ) ) ; if ( ST . IsIRStructurizerEnabled ( ) || ST . getGeneration ( ) > AMDGPUSubtarget :: NORTHERN_ISLANDS ) addPass ( createStructurizeCFGPass ( ) ) ; if ( ST . getGeneration ( ) > AMDGPUSubtarget :: NORTHERN_ISLANDS ) { addPass ( createSinkingPass ( ) ) ; addPass ( createSITypeRewriter ( ) ) ; addPass ( createSIAnnotateControlFlowPass ( ) ) ; } else { addPass ( createR600TextureIntrinsicsReplacer ( ) ) ; } return false ; } </s>


<s> DFAPacketizer * Tile64InstrInfo :: CreateTargetScheduleState ( const TargetMachine * TM , const ScheduleDAG * DAG ) const { const InstrItineraryData * II = TM -> getInstrItineraryData ( ) ; return TM -> getSubtarget < Tile64GenSubtargetInfo > ( ) . createDFAPacketizer ( II ) ; } </s>

Create machine specific model for scheduling .


<s>
bool
NyuziAsmPrinter
::
PrintAsmMemoryOperand
(
const
MachineInstr
*
MI
,
unsigned
OpNum
,
unsigned
AsmVariant
,
const
char
*
ExtraCode
,
raw_ostream
&
O
)
{
const
MachineOperand
&
MO
=
MI
->
getOperand
(
OpNum
)
;
assert
(
MO
.
isReg
(
)
&&
"unexpected inline asm memory operand"
)
;
O
<<
"("
<<
NyuziInstPrinter
::
getRegisterName
(
MO
.
getReg
(
)
)
<<
")"
;
return
false
;
}
</s>

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

Nyuzi
Nyuzi
"unexpected inline asm memory operand"
"("
Nyuzi
")"


<s>
bool
HexagonInstrInfo
::
PredicateInstruction
(
MachineInstr
*
MI
,
const
SmallVectorImpl
<
MachineOperand
>
&
Cond
)
const
{
if
(
Cond
.
empty
(
)
||
isEndLoopN
(
Cond
[
0
]
.
getImm
(
)
)
)
{
DEBUG
(
dbgs
(
)
<<
"\nCannot predicate:"
;
MI
->
dump
(
)
;
)
;
return
false
;
}
int
Opc
=
MI
->
getOpcode
(
)
;
assert
(
isPredicable
(
MI
)
&&
"Expected predicable instruction"
)
;
bool
invertJump
=
predOpcodeHasNot
(
Cond
)
;
MachineBasicBlock
&
B
=
*
MI
->
getParent
(
)
;
DebugLoc
DL
=
MI
->
getDebugLoc
(
)
;
unsigned
PredOpc
=
getCondOpcode
(
Opc
,
invertJump
)
;
MachineInstrBuilder
T
=
BuildMI
(
B
,
MI
,
DL
,
get
(
PredOpc
)
)
;
unsigned
NOp
=
0
,
NumOps
=
MI
->
getNumOperands
(
)
;
while
(
NOp
<
NumOps
)
{
MachineOperand
&
Op
=
MI
->
getOperand
(
NOp
)
;
if
(
!
Op
.
isReg
(
)
||
!
Op
.
isDef
(
)
||
Op
.
isImplicit
(
)
)
break
;
T
.
addOperand
(
Op
)
;
NOp
++
;
}
unsigned
PredReg
,
PredRegPos
,
PredRegFlags
;
bool
GotPredReg
=
getPredReg
(
Cond
,
PredReg
,
PredRegPos
,
PredRegFlags
)
;
(
void
)
GotPredReg
;
assert
(
GotPredReg
)
;
T
.
addReg
(
PredReg
,
PredRegFlags
)
;
while
(
NOp
<
NumOps
)
T
.
addOperand
(
MI
->
getOperand
(
NOp
++
)
)
;
MI
->
setDesc
(
get
(
PredOpc
)
)
;
while
(
unsigned
n
=
MI
->
getNumOperands
(
)
)
MI
->
RemoveOperand
(
n
1
)
;
for
(
unsigned
i
=
0
,
n
=
T
->
getNumOperands
(
)
;
i
<
n
;
++
i
)
MI
->
addOperand
(
T
->
getOperand
(
i
)
)
;
MachineBasicBlock
::
instr_iterator
TI
=
&
*
T
;
B
.
erase
(
TI
)
;
MachineRegisterInfo
&
MRI
=
B
.
getParent
(
)
->
getRegInfo
(
)
;
MRI
.
clearKillFlags
(
PredReg
)
;
return
true
;
}
</s>

Convert the instruction into a predicated instruction .


<s> const SparcSubtarget * SparcTargetMachine :: getSubtargetImpl ( const Function & F ) const { Attribute CPUAttr = F . getFnAttribute ( "target-cpu" ) ; Attribute FSAttr = F . getFnAttribute ( "target-features" ) ; std :: string CPU = ! CPUAttr . hasAttribute ( Attribute :: None ) ? CPUAttr . getValueAsString ( ) . str ( ) : TargetCPU ; std :: string FS = ! FSAttr . hasAttribute ( Attribute :: None ) ? FSAttr . getValueAsString ( ) . str ( ) : TargetFS ; bool softFloat = F . hasFnAttribute ( "use-soft-float" ) && F . getFnAttribute ( "use-soft-float" ) . getValueAsString ( ) == "true" ; if ( softFloat ) FS += FS . empty ( ) ? "+soft-float" : ",+soft-float" ; auto & I = SubtargetMap [ CPU + FS ] ; if ( ! I ) { resetTargetOptions ( F ) ; I = llvm :: make_unique < SparcSubtarget > ( TargetTriple , CPU , FS , * this , this -> is64Bit ) ; } return I . get ( ) ; } </s>

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

Sparc Sparc Sparc "target-cpu" "target-features" "use-soft-float" "use-soft-float" "true" "+soft-float" ",+soft-float" Sparc


<s>
bool
X86InsertPrefetch
::
doInitialization
(
Module
&
M
)
{
if
(
Filename
.
empty
(
)
)
return
false
;
LLVMContext
&
Ctx
=
M
.
getContext
(
)
;
ErrorOr
<
std
::
unique_ptr
<
SampleProfileReader
>>
ReaderOrErr
=
SampleProfileReader
::
create
(
Filename
,
Ctx
)
;
if
(
std
::
error_code
EC
=
ReaderOrErr
.
getError
(
)
)
{
std
::
string
Msg
=
"Could not open profile: "
+
EC
.
message
(
)
;
Ctx
.
diagnose
(
DiagnosticInfoSampleProfile
(
Filename
,
Msg
,
DiagnosticSeverity
::
DS_Warning
)
)
;
return
false
;
}
Reader
=
std
::
move
(
ReaderOrErr
.
get
(
)
)
;
Reader
->
read
(
)
;
return
true
;
}
</s>

Set up the AsmPrinter when we are working on a new module .


<s> MachineBasicBlock :: iterator X86InstrInfo :: insertOutlinedCall ( Module & M , MachineBasicBlock & MBB , MachineBasicBlock :: iterator & It , MachineFunction & MF , const outliner :: Candidate & C ) const { if ( C . CallConstructionID == MachineOutlinerTailCall ) { It = MBB . insert ( It , BuildMI ( MF , DebugLoc ( ) , get ( X86 :: TAILJMPd64 ) ) . addGlobalAddress ( M . getNamedValue ( MF . getName ( ) ) ) ) ; } else { It = MBB . insert ( It , BuildMI ( MF , DebugLoc ( ) , get ( X86 :: CALL64pcrel32 ) ) . addGlobalAddress ( M . getNamedValue ( MF . getName ( ) ) ) ) ; } return It ; } </s>

Insert a call to an outlined function into the program .


<s> const AArch64GNULDBackend & getTarget ( ) const { return m_Target ; } </s>

getTarget - Return the target machine this machine code is compiled with


<s> static void core2i7_dfa_post_advance_cycle ( void ) { ix86_first_cycle_multipass_data_t data = ix86_first_cycle_multipass_data ; gcc_assert ( data -> ifetch_block_n_insns <= core2i7_ifetch_block_max_insns ) ; data -> ifetch_block_len = 0 ; data -> ifetch_block_n_insns = 0 ; } </s>

Advancing the cycle ; reset ifetch block counts .


<s> static std :: unique_ptr < FISCOperand > CreateReg ( unsigned RegNum , SMLoc S , SMLoc E ) { auto Op = make_unique < FISCOperand > ( k_Register ) ; Op -> Reg . RegNum = RegNum ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>

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


<s> SDValue AArch64TargetLowering :: getRecipEstimate ( SDValue Operand , SelectionDAG & DAG , int Enabled , int & ExtraSteps ) const { if ( Enabled == ReciprocalEstimate :: Enabled ) if ( SDValue Estimate = getEstimate ( Subtarget , AArch64ISD :: FRECPE , Operand , DAG , ExtraSteps ) ) { SDLoc DL ( Operand ) ; EVT VT = Operand . getValueType ( ) ; SDNodeFlags Flags ; Flags . setAllowReassociation ( true ) ; for ( int i = ExtraSteps ; i > 0 ; -- i ) { SDValue Step = DAG . getNode ( AArch64ISD :: FRECPS , DL , VT , Operand , Estimate , Flags ) ; Estimate = DAG . getNode ( ISD :: FMUL , DL , VT , Estimate , Step , Flags ) ; } ExtraSteps = 0 ; return Estimate ; } return SDValue ( ) ; } </s>

Return a reciprocal estimate value for the input operand .


<s> static void cris_operand_lossage ( const char * msgid , rtx op ) { debug_rtx ( op ) ; output_operand_lossage ( "%s" , msgid ) ; } </s>

Emit an error message when we 're in an asm , and a fatal error for `` normal '' insns . Formatted output is n't easily implemented , since we use output_operand_lossage to output the actual message and handle the categorization of the error .


<s> SDValue AArch64SelectionDAGInfo :: EmitTargetCodeForMemset ( SelectionDAG & DAG , const SDLoc & dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , unsigned Align , bool isVolatile , MachinePointerInfo DstPtrInfo ) const { ConstantSDNode * V = dyn_cast < ConstantSDNode > ( Src ) ; ConstantSDNode * SizeValue = dyn_cast < ConstantSDNode > ( Size ) ; const AArch64Subtarget & STI = DAG . getMachineFunction ( ) . getSubtarget < AArch64Subtarget > ( ) ; const char * bzeroName = ( V && V -> isNullValue ( ) ) ? DAG . getTargetLoweringInfo ( ) . getLibcallName ( RTLIB :: BZERO ) : nullptr ; if ( bzeroName && ( ! SizeValue || SizeValue -> getZExtValue ( ) > 256 ) ) { const AArch64TargetLowering & TLI = * STI . getTargetLowering ( ) ; EVT IntPtr = TLI . getPointerTy ( DAG . getDataLayout ( ) ) ; Type * IntPtrTy = DAG . getDataLayout ( ) . getIntPtrType ( * DAG . getContext ( ) ) ; TargetLowering :: ArgListTy Args ; TargetLowering :: ArgListEntry Entry ; Entry . Node = Dst ; Entry . Ty = IntPtrTy ; Args . push_back ( Entry ) ; Entry . Node = Size ; Args . push_back ( Entry ) ; TargetLowering :: CallLoweringInfo CLI ( DAG ) ; CLI . setDebugLoc ( dl ) . setChain ( Chain ) . setLibCallee ( CallingConv :: C , Type :: getVoidTy ( * DAG . getContext ( ) ) , DAG . getExternalSymbol ( bzeroName , IntPtr ) , std :: move ( Args ) ) . setDiscardResult ( ) ; std :: pair < SDValue , SDValue > CallResult = TLI . LowerCallTo ( CLI ) ; return CallResult . second ; } return SDValue ( ) ; } </s>

Emit target-specific code that performs a memset .


<s>
virtual
void
print
(
raw_ostream
&
O
)
const
{
switch
(
Kind
)
{
case
k_Token
:
O
<<
"Token: \""
<<
getToken
(
)
<<
"\""
;
break
;
case
k_Register
:
O
<<
"Register: "
<<
getReg
(
)
;
break
;
case
k_Immediate
:
O
<<
"Immediate: \""
<<
*
getImm
(
)
<<
"\""
;
break
;
case
k_Memri
:
{
O
<<
"Memri: \""
<<
getReg
(
)
<<
'+'
<<
*
getImm
(
)
<<
"\""
;
break
;
}
}
O
<<
"\n"
;
}
</s>

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


<s> rtx ix86_build_const_vector ( machine_mode mode , bool vect , rtx value ) { int i , n_elt ; rtvec v ; machine_mode scalar_mode ; switch ( mode ) { case V64QImode : case V32QImode : case V16QImode : case V32HImode : case V16HImode : case V8HImode : case V16SImode : case V8SImode : case V4SImode : case V8DImode : case V4DImode : case V2DImode : gcc_assert ( vect ) ; case V16SFmode : case V8SFmode : case V4SFmode : case V8DFmode : case V4DFmode : case V2DFmode : n_elt = GET_MODE_NUNITS ( mode ) ; v = rtvec_alloc ( n_elt ) ; scalar_mode = GET_MODE_INNER ( mode ) ; RTVEC_ELT ( v , 0 ) = value ; for ( i = 1 ; i < n_elt ; ++ i ) RTVEC_ELT ( v , i ) = vect ? value : CONST0_RTX ( scalar_mode ) ; return gen_rtx_CONST_VECTOR ( mode , v ) ; default : gcc_unreachable ( ) ; } } </s>

A subroutine of ix86_build_signbit_mask . If VECT is true , then replicate the value for all elements of the vector register .


<s> static void epiphany_print_operand_address ( FILE * file , machine_mode , rtx addr ) { rtx base , index = 0 ; int offset = 0 ; switch ( GET_CODE ( addr ) ) { case REG : fputs ( reg_names [ REGNO ( addr ) ] , file ) ; break ; case SYMBOL_REF : if ( 0 && SYMBOL_REF_FUNCTION_P ( addr ) ) { output_addr_const ( file , addr ) ; } else { output_addr_const ( file , addr ) ; } break ; case PLUS : if ( GET_CODE ( XEXP ( addr , 0 ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , 0 ) ) , base = XEXP ( addr , 1 ) ; else if ( GET_CODE ( XEXP ( addr , 1 ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , 1 ) ) , base = XEXP ( addr , 0 ) ; else base = XEXP ( addr , 0 ) , index = XEXP ( addr , 1 ) ; gcc_assert ( GET_CODE ( base ) == REG ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ; if ( index == 0 ) { fprintf ( file , ",%s%d" , IMMEDIATE_PREFIX , offset / current_frame_info . stld_sz ) ; } else { switch ( GET_CODE ( index ) ) { case REG : fprintf ( file , ",%s" , reg_names [ REGNO ( index ) ] ) ; break ; case SYMBOL_REF : fputc ( ',' , file ) , output_addr_const ( file , index ) ; break ; default : gcc_unreachable ( ) ; } } break ; case PRE_INC : case PRE_DEC : case POST_INC : case POST_DEC : case POST_MODIFY : gcc_unreachable ( ) ; break ; default : output_addr_const ( file , addr ) ; break ; } } </s>

Print a memory address as an operand to reference that memory location .


<s> bool PPCFrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , ArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; const PPCInstrInfo & TII = * Subtarget . getInstrInfo ( ) ; PPCFunctionInfo * FI = MF -> getInfo < PPCFunctionInfo > ( ) ; bool MustSaveTOC = FI -> mustSaveTOC ( ) ; DebugLoc DL ; bool CRSpilled = false ; MachineInstrBuilder CRMIB ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; if ( Reg == PPC :: VRSAVE ) continue ; bool IsCRField = PPC :: CR2 <= Reg && Reg <= PPC :: CR4 ; const MachineRegisterInfo & MRI = MF -> getRegInfo ( ) ; bool IsLiveIn = MRI . isLiveIn ( Reg ) ; if ( ! IsLiveIn ) MBB . addLiveIn ( Reg ) ; if ( CRSpilled && IsCRField ) { CRMIB . addReg ( Reg , RegState :: ImplicitKill ) ; continue ; } if ( ( Reg == PPC :: X2 || Reg == PPC :: R2 ) && MustSaveTOC ) continue ; if ( IsCRField ) { PPCFunctionInfo * FuncInfo = MF -> getInfo < PPCFunctionInfo > ( ) ; if ( ! Subtarget . is32BitELFABI ( ) ) { FuncInfo -> addMustSaveCR ( Reg ) ; } else { CRSpilled = true ; FuncInfo -> setSpillsCR ( ) ; CRMIB = BuildMI ( * MF , DL , TII . get ( PPC :: MFCR ) , PPC :: R12 ) . addReg ( Reg , RegState :: ImplicitKill ) ; MBB . insert ( MI , CRMIB ) ; MBB . insert ( MI , addFrameReference ( BuildMI ( * MF , DL , TII . get ( PPC :: STW ) ) . addReg ( PPC :: R12 , getKillRegState ( true ) ) , CSI [ i ] . getFrameIdx ( ) ) ) ; } } else { if ( CSI [ i ] . isSpilledToReg ( ) ) { NumPESpillVSR ++ ; BuildMI ( MBB , MI , DL , TII . get ( PPC :: MTVSRD ) , CSI [ i ] . getDstReg ( ) ) . addReg ( Reg , getKillRegState ( true ) ) ; } else { const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; if ( Subtarget . needsSwapsForVSXMemOps ( ) && ! MF -> getFunction ( ) . hasFnAttribute ( Attribute :: NoUnwind ) ) TII . storeRegToStackSlotNoUpd ( MBB , MI , Reg , ! IsLiveIn , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; else TII . storeRegToStackSlot ( MBB , MI , Reg , ! IsLiveIn , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; } } } return true ; } </s>

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


<s> MachineRegisterInfo & getRegInfo ( Block & MBB ) { return MBB . getParent ( ) -> getRegInfo ( ) ; } </s>

getRegInfo - Return information about the registers currently in use .


<s> DecodeStatus OR1KDisassembler :: getInstruction ( MCInst & instr , uint64_t & Size , const MemoryObject & Region , uint64_t Address , raw_ostream & vStream , raw_ostream & cStream ) const { uint32_t Insn ; DecodeStatus Result = readInstruction32 ( Region , Address , Size , Insn ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; Result = decodeInstruction ( DecoderTableOR1K32 , instr , Insn , Address , this , STI ) ; if ( Result != MCDisassembler :: Fail ) { Size = 4 ; return Result ; } return MCDisassembler :: Fail ; } </s>

Returns the disassembly of a single instruction .


<s>
bool
X86FrameLowering
::
canUseAsEpilogue
(
const
MachineBasicBlock
&
MBB
)
const
{
assert
(
MBB
.
getParent
(
)
&&
"Block is not attached to a function!"
)
;
if
(
MBB
.
getParent
(
)
->
getSubtarget
<
X86Subtarget
>
(
)
.
isTargetWin64
(
)
&&
!
MBB
.
succ_empty
(
)
&&
!
MBB
.
isReturnBlock
(
)
)
return
false
;
if
(
canUseLEAForSPInEpilogue
(
*
MBB
.
getParent
(
)
)
)
return
true
;
return
!
terminatorsNeedFlagsAsInput
(
MBB
)
;
}
</s>

Check whether or not the given MBB can be used as a epilogue for the target .


<s> void ARMPassConfig :: addPreEmitPass ( ) { addPass ( createThumb2SizeReductionPass ( ) ) ; addPass ( createUnpackMachineBundles ( [ this ] ( const Function & F ) { return this -> TM -> getSubtarget < ARMSubtarget > ( F ) . isThumb2 ( ) ; } ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createARMOptimizeBarriersPass ( ) ) ; addPass ( createARMConstantIslandPass ( ) ) ; } </s>

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


<s> unsigned CFStack :: getLoopDepth ( ) { return LoopStack . size ( ) ; } </s>

Return the loop nesting level of the specified block .


ARCTargetMachine ctor - Create an ILP32 architecture model .


<s> int m32c_hard_regno_ok ( int regno , machine_mode mode ) { return m32c_hard_regno_nregs_1 ( regno , mode ) != 0 ; } </s>

Implements HARD_REGNO_MODE_OK . The above function does the work already ; just test its return value .


<s> void AMDGPUPassConfig :: addPreSched2 ( ) { const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . getGeneration ( ) <= AMDGPUSubtarget :: NORTHERN_ISLANDS ) addPass ( createR600EmitClauseMarkers ( ) , false ) ; if ( ST . isIfCvtEnabled ( ) ) addPass ( & IfConverterID , false ) ; if ( ST . getGeneration ( ) <= AMDGPUSubtarget :: NORTHERN_ISLANDS ) addPass ( createR600ClauseMergePass ( * TM ) , false ) ; if ( ST . getGeneration ( ) >= AMDGPUSubtarget :: SOUTHERN_ISLANDS ) { addPass ( createSIInsertWaits ( * TM ) , false ) ; } } </s>

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


"SRetReturnReg should have been set in LowerFormalArguments()."

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


<s> BitVector LC2200RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { static const MCPhysReg ReservedGPR32 [ ] = { LC2200 :: zero , LC2200 :: sp , LC2200 :: fp , LC2200 :: pc } ; BitVector Reserved ( getNumRegs ( ) ) ; for ( unsigned short I : ReservedGPR32 ) { Reserved . set ( I ) ; } return Reserved ; } </s>

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


<s>
static
void
tilepro_asm_trampoline_template
(
FILE
*
file
)
{
fprintf
(
file
,
"\tlnk   r10\n"
)
;
fprintf
(
file
,
"\taddi  r10, r10, 32\n"
)
;
fprintf
(
file
,
"\tlwadd r11, r10, %d\n"
,
GET_MODE_SIZE
(
ptr_mode
)
)
;
fprintf
(
file
,
"\tlw    r10, r10\n"
)
;
fprintf
(
file
,
"\tjr    r11\n"
)
;
fprintf
(
file
,
"\t.word 0 # <function address>\n"
)
;
fprintf
(
file
,
"\t.word 0 # <static chain value>\n"
)
;
}
</s>

tilepro
"\tlnk   r10\n"
"\taddi  r10, r10, 32\n"
"\tlwadd r11, r10, %d\n"
"\tlw    r10, r10\n"
"\tjr    r11\n"
"\t.word 0 # <function address>\n"
"\t.word 0 # <static chain value>\n"


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


<s>
void
AMDGPUAsmBackend
::
applyFixup
(
const
MCFixup
&
Fixup
,
char
*
Data
,
unsigned
DataSize
,
uint64_t
Value
,
bool
IsPCRel
)
const
{
switch
(
(
unsigned
)
Fixup
.
getKind
(
)
)
{
case
AMDGPU
::
fixup_si_sopp_br
:
{
uint16_t
*
Dst
=
(
uint16_t
*
)
(
Data
+
Fixup
.
getOffset
(
)
)
;
*
Dst
=
(
Value
4
)
/
4
;
break
;
}
case
AMDGPU
::
fixup_si_rodata
:
{
uint32_t
*
Dst
=
(
uint32_t
*
)
(
Data
+
Fixup
.
getOffset
(
)
)
;
*
Dst
=
Value
;
break
;
}
case
AMDGPU
::
fixup_si_end_of_text
:
{
uint32_t
*
Dst
=
(
uint32_t
*
)
(
Data
+
Fixup
.
getOffset
(
)
)
;
*
Dst
=
Value
+
4
;
break
;
}
default
:
{
unsigned
NumBytes
=
getFixupKindNumBytes
(
Fixup
.
getKind
(
)
)
;
if
(
!
Value
)
return
;
MCFixupKindInfo
Info
=
getFixupKindInfo
(
Fixup
.
getKind
(
)
)
;
Value
<<=
Info
.
TargetOffset
;
unsigned
Offset
=
Fixup
.
getOffset
(
)
;
assert
(
Offset
+
NumBytes
<=
DataSize
&&
"Invalid fixup offset!"
)
;
for
(
unsigned
i
=
0
;
i
!=
NumBytes
;
++
i
)
Data
[
Offset
+
i
]
|=
uint8_t
(
(
Value
>>
(
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 .


Create mask of ones , covering the lowest to highest bits set in VAL_IN . Assumed precondition : VAL_IN Is not zero .


<s> void CSKYFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { CSKYMachineFunctionInfo * CFI = MF . getInfo < CSKYMachineFunctionInfo > ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; Register FPReg = getFPReg ( STI ) ; Register SPReg = CSKY :: R14 ; MachineBasicBlock :: iterator MBBI = MBB . end ( ) ; DebugLoc DL ; if ( ! MBB . empty ( ) ) { MBBI = MBB . getFirstTerminator ( ) ; if ( MBBI == MBB . end ( ) ) MBBI = MBB . getLastNonDebugInstr ( ) ; DL = MBBI -> getDebugLoc ( ) ; if ( ! MBBI -> isTerminator ( ) ) MBBI = std :: next ( MBBI ) ; } const auto & CSI = MFI . getCalleeSavedInfo ( ) ; uint64_t StackSize = MFI . getStackSize ( ) ; uint64_t ActualSize = CFI -> getCalleeSaveAreaSize ( ) + CFI -> getVarArgsSaveSize ( ) ; auto LastFrameDestroy = MBBI ; if ( ! CSI . empty ( ) ) LastFrameDestroy = std :: prev ( MBBI , CSI . size ( ) ) ; if ( hasFP ( MF ) ) { const CSKYInstrInfo * TII = STI . getInstrInfo ( ) ; BuildMI ( MBB , LastFrameDestroy , DL , TII -> get ( TargetOpcode :: COPY ) , SPReg ) . addReg ( FPReg ) . setMIFlag ( MachineInstr :: NoFlags ) ; } else { adjustReg ( MBB , LastFrameDestroy , DL , SPReg , SPReg , ( StackSize - ActualSize ) , MachineInstr :: FrameDestroy ) ; } adjustReg ( MBB , MBBI , DL , SPReg , SPReg , ActualSize , MachineInstr :: FrameDestroy ) ; } </s>


<s> static void rs6000_eliminate_indexed_memrefs ( rtx operands [ 2 ] ) { if ( reload_in_progress ) return ; if ( GET_CODE ( operands [ 0 ] ) == MEM && GET_CODE ( XEXP ( operands [ 0 ] , 0 ) ) != REG && ! legitimate_constant_pool_address_p ( XEXP ( operands [ 0 ] , 0 ) , GET_MODE ( operands [ 0 ] ) , false ) ) operands [ 0 ] = replace_equiv_address ( operands [ 0 ] , copy_addr_to_reg ( XEXP ( operands [ 0 ] , 0 ) ) ) ; if ( GET_CODE ( operands [ 1 ] ) == MEM && GET_CODE ( XEXP ( operands [ 1 ] , 0 ) ) != REG && ! legitimate_constant_pool_address_p ( XEXP ( operands [ 1 ] , 0 ) , GET_MODE ( operands [ 1 ] ) , false ) ) operands [ 1 ] = replace_equiv_address ( operands [ 1 ] , copy_addr_to_reg ( XEXP ( operands [ 1 ] , 0 ) ) ) ; } </s>

Helper for the following . Get rid of [ r+r ] memory refs in cases where it wo n't work ( TImode , TFmode ) .


<s> static HOST_WIDE_INT aarch64_simd_vector_alignment ( const_tree type ) { if ( TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) return GET_MODE_CLASS ( TYPE_MODE ( type ) ) == MODE_VECTOR_BOOL ? 16 : 128 ; return wi :: umin ( wi :: to_wide ( TYPE_SIZE ( type ) ) , 128 ) . to_uhwi ( ) ; } </s>

Implement target hook TARGET_VECTOR_ALIGNMENT . The AAPCS64 sets the maximum alignment of a vector to 128 bits .


<s> bool aarch64_modes_tieable_p ( machine_mode mode1 , machine_mode mode2 ) { if ( GET_MODE_CLASS ( mode1 ) == GET_MODE_CLASS ( mode2 ) ) return true ; if ( TARGET_SIMD && aarch64_vector_mode_p ( mode1 ) && aarch64_vector_mode_p ( mode2 ) ) return true ; return false ; } </s>

Implement MODES_TIEABLE_P . In principle we should always return true . However due to issues with register allocation it is preferable to avoid tieing integer scalar and FP scalar modes . Executing integer operations in general registers is better than treating them as scalar vector operations . This reduces latency and avoids redundant int < - > FP moves . So tie modes if they are either the same class , or vector modes with other vector modes , vector structs or any scalar mode .


<s> const char * ix86_output_indirect_function_return ( rtx ret_op ) { if ( cfun -> machine -> function_return_type != indirect_branch_keep ) { char thunk_name [ 32 ] ; enum indirect_thunk_prefix need_prefix = indirect_thunk_need_prefix ( current_output_insn ) ; unsigned int regno = REGNO ( ret_op ) ; gcc_assert ( regno == CX_REG ) ; if ( cfun -> machine -> function_return_type != indirect_branch_thunk_inline ) { bool need_thunk = ( cfun -> machine -> function_return_type == indirect_branch_thunk ) ; indirect_thunk_name ( thunk_name , regno , need_prefix , true ) ; if ( need_thunk ) { indirect_return_via_cx = true ; SET_HARD_REG_BIT ( indirect_thunks_used , CX_REG ) ; } fprintf ( asm_out_file , "\tjmp\t" ) ; assemble_name ( asm_out_file , thunk_name ) ; putc ( '\n' , asm_out_file ) ; } else output_indirect_thunk ( regno ) ; } else { output_asm_insn ( "%!jmp\t%A0" , & ret_op ) ; if ( ix86_harden_sls & harden_sls_indirect_jmp ) fputs ( "\tint3\n" , asm_out_file ) ; } return "" ; } </s>

Output indirect function return . RET_OP is the function return target .


<s> bool aarch64_sve_ldnf1_operand_p ( rtx op ) { struct aarch64_address_info addr ; return ( MEM_P ( op ) && aarch64_classify_address ( & addr , XEXP ( op , 0 ) , GET_MODE ( op ) , false ) && addr . type == ADDRESS_REG_IMM ) ; } </s>

Return true if OP is a valid MEM operand for an SVE LDNF1 instruction .


<s> unsigned X86TargetLowering :: getByValTypeAlignment ( Type * Ty ) const { if ( Subtarget -> is64Bit ( ) ) { unsigned TyAlign = TD -> getABITypeAlignment ( Ty ) ; if ( TyAlign > 8 ) return TyAlign ; return 8 ; } unsigned Align = 4 ; if ( Subtarget -> hasSSE1 ( ) ) getMaxByValAlign ( Ty , Align ) ; return Align ; } </s>

Return the desired alignment for ByVal aggregate function arguments in the caller parameter area .


<s> void AArch64RegisterInfo :: materializeFrameBaseRegister ( MachineBasicBlock * MBB , unsigned BaseReg , int FrameIdx , int64_t Offset ) const { MachineBasicBlock :: iterator Ins = MBB -> begin ( ) ; DebugLoc DL ; if ( Ins != MBB -> end ( ) ) DL = Ins -> getDebugLoc ( ) ; const MachineFunction & MF = * MBB -> getParent ( ) ; const AArch64InstrInfo * TII = MF . getSubtarget < AArch64Subtarget > ( ) . getInstrInfo ( ) ; const MCInstrDesc & MCID = TII -> get ( AArch64 :: ADDXri ) ; MachineRegisterInfo & MRI = MBB -> getParent ( ) -> getRegInfo ( ) ; MRI . constrainRegClass ( BaseReg , TII -> getRegClass ( MCID , 0 , this , MF ) ) ; unsigned Shifter = AArch64_AM :: getShifterImm ( AArch64_AM :: LSL , 0 ) ; BuildMI ( * MBB , Ins , DL , MCID , BaseReg ) . addFrameIndex ( FrameIdx ) . addImm ( Offset ) . addImm ( Shifter ) ; } </s>

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


<s> static rtx rs6000_finish_function_arg ( machine_mode mode , rtx * rvec , int k ) { gcc_assert ( k >= 1 ) ; if ( k == 1 ) { if ( XEXP ( rvec [ 0 ] , 0 ) == NULL_RTX ) return NULL_RTX ; if ( GET_MODE ( XEXP ( rvec [ 0 ] , 0 ) ) == mode ) return XEXP ( rvec [ 0 ] , 0 ) ; } return gen_rtx_PARALLEL ( mode , gen_rtvec_v ( k , rvec ) ) ; } </s>

RVEC is a vector of K components of an argument of mode MODE . Construct the final function_arg return value from it .


"\n******** JVM Load/Store Elimination Optimization ********\n"

runOnMachineFunction - Emit the function body .


<s> int alpha_split_conditional_move ( enum rtx_code code , rtx dest , rtx cond , rtx t_rtx , rtx f_rtx ) { HOST_WIDE_INT t , f , diff ; enum machine_mode mode ; rtx target , subtarget , tmp ; mode = GET_MODE ( dest ) ; t = INTVAL ( t_rtx ) ; f = INTVAL ( f_rtx ) ; diff = t - f ; if ( ( ( code == NE || code == EQ ) && diff < 0 ) || ( code == GE || code == GT ) ) { code = reverse_condition ( code ) ; diff = t , t = f , f = diff ; diff = t - f ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( ! no_new_pseudos ) subtarget = gen_reg_rtx ( DImode ) ; else subtarget = target ; } if ( f == 0 && exact_log2 ( diff ) > 0 && ( diff <= 8 || alpha_tune == PROCESSOR_EV6 ) ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , copy_rtx ( subtarget ) , tmp ) ) ; tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( t ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; } else if ( f == 0 && t == - 1 ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , copy_rtx ( subtarget ) , tmp ) ) ; emit_insn ( gen_negdi2 ( target , copy_rtx ( subtarget ) ) ) ; } else if ( diff == 1 || diff == 4 || diff == 8 ) { rtx add_op ; tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , copy_rtx ( subtarget ) , tmp ) ) ; if ( diff == 1 ) emit_insn ( gen_adddi3 ( target , copy_rtx ( subtarget ) , GEN_INT ( f ) ) ) ; else { add_op = GEN_INT ( f ) ; if ( sext_add_operand ( add_op , mode ) ) { tmp = gen_rtx_MULT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( diff ) ) ; tmp = gen_rtx_PLUS ( DImode , tmp , add_op ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; } else return 0 ; } } else return 0 ; return 1 ; } </s>

Simplify a conditional move of two constants into a setcc with arithmetic . This is done with a splitter since combine would just undo the work if done during code generation . It also catches cases we would n't have before cse .


<s>
bool
SystemZAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
SmallVectorImpl
<
MCParsedAsmOperand
*
>
&
Operands
)
{
Operands
.
push_back
(
SystemZOperand
::
createToken
(
Name
,
NameLoc
)
)
;
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
if
(
parseOperand
(
Operands
,
Name
)
)
{
Parser
.
eatToEndOfStatement
(
)
;
return
true
;
}
while
(
getLexer
(
)
.
is
(
AsmToken
::
Comma
)
)
{
Parser
.
Lex
(
)
;
if
(
parseOperand
(
Operands
,
Name
)
)
{
Parser
.
eatToEndOfStatement
(
)
;
return
true
;
}
}
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
SMLoc
Loc
=
getLexer
(
)
.
getLoc
(
)
;
Parser
.
eatToEndOfStatement
(
)
;
return
Error
(
Loc
,
"unexpected token in argument list"
)
;
}
}
Parser
.
Lex
(
)
;
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .

SystemZ
SystemZ
SystemZ
"unexpected token in argument list"


<s> static int get_vsel_insn ( enum machine_mode mode ) { switch ( mode ) { case V4SImode : return UNSPEC_VSEL4SI ; break ; case V4SFmode : return UNSPEC_VSEL4SF ; break ; case V8HImode : return UNSPEC_VSEL8HI ; break ; case V16QImode : return UNSPEC_VSEL16QI ; break ; default : return INSN_NOT_AVAILABLE ; break ; } return INSN_NOT_AVAILABLE ; } </s>

Return vector select instruction for MODE . Return INSN_NOT_AVAILABLE , if valid insn doesn exist for given mode .


<s> struct xstormy16_stack_layout xstormy16_compute_stack_layout ( void ) { struct xstormy16_stack_layout layout ; int regno ; const int ifun = xstormy16_interrupt_function_p ( ) ; layout . locals_size = get_frame_size ( ) ; layout . register_save_size = 0 ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( REG_NEEDS_SAVE ( regno , ifun ) ) layout . register_save_size += UNITS_PER_WORD ; if ( current_function_stdarg ) layout . stdarg_save_size = NUM_ARGUMENT_REGISTERS * UNITS_PER_WORD ; else layout . stdarg_save_size = 0 ; layout . frame_size = ( layout . locals_size + layout . register_save_size + layout . stdarg_save_size ) ; if ( current_function_args_size <= 2048 && current_function_args_size != - 1 ) { if ( layout . frame_size + INCOMING_FRAME_SP_OFFSET + current_function_args_size <= 2048 ) layout . fp_minus_ap = layout . frame_size + INCOMING_FRAME_SP_OFFSET ; else layout . fp_minus_ap = 2048 - current_function_args_size ; } else layout . fp_minus_ap = ( layout . stdarg_save_size + layout . register_save_size + INCOMING_FRAME_SP_OFFSET ) ; layout . sp_minus_fp = ( layout . frame_size + INCOMING_FRAME_SP_OFFSET - layout . fp_minus_ap ) ; layout . first_local_minus_ap = layout . sp_minus_fp - layout . locals_size ; return layout ; } </s>


<s> bool X86TargetLowering :: shouldReduceLoadWidth ( SDNode * Load , ISD :: LoadExtType ExtTy , EVT NewVT ) const { SDValue BasePtr = cast < LoadSDNode > ( Load ) -> getBasePtr ( ) ; if ( BasePtr . getOpcode ( ) == X86ISD :: WrapperRIP ) if ( const auto * GA = dyn_cast < GlobalAddressSDNode > ( BasePtr . getOperand ( 0 ) ) ) return GA -> getTargetFlags ( ) != X86II :: MO_GOTTPOFF ; EVT VT = Load -> getValueType ( 0 ) ; if ( ( VT . is256BitVector ( ) || VT . is512BitVector ( ) ) && ! Load -> hasOneUse ( ) ) { for ( auto UI = Load -> use_begin ( ) , UE = Load -> use_end ( ) ; UI != UE ; ++ UI ) { if ( UI . getUse ( ) . getResNo ( ) != 0 ) continue ; if ( UI -> getOpcode ( ) != ISD :: EXTRACT_SUBVECTOR || ! UI -> hasOneUse ( ) || UI -> use_begin ( ) -> getOpcode ( ) != ISD :: STORE ) return true ; } return false ; } return true ; } </s>

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


"\nrs6000_secondary_reload_gpr, type = %s\n"

Convert reloads involving 64-bit gprs and misaligned offset addressing , or multiple 32-bit gprs and offsets that are too large , to use indirect addressing .


<s> bool AArch64LoadStoreOpt :: runOnMachineFunction ( MachineFunction & Fn ) { if ( skipFunction ( * Fn . getFunction ( ) ) ) return false ; Subtarget = & static_cast < const AArch64Subtarget & > ( Fn . getSubtarget ( ) ) ; TII = static_cast < const AArch64InstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; TRI = Subtarget -> getRegisterInfo ( ) ; ModifiedRegs . resize ( TRI -> getNumRegs ( ) ) ; UsedRegs . resize ( TRI -> getNumRegs ( ) ) ; bool Modified = false ; bool enableNarrowZeroStOpt = ! Subtarget -> requiresStrictAlign ( ) ; for ( auto & MBB : Fn ) Modified |= optimizeBlock ( MBB , enableNarrowZeroStOpt ) ; return Modified ; } </s>


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

Check whether the given instruction may need relaxation .


<s> void function_arg_advance ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ) { struct mips_arg_info info ; mips_arg_info ( cum , mode , type , named , & info ) ; if ( ! info . fpr_p ) cum -> gp_reg_found = true ; if ( cum -> arg_number < 2 && info . fpr_p ) cum -> fp_code += ( mode == SFmode ? 1 : 2 ) << ( ( cum -> arg_number - 1 ) * 2 ) ; if ( mips_abi != ABI_EABI || ! info . fpr_p ) cum -> num_gprs = info . reg_offset + info . reg_words ; else if ( info . reg_words > 0 ) cum -> num_fprs += FP_INC ; if ( info . stack_words > 0 ) cum -> stack_words = info . stack_offset + info . stack_words ; cum -> arg_number ++ ; } </s>

Handle the FUNCTION_ARG_ADVANCE macro . Update the data in CUM to advance over an argument of mode MODE and data type TYPE . TYPE is null for libcalls where that information may not be available .


<s> AlphaTargetLowering :: ConstraintType AlphaTargetLowering :: getConstraintType ( const std :: string & Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'f' : case 'r' : return C_RegisterClass ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s> static std :: string toString ( const APFloat & FP ) { if ( FP . isNaN ( ) && ! FP . bitwiseIsEqual ( APFloat :: getQNaN ( FP . getSemantics ( ) ) ) && ! FP . bitwiseIsEqual ( APFloat :: getQNaN ( FP . getSemantics ( ) , true ) ) ) { APInt AI = FP . bitcastToAPInt ( ) ; return std :: string ( AI . isNegative ( ) ? "-" : "" ) + "nan:0x" + utohexstr ( AI . getZExtValue ( ) & ( AI . getBitWidth ( ) == 32 ? INT64_C ( 0x007fffff ) : INT64_C ( 0x000fffffffffffff ) ) , true ) ; } static const size_t BufBytes = 128 ; char buf [ BufBytes ] ; auto Written = FP . convertToHexString ( buf , 0 , false , APFloat :: rmNearestTiesToEven ) ; ( void ) Written ; assert ( Written != 0 ) ; assert ( Written < BufBytes ) ; return buf ; } </s>

Convert to a decimal representation in a string .


<s>
SDValue
WebAssemblyTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"unimplemented operation lowering"
)
;
return
SDValue
(
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .

WebAssembly
WebAssembly
"unimplemented operation lowering"
ISD::GlobalAddress


<s> static int ia64_arg_partial_bytes ( cumulative_args_t cum_v , machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int words = ia64_function_arg_words ( type , mode ) ; int offset = ia64_function_arg_offset ( cum , type , words ) ; if ( cum -> words + offset >= MAX_ARGUMENT_SLOTS ) return 0 ; if ( words + cum -> words + offset <= MAX_ARGUMENT_SLOTS ) return 0 ; return ( MAX_ARGUMENT_SLOTS - cum -> words - offset ) * UNITS_PER_WORD ; } </s>

Return number of bytes , at the beginning of the argument , that must be put in registers . 0 is the argument is entirely in registers or entirely in memory .


Implement TARGET_BUILD_BUILTIN_VA_LIST . Return the type to use as __builtin_va_list . AAPCS64 \S 7.1.4 requires that va_list be a typedef for a type defined as : struct __va_list { void * __stack ; void * __gr_top ; void * __vr_top ; int __gr_offs ; int __vr_offs ; } ;


<s> virtual bool addPreSched2 ( ) { addPass ( createPatmosPMLProfileImport ( getPatmosTargetMachine ( ) ) ) ; if ( PatmosSinglePathInfo :: isEnabled ( ) ) { addPass ( createPatmosSinglePathInfoPass ( getPatmosTargetMachine ( ) ) ) ; addPass ( createPatmosSPBundlingPass ( getPatmosTargetMachine ( ) ) ) ; addPass ( createPatmosSPReducePass ( getPatmosTargetMachine ( ) ) ) ; addPass ( createSPSchedulerPass ( getPatmosTargetMachine ( ) ) ) ; } else { if ( getOptLevel ( ) != CodeGenOpt :: None && ! DisableIfConverter ) { addPass ( & IfConverterID ) ; addPass ( & UnreachableMachineBlockElimID ) ; } if ( getOptLevel ( ) != CodeGenOpt :: None ) { TargetPassConfig :: addBlockPlacement ( ) ; } } addPass ( createPatmosStackCacheAnalysisInfo ( getPatmosTargetMachine ( ) ) ) ; if ( EnableStackCacheAnalysis ) { addPass ( createPatmosStackCacheAnalysis ( getPatmosTargetMachine ( ) ) ) ; } return true ; } </s>

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

Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos Patmos


<s> static int sh_pr_n_sets ( void ) { return DF_REG_DEF_COUNT ( PR_REG ) ; } </s>

For use by ALLOCATE_INITIAL_VALUE . Note that sh.md contains some 'special function ' patterns ( type sfunc ) that clobber pr , but that do not look like function calls to leaf_function_p . Hence we must do this extra check .


<s> bool RISCVGatherScatterLowering :: runOnFunction ( Function & F ) { if ( skipFunction ( F ) ) return false ; auto & TPC = getAnalysis < TargetPassConfig > ( ) ; auto & TM = TPC . getTM < RISCVTargetMachine > ( ) ; ST = & TM . getSubtarget < RISCVSubtarget > ( F ) ; if ( ! ST -> hasStdExtV ( ) || ! ST -> useRVVForFixedLengthVectors ( ) ) return false ; TLI = ST -> getTargetLowering ( ) ; DL = & F . getParent ( ) -> getDataLayout ( ) ; LI = & getAnalysis < LoopInfoWrapperPass > ( ) . getLoopInfo ( ) ; SmallVector < IntrinsicInst * , 4 > Gathers ; SmallVector < IntrinsicInst * , 4 > Scatters ; bool Changed = false ; for ( BasicBlock & BB : F ) { for ( Instruction & I : BB ) { IntrinsicInst * II = dyn_cast < IntrinsicInst > ( & I ) ; if ( II && II -> getIntrinsicID ( ) == Intrinsic :: masked_gather && isa < FixedVectorType > ( II -> getType ( ) ) ) { Gathers . push_back ( II ) ; } else if ( II && II -> getIntrinsicID ( ) == Intrinsic :: masked_scatter && isa < FixedVectorType > ( II -> getArgOperand ( 0 ) -> getType ( ) ) ) { Scatters . push_back ( II ) ; } } } for ( auto * II : Gathers ) Changed |= tryCreateStridedLoadStore ( II , II -> getType ( ) , II -> getArgOperand ( 0 ) , II -> getArgOperand ( 1 ) ) ; for ( auto * II : Scatters ) Changed |= tryCreateStridedLoadStore ( II , II -> getArgOperand ( 0 ) -> getType ( ) , II -> getArgOperand ( 1 ) , II -> getArgOperand ( 2 ) ) ; while ( ! MaybeDeadPHIs . empty ( ) ) { if ( auto * Phi = dyn_cast_or_null < PHINode > ( MaybeDeadPHIs . pop_back_val ( ) ) ) RecursivelyDeleteDeadPHINode ( Phi ) ; } return Changed ; } </s>

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


<s> UPTSubtarget & UPTSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = CPU ; if ( CPUName . empty ( ) ) CPUName = "generic-upt" ; ParseSubtargetFeatures ( CPUName , FS ) ; return * this ; } </s>

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


<s>
void
PPCInstPrinter
::
printInst
(
const
MCInst
*
MI
,
raw_ostream
&
O
,
StringRef
Annot
)
{
if
(
MI
->
getOpcode
(
)
==
PPC
::
RLWINM
)
{
unsigned
char
SH
=
MI
->
getOperand
(
2
)
.
getImm
(
)
;
unsigned
char
MB
=
MI
->
getOperand
(
3
)
.
getImm
(
)
;
unsigned
char
ME
=
MI
->
getOperand
(
4
)
.
getImm
(
)
;
bool
useSubstituteMnemonic
=
false
;
if
(
SH
<=
31
&&
MB
==
0
&&
ME
==
(
31
SH
)
)
{
O
<<
"\tslwi "
;
useSubstituteMnemonic
=
true
;
}
if
(
SH
<=
31
&&
MB
==
(
32
SH
)
&&
ME
==
31
)
{
O
<<
"\tsrwi "
;
useSubstituteMnemonic
=
true
;
SH
=
32
SH
;
}
if
(
useSubstituteMnemonic
)
{
printOperand
(
MI
,
0
,
O
)
;
O
<<
", "
;
printOperand
(
MI
,
1
,
O
)
;
O
<<
", "
<<
(
unsigned
int
)
SH
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
}
if
(
(
MI
->
getOpcode
(
)
==
PPC
::
OR
||
MI
->
getOpcode
(
)
==
PPC
::
OR8
)
&&
MI
->
getOperand
(
1
)
.
getReg
(
)
==
MI
->
getOperand
(
2
)
.
getReg
(
)
)
{
O
<<
"\tmr "
;
printOperand
(
MI
,
0
,
O
)
;
O
<<
", "
;
printOperand
(
MI
,
1
,
O
)
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
if
(
MI
->
getOpcode
(
)
==
PPC
::
RLDICR
)
{
unsigned
char
SH
=
MI
->
getOperand
(
2
)
.
getImm
(
)
;
unsigned
char
ME
=
MI
->
getOperand
(
3
)
.
getImm
(
)
;
if
(
63
SH
==
ME
)
{
O
<<
"\tsldi "
;
printOperand
(
MI
,
0
,
O
)
;
O
<<
", "
;
printOperand
(
MI
,
1
,
O
)
;
O
<<
", "
<<
(
unsigned
int
)
SH
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
}
printInstruction
(
MI
,
O
)
;
printAnnotation
(
O
,
Annot
)
;
}
</s>

Print the specified MCInst to the specified raw_ostream .


<s> unsigned getExceptionSelectorRegister ( const Constant * PersonalityFn ) const override { return AArch64 :: X1 ; } </s>

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


<s>
void
WebAssemblyTargetAsmStreamer
::
emitImportName
(
const
MCSymbolWasm
*
Sym
,
StringRef
ImportName
)
{
OS
<<
"\t.import_name\t"
<<
Sym
->
getName
(
)
<<
", "
<<
ImportName
<<
'\n'
;
}
</s>

WebAssembly
WebAssembly
"\t.import_name\t"
", "


<s> bool BlackfinTargetLowering :: isOffsetFoldingLegal ( const GlobalAddressSDNode * GA ) const { return false ; } </s>

Return true if folding a constant offset with the given GlobalAddress is legal .


<s> Value * AArch64TargetLowering :: getIRStackGuard ( IRBuilder < > & IRB ) const { if ( ! Subtarget -> isTargetAndroid ( ) ) return TargetLowering :: getIRStackGuard ( IRB ) ; const unsigned TlsOffset = 0x28 ; Module * M = IRB . GetInsertBlock ( ) -> getParent ( ) -> getParent ( ) ; Function * ThreadPointerFunc = Intrinsic :: getDeclaration ( M , Intrinsic :: thread_pointer ) ; return IRB . CreatePointerCast ( IRB . CreateConstGEP1_32 ( IRB . CreateCall ( ThreadPointerFunc ) , TlsOffset ) , Type :: getInt8PtrTy ( IRB . getContext ( ) ) -> getPointerTo ( 0 ) ) ; } </s>

If the target has a standard location for the stack protector cookie , returns the address of that location .


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

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


<s> static bool rs6000_reg_live_or_pic_offset_p ( int reg ) { return ( ( ( crtl -> calls_eh_return || df_regs_ever_live_p ( reg ) ) && ( ! call_used_regs [ reg ] || ( reg == RS6000_PIC_OFFSET_TABLE_REGNUM && ! TARGET_SINGLE_PIC_BASE && TARGET_TOC && TARGET_MINIMAL_TOC ) ) ) || ( reg == RS6000_PIC_OFFSET_TABLE_REGNUM && ! TARGET_SINGLE_PIC_BASE && ( ( DEFAULT_ABI == ABI_V4 && flag_pic != 0 ) || ( DEFAULT_ABI == ABI_DARWIN && flag_pic ) ) ) ) ; } </s>

Determine whether the gp REG is really used .


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

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


<s> unsigned X86InstrInfo :: isLoadFromStackSlotPostFE ( const MachineInstr & MI , int & FrameIndex ) const { unsigned Dummy ; if ( isFrameLoadOpcode ( MI . getOpcode ( ) , Dummy ) ) { unsigned Reg ; if ( ( Reg = isLoadFromStackSlot ( MI , FrameIndex ) ) ) return Reg ; const MachineMemOperand * Dummy ; return hasLoadFromStackSlot ( MI , Dummy , FrameIndex ) ; } return 0 ; } </s>

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


<s> static rtx m68k_call_tls_get_addr ( rtx x , rtx eqv , enum m68k_reloc reloc ) { rtx a0 ; rtx_insn * insns ; rtx dest ; start_sequence ( ) ; x = m68k_wrap_symbol ( x , reloc , m68k_get_gp ( ) , NULL_RTX ) ; m68k_libcall_value_in_a0_p = true ; a0 = emit_library_call_value ( m68k_get_tls_get_addr ( ) , NULL_RTX , LCT_PURE , Pmode , 1 , x , Pmode ) ; m68k_libcall_value_in_a0_p = false ; insns = get_insns ( ) ; end_sequence ( ) ; gcc_assert ( can_create_pseudo_p ( ) ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , a0 , eqv ) ; return dest ; } </s>

Emit instruction sequence that calls __tls_get_addr . X is the TLS symbol we are referencing and RELOC is the symbol type to use ( either TLSGD or TLSLDM ) . EQV is the REG_EQUAL note for the sequence emitted . A pseudo register with result of __tls_get_addr call is returned .


<s> bool SITargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned AddrSpace , unsigned Align , bool * IsFast ) const { if ( IsFast ) * IsFast = false ; if ( VT == MVT :: Other || ( VT != MVT :: Other && VT . getSizeInBits ( ) > 1024 && VT . getStoreSize ( ) > 16 ) ) { return false ; } if ( AddrSpace == AMDGPUAS :: LOCAL_ADDRESS || AddrSpace == AMDGPUAS :: REGION_ADDRESS ) { bool AlignedBy4 = ( Align % 4 == 0 ) ; if ( IsFast ) * IsFast = AlignedBy4 ; return AlignedBy4 ; } if ( ! Subtarget -> hasUnalignedScratchAccess ( ) && ( AddrSpace == AMDGPUAS :: PRIVATE_ADDRESS || AddrSpace == AMDGPUAS :: FLAT_ADDRESS ) ) { return false ; } if ( Subtarget -> hasUnalignedBufferAccess ( ) ) { if ( IsFast ) { * IsFast = ( AddrSpace == AMDGPUAS :: CONSTANT_ADDRESS || AddrSpace == AMDGPUAS :: CONSTANT_ADDRESS_32BIT ) ? ( Align % 4 == 0 ) : true ; } return true ; } if ( VT . bitsLT ( MVT :: i32 ) ) return false ; if ( IsFast ) * IsFast = true ; return VT . bitsGT ( MVT :: i32 ) && Align % 4 == 0 ; } </s>

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


"SPUTargetLowering::LowerOperation(): need to lower this!\n"

LowerOperation - Provide custom lowering hooks for some operations .


<s> static void ix86_emit_restore_regs_using_mov ( rtx pointer , HOST_WIDE_INT offset , int maybe_eh_return ) { int regno ; rtx base_address = gen_rtx_MEM ( Pmode , pointer ) ; for ( regno = 0 ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ix86_save_reg ( regno , maybe_eh_return ) ) { if ( TARGET_64BIT && offset != trunc_int_for_mode ( offset , SImode ) ) { rtx r11 ; r11 = gen_rtx_REG ( DImode , FIRST_REX_INT_REG + 3 ) ; emit_move_insn ( r11 , GEN_INT ( offset ) ) ; emit_insn ( gen_adddi3 ( r11 , r11 , pointer ) ) ; base_address = gen_rtx_MEM ( Pmode , r11 ) ; offset = 0 ; } emit_move_insn ( gen_rtx_REG ( Pmode , regno ) , adjust_address ( base_address , Pmode , offset ) ) ; offset += UNITS_PER_WORD ; } } </s>

Emit code to restore saved registers using MOV insns . First register is restored from POINTER + OFFSET .


<s> void AMDGPUDAGToDAGISel :: PreprocessISelDAG ( ) { MachineFrameInfo & MFI = CurDAG -> getMachineFunction ( ) . getFrameInfo ( ) ; for ( int I = MFI . getObjectIndexBegin ( ) , E = MFI . getObjectIndexEnd ( ) ; I != E ; ++ I ) { SDValue FI = CurDAG -> getTargetFrameIndex ( I , MVT :: i32 ) ; if ( FI . use_empty ( ) ) continue ; SDValue EffectiveFI = FI ; auto It = FI -> use_begin ( ) ; if ( It -> getOpcode ( ) == ISD :: AssertZext && FI -> hasOneUse ( ) ) { EffectiveFI = SDValue ( * It , 0 ) ; It = EffectiveFI -> use_begin ( ) ; } for ( auto It = EffectiveFI -> use_begin ( ) ; ! It . atEnd ( ) ; ) { SDUse & Use = It . getUse ( ) ; SDNode * User = Use . getUser ( ) ; unsigned OpIdx = It . getOperandNo ( ) ; ++ It ; if ( MemSDNode * M = dyn_cast < MemSDNode > ( User ) ) { unsigned PtrIdx = M -> getOpcode ( ) == ISD :: STORE ? 2 : 1 ; if ( OpIdx == PtrIdx ) continue ; unsigned OpN = M -> getNumOperands ( ) ; SDValue NewOps [ 8 ] ; assert ( OpN < array_lengthof ( NewOps ) ) ; for ( unsigned Op = 0 ; Op != OpN ; ++ Op ) { if ( Op != OpIdx ) { NewOps [ Op ] = M -> getOperand ( Op ) ; continue ; } MachineSDNode * Mov = CurDAG -> getMachineNode ( AMDGPU :: V_MOV_B32_e32 , SDLoc ( M ) , MVT :: i32 , FI ) ; NewOps [ Op ] = SDValue ( Mov , 0 ) ; } CurDAG -> UpdateNodeOperands ( M , makeArrayRef ( NewOps , OpN ) ) ; } } } } </s>

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


<s> static int rename_dest ( tag_insn_info * insn_info , tag_map_t & tag_map ) { struct du_chain * chain = NULL ; du_head_p head = NULL ; int i ; unsigned dest_regno = REGNO ( insn_info -> dest ) ; if ( unsafe_rename_p ( dest_regno ) ) return - 1 ; rtx_insn * insn = insn_info -> insn ; operand_rr_info * dest_op_info = insn_rr [ INSN_UID ( insn ) ] . op_info ; for ( i = 0 ; i < dest_op_info -> n_chains ; i ++ ) { if ( dest_op_info -> heads [ i ] -> regno != dest_regno ) continue ; head = dest_op_info -> heads [ i ] ; if ( ! head -> first ) head = regrename_chain_from_id ( head -> id ) ; for ( chain = head -> first ; chain ; chain = chain -> next_use ) if ( chain -> insn == insn ) return rename_chain ( insn_info , tag_map , head ) ; } return - 1 ; } </s>

Go through the def/use chains for the register and find the chain for this insn to rename . The function returns the hard register number in case of a successful rename and -1 otherwise .


<s> static bool avr_return_in_memory ( tree type , tree fntype ATTRIBUTE_UNUSED ) { if ( TYPE_MODE ( type ) == BLKmode ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; return ( size == - 1 || size > 8 ) ; } else return false ; } </s>

Worker function for TARGET_RETURN_IN_MEMORY .


"Unexpected base pointer for inline asm memory operand."

"Unexpected offset for inline asm memory operand."

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


<s>
void
Thumb1InstrInfo
::
loadRegFromStackSlot
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
unsigned
DestReg
,
int
FI
,
const
TargetRegisterClass
*
RC
,
const
TargetRegisterInfo
*
TRI
)
const
{
assert
(
(
RC
==
ARM
::
tGPRRegisterClass
||
(
TargetRegisterInfo
::
isPhysicalRegister
(
DestReg
)
&&
isARMLowRegister
(
DestReg
)
)
)
&&
"Unknown regclass!"
)
;
if
(
RC
==
ARM
::
tGPRRegisterClass
||
(
TargetRegisterInfo
::
isPhysicalRegister
(
DestReg
)
&&
isARMLowRegister
(
DestReg
)
)
)
{
DebugLoc
DL
;
if
(
I
!=
MBB
.
end
(
)
)
DL
=
I
->
getDebugLoc
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
MachineFrameInfo
&
MFI
=
*
MF
.
getFrameInfo
(
)
;
MachineMemOperand
*
MMO
=
MF
.
getMachineMemOperand
(
MachinePointerInfo
::
getFixedStack
(
FI
)
,
MachineMemOperand
::
MOLoad
,
MFI
.
getObjectSize
(
FI
)
,
MFI
.
getObjectAlignment
(
FI
)
)
;
AddDefaultPred
(
BuildMI
(
MBB
,
I
,
DL
,
get
(
ARM
::
tLDRspi
)
,
DestReg
)
.
addFrameIndex
(
FI
)
.
addImm
(
0
)
.
addMemOperand
(
MMO
)
)
;
}
}
</s>

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

ARM
ARM::tGPRRegisterClass
ARM
"Unknown regclass!"
ARM::tGPRRegisterClass
ARM
ARM::tLDRspi
0


<s> void rvexTargetObjectFile :: Initialize ( MCContext & Ctx , const TargetMachine & TM ) { TargetLoweringObjectFileELF :: Initialize ( Ctx , TM ) ; SmallDataSection = getContext ( ) . getELFSection ( ".sdata" , ELF :: SHT_PROGBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC , SectionKind :: getDataRel ( ) ) ; SmallBSSSection = getContext ( ) . getELFSection ( ".sbss" , ELF :: SHT_NOBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC , SectionKind :: getBSS ( ) ) ; } </s>

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