<s> unsigned MipsSEInstrInfo :: isLoadFromStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { if ( MI . mayLoad ( ) ) { if ( ( MI . getOperand ( 1 ) . isFI ( ) ) && ( MI . getOperand ( 2 ) . isImm ( ) ) && ( isZeroImm ( MI . getOperand ( 2 ) ) ) ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

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


<s> unsigned AArch64Subtarget :: classifyGlobalFunctionReference ( const GlobalValue * GV , const TargetMachine & TM ) const { if ( TM . getCodeModel ( ) == CodeModel :: Large && isTargetMachO ( ) && ! GV -> hasInternalLinkage ( ) ) return AArch64II :: MO_GOT ; auto * F = dyn_cast < Function > ( GV ) ; if ( UseNonLazyBind && F && F -> hasFnAttribute ( Attribute :: NonLazyBind ) && ! TM . shouldAssumeDSOLocal ( * GV -> getParent ( ) , GV ) ) return AArch64II :: MO_GOT ; if ( getTargetTriple ( ) . isOSWindows ( ) ) return ClassifyGlobalReference ( GV , TM ) ; return AArch64II :: MO_NO_FLAG ; } </s>

Classify a global function reference for the current subtarget .


<s> static void get_scratch_register_on_entry ( struct scratch_reg * sr , unsigned int regno1 , unsigned long live_regs ) { int regno = - 1 ; sr -> saved = false ; if ( regno1 != LR_REGNUM && ( live_regs & ( 1 << LR_REGNUM ) ) != 0 ) regno = LR_REGNUM ; else { unsigned int i ; for ( i = 4 ; i < 11 ; i ++ ) if ( regno1 != i && ( live_regs & ( 1 << i ) ) != 0 ) { regno = i ; break ; } if ( regno < 0 ) { if ( regno1 == IP_REGNUM && IS_NESTED ( arm_current_func_type ( ) ) ) regno1 = 3 ; regno = ( regno1 == 3 ? 2 : 3 ) ; sr -> saved = REGNO_REG_SET_P ( df_get_live_out ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) , regno ) ; } } sr -> reg = gen_rtx_REG ( SImode , regno ) ; if ( sr -> saved ) { rtx addr = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; rtx insn = emit_set_insn ( gen_frame_mem ( SImode , addr ) , sr -> reg ) ; rtx x = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - 4 ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , x ) ; } } </s>

Return a short-lived scratch register for use on function entry . In 32-bit mode , it is valid only after the registers are saved in the prologue . This register must be released by means of release_scratch_register_on_entry once it is dead .


<s> unsigned AArch64RegisterInfo :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { const AArch64FrameLowering * TFI = getFrameLowering ( MF ) ; switch ( RC -> getID ( ) ) { default : return 0 ; case AArch64 :: GPR32RegClassID : case AArch64 :: GPR32spRegClassID : case AArch64 :: GPR32allRegClassID : case AArch64 :: GPR64spRegClassID : case AArch64 :: GPR64allRegClassID : case AArch64 :: GPR64RegClassID : case AArch64 :: GPR32commonRegClassID : case AArch64 :: GPR64commonRegClassID : return 32 - 1 - ( TFI -> hasFP ( MF ) || TT . isOSDarwin ( ) ) - MF . getSubtarget < AArch64Subtarget > ( ) . getNumXRegisterReserved ( ) - hasBasePointer ( MF ) ; case AArch64 :: FPR8RegClassID : case AArch64 :: FPR16RegClassID : case AArch64 :: FPR32RegClassID : case AArch64 :: FPR64RegClassID : case AArch64 :: FPR128RegClassID : return 32 ; case AArch64 :: DDRegClassID : case AArch64 :: DDDRegClassID : case AArch64 :: DDDDRegClassID : case AArch64 :: QQRegClassID : case AArch64 :: QQQRegClassID : case AArch64 :: QQQQRegClassID : return 32 ; case AArch64 :: FPR128_loRegClassID : return 16 ; } } </s>

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


<s> bool SystemZMCAsmBackend :: writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { for ( uint64_t I = 0 ; I != Count ; ++ I ) OW -> write8 ( 7 ) ; return true ; } </s>

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


<s> static void ix86_output_jmp_thunk_or_indirect ( const char * thunk_name , const int regno ) { if ( thunk_name != NULL ) { if ( REX_INT_REGNO_P ( regno ) && ix86_indirect_branch_cs_prefix ) fprintf ( asm_out_file , "\tcs\n" ) ; fprintf ( asm_out_file , "\tjmp\t" ) ; assemble_name ( asm_out_file , thunk_name ) ; putc ( '\n' , asm_out_file ) ; if ( ( ix86_harden_sls & harden_sls_indirect_jmp ) ) fputs ( "\tint3\n" , asm_out_file ) ; } else output_indirect_thunk ( regno ) ; } </s>


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

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


<s> const TargetRegisterClass * SHUXIRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return & SHUXI :: GPRegsRegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s> Sched :: Preference PPCTargetLowering :: getSchedulingPreference ( SDNode * N ) const { if ( DisableILPPref || Subtarget . enableMachineScheduler ( ) ) return TargetLowering :: getSchedulingPreference ( N ) ; return Sched :: ILP ; } </s>


<s>
bool
X86CallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
ArrayRef
<
Register
>
VRegs
,
FunctionLoweringInfo
&
FLI
)
const
{
assert
(
(
(
Val
&&
!
VRegs
.
empty
(
)
)
||
(
!
Val
&&
VRegs
.
empty
(
)
)
)
&&
"Return value without a vreg"
)
;
auto
MIB
=
MIRBuilder
.
buildInstrNoInsert
(
X86
::
RET
)
.
addImm
(
0
)
;
if
(
!
VRegs
.
empty
(
)
)
{
MachineFunction
&
MF
=
MIRBuilder
.
getMF
(
)
;
const
Function
&
F
=
MF
.
getFunction
(
)
;
MachineRegisterInfo
&
MRI
=
MF
.
getRegInfo
(
)
;
const
DataLayout
&
DL
=
MF
.
getDataLayout
(
)
;
ArgInfo
OrigRetInfo
(
VRegs
,
Val
->
getType
(
)
,
0
)
;
setArgFlags
(
OrigRetInfo
,
AttributeList
::
ReturnIndex
,
DL
,
F
)
;
SmallVector
<
ArgInfo
,
4
>
SplitRetInfos
;
splitToValueTypes
(
OrigRetInfo
,
SplitRetInfos
,
DL
,
F
.
getCallingConv
(
)
)
;
X86OutgoingValueAssigner
Assigner
(
RetCC_X86
)
;
X86OutgoingValueHandler
Handler
(
MIRBuilder
,
MRI
,
MIB
)
;
if
(
!
determineAndHandleAssignments
(
Handler
,
Assigner
,
SplitRetInfos
,
MIRBuilder
,
F
.
getCallingConv
(
)
,
F
.
isVarArg
(
)
)
)
return
false
;
}
MIRBuilder
.
insertInstr
(
MIB
)
;
return
true
;
}
</s>

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


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

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s> bool XNCMTargetLowering :: isTruncateFree ( EVT VT1 , EVT VT2 ) const { if ( ! VT1 . isInteger ( ) || ! VT2 . isInteger ( ) ) return false ; return ( VT1 . getSizeInBits ( ) > VT2 . getSizeInBits ( ) ) ; } </s>

Return true if it 's free to truncate a value of type Ty1 to type Ty2 .


<s> bool shouldInsertFencesForAtomic ( const Instruction * I ) const override { return true ; } </s>

Helper functions for atomic operations .


<s> static int arm_issue_rate ( void ) { switch ( arm_tune ) { case xgene1 : return 4 ; case cortexa15 : case cortexa57 : case exynosm1 : return 3 ; case cortexm7 : case cortexr4 : case cortexr4f : case cortexr5 : case genericv7a : case cortexa5 : case cortexa7 : case cortexa8 : case cortexa9 : case cortexa12 : case cortexa17 : case cortexa53 : case fa726te : case marvell_pj4 : return 2 ; default : return 1 ; } } </s>

Most ARM cores are single issue , but some newer ones can dual issue . The scheduler descriptions rely on this being correct .


<s> std :: pair < const TargetRegisterClass * , uint8_t > ARMTargetLowering :: findRepresentativeClass ( EVT VT ) const { const TargetRegisterClass * RRC = 0 ; uint8_t Cost = 1 ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { default : return TargetLowering :: findRepresentativeClass ( VT ) ; case MVT :: f32 : case MVT :: f64 : case MVT :: v8i8 : case MVT :: v4i16 : case MVT :: v2i32 : case MVT :: v1i64 : case MVT :: v2f32 : RRC = & ARM :: DPRRegClass ; if ( Subtarget -> useNEONForSinglePrecisionFP ( ) ) Cost = 2 ; break ; case MVT :: v16i8 : case MVT :: v8i16 : case MVT :: v4i32 : case MVT :: v2i64 : case MVT :: v4f32 : case MVT :: v2f64 : RRC = & ARM :: DPRRegClass ; Cost = 2 ; break ; case MVT :: v4i64 : RRC = & ARM :: DPRRegClass ; Cost = 4 ; break ; case MVT :: v8i64 : RRC = & ARM :: DPRRegClass ; Cost = 8 ; break ; } return std :: make_pair ( RRC , Cost ) ; } </s>

Return the largest legal super-reg register class of the register class for the specified type and its associated `` cost '' .


<s> inline tree get_svbool_t ( void ) { return acle_vector_types [ 0 ] [ VECTOR_TYPE_svbool_t ] ; } </s>


<s>
void
MipsRegisterBankInfo
::
applyMappingImpl
(
const
OperandsMapper
&
OpdMapper
)
const
{
MachineInstr
&
MI
=
OpdMapper
.
getMI
(
)
;
InstListTy
NewInstrs
;
MachineIRBuilder
B
(
MI
)
;
MachineFunction
*
MF
=
MI
.
getMF
(
)
;
MachineRegisterInfo
&
MRI
=
OpdMapper
.
getMRI
(
)
;
InstManager
NewInstrObserver
(
NewInstrs
)
;
GISelObserverWrapper
WrapperObserver
(
&
NewInstrObserver
)
;
LegalizerHelper
Helper
(
*
MF
,
WrapperObserver
,
B
)
;
LegalizationArtifactCombiner
ArtCombiner
(
B
,
MF
->
getRegInfo
(
)
,
*
MF
->
getSubtarget
(
)
.
getLegalizerInfo
(
)
)
;
switch
(
MI
.
getOpcode
(
)
)
{
case
TargetOpcode
::
G_LOAD
:
case
TargetOpcode
::
G_STORE
:
case
TargetOpcode
::
G_PHI
:
case
TargetOpcode
::
G_SELECT
:
case
TargetOpcode
::
G_IMPLICIT_DEF
:
{
Helper
.
narrowScalar
(
MI
,
0
,
LLT
::
scalar
(
32
)
)
;
while
(
!
NewInstrs
.
empty
(
)
)
{
MachineInstr
*
NewMI
=
NewInstrs
.
pop_back_val
(
)
;
if
(
NewMI
->
getOpcode
(
)
==
TargetOpcode
::
G_UNMERGE_VALUES
)
{
SmallVector
<
MachineInstr
*
,
2
>
DeadInstrs
;
ArtCombiner
.
tryCombineMerges
(
*
NewMI
,
DeadInstrs
)
;
for
(
MachineInstr
*
DeadMI
:
DeadInstrs
)
DeadMI
->
eraseFromParent
(
)
;
}
else
if
(
NewMI
->
getOpcode
(
)
==
TargetOpcode
::
G_MERGE_VALUES
)
continue
;
else
for
(
auto
Op
:
NewMI
->
operands
(
)
)
{
if
(
Op
.
isReg
(
)
)
{
assert
(
MRI
.
getType
(
Op
.
getReg
(
)
)
.
getSizeInBits
(
)
==
32
&&
"Only 32 bit gprb is handled here.\n"
)
;
MRI
.
setRegBank
(
Op
.
getReg
(
)
,
getRegBank
(
Mips
::
GPRBRegBankID
)
)
;
}
}
}
return
;
}
case
TargetOpcode
::
G_UNMERGE_VALUES
:
{
SmallVector
<
MachineInstr
*
,
2
>
DeadInstrs
;
ArtCombiner
.
tryCombineMerges
(
MI
,
DeadInstrs
)
;
for
(
MachineInstr
*
DeadMI
:
DeadInstrs
)
DeadMI
->
eraseFromParent
(
)
;
return
;
}
default
:
break
;
}
return
applyDefaultMapping
(
OpdMapper
)
;
}
</s>


"Can't load this register from stack slot"

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


<s>
void
ARM64AsmBackend
::
applyFixup
(
const
MCFixup
&
Fixup
,
char
*
Data
,
unsigned
DataSize
,
uint64_t
Value
,
bool
IsPCRel
)
const
{
unsigned
NumBytes
=
getFixupKindNumBytes
(
Fixup
.
getKind
(
)
)
;
if
(
!
Value
)
return
;
MCFixupKindInfo
Info
=
getFixupKindInfo
(
Fixup
.
getKind
(
)
)
;
Value
=
adjustFixupValue
(
Fixup
.
getKind
(
)
,
Value
)
;
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 .


<s> void emitFill ( const MCExpr & NumBytes , uint64_t FillValue , SMLoc Loc ) override { EmitMappingSymbol ( "$d" ) ; MCObjectStreamer :: emitFill ( NumBytes , FillValue , Loc ) ; } </s>

Emit Size bytes worth of the value specified by FillValue .


This method may be implemented by targets that want to run passes after register allocation pass pipeline but before prolog-epilog insertion .


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { if ( ( Count % 4 ) != 0 ) return false ; for ( uint64_t i = 0 ; i < Count ; i += 4 ) OW -> Write32 ( 0x00000000 ) ; return true ; } </s>


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


<s> static bool tryAddingSymbolicOperand ( int64_t Value , bool isBranch , uint64_t Address , uint64_t Offset , uint64_t Width , MCInst & MI , const MCDisassembler * Dis ) { return Dis -> tryAddingSymbolicOperand ( MI , Value , Address , isBranch , Offset , Width ) ; } </s>

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


<s> static unsigned estimateStackSize ( MachineFunction & MF ) { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const TargetFrameLowering * TFI = MF . getTarget ( ) . getFrameLowering ( ) ; const TargetRegisterInfo * RegInfo = MF . getTarget ( ) . getRegisterInfo ( ) ; unsigned MaxAlign = MFI -> getMaxAlignment ( ) ; int Offset = 0 ; for ( int i = MFI -> getObjectIndexBegin ( ) ; i != 0 ; ++ i ) { int FixedOff = - MFI -> getObjectOffset ( i ) ; if ( FixedOff > Offset ) Offset = FixedOff ; } for ( unsigned i = 0 , e = MFI -> getObjectIndexEnd ( ) ; i != e ; ++ i ) { if ( MFI -> isDeadObjectIndex ( i ) ) continue ; Offset += MFI -> getObjectSize ( i ) ; unsigned Align = MFI -> getObjectAlignment ( i ) ; Offset = ( Offset + Align - 1 ) / Align * Align ; MaxAlign = std :: max ( Align , MaxAlign ) ; } if ( MFI -> adjustsStack ( ) && TFI -> hasReservedCallFrame ( MF ) ) Offset += MFI -> getMaxCallFrameSize ( ) ; unsigned StackAlign ; if ( MFI -> adjustsStack ( ) || MFI -> hasVarSizedObjects ( ) || ( RegInfo -> needsStackRealignment ( MF ) && MFI -> getObjectIndexEnd ( ) != 0 ) ) StackAlign = TFI -> getStackAlignment ( ) ; else StackAlign = TFI -> getTransientStackAlignment ( ) ; StackAlign = std :: max ( StackAlign , MaxAlign ) ; unsigned AlignMask = StackAlign - 1 ; Offset = ( Offset + AlignMask ) & ~ uint64_t ( AlignMask ) ; return ( unsigned ) Offset ; } </s>

Estimate and return the size of the stack frame .


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


<s> void EmitInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI ) override { EmitA64MappingSymbol ( ) ; MCELFStreamer :: EmitInstruction ( Inst , STI ) ; } </s>

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


<s>
void
assignValueToAddress
(
Register
ValVReg
,
Register
Addr
,
LLT
MemTy
,
MachinePointerInfo
&
MPO
,
CCValAssign
&
VA
)
override
{
if
(
VA
.
getLocInfo
(
)
==
CCValAssign
::
SExt
||
VA
.
getLocInfo
(
)
==
CCValAssign
::
ZExt
)
{
MemTy
=
LLT
::
scalar
(
32
)
;
assert
(
MRI
.
getType
(
ValVReg
)
.
isScalar
(
)
&&
"Only scalars supported atm"
)
;
auto
LoadVReg
=
buildLoad
(
LLT
::
scalar
(
32
)
,
Addr
,
MemTy
,
MPO
)
;
MIRBuilder
.
buildTrunc
(
ValVReg
,
LoadVReg
)
;
}
else
{
buildLoad
(
ValVReg
,
Addr
,
MemTy
,
MPO
)
;
}
}
</s>

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


<s> void MipsRegisterInfo :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineBasicBlock :: iterator MBBI = prior ( MBB . end ( ) ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; MipsFunctionInfo * MipsFI = MF . getInfo < MipsFunctionInfo > ( ) ; DebugLoc dl = MBBI -> getDebugLoc ( ) ; int NumBytes = ( int ) MFI -> getStackSize ( ) ; int FPOffset = MipsFI -> getFPStackOffset ( ) ; int RAOffset = MipsFI -> getRAStackOffset ( ) ; if ( hasFP ( MF ) ) { BuildMI ( MBB , MBBI , dl , TII . get ( Mips :: ADDu ) , Mips :: SP ) . addReg ( Mips :: FP ) . addReg ( Mips :: ZERO ) ; BuildMI ( MBB , MBBI , dl , TII . get ( Mips :: LW ) , Mips :: FP ) . addImm ( FPOffset ) . addReg ( Mips :: SP ) ; } if ( MFI -> hasCalls ( ) ) { BuildMI ( MBB , MBBI , dl , TII . get ( Mips :: LW ) , Mips :: RA ) . addImm ( RAOffset ) . addReg ( Mips :: SP ) ; } if ( NumBytes ) { BuildMI ( MBB , MBBI , dl , TII . get ( Mips :: ADDiu ) , Mips :: SP ) . addReg ( Mips :: SP ) . addImm ( NumBytes ) ; } } </s>

Mips Mips Mips Mips Mips Mips Mips Mips::ADDu Mips::SP Mips::FP Mips::ZERO Mips::LW Mips::FP Mips::SP Mips::LW Mips::RA Mips::SP Mips::ADDiu Mips::SP Mips::SP


<s> static bool expand_vec_perm_pshufb2 ( struct expand_vec_perm_d * d ) { rtx rperm [ 2 ] [ 16 ] , vperm , l , h , op , m128 ; unsigned int i , nelt , eltsz ; if ( ! TARGET_SSSE3 || GET_MODE_SIZE ( d -> vmode ) != 16 ) return false ; gcc_assert ( ! d -> one_operand_p ) ; if ( d -> testing_p ) return true ; nelt = d -> nelt ; eltsz = GET_MODE_SIZE ( GET_MODE_INNER ( d -> vmode ) ) ; m128 = GEN_INT ( - 128 ) ; for ( i = 0 ; i < nelt ; ++ i ) { unsigned j , e = d -> perm [ i ] ; unsigned which = ( e >= nelt ) ; if ( e >= nelt ) e -= nelt ; for ( j = 0 ; j < eltsz ; ++ j ) { rperm [ which ] [ i * eltsz + j ] = GEN_INT ( e * eltsz + j ) ; rperm [ 1 - which ] [ i * eltsz + j ] = m128 ; } } vperm = gen_rtx_CONST_VECTOR ( V16QImode , gen_rtvec_v ( 16 , rperm [ 0 ] ) ) ; vperm = force_reg ( V16QImode , vperm ) ; l = gen_reg_rtx ( V16QImode ) ; op = gen_lowpart ( V16QImode , d -> op0 ) ; emit_insn ( gen_ssse3_pshufbv16qi3 ( l , op , vperm ) ) ; vperm = gen_rtx_CONST_VECTOR ( V16QImode , gen_rtvec_v ( 16 , rperm [ 1 ] ) ) ; vperm = force_reg ( V16QImode , vperm ) ; h = gen_reg_rtx ( V16QImode ) ; op = gen_lowpart ( V16QImode , d -> op1 ) ; emit_insn ( gen_ssse3_pshufbv16qi3 ( h , op , vperm ) ) ; op = d -> target ; if ( d -> vmode != V16QImode ) op = gen_reg_rtx ( V16QImode ) ; emit_insn ( gen_iorv16qi3 ( op , l , h ) ) ; if ( op != d -> target ) emit_move_insn ( d -> target , gen_lowpart ( d -> vmode , op ) ) ; return true ; } </s>

A subroutine of expand_vec_perm_even_odd_1 . Implement the double-word permutation with two pshufb insns and an ior . We should have already failed all two instruction sequences .


"256-bit vector operations only available in AVX2"

"256-bit insert/extract only available in AVX2"

Change the opcode of MI to execute in Domain .


<s> int neon_immediate_valid_for_move ( rtx op , machine_mode mode , rtx * modconst , int * elementwidth ) { rtx tmpconst ; int tmpwidth ; int retval = neon_valid_immediate ( op , mode , 0 , & tmpconst , & tmpwidth ) ; if ( retval == - 1 ) return 0 ; if ( modconst ) * modconst = tmpconst ; if ( elementwidth ) * elementwidth = tmpwidth ; return 1 ; } </s>

Return TRUE if rtx X is legal for use as either a Neon VMOV ( or , implicitly , VMVN ) immediate . Write back width per element to * ELEMENTWIDTH ( or zero for float elements ) , and a modified constant ( whatever should be output for a VMOV ) in * MODCONST .


<s> SDValue ARMTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { default : break ; case ISD :: ADD : return PerformADDCombine ( N , DCI , Subtarget ) ; case ISD :: SUB : return PerformSUBCombine ( N , DCI ) ; case ISD :: MUL : return PerformMULCombine ( N , DCI , Subtarget ) ; case ISD :: OR : return PerformORCombine ( N , DCI , Subtarget ) ; case ISD :: XOR : return PerformXORCombine ( N , DCI , Subtarget ) ; case ISD :: AND : return PerformANDCombine ( N , DCI , Subtarget ) ; case ARMISD :: BFI : return PerformBFICombine ( N , DCI ) ; case ARMISD :: VMOVRRD : return PerformVMOVRRDCombine ( N , DCI ) ; case ARMISD :: VMOVDRR : return PerformVMOVDRRCombine ( N , DCI . DAG ) ; case ISD :: STORE : return PerformSTORECombine ( N , DCI ) ; case ISD :: BUILD_VECTOR : return PerformBUILD_VECTORCombine ( N , DCI ) ; case ISD :: INSERT_VECTOR_ELT : return PerformInsertEltCombine ( N , DCI ) ; case ISD :: VECTOR_SHUFFLE : return PerformVECTOR_SHUFFLECombine ( N , DCI . DAG ) ; case ARMISD :: VDUPLANE : return PerformVDUPLANECombine ( N , DCI ) ; case ISD :: FP_TO_SINT : case ISD :: FP_TO_UINT : return PerformVCVTCombine ( N , DCI , Subtarget ) ; case ISD :: FDIV : return PerformVDIVCombine ( N , DCI , Subtarget ) ; case ISD :: INTRINSIC_WO_CHAIN : return PerformIntrinsicCombine ( N , DCI . DAG ) ; case ISD :: SHL : case ISD :: SRA : case ISD :: SRL : return PerformShiftCombine ( N , DCI . DAG , Subtarget ) ; case ISD :: SIGN_EXTEND : case ISD :: ZERO_EXTEND : case ISD :: ANY_EXTEND : return PerformExtendCombine ( N , DCI . DAG , Subtarget ) ; case ISD :: SELECT_CC : return PerformSELECT_CCCombine ( N , DCI . DAG , Subtarget ) ; case ARMISD :: CMOV : return PerformCMOVCombine ( N , DCI . DAG ) ; case ARMISD :: VLD2DUP : case ARMISD :: VLD3DUP : case ARMISD :: VLD4DUP : return CombineBaseUpdate ( N , DCI ) ; case ISD :: INTRINSIC_VOID : case ISD :: INTRINSIC_W_CHAIN : switch ( cast < ConstantSDNode > ( N -> getOperand ( 1 ) ) -> getZExtValue ( ) ) { case Intrinsic :: arm_neon_vld1 : case Intrinsic :: arm_neon_vld2 : case Intrinsic :: arm_neon_vld3 : case Intrinsic :: arm_neon_vld4 : case Intrinsic :: arm_neon_vld2lane : case Intrinsic :: arm_neon_vld3lane : case Intrinsic :: arm_neon_vld4lane : case Intrinsic :: arm_neon_vst1 : case Intrinsic :: arm_neon_vst2 : case Intrinsic :: arm_neon_vst3 : case Intrinsic :: arm_neon_vst4 : case Intrinsic :: arm_neon_vst2lane : case Intrinsic :: arm_neon_vst3lane : case Intrinsic :: arm_neon_vst4lane : return CombineBaseUpdate ( N , DCI ) ; default : break ; } break ; } return SDValue ( ) ; } </s>

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


<s> bool OptimizeLEAPass :: runOnMachineFunction ( MachineFunction & MF ) { bool Changed = false ; if ( DisableX86LEAOpt || ! MF . getFunction ( ) -> optForSize ( ) ) return false ; MRI = & MF . getRegInfo ( ) ; TII = MF . getSubtarget < X86Subtarget > ( ) . getInstrInfo ( ) ; TRI = MF . getSubtarget < X86Subtarget > ( ) . getRegisterInfo ( ) ; for ( auto & MBB : MF ) { MemOpMap LEAs ; InstrPos . clear ( ) ; findLEAs ( MBB , LEAs ) ; if ( LEAs . empty ( ) ) continue ; if ( MF . getFunction ( ) -> optForMinSize ( ) ) Changed |= removeRedundantLEAs ( LEAs ) ; Changed |= removeRedundantAddrCalc ( LEAs ) ; } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool ARMTargetLowering :: getPreIndexedAddressParts ( SDNode * N , SDValue & Base , SDValue & Offset , ISD :: MemIndexedMode & AM , SelectionDAG & DAG ) const { if ( Subtarget -> isThumb ( ) ) return false ; MVT VT ; SDValue Ptr ; bool isSEXTLoad = false ; if ( LoadSDNode * LD = dyn_cast < LoadSDNode > ( N ) ) { Ptr = LD -> getBasePtr ( ) ; VT = LD -> getMemoryVT ( ) ; isSEXTLoad = LD -> getExtensionType ( ) == ISD :: SEXTLOAD ; } else if ( StoreSDNode * ST = dyn_cast < StoreSDNode > ( N ) ) { Ptr = ST -> getBasePtr ( ) ; VT = ST -> getMemoryVT ( ) ; } else return false ; bool isInc ; bool isLegal = getIndexedAddressParts ( Ptr . getNode ( ) , VT , isSEXTLoad , Base , Offset , isInc , DAG ) ; if ( isLegal ) { AM = isInc ? ISD :: PRE_INC : ISD :: PRE_DEC ; return true ; } return false ; } </s>

Returns true by value , base pointer and offset pointer and addressing mode by reference if the node 's address can be legally represented as pre-indexed load / store address .

ARM ARM ISD::MemIndexedMode ISD::SEXTLOAD ISD::PRE_INC ISD::PRE_DEC


<s> bool MipsLegalizerInfo :: legalizeCustom ( MachineInstr & MI , MachineRegisterInfo & MRI , MachineIRBuilder & MIRBuilder , GISelChangeObserver & Observer ) const { using namespace TargetOpcode ; MIRBuilder . setInstr ( MI ) ; const MipsSubtarget & STI = static_cast < const MipsSubtarget & > ( MIRBuilder . getMF ( ) . getSubtarget ( ) ) ; const LLT s32 = LLT :: scalar ( 32 ) ; const LLT s64 = LLT :: scalar ( 64 ) ; switch ( MI . getOpcode ( ) ) { case G_UITOFP : { Register Dst = MI . getOperand ( 0 ) . getReg ( ) ; Register Src = MI . getOperand ( 1 ) . getReg ( ) ; LLT DstTy = MRI . getType ( Dst ) ; LLT SrcTy = MRI . getType ( Src ) ; if ( SrcTy != s32 ) return false ; if ( DstTy != s32 && DstTy != s64 ) return false ; MachineInstrBuilder Bitcast = MIRBuilder . buildInstr ( STI . isFP64bit ( ) ? Mips :: BuildPairF64_64 : Mips :: BuildPairF64 , { s64 } , { Src , MIRBuilder . buildConstant ( s32 , UINT32_C ( 0x43300000 ) ) } ) ; Bitcast . constrainAllUses ( MIRBuilder . getTII ( ) , * STI . getRegisterInfo ( ) , * STI . getRegBankInfo ( ) ) ; MachineInstrBuilder TwoP52FP = MIRBuilder . buildFConstant ( s64 , BitsToDouble ( UINT64_C ( 0x4330000000000000 ) ) ) ; if ( DstTy == s64 ) MIRBuilder . buildFSub ( Dst , Bitcast , TwoP52FP ) ; else { MachineInstrBuilder ResF64 = MIRBuilder . buildFSub ( s64 , Bitcast , TwoP52FP ) ; MIRBuilder . buildFPTrunc ( Dst , ResF64 ) ; } MI . eraseFromParent ( ) ; break ; } default : return false ; } return true ; } </s>

Called for instructions with the Custom LegalizationAction .


<s>
bool
ARM64FrameLowering
::
hasFP
(
const
MachineFunction
&
MF
)
const
{
const
MachineFrameInfo
*
MFI
=
MF
.
getFrameInfo
(
)
;
const
TargetRegisterInfo
*
RegInfo
=
MF
.
getTarget
(
)
.
getRegisterInfo
(
)
;
assert
(
!
RegInfo
->
needsStackRealignment
(
MF
)
&&
"No stack realignment on ARM64!"
)
;
return
(
MFI
->
hasCalls
(
)
||
MFI
->
hasVarSizedObjects
(
)
||
MFI
->
isFrameAddressTaken
(
)
)
;
}
</s>

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


<s> DEBUG_FUNCTION void debug_dispatch_window ( int window_num ) { debug_dispatch_window_file ( stdout , window_num ) ; } </s>


<s> static int loongarch_memory_move_cost ( machine_mode mode , reg_class_t rclass , bool in ) { return ( loongarch_cost -> memory_latency + memory_move_secondary_cost ( mode , rclass , in ) ) ; } </s>


<s> static void do_cmpb3 ( rtx dest , rtx src1 , rtx src2 ) { if ( GET_MODE ( dest ) == DImode ) emit_insn ( gen_cmpbdi3 ( dest , src1 , src2 ) ) ; else emit_insn ( gen_cmpbsi3 ( dest , src1 , src2 ) ) ; } </s>

Emit an cmpb of the proper mode for DEST . DEST is the destination register for the cmpb . SRC1 is the first input . SRC2 is the second input . Computes cmpb of SRC1 , SRC2 .


<s> Optional < Instruction * > AArch64TTIImpl :: instCombineIntrinsic ( InstCombiner & IC , IntrinsicInst & II ) const { Intrinsic :: ID IID = II . getIntrinsicID ( ) ; switch ( IID ) { default : break ; case Intrinsic :: aarch64_sve_convert_from_svbool : return instCombineConvertFromSVBool ( IC , II ) ; case Intrinsic :: aarch64_sve_dup : return instCombineSVEDup ( IC , II ) ; case Intrinsic :: aarch64_sve_dup_x : return instCombineSVEDupX ( IC , II ) ; case Intrinsic :: aarch64_sve_cmpne : case Intrinsic :: aarch64_sve_cmpne_wide : return instCombineSVECmpNE ( IC , II ) ; case Intrinsic :: aarch64_sve_rdffr : return instCombineRDFFR ( IC , II ) ; case Intrinsic :: aarch64_sve_lasta : case Intrinsic :: aarch64_sve_lastb : return instCombineSVELast ( IC , II ) ; case Intrinsic :: aarch64_sve_cntd : return instCombineSVECntElts ( IC , II , 2 ) ; case Intrinsic :: aarch64_sve_cntw : return instCombineSVECntElts ( IC , II , 4 ) ; case Intrinsic :: aarch64_sve_cnth : return instCombineSVECntElts ( IC , II , 8 ) ; case Intrinsic :: aarch64_sve_cntb : return instCombineSVECntElts ( IC , II , 16 ) ; case Intrinsic :: aarch64_sve_ptest_any : case Intrinsic :: aarch64_sve_ptest_first : case Intrinsic :: aarch64_sve_ptest_last : return instCombineSVEPTest ( IC , II ) ; case Intrinsic :: aarch64_sve_mul : case Intrinsic :: aarch64_sve_fmul : return instCombineSVEVectorMul ( IC , II ) ; case Intrinsic :: aarch64_sve_fadd : return instCombineSVEVectorFAdd ( IC , II ) ; case Intrinsic :: aarch64_sve_fsub : return instCombineSVEVectorBinOp ( IC , II ) ; case Intrinsic :: aarch64_sve_tbl : return instCombineSVETBL ( IC , II ) ; case Intrinsic :: aarch64_sve_uunpkhi : case Intrinsic :: aarch64_sve_uunpklo : case Intrinsic :: aarch64_sve_sunpkhi : case Intrinsic :: aarch64_sve_sunpklo : return instCombineSVEUnpack ( IC , II ) ; case Intrinsic :: aarch64_sve_tuple_get : return instCombineSVETupleGet ( IC , II ) ; case Intrinsic :: aarch64_sve_zip1 : case Intrinsic :: aarch64_sve_zip2 : return instCombineSVEZip ( IC , II ) ; case Intrinsic :: aarch64_sve_ld1_gather_index : return instCombineLD1GatherIndex ( IC , II ) ; case Intrinsic :: aarch64_sve_st1_scatter_index : return instCombineST1ScatterIndex ( IC , II ) ; case Intrinsic :: aarch64_sve_ld1 : return instCombineSVELD1 ( IC , II , DL ) ; case Intrinsic :: aarch64_sve_st1 : return instCombineSVEST1 ( IC , II , DL ) ; } return None ; } </s>

Targets can implement their own combinations for target-specific intrinsics .


<s> bool AArch64FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; static LoadStoreMethod PossibleClasses [ ] = { { & AArch64 :: GPR64RegClass , AArch64 :: LSPair64_STR , AArch64 :: LS64_STR } , { & AArch64 :: FPR64RegClass , AArch64 :: LSFPPair64_STR , AArch64 :: LSFP64_STR } , } ; unsigned NumClasses = llvm :: array_lengthof ( PossibleClasses ) ; emitFrameMemOps ( true , MBB , MBBI , CSI , TRI , PossibleClasses , NumClasses ) ; 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 AArch64InstrInfo :: isFunctionSafeToOutlineFrom ( MachineFunction & MF , bool OutlineFromLinkOnceODRs ) const { const Function & F = MF . getFunction ( ) ; if ( ! OutlineFromLinkOnceODRs && F . hasLinkOnceODRLinkage ( ) ) return false ; AArch64FunctionInfo * AFI = MF . getInfo < AArch64FunctionInfo > ( ) ; if ( ! AFI || AFI -> hasRedZone ( ) . getValueOr ( true ) ) return false ; return true ; } </s>

Return true if the function can safely be outlined from .


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

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


<s>
static
rtx
mips_prepare_builtin_arg
(
enum
insn_code
icode
,
unsigned
int
op
,
tree
*
arglist
)
{
rtx
value
;
enum
machine_mode
mode
;
value
=
expand_expr
(
TREE_VALUE
(
*
arglist
)
,
NULL_RTX
,
VOIDmode
,
0
)
;
mode
=
insn_data
[
icode
]
.
operand
[
op
]
.
mode
;
if
(
!
insn_data
[
icode
]
.
operand
[
op
]
.
predicate
(
value
,
mode
)
)
{
value
=
copy_to_mode_reg
(
mode
,
value
)
;
if
(
!
insn_data
[
icode
]
.
operand
[
op
]
.
predicate
(
value
,
mode
)
)
{
error
(
"invalid argument to builtin function"
)
;
return
const0_rtx
;
}
}
*
arglist
=
TREE_CHAIN
(
*
arglist
)
;
return
value
;
}
</s>

Take the head of argument list * ARGLIST and convert it into a form suitable for input operand OP of instruction ICODE . Return the value and point * ARGLIST at the next element of the list .

mips
0
"invalid argument to builtin function"


<s>
Register
getStackAddress
(
uint64_t
Size
,
int64_t
Offset
,
MachinePointerInfo
&
MPO
,
ISD
::
ArgFlagsTy
Flags
)
override
{
MachineFunction
&
MF
=
MIRBuilder
.
getMF
(
)
;
LLT
p0
=
LLT
::
pointer
(
0
,
64
)
;
LLT
s64
=
LLT
::
scalar
(
64
)
;
if
(
IsTailCall
)
{
assert
(
!
Flags
.
isByVal
(
)
&&
"byval unhandled with tail calls"
)
;
Offset
+=
FPDiff
;
int
FI
=
MF
.
getFrameInfo
(
)
.
CreateFixedObject
(
Size
,
Offset
,
true
)
;
auto
FIReg
=
MIRBuilder
.
buildFrameIndex
(
p0
,
FI
)
;
MPO
=
MachinePointerInfo
::
getFixedStack
(
MF
,
FI
)
;
return
FIReg
.
getReg
(
0
)
;
}
if
(
!
SPReg
)
SPReg
=
MIRBuilder
.
buildCopy
(
p0
,
Register
(
AArch64
::
SP
)
)
.
getReg
(
0
)
;
auto
OffsetReg
=
MIRBuilder
.
buildConstant
(
s64
,
Offset
)
;
auto
AddrReg
=
MIRBuilder
.
buildPtrAdd
(
p0
,
SPReg
,
OffsetReg
)
;
MPO
=
MachinePointerInfo
::
getStack
(
MF
,
Offset
)
;
return
AddrReg
.
getReg
(
0
)
;
}
</s>

Materialize a VReg containing the address of the specified stack-based object .


<s> bool SparcAsmPrinter :: PrintAsmMemoryOperand ( const MachineInstr * MI , unsigned OpNo , const char * ExtraCode , raw_ostream & O ) { if ( ExtraCode && ExtraCode [ 0 ] ) return true ; O << '[' ; printMemOperand ( MI , OpNo , O ) ; O << ']' ; return false ; } </s>

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


<s> const uint16_t * SparcRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const uint16_t CalleeSavedRegs [ ] = { 0 } ; return CalleeSavedRegs ; } </s>


<s> static bool isPairedLdSt ( const MachineInstr & MI ) { switch ( MI . getOpcode ( ) ) { default : return false ; case AArch64 :: LDPSi : case AArch64 :: LDPSWi : case AArch64 :: LDPDi : case AArch64 :: LDPQi : case AArch64 :: LDPWi : case AArch64 :: LDPXi : case AArch64 :: STPSi : case AArch64 :: STPDi : case AArch64 :: STPQi : case AArch64 :: STPWi : case AArch64 :: STPXi : return true ; } } </s>

Returns whether the instruction is a paired load/store .


"Instr doesn't have FrameIndex operand!"

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


<s> int label_mentioned_p ( rtx x ) { const char * fmt ; int i ; if ( LABEL_REF_P ( x ) ) return 1 ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , 1 ) == UNSPEC_TLS ) return 0 ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - 1 ; i >= 0 ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( x , i ) - 1 ; j >= 0 ; j -- ) if ( label_mentioned_p ( XVECEXP ( x , i , j ) ) ) return 1 ; } else if ( fmt [ i ] == 'e' && label_mentioned_p ( XEXP ( x , i ) ) ) return 1 ; } return 0 ; } </s>

Return TRUE if X references a LABEL_REF .


<s> static rtx rs6000_complex_function_value ( machine_mode mode ) { unsigned int regno ; rtx r1 , r2 ; machine_mode inner = GET_MODE_INNER ( mode ) ; unsigned int inner_bytes = GET_MODE_UNIT_SIZE ( mode ) ; if ( TARGET_FLOAT128_TYPE && ( mode == KCmode || ( mode == TCmode && TARGET_IEEEQUAD ) ) ) regno = ALTIVEC_ARG_RETURN ; else if ( FLOAT_MODE_P ( mode ) && TARGET_HARD_FLOAT && TARGET_FPRS ) regno = FP_ARG_RETURN ; else { regno = GP_ARG_RETURN ; if ( TARGET_32BIT && inner_bytes >= 4 ) return gen_rtx_REG ( mode , regno ) ; } if ( inner_bytes >= 8 ) return gen_rtx_REG ( mode , regno ) ; r1 = gen_rtx_EXPR_LIST ( inner , gen_rtx_REG ( inner , regno ) , const0_rtx ) ; r2 = gen_rtx_EXPR_LIST ( inner , gen_rtx_REG ( inner , regno + 1 ) , GEN_INT ( inner_bytes ) ) ; return gen_rtx_PARALLEL ( mode , gen_rtvec ( 2 , r1 , r2 ) ) ; } </s>

Return an RTX representing where to find the function value of a function returning MODE .


<s> static rtx pru_to_int_mode ( rtx x ) { machine_mode mode = GET_MODE ( x ) ; return VOIDmode == mode ? x : simplify_gen_subreg ( int_mode_for_mode ( mode ) . require ( ) , x , mode , 0 ) ; } </s>

Access some RTX as INT_MODE . If X is a CONST_FIXED we can get the bit representation of X by `` casting '' it to CONST_INT .


<s>
static
tree
rs6000_handle_struct_attribute
(
tree
*
node
,
tree
name
,
tree
args
ATTRIBUTE_UNUSED
,
int
flags
ATTRIBUTE_UNUSED
,
bool
*
no_add_attrs
)
{
tree
*
type
=
;
if
(
DECL_P
(
*
node
)
)
{
if
(
TREE_CODE
(
*
node
)
==
TYPE_DECL
)
type
=
&
TREE_TYPE
(
*
node
)
;
}
else
type
=
node
;
if
(
!
(
type
&&
(
TREE_CODE
(
*
type
)
==
RECORD_TYPE
||
TREE_CODE
(
*
type
)
==
UNION_TYPE
)
)
)
{
warning
(
OPT_Wattributes
,
"%qE attribute ignored"
,
name
)
;
*
no_add_attrs
=
true
;
}
else
if
(
(
is_attribute_p
(
"ms_struct"
,
name
)
&&
lookup_attribute
(
"gcc_struct"
,
TYPE_ATTRIBUTES
(
*
type
)
)
)
||
(
(
is_attribute_p
(
"gcc_struct"
,
name
)
&&
lookup_attribute
(
"ms_struct"
,
TYPE_ATTRIBUTES
(
*
type
)
)
)
)
)
{
warning
(
OPT_Wattributes
,
"%qE incompatible attribute ignored"
,
name
)
;
*
no_add_attrs
=
true
;
}
return
NULL_TREE
;
}
</s>

Handle a `` ms_struct '' or `` gcc_struct '' attribute ; arguments as in struct attribute_spec.handler .


<s>
MCDisassembler
::
DecodeStatus
X86GenericDisassembler
::
getInstruction
(
MCInst
&
Instr
,
uint64_t
&
Size
,
ArrayRef
<
uint8_t
>
Bytes
,
uint64_t
Address
,
raw_ostream
&
CStream
)
const
{
CommentStream
=
&
CStream
;
InternalInstruction
Insn
;
memset
(
&
Insn
,
0
,
sizeof
(
InternalInstruction
)
)
;
Insn
.
bytes
=
Bytes
;
Insn
.
startLocation
=
Address
;
Insn
.
readerCursor
=
Address
;
Insn
.
mode
=
fMode
;
if
(
Bytes
.
empty
(
)
||
readPrefixes
(
&
Insn
)
||
readOpcode
(
&
Insn
)
||
getInstructionID
(
&
Insn
,
MII
.
get
(
)
)
||
Insn
.
instructionID
==
0
||
readOperands
(
&
Insn
)
)
{
Size
=
Insn
.
readerCursor
Address
;
return
Fail
;
}
Insn
.
operands
=
x86OperandSets
[
Insn
.
spec
->
operands
]
;
Insn
.
length
=
Insn
.
readerCursor
Insn
.
startLocation
;
Size
=
Insn
.
length
;
if
(
Size
>
15
)
LLVM_DEBUG
(
dbgs
(
)
<<
"Instruction exceeds 15-byte limit"
)
;
bool
Ret
=
translateInstruction
(
Instr
,
Insn
,
this
)
;
if
(
!
Ret
)
{
unsigned
Flags
=
X86
::
IP_NO_PREFIX
;
if
(
Insn
.
hasAdSize
)
Flags
|=
X86
::
IP_HAS_AD_SIZE
;
if
(
!
Insn
.
mandatoryPrefix
)
{
if
(
Insn
.
hasOpSize
)
Flags
|=
X86
::
IP_HAS_OP_SIZE
;
if
(
Insn
.
repeatPrefix
==
0xf2
)
Flags
|=
X86
::
IP_HAS_REPEAT_NE
;
else
if
(
Insn
.
repeatPrefix
==
0xf3
&&
Insn
.
opcode
!=
0x90
)
Flags
|=
X86
::
IP_HAS_REPEAT
;
if
(
Insn
.
hasLockPrefix
)
Flags
|=
X86
::
IP_HAS_LOCK
;
}
Instr
.
setFlags
(
Flags
)
;
}
return
(
!
Ret
)
Success
:
Fail
;
}
</s>

Returns the disassembly of a single instruction .


<s> bool isReg ( ) const { return Kind == k_Register && ! Reg . isVector ; } </s>


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

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


<s> static int vax_return_pops_args ( tree fundecl ATTRIBUTE_UNUSED , tree funtype ATTRIBUTE_UNUSED , int size ) { return size > 255 * 4 ? 0 : size ; } </s>

Value is the number of bytes of arguments automatically popped when returning from a subroutine call . FUNDECL is the declaration node of the function ( as a tree ) , FUNTYPE is the data type of the function ( as a tree ) , or for a library call it is an identifier node for the subroutine name . SIZE is the number of bytes of arguments passed on the stack . On the VAX , the RET insn pops a maximum of 255 args for any function .


<s>
SDValue
TOYTargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
const
SmallVectorImpl
<
SDValue
>
&
OutVals
,
const
SDLoc
&
dl
,
SelectionDAG
&
DAG
)
const
{
if
(
isVarArg
)
{
report_fatal_error
(
"VarArg not supported"
)
;
}
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
DAG
.
getMachineFunction
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_TOY
)
;
SDValue
Flag
;
SmallVector
<
SDValue
,
4
>
RetOps
(
1
,
Chain
)
;
for
(
unsigned
i
=
0
,
e
=
RVLocs
.
size
(
)
;
i
<
e
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
OutVals
[
i
]
,
Flag
)
;
Flag
=
Chain
.
getValue
(
1
)
;
RetOps
.
push_back
(
DAG
.
getRegister
(
VA
.
getLocReg
(
)
,
VA
.
getLocVT
(
)
)
)
;
}
RetOps
[
0
]
=
Chain
;
if
(
Flag
.
getNode
(
)
)
{
RetOps
.
push_back
(
Flag
)
;
}
return
DAG
.
getNode
(
TOYISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
RetOps
)
;
}
</s>

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


"PowerPC DAG->DAG Pattern Instruction Selection"

getPassName - Return a nice clean name for a pass .


<s> static int optimal_immediate_sequence ( enum rtx_code code , unsigned HOST_WIDE_INT val , struct four_ints * return_sequence ) { int best_consecutive_zeros = 0 ; int i ; int best_start = 0 ; int insns1 , insns2 ; struct four_ints tmp_sequence ; if ( TARGET_ARM ) { for ( i = 0 ; i < 32 ; i += 2 ) { int consecutive_zeros = 0 ; if ( ! ( val & ( 3 << i ) ) ) { while ( ( i < 32 ) && ! ( val & ( 3 << i ) ) ) { consecutive_zeros += 2 ; i += 2 ; } if ( consecutive_zeros > best_consecutive_zeros ) { best_consecutive_zeros = consecutive_zeros ; best_start = i - consecutive_zeros ; } i -= 2 ; } } } insns1 = optimal_immediate_sequence_1 ( code , val , return_sequence , best_start ) ; if ( best_start != 0 && ( ( HOST_WIDE_INT_1U << best_start ) < val ) ) { insns2 = optimal_immediate_sequence_1 ( code , val , & tmp_sequence , 0 ) ; if ( insns2 <= insns1 ) { * return_sequence = tmp_sequence ; insns1 = insns2 ; } } return insns1 ; } </s>

Return a sequence of integers , in RETURN_SEQUENCE that fit into ARM/THUMB2 immediates , and add up to VAL . Thr function return value gives the number of insns required .


<s> void LoongArchInstPrinter :: printInst ( const MCInst * MI , uint64_t Address , StringRef Annot , const MCSubtargetInfo & STI , raw_ostream & O ) { if ( ! printAliasInstr ( MI , Address , STI , O ) ) printInstruction ( MI , Address , STI , O ) ; printAnnotation ( O , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


<s> static void loongarch_legitimize_const_move ( machine_mode mode , rtx dest , rtx src ) { rtx base , offset ; if ( splittable_const_int_operand ( src , mode ) ) { loongarch_move_integer ( dest , dest , INTVAL ( src ) ) ; return ; } if ( loongarch_split_symbol ( dest , src , MAX_MACHINE_MODE , & src ) ) { loongarch_emit_set ( dest , src ) ; return ; } if ( loongarch_tls_symbol_p ( src ) ) { loongarch_emit_move ( dest , loongarch_legitimize_tls_address ( src ) ) ; return ; } split_const ( src , & base , & offset ) ; if ( offset != const0_rtx && ( targetm . cannot_force_const_mem ( mode , src ) || ( can_create_pseudo_p ( ) ) ) ) { base = loongarch_force_temporary ( dest , base ) ; loongarch_emit_move ( dest , loongarch_add_offset ( NULL , base , INTVAL ( offset ) ) ) ; return ; } src = force_const_mem ( mode , src ) ; loongarch_emit_move ( dest , src ) ; } </s>

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


<s> AArch64GenInstrInfo :: MachineOutlinerInstrType AArch64InstrInfo :: getOutliningType ( MachineInstr & MI ) const { MachineFunction * MF = MI . getParent ( ) -> getParent ( ) ; AArch64FunctionInfo * FuncInfo = MF -> getInfo < AArch64FunctionInfo > ( ) ; if ( FuncInfo -> getLOHRelated ( ) . count ( & MI ) ) return MachineOutlinerInstrType :: Illegal ; if ( MI . isDebugValue ( ) || MI . isIndirectDebugValue ( ) ) return MachineOutlinerInstrType :: Invisible ; if ( MI . isTerminator ( ) ) { if ( MI . getParent ( ) -> succ_empty ( ) ) return MachineOutlinerInstrType :: Legal ; return MachineOutlinerInstrType :: Illegal ; } if ( MI . isPosition ( ) ) return MachineOutlinerInstrType :: Illegal ; if ( MI . readsRegister ( AArch64 :: W30 , & getRegisterInfo ( ) ) || MI . modifiesRegister ( AArch64 :: W30 , & getRegisterInfo ( ) ) ) return MachineOutlinerInstrType :: Illegal ; for ( const MachineOperand & MOP : MI . operands ( ) ) { if ( MOP . isCPI ( ) || MOP . isJTI ( ) || MOP . isCFIIndex ( ) || MOP . isFI ( ) || MOP . isTargetIndex ( ) ) return MachineOutlinerInstrType :: Illegal ; if ( MOP . isReg ( ) && getRegisterInfo ( ) . regsOverlap ( MOP . getReg ( ) , AArch64 :: LR ) ) return MachineOutlinerInstrType :: Illegal ; } if ( MI . modifiesRegister ( AArch64 :: SP , & RI ) || MI . readsRegister ( AArch64 :: SP , & RI ) ) { if ( MI . mayLoadOrStore ( ) ) { unsigned Base ; int64_t Offset ; unsigned DummyWidth ; if ( ! getMemOpBaseRegImmOfsWidth ( MI , Base , Offset , DummyWidth , & RI ) || Base != AArch64 :: SP ) return MachineOutlinerInstrType :: Illegal ; int64_t MinOffset , MaxOffset ; unsigned DummyScale ; getMemOpInfo ( MI . getOpcode ( ) , DummyScale , DummyWidth , MinOffset , MaxOffset ) ; if ( Offset + 16 < MinOffset || Offset + 16 > MaxOffset ) return MachineOutlinerInstrType :: Illegal ; return MachineOutlinerInstrType :: Legal ; } return MachineOutlinerInstrType :: Illegal ; } return MachineOutlinerInstrType :: Legal ; } </s>

Returns how or if MIT should be outlined .


<s> unsigned getNumFixupKinds ( ) const { return ARM64 :: NumTargetFixupKinds ; } </s>

Get the number of target specific fixup kinds .


<s> void SparcInstPrinter :: printInst ( const MCInst * MI , raw_ostream & O , StringRef Annot , const MCSubtargetInfo & STI ) { if ( ! printAliasInstr ( MI , STI , O ) && ! printSparcAliasInstr ( MI , STI , O ) ) printInstruction ( MI , STI , O ) ; printAnnotation ( O , Annot ) ; } </s>


<s> bool loongarch_epilogue_uses ( unsigned int regno ) { if ( regno == RETURN_ADDR_REGNUM ) return true ; return false ; } </s>


<s> int arm_mac_accumulator_is_mul_result ( rtx producer , rtx consumer ) { rtx mul = PATTERN ( producer ) ; rtx mac = PATTERN ( consumer ) ; rtx mul_result ; rtx mac_op0 , mac_op1 , mac_acc ; if ( GET_CODE ( mul ) == COND_EXEC ) mul = COND_EXEC_CODE ( mul ) ; if ( GET_CODE ( mac ) == COND_EXEC ) mac = COND_EXEC_CODE ( mac ) ; if ( ( GET_CODE ( mul ) != SET || GET_CODE ( XEXP ( mul , 1 ) ) != MULT ) || ( GET_CODE ( mac ) != SET || GET_CODE ( XEXP ( mac , 1 ) ) != PLUS || GET_CODE ( XEXP ( XEXP ( mac , 1 ) , 0 ) ) != MULT ) ) return 0 ; mul_result = XEXP ( mul , 0 ) ; mac_op0 = XEXP ( XEXP ( XEXP ( mac , 1 ) , 0 ) , 0 ) ; mac_op1 = XEXP ( XEXP ( XEXP ( mac , 1 ) , 0 ) , 1 ) ; mac_acc = XEXP ( XEXP ( mac , 1 ) , 1 ) ; return ( reg_overlap_mentioned_p ( mul_result , mac_acc ) && ! reg_overlap_mentioned_p ( mul_result , mac_op0 ) && ! reg_overlap_mentioned_p ( mul_result , mac_op1 ) ) ; } </s>

Return non-zero if the consumer ( a multiply-accumulate instruction ) has an accumulator dependency on the result of the producer ( a multiplication instruction ) and no other dependency on that result .


For the element-reversing load/store built-ins , produce the correct insn_code depending on the target endianness .


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
override
{
const
static
MCFixupKindInfo
Infos
[
X86
::
NumTargetFixupKinds
]
=
{
{
"reloc_riprel_4byte"
,
0
,
4
*
8
,
MCFixupKindInfo
::
FKF_IsPCRel
,
}
,
{
"reloc_riprel_4byte_movq_load"
,
0
,
4
*
8
,
MCFixupKindInfo
::
FKF_IsPCRel
,
}
,
{
"reloc_signed_4byte"
,
0
,
4
*
8
,
0
}
,
{
"reloc_global_offset_table"
,
0
,
4
*
8
,
0
}
,
{
"reloc_global_offset_table8"
,
0
,
8
*
8
,
0
}
,
}
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s> static tree xstormy16_build_builtin_va_list ( void ) { tree f_1 , f_2 , record , type_decl ; record = ( * lang_hooks . types . make_type ) ( RECORD_TYPE ) ; type_decl = build_decl ( TYPE_DECL , get_identifier ( "__va_list_tag" ) , record ) ; f_1 = build_decl ( FIELD_DECL , get_identifier ( "base" ) , ptr_type_node ) ; f_2 = build_decl ( FIELD_DECL , get_identifier ( "count" ) , unsigned_type_node ) ; DECL_FIELD_CONTEXT ( f_1 ) = record ; DECL_FIELD_CONTEXT ( f_2 ) = record ; TREE_CHAIN ( record ) = type_decl ; TYPE_NAME ( record ) = type_decl ; TYPE_FIELDS ( record ) = f_1 ; TREE_CHAIN ( f_1 ) = f_2 ; layout_type ( record ) ; return record ; } </s>

Build the va_list type . For this chip , va_list is a record containing a counter and a pointer . The counter is of type 'int ' and indicates how many bytes have been used to date . The pointer indicates the stack position for arguments that have not been passed in registers . To keep the layout nice , the pointer is first in the structure .


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

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


<s>
void
mmix_override_options
(
void
)
{
if
(
flag_pic
)
{
warning
(
0
,
"-f%s not supported: ignored"
,
(
flag_pic
>
1
)
"PIC"
:
"pic"
)
;
flag_pic
=
0
;
}
}
</s>


<s> bool mem_operand_ds_form ( rtx op , machine_mode mode ) { unsigned HOST_WIDE_INT offset ; int extra ; rtx addr = XEXP ( op , 0 ) ; if ( ! offsettable_address_p ( false , mode , addr ) ) return false ; op = address_offset ( addr ) ; if ( op == NULL_RTX ) return true ; offset = INTVAL ( op ) ; if ( ( offset & 3 ) != 0 ) return false ; extra = GET_MODE_SIZE ( mode ) - UNITS_PER_WORD ; if ( extra < 0 ) extra = 0 ; if ( GET_CODE ( addr ) == LO_SUM ) offset = ( ( offset & 0xffff ) ^ 0x8000 ) - 0x8000 ; return offset + 0x8000 < 0x10000u - extra ; } </s>

As above , but for DS-FORM VSX insns . Unlike mem_operand_gpr , enforce an offset divisible by 4 even for 32-bit .


<s> MipsTargetLowering :: ConstraintType MipsTargetLowering :: getConstraintType ( const std :: string & Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'd' : case 'y' : case 'f' : case 'c' : case 'l' : case 'x' : return C_RegisterClass ; case 'R' : return C_Memory ; } } if ( Constraint == "ZC" ) return C_Memory ; return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s> void PPCRegisterInfo :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { if ( PerformTailCallOpt && I -> getOpcode ( ) == PPC :: ADJCALLSTACKUP ) { if ( int CalleeAmt = I -> getOperand ( 1 ) . getImm ( ) ) { bool is64Bit = Subtarget . isPPC64 ( ) ; CalleeAmt *= - 1 ; unsigned StackReg = is64Bit ? PPC :: X1 : PPC :: R1 ; unsigned TmpReg = is64Bit ? PPC :: X0 : PPC :: R0 ; unsigned ADDIInstr = is64Bit ? PPC :: ADDI8 : PPC :: ADDI ; unsigned ADDInstr = is64Bit ? PPC :: ADD8 : PPC :: ADD4 ; unsigned LISInstr = is64Bit ? PPC :: LIS8 : PPC :: LIS ; unsigned ORIInstr = is64Bit ? PPC :: ORI8 : PPC :: ORI ; MachineInstr * MI = I ; DebugLoc dl = MI -> getDebugLoc ( ) ; if ( isInt16 ( CalleeAmt ) ) { BuildMI ( MBB , I , dl , TII . get ( ADDIInstr ) , StackReg ) . addReg ( StackReg ) . addImm ( CalleeAmt ) ; } else { MachineBasicBlock :: iterator MBBI = I ; BuildMI ( MBB , MBBI , dl , TII . get ( LISInstr ) , TmpReg ) . addImm ( CalleeAmt >> 16 ) ; BuildMI ( MBB , MBBI , dl , TII . get ( ORIInstr ) , TmpReg ) . addReg ( TmpReg , RegState :: Kill ) . addImm ( CalleeAmt & 0xFFFF ) ; BuildMI ( MBB , MBBI , dl , TII . get ( ADDInstr ) ) . addReg ( StackReg ) . addReg ( StackReg ) . addReg ( TmpReg ) ; } } } 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>
const
MCFixupKindInfo
&
X86AsmBackend
::
getFixupKindInfo
(
MCFixupKind
Kind
)
const
{
const
static
MCFixupKindInfo
Infos
[
X86
::
NumTargetFixupKinds
]
=
{
{
"reloc_riprel_4byte"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_riprel_4byte_movq_load"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_riprel_4byte_relax"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_riprel_4byte_relax_rex"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_signed_4byte"
,
0
,
32
,
0
}
,
{
"reloc_signed_4byte_relax"
,
0
,
32
,
0
}
,
{
"reloc_global_offset_table"
,
0
,
32
,
0
}
,
{
"reloc_global_offset_table8"
,
0
,
64
,
0
}
,
{
"reloc_branch_4byte_pcrel"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
}
;
if
(
Kind
>=
FirstLiteralRelocationKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
FK_NONE
)
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
assert
(
Infos
[
Kind
FirstTargetFixupKind
]
.
Name
&&
"Empty fixup name!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s>
unsigned
PPCTTIImpl
::
getArithmeticInstrCost
(
unsigned
Opcode
,
Type
*
Ty
,
TTI
::
OperandValueKind
Op1Info
,
TTI
::
OperandValueKind
Op2Info
,
TTI
::
OperandValueProperties
Opd1PropInfo
,
TTI
::
OperandValueProperties
Opd2PropInfo
)
{
assert
(
TLI
->
InstructionOpcodeToISD
(
Opcode
)
&&
"Invalid opcode"
)
;
return
BaseT
::
getArithmeticInstrCost
(
Opcode
,
Ty
,
Op1Info
,
Op2Info
,
Opd1PropInfo
,
Opd2PropInfo
)
;
}
</s>

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


<s> void rs6000_emit_sCOND ( machine_mode mode , rtx operands [ ] ) { rtx condition_rtx ; machine_mode op_mode ; enum rtx_code cond_code ; rtx result = operands [ 0 ] ; condition_rtx = rs6000_generate_compare ( operands [ 1 ] , mode ) ; cond_code = GET_CODE ( condition_rtx ) ; if ( FLOAT_MODE_P ( mode ) && ! TARGET_FPRS && TARGET_HARD_FLOAT ) { rtx t ; PUT_MODE ( condition_rtx , SImode ) ; t = XEXP ( condition_rtx , 0 ) ; gcc_assert ( cond_code == NE || cond_code == EQ ) ; if ( cond_code == NE ) emit_insn ( gen_e500_flip_gt_bit ( t , t ) ) ; emit_insn ( gen_move_from_CR_gt_bit ( result , t ) ) ; return ; } if ( cond_code == NE || cond_code == GE || cond_code == LE || cond_code == GEU || cond_code == LEU || cond_code == ORDERED || cond_code == UNGE || cond_code == UNLE ) { rtx not_result = gen_reg_rtx ( CCEQmode ) ; rtx not_op , rev_cond_rtx ; machine_mode cc_mode ; cc_mode = GET_MODE ( XEXP ( condition_rtx , 0 ) ) ; rev_cond_rtx = gen_rtx_fmt_ee ( rs6000_reverse_condition ( cc_mode , cond_code ) , SImode , XEXP ( condition_rtx , 0 ) , const0_rtx ) ; not_op = gen_rtx_COMPARE ( CCEQmode , rev_cond_rtx , const0_rtx ) ; emit_insn ( gen_rtx_SET ( not_result , not_op ) ) ; condition_rtx = gen_rtx_EQ ( VOIDmode , not_result , const0_rtx ) ; } op_mode = GET_MODE ( XEXP ( operands [ 1 ] , 0 ) ) ; if ( op_mode == VOIDmode ) op_mode = GET_MODE ( XEXP ( operands [ 1 ] , 1 ) ) ; if ( TARGET_POWERPC64 && ( op_mode == DImode || FLOAT_MODE_P ( mode ) ) ) { PUT_MODE ( condition_rtx , DImode ) ; convert_move ( result , condition_rtx , 0 ) ; } else { PUT_MODE ( condition_rtx , SImode ) ; emit_insn ( gen_rtx_SET ( result , condition_rtx ) ) ; } } </s>


"Flag output operand is of invalid type"


<s> void MipsSEFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const MipsSEInstrInfo & TII = * static_cast < const MipsSEInstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; DebugLoc dl = MBBI -> getDebugLoc ( ) ; unsigned SP = STI . isABI_N64 ( ) ? Mips :: SP_64 : Mips :: SP ; unsigned FP = STI . isABI_N64 ( ) ? Mips :: FP_64 : Mips :: FP ; unsigned ZERO = STI . isABI_N64 ( ) ? Mips :: ZERO_64 : Mips :: ZERO ; unsigned ADDu = STI . isABI_N64 ( ) ? Mips :: DADDu : Mips :: ADDu ; if ( hasFP ( MF ) ) { MachineBasicBlock :: iterator I = MBBI ; for ( unsigned i = 0 ; i < MFI -> getCalleeSavedInfo ( ) . size ( ) ; ++ i ) -- I ; BuildMI ( MBB , I , dl , TII . get ( ADDu ) , SP ) . addReg ( FP ) . addReg ( ZERO ) ; } uint64_t StackSize = MFI -> getStackSize ( ) ; if ( ! StackSize ) return ; TII . adjustStackPtr ( SP , StackSize , MBB , MBBI ) ; } </s>

Mips Mips Mips Mips Mips::SP_64 Mips::SP Mips::FP_64 Mips::FP Mips::ZERO_64 Mips::ZERO Mips::DADDu Mips::ADDu 0


<s> static int ix86_widen_mult_cost ( const struct processor_costs * cost , enum machine_mode mode , bool uns_p ) { gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) ; int extra_cost = 0 ; int basic_cost = 0 ; switch ( mode ) { case V8HImode : case V16HImode : if ( ! uns_p || mode == V16HImode ) extra_cost = cost -> sse_op * 2 ; basic_cost = cost -> mulss * 2 + cost -> sse_op * 4 ; break ; case V4SImode : case V8SImode : basic_cost = cost -> mulss * 2 + cost -> sse_op * 2 ; break ; case V2DImode : if ( ! TARGET_SSE4_1 && ! uns_p ) extra_cost = ( cost -> mulss + cost -> addss + cost -> sse_op ) * 4 + cost -> sse_op * 2 ; case V4DImode : basic_cost = cost -> mulss * 2 + cost -> sse_op * 4 ; break ; default : gcc_unreachable ( ) ; } return ix86_vec_cost ( mode , basic_cost + extra_cost ) ; } </s>

Return cost of vec_widen_ < s > mult_hi/lo_ < mode > , vec_widen_ < s > mul_hi/lo_ < mode > is only available for VI124_AVX2 .


"%qE attribute only applies to functions"


<s> enum machine_mode select_cc_mode ( enum rtx_code op , rtx x , rtx y ATTRIBUTE_UNUSED ) { if ( GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ) { switch ( op ) { case EQ : case NE : case UNORDERED : case ORDERED : case UNLT : case UNLE : case UNGT : case UNGE : case UNEQ : case LTGT : return CCFPmode ; case LT : case LE : case GT : case GE : return CCFPEmode ; default : gcc_unreachable ( ) ; } } else if ( GET_CODE ( x ) == PLUS || GET_CODE ( x ) == MINUS || GET_CODE ( x ) == NEG || GET_CODE ( x ) == ASHIFT ) { if ( TARGET_ARCH64 && GET_MODE ( x ) == DImode ) return CCX_NOOVmode ; else return CC_NOOVmode ; } else { if ( TARGET_ARCH64 && GET_MODE ( x ) == DImode ) return CCXmode ; else return CCmode ; } } </s>

Given a comparison code ( EQ , NE , etc . ) and the first operand of a COMPARE , return the mode to be used for the comparison . For floating-point , CCFP [ E ] mode is used . CC_NOOVmode should be used when the first operand is a PLUS , MINUS , NEG , or ASHIFT . CCmode should be used when no special processing is needed .


<s> void Thumb2InstrInfo :: storeRegToStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned SrcReg , bool isKill , int FI , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { if ( RC == ARM :: GPRRegisterClass || RC == ARM :: tGPRRegisterClass || RC == ARM :: tcGPRRegisterClass || RC == ARM :: rGPRRegisterClass ) { DebugLoc DL ; if ( I != MBB . end ( ) ) DL = I -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = * MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo ( PseudoSourceValue :: getFixedStack ( FI ) ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FI ) , MFI . getObjectAlignment ( FI ) ) ; AddDefaultPred ( BuildMI ( MBB , I , DL , get ( ARM :: t2STRi12 ) ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addFrameIndex ( FI ) . addImm ( 0 ) . addMemOperand ( MMO ) ) ; return ; } ARMBaseInstrInfo :: storeRegToStackSlot ( MBB , I , SrcReg , isKill , FI , RC , TRI ) ; } </s>

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

ARM ARM::GPRRegisterClass ARM::tGPRRegisterClass ARM::tcGPRRegisterClass ARM::rGPRRegisterClass ARM::t2STRi12 0 ARM


<s> void Cpu0TargetObjectFile :: Initialize ( MCContext & Ctx , const TargetMachine & TM ) { TargetLoweringObjectFileELF :: Initialize ( Ctx , TM ) ; InitializeELF ( TM . Options . UseInitArray ) ; SmallDataSection = getContext ( ) . getELFSection ( ".sdata" , ELF :: SHT_PROGBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ; SmallBSSSection = getContext ( ) . getELFSection ( ".sbss" , ELF :: SHT_NOBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ; this -> TM = & static_cast < const Cpu0TargetMachine & > ( TM ) ; } </s>

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


Decide how much space to reserve for callee-save target registers in case target register allocation wants to use them . LIVE_REGS_MASK is the register mask calculated by calc_live_regs .


"No MachineFunctionInfo for this function!"

runOnMachineFunction - Emit the function body .


"Unknown opcode to check as cheap as a move!"

Return true if the instruction is as cheap as a move instruction .


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

Check whether the given instruction may need relaxation .


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


Returns a function decl for a vectorized version of the builtin function with builtin function code FN and the result vector type TYPE , or NULL_TREE if it is not available .


<s> X86Subtarget :: X86Subtarget ( const Triple & TT , StringRef CPU , StringRef FS , const X86TargetMachine & TM , unsigned StackAlignOverride , unsigned PreferVectorWidthOverride ) : X86GenSubtargetInfo ( TT , CPU , FS ) , X86ProcFamily ( Others ) , PICStyle ( PICStyles :: None ) , TM ( TM ) , TargetTriple ( TT ) , StackAlignOverride ( StackAlignOverride ) , PreferVectorWidthOverride ( PreferVectorWidthOverride ) , In64BitMode ( TargetTriple . getArch ( ) == Triple :: x86_64 ) , In32BitMode ( TargetTriple . getArch ( ) == Triple :: x86 && TargetTriple . getEnvironment ( ) != Triple :: CODE16 ) , In16BitMode ( TargetTriple . getArch ( ) == Triple :: x86 && TargetTriple . getEnvironment ( ) == Triple :: CODE16 ) , InstrInfo ( initializeSubtargetDependencies ( CPU , FS ) ) , TLInfo ( TM , * this ) , FrameLowering ( * this , getStackAlignment ( ) ) { if ( ! isPositionIndependent ( ) ) setPICStyle ( PICStyles :: None ) ; else if ( is64Bit ( ) ) setPICStyle ( PICStyles :: RIPRel ) ; else if ( isTargetCOFF ( ) ) setPICStyle ( PICStyles :: None ) ; else if ( isTargetDarwin ( ) ) setPICStyle ( PICStyles :: StubPIC ) ; else if ( isTargetELF ( ) ) setPICStyle ( PICStyles :: GOT ) ; CallLoweringInfo . reset ( new X86CallLowering ( * getTargetLowering ( ) ) ) ; Legalizer . reset ( new X86LegalizerInfo ( * this , TM ) ) ; auto * RBI = new X86RegisterBankInfo ( * getRegisterInfo ( ) ) ; RegBankInfo . reset ( RBI ) ; InstSelector . reset ( createX86InstructionSelector ( TM , * this , * RBI ) ) ; } </s>

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


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

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


<s> unsigned X86TargetLowering :: combineRepeatedFPDivisors ( ) const { return 2 ; } </s>

Indicate whether this target prefers to combine FDIVs with the same divisor .


<s> const uint16_t * X86TargetLowering :: getScratchRegisters ( CallingConv :: ID ) const { static const uint16_t ScratchRegs [ ] = { X86 :: R11 , 0 } ; return ScratchRegs ; } </s>

Returns a 0 terminated array of registers that can be safely used as scratch registers .


"ARM MVE TailPred and VPT Optimisation Pass"

getPassName - Return a nice clean name for a pass .


"Unsupported cpu name returned from kernel for -mcpu=native: %s\n"

"Please use an explicit cpu name.  Valid cpu names are: %s"

Returns the canonical AT_PLATFORM if present , otherwise NULL .


<s> static SDValue getVectorShuffle ( SelectionDAG & DAG , EVT VT , const SDLoc & dl , SDValue V1 , SDValue V2 , ArrayRef < int > Mask ) { if ( ( ISD :: isBuildVectorOfConstantSDNodes ( V1 . getNode ( ) ) || V1 . isUndef ( ) ) && ( ISD :: isBuildVectorOfConstantSDNodes ( V2 . getNode ( ) ) || V2 . isUndef ( ) ) ) { SmallVector < SDValue > Ops ( Mask . size ( ) , DAG . getUNDEF ( VT . getScalarType ( ) ) ) ; for ( int I = 0 , NumElts = Mask . size ( ) ; I != NumElts ; ++ I ) { int M = Mask [ I ] ; if ( M < 0 ) continue ; SDValue V = ( M < NumElts ) ? V1 : V2 ; if ( V . isUndef ( ) ) continue ; Ops [ I ] = V . getOperand ( M % NumElts ) ; } return DAG . getBuildVector ( VT , dl , Ops ) ; } return DAG . getVectorShuffle ( VT , dl , V1 , V2 , Mask ) ; } </s>


<s>
void
SystemZTargetLowering
::
LowerOperationWrapper
(
SDNode
*
N
,
SmallVectorImpl
<
SDValue
>
&
Results
,
SelectionDAG
&
DAG
)
const
{
switch
(
N
->
getOpcode
(
)
)
{
case
ISD
::
ATOMIC_LOAD
:
{
SDLoc
DL
(
N
)
;
SDVTList
Tys
=
DAG
.
getVTList
(
MVT
::
Untyped
,
MVT
::
Other
)
;
SDValue
Ops
[
]
=
{
N
->
getOperand
(
0
)
,
N
->
getOperand
(
1
)
}
;
MachineMemOperand
*
MMO
=
cast
<
AtomicSDNode
>
(
N
)
->
getMemOperand
(
)
;
SDValue
Res
=
DAG
.
getMemIntrinsicNode
(
SystemZISD
::
ATOMIC_LOAD_128
,
DL
,
Tys
,
Ops
,
MVT
::
i128
,
MMO
)
;
Results
.
push_back
(
lowerGR128ToI128
(
DAG
,
Res
)
)
;
Results
.
push_back
(
Res
.
getValue
(
1
)
)
;
break
;
}
case
ISD
::
ATOMIC_STORE
:
{
SDLoc
DL
(
N
)
;
SDVTList
Tys
=
DAG
.
getVTList
(
MVT
::
Other
)
;
SDValue
Ops
[
]
=
{
N
->
getOperand
(
0
)
,
lowerI128ToGR128
(
DAG
,
N
->
getOperand
(
2
)
)
,
N
->
getOperand
(
1
)
}
;
MachineMemOperand
*
MMO
=
cast
<
AtomicSDNode
>
(
N
)
->
getMemOperand
(
)
;
SDValue
Res
=
DAG
.
getMemIntrinsicNode
(
SystemZISD
::
ATOMIC_STORE_128
,
DL
,
Tys
,
Ops
,
MVT
::
i128
,
MMO
)
;
if
(
cast
<
AtomicSDNode
>
(
N
)
->
getOrdering
(
)
==
AtomicOrdering
::
SequentiallyConsistent
)
Res
=
SDValue
(
DAG
.
getMachineNode
(
SystemZ
::
Serialize
,
DL
,
MVT
::
Other
,
Res
)
,
0
)
;
Results
.
push_back
(
Res
)
;
break
;
}
case
ISD
::
ATOMIC_CMP_SWAP_WITH_SUCCESS
:
{
SDLoc
DL
(
N
)
;
SDVTList
Tys
=
DAG
.
getVTList
(
MVT
::
Untyped
,
MVT
::
i32
,
MVT
::
Other
)
;
SDValue
Ops
[
]
=
{
N
->
getOperand
(
0
)
,
N
->
getOperand
(
1
)
,
lowerI128ToGR128
(
DAG
,
N
->
getOperand
(
2
)
)
,
lowerI128ToGR128
(
DAG
,
N
->
getOperand
(
3
)
)
}
;
MachineMemOperand
*
MMO
=
cast
<
AtomicSDNode
>
(
N
)
->
getMemOperand
(
)
;
SDValue
Res
=
DAG
.
getMemIntrinsicNode
(
SystemZISD
::
ATOMIC_CMP_SWAP_128
,
DL
,
Tys
,
Ops
,
MVT
::
i128
,
MMO
)
;
SDValue
Success
=
emitSETCC
(
DAG
,
DL
,
Res
.
getValue
(
1
)
,
SystemZ
::
CCMASK_CS
,
SystemZ
::
CCMASK_CS_EQ
)
;
Success
=
DAG
.
getZExtOrTrunc
(
Success
,
DL
,
N
->
getValueType
(
1
)
)
;
Results
.
push_back
(
lowerGR128ToI128
(
DAG
,
Res
)
)
;
Results
.
push_back
(
Success
)
;
Results
.
push_back
(
Res
.
getValue
(
2
)
)
;
break
;
}
default
:
llvm_unreachable
(
"Unexpected node to lower"
)
;
}
}
</s>

This callback is invoked by the type legalizer to legalize nodes with an illegal operand type but legal result types .


<s>
unsigned
PPCInstrInfo
::
reduceLoopCount
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
&
PreHeader
,
MachineInstr
*
IndVar
,
MachineInstr
&
Cmp
,
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
SmallVectorImpl
<
MachineInstr
*
>
&
PrevInsts
,
unsigned
Iter
,
unsigned
MaxIter
)
const
{
assert
(
(
!
IndVar
)
&&
isBDNZ
(
Cmp
.
getOpcode
(
)
)
&&
"Expecting a CTR loop"
)
;
MachineFunction
*
MF
=
MBB
.
getParent
(
)
;
DebugLoc
DL
=
Cmp
.
getDebugLoc
(
)
;
MachineInstr
*
Loop
=
findLoopInstr
(
PreHeader
)
;
if
(
!
Loop
)
return
0
;
unsigned
LoopCountReg
=
Loop
->
getOperand
(
0
)
.
getReg
(
)
;
MachineRegisterInfo
&
MRI
=
MF
->
getRegInfo
(
)
;
MachineInstr
*
LoopCount
=
MRI
.
getUniqueVRegDef
(
LoopCountReg
)
;
if
(
!
LoopCount
)
return
0
;
if
(
LoopCount
->
getOpcode
(
)
==
PPC
::
LI8
||
LoopCount
->
getOpcode
(
)
==
PPC
::
LI
)
{
int64_t
Offset
=
LoopCount
->
getOperand
(
1
)
.
getImm
(
)
;
if
(
Offset
<=
1
)
{
LoopCount
->
eraseFromParent
(
)
;
Loop
->
eraseFromParent
(
)
;
return
0
;
}
LoopCount
->
getOperand
(
1
)
.
setImm
(
Offset
1
)
;
return
Offset
1
;
}
Cond
.
push_back
(
MachineOperand
::
CreateImm
(
0
)
)
;
Cond
.
push_back
(
MachineOperand
::
CreateReg
(
Subtarget
.
isPPC64
(
)
PPC
::
CTR8
:
PPC
::
CTR
,
true
)
)
;
return
LoopCountReg
;
}
</s>

Generate code to reduce the loop iteration by one and check if the loop is finished .


<s> static machine_mode sparc_secondary_memory_needed_mode ( machine_mode mode ) { if ( TARGET_ARCH64 ) { if ( GET_MODE_BITSIZE ( mode ) < 32 ) return mode_for_size ( 32 , GET_MODE_CLASS ( mode ) , 0 ) . require ( ) ; return mode ; } else { if ( GET_MODE_BITSIZE ( mode ) < BITS_PER_WORD ) return mode_for_size ( BITS_PER_WORD , GET_MODE_CLASS ( mode ) , 0 ) . require ( ) ; return mode ; } } </s>

Implement TARGET_SECONDARY_MEMORY_NEEDED_MODE . get_secondary_mem widens its argument to BITS_PER_WORD which loses on v9 because the movsi and movsf patterns do n't handle r/f moves . For v8 we copy the default definition .


<s>
static
uint32_t
getBranchTargetOpValue
(
const
MCInst
&
MI
,
unsigned
OpIdx
,
unsigned
FixupKind
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
{
const
MCOperand
&
MO
=
MI
.
getOperand
(
OpIdx
)
;
if
(
MO
.
isImm
(
)
)
return
MO
.
getImm
(
)
;
assert
(
MO
.
isExpr
(
)
&&
"Unexpected branch target type!"
)
;
const
MCExpr
*
Expr
=
MO
.
getExpr
(
)
;
MCFixupKind
Kind
=
MCFixupKind
(
FixupKind
)
;
Fixups
.
push_back
(
MCFixup
::
create
(
0
,
Expr
,
Kind
,
MI
.
getLoc
(
)
)
)
;
return
0
;
}
</s>

getBranchTargetOpValue - Return binary encoding of the branch target operand .


<s> bool PPCDarwinAsmPrinter :: doFinalization ( Module & M ) { bool isPPC64 = TM . getDataLayout ( ) -> getPointerSizeInBits ( ) == 64 ; const TargetLoweringObjectFileMachO & TLOFMacho = static_cast < const TargetLoweringObjectFileMachO & > ( getObjFileLowering ( ) ) ; MachineModuleInfoMachO & MMIMacho = MMI -> getObjFileInfo < MachineModuleInfoMachO > ( ) ; MachineModuleInfoMachO :: SymbolListTy Stubs = MMIMacho . GetFnStubList ( ) ; if ( ! Stubs . empty ( ) ) EmitFunctionStubs ( Stubs ) ; if ( MAI -> doesSupportExceptionHandling ( ) && MMI ) { const std :: vector < const Function * > & Personalities = MMI -> getPersonalities ( ) ; for ( std :: vector < const Function * > :: const_iterator I = Personalities . begin ( ) , E = Personalities . end ( ) ; I != E ; ++ I ) { if ( * I ) { MCSymbol * NLPSym = GetSymbolWithGlobalValueBase ( * I , "$non_lazy_ptr" ) ; MachineModuleInfoImpl :: StubValueTy & StubSym = MMIMacho . getGVStubEntry ( NLPSym ) ; StubSym = MachineModuleInfoImpl :: StubValueTy ( Mang -> getSymbol ( * I ) , true ) ; } } } Stubs = MMIMacho . GetGVStubList ( ) ; if ( ! Stubs . empty ( ) ) { OutStreamer . SwitchSection ( TLOFMacho . getNonLazySymbolPointerSection ( ) ) ; EmitAlignment ( isPPC64 ? 3 : 2 ) ; for ( unsigned i = 0 , e = Stubs . size ( ) ; i != e ; ++ i ) { OutStreamer . EmitLabel ( Stubs [ i ] . first ) ; MachineModuleInfoImpl :: StubValueTy & MCSym = Stubs [ i ] . second ; OutStreamer . EmitSymbolAttribute ( MCSym . getPointer ( ) , MCSA_IndirectSymbol ) ; if ( MCSym . getInt ( ) ) OutStreamer . EmitIntValue ( 0 , isPPC64 ? 8 : 4 ) ; else OutStreamer . EmitValue ( MCSymbolRefExpr :: Create ( MCSym . getPointer ( ) , OutContext ) , isPPC64 ? 8 : 4 ) ; } Stubs . clear ( ) ; OutStreamer . AddBlankLine ( ) ; } Stubs = MMIMacho . GetHiddenGVStubList ( ) ; if ( ! Stubs . empty ( ) ) { OutStreamer . SwitchSection ( getObjFileLowering ( ) . getDataSection ( ) ) ; EmitAlignment ( isPPC64 ? 3 : 2 ) ; for ( unsigned i = 0 , e = Stubs . size ( ) ; i != e ; ++ i ) { OutStreamer . EmitLabel ( Stubs [ i ] . first ) ; OutStreamer . EmitValue ( MCSymbolRefExpr :: Create ( Stubs [ i ] . second . getPointer ( ) , OutContext ) , isPPC64 ? 8 : 4 ) ; } Stubs . clear ( ) ; OutStreamer . AddBlankLine ( ) ; } OutStreamer . EmitAssemblerFlag ( MCAF_SubsectionsViaSymbols ) ; return AsmPrinter :: doFinalization ( M ) ; } </s>

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


<s> rtx csky_return_addr ( int count , rtx frame ATTRIBUTE_UNUSED ) { if ( count != 0 ) return NULL_RTX ; return get_hard_reg_initial_val ( Pmode , CSKY_LR_REGNUM ) ; } </s>

Return an RTX indicating where the return address to the calling function can be found .


<s> static enum reg_class rs6000_secondary_reload_class ( enum reg_class rclass , machine_mode mode , rtx in ) { int regno ; if ( TARGET_ELF || ( DEFAULT_ABI == ABI_DARWIN && MACHOPIC_INDIRECT ) ) { if ( rclass != BASE_REGS && ( GET_CODE ( in ) == SYMBOL_REF || GET_CODE ( in ) == HIGH || GET_CODE ( in ) == LABEL_REF || GET_CODE ( in ) == CONST ) ) return BASE_REGS ; } if ( GET_CODE ( in ) == REG ) { regno = REGNO ( in ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) { regno = true_regnum ( in ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) regno = - 1 ; } } else if ( GET_CODE ( in ) == SUBREG ) { regno = true_regnum ( in ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) regno = - 1 ; } else regno = - 1 ; if ( TARGET_VSX && GET_MODE_SIZE ( mode ) < 16 && ( ( ( rclass == GENERAL_REGS || rclass == BASE_REGS ) && ( regno >= 0 && ALTIVEC_REGNO_P ( regno ) ) ) || ( ( rclass == VSX_REGS || rclass == ALTIVEC_REGS ) && ( regno >= 0 && INT_REGNO_P ( regno ) ) ) ) ) return FLOAT_REGS ; if ( rclass == GENERAL_REGS || rclass == BASE_REGS || ( regno >= 0 && INT_REGNO_P ( regno ) ) ) return NO_REGS ; if ( rclass == VSX_REGS && ( regno == - 1 || VSX_REGNO_P ( regno ) ) ) return NO_REGS ; if ( ( regno == - 1 || FP_REGNO_P ( regno ) ) && ( rclass == FLOAT_REGS || rclass == NON_SPECIAL_REGS ) ) return ( mode != SDmode || lra_in_progress ) ? NO_REGS : GENERAL_REGS ; if ( ( regno == - 1 || ALTIVEC_REGNO_P ( regno ) ) && rclass == ALTIVEC_REGS ) return NO_REGS ; if ( ( rclass == CR_REGS || rclass == CR0_REGS ) && regno >= 0 && CR_REGNO_P ( regno ) ) return NO_REGS ; return GENERAL_REGS ; } </s>

Return the register class of a scratch register needed to copy IN into or out of a register in RCLASS in MODE . If it can be done directly , NO_REGS is returned .


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


<s> bool ix86_match_ccmode ( rtx insn , machine_mode req_mode ) { rtx set ; machine_mode set_mode ; set = PATTERN ( insn ) ; if ( GET_CODE ( set ) == PARALLEL ) set = XVECEXP ( set , 0 , 0 ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; gcc_assert ( GET_CODE ( SET_SRC ( set ) ) == COMPARE ) ; set_mode = GET_MODE ( SET_DEST ( set ) ) ; switch ( set_mode ) { case E_CCNOmode : if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , 1 ) != const0_rtx ) ) return false ; break ; case E_CCmode : if ( req_mode == CCGCmode ) return false ; case E_CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return false ; case E_CCGOCmode : if ( req_mode == CCZmode ) return false ; case E_CCZmode : break ; case E_CCGZmode : case E_CCAmode : case E_CCCmode : case E_CCOmode : case E_CCPmode : case E_CCSmode : if ( set_mode != req_mode ) return false ; break ; default : gcc_unreachable ( ) ; } return GET_MODE ( SET_SRC ( set ) ) == set_mode ; } </s>

Return TRUE or FALSE depending on whether the first SET in INSN has source and destination with matching CC modes , and that the CC mode is at least as constrained as REQ_MODE .


This routine handles long unconditional branches that exceed the maximum range of a simple branch instruction .


<s> EVT SparcTargetLowering :: getSetCCResultType ( const DataLayout & , LLVMContext & , EVT VT ) const { if ( ! VT . isVector ( ) ) return MVT :: i32 ; return VT . changeVectorElementTypeToInteger ( ) ; } </s>

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


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

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


<s> static rtx mep_convert_arg ( machine_mode mode , rtx arg ) { if ( GET_MODE ( arg ) != mode && register_operand ( arg , VOIDmode ) && GET_MODE_SIZE ( GET_MODE ( arg ) ) == GET_MODE_SIZE ( mode ) ) return simplify_gen_subreg ( mode , arg , GET_MODE ( arg ) , 0 ) ; return arg ; } </s>

If ARG is a register operand that is the same size as MODE , convert it to MODE using a subreg . Otherwise return ARG as-is .


<s>
static
void
rs6000_output_function_prologue
(
FILE
*
file
)
{
if
(
!
cfun
->
is_thunk
)
rs6000_output_savres_externs
(
file
)
;
if
(
rs6000_global_entry_point_needed_p
(
)
)
{
const
char
*
name
=
XSTR
(
XEXP
(
DECL_RTL
(
current_function_decl
)
,
0
)
,
0
)
;
(
*
targetm
.
asm_out
.
internal_label
)
(
file
,
"LCF"
,
rs6000_pic_labelno
)
;
if
(
TARGET_CMODEL
!=
CMODEL_LARGE
)
{
char
buf
[
256
]
;
ASM_GENERATE_INTERNAL_LABEL
(
buf
,
"LCF"
,
rs6000_pic_labelno
)
;
fprintf
(
file
,
"0:\taddis 2,12,.TOC.-"
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"@ha\n"
)
;
fprintf
(
file
,
"\taddi 2,2,.TOC.-"
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"@l\n"
)
;
}
else
{
char
buf
[
256
]
;
fprintf
(
file
,
"\t.reloc .,R_PPC64_ENTRY\n"
)
;
fprintf
(
file
,
"\tld 2,"
)
;
ASM_GENERATE_INTERNAL_LABEL
(
buf
,
"LCL"
,
rs6000_pic_labelno
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"-"
)
;
ASM_GENERATE_INTERNAL_LABEL
(
buf
,
"LCF"
,
rs6000_pic_labelno
)
;
assemble_name
(
file
,
buf
)
;
fprintf
(
file
,
"(12)\n"
)
;
fprintf
(
file
,
"\tadd 2,2,12\n"
)
;
}
fputs
(
"\t.localentry\t"
,
file
)
;
assemble_name
(
file
,
name
)
;
fputs
(
",.-"
,
file
)
;
assemble_name
(
file
,
name
)
;
fputs
(
"\n"
,
file
)
;
}
if
(
TARGET_PROFILE_KERNEL
&&
crtl
->
profile
)
{
gcc_assert
(
DEFAULT_ABI
==
ABI_AIX
||
DEFAULT_ABI
==
ABI_ELFv2
)
;
gcc_assert
(
!
TARGET_32BIT
)
;
asm_fprintf
(
file
,
"\tmflr %s\n"
,
reg_names
[
0
]
)
;
if
(
DEFAULT_ABI
!=
ABI_ELFv2
&&
cfun
->
static_chain_decl
!=
)
{
asm_fprintf
(
file
,
"\tstd %s,24(%s)\n"
,
reg_names
[
STATIC_CHAIN_REGNUM
]
,
reg_names
[
1
]
)
;
fprintf
(
file
,
"\tbl %s\n"
,
RS6000_MCOUNT
)
;
asm_fprintf
(
file
,
"\tld %s,24(%s)\n"
,
reg_names
[
STATIC_CHAIN_REGNUM
]
,
reg_names
[
1
]
)
;
}
else
fprintf
(
file
,
"\tbl %s\n"
,
RS6000_MCOUNT
)
;
}
rs6000_pic_labelno
++
;
}
</s>


<s> static bool arm_needs_doubleword_align ( machine_mode mode , const_tree type ) { return ( GET_MODE_ALIGNMENT ( mode ) > PARM_BOUNDARY || ( type && TYPE_ALIGN ( type ) > PARM_BOUNDARY ) ) ; } </s>

Return 1 if double word alignment is required for argument passing . Return -1 if double word alignment used to be required for argument passing before PR77728 ABI fix , but is not required anymore . Return 0 if double word alignment is not required and was n't requried before either .


<s> bool X86AsmParser :: ParseDirective ( AsmToken DirectiveID ) { StringRef IDVal = DirectiveID . getIdentifier ( ) ; if ( IDVal == ".word" ) return ParseDirectiveWord ( 2 , DirectiveID . getLoc ( ) ) ; else if ( IDVal . startswith ( ".code" ) ) return ParseDirectiveCode ( IDVal , DirectiveID . getLoc ( ) ) ; else if ( IDVal . startswith ( ".intel_syntax" ) ) { getParser ( ) . setAssemblerDialect ( 1 ) ; if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { if ( Parser . getTok ( ) . getString ( ) == "noprefix" ) { Parser . Lex ( ) ; } else return true ; } return false ; } return true ; } </s>

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


<s> Optional < ParamLoadedValue > MipsInstrInfo :: describeLoadedValue ( const MachineInstr & MI , Register Reg ) const { DIExpression * Expr = DIExpression :: get ( MI . getMF ( ) -> getFunction ( ) . getContext ( ) , { } ) ; if ( auto RegImm = isAddImmediate ( MI , Reg ) ) { Register SrcReg = RegImm -> Reg ; int64_t Offset = RegImm -> Imm ; if ( SrcReg == Mips :: ZERO || SrcReg == Mips :: ZERO_64 ) { return ParamLoadedValue ( MI . getOperand ( 2 ) , Expr ) ; } Expr = DIExpression :: prepend ( Expr , DIExpression :: ApplyOffset , Offset ) ; return ParamLoadedValue ( MachineOperand :: CreateReg ( SrcReg , false ) , Expr ) ; } else if ( auto DestSrc = isCopyInstr ( MI ) ) { const MachineFunction * MF = MI . getMF ( ) ; const TargetRegisterInfo * TRI = MF -> getSubtarget ( ) . getRegisterInfo ( ) ; Register DestReg = DestSrc -> Destination -> getReg ( ) ; if ( TRI -> isSuperRegister ( Reg , DestReg ) || TRI -> isSubRegister ( Reg , DestReg ) ) return None ; } return TargetInstrInfo :: describeLoadedValue ( MI , Reg ) ; } </s>

Produce the expression describing the MI loading a value into the physical register Reg .


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

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


<s> enum direction function_arg_padding ( enum machine_mode mode , tree type ) { if ( ! AGGREGATE_PADDING_FIXED ) { if ( BYTES_BIG_ENDIAN ) { HOST_WIDE_INT size = 0 ; if ( mode == BLKmode ) { if ( type && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST ) size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ; if ( size == 1 || size == 2 || size == 4 ) return downward ; } return upward ; } if ( AGGREGATES_PAD_UPWARD_ALWAYS ) { if ( type != 0 && AGGREGATE_TYPE_P ( type ) ) return upward ; } return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) ; } </s>

Handle the FUNCTION_ARG_PADDING macro . For the 64 bit ABI structs are always stored left shifted in their argument slot .


<s> static rtx gen_save_register_window ( rtx increment ) { if ( TARGET_ARCH64 ) return gen_save_register_windowdi ( increment ) ; else return gen_save_register_windowsi ( increment ) ; } </s>


<s> int includes_rshift_p ( rtx shiftop , rtx andop ) { unsigned HOST_WIDE_INT shift_mask = ~ ( unsigned HOST_WIDE_INT ) 0 ; shift_mask >>= INTVAL ( shiftop ) ; return ( INTVAL ( andop ) & 0xffffffff & ~ shift_mask ) == 0 ; } </s>


<s> const char * pa_output_mod_insn ( int unsignedp , rtx_insn * insn ) { if ( unsignedp ) { import_milli ( remU ) ; return pa_output_millicode_call ( insn , gen_rtx_SYMBOL_REF ( SImode , "$$remU" ) ) ; } else { import_milli ( remI ) ; return pa_output_millicode_call ( insn , gen_rtx_SYMBOL_REF ( SImode , "$$remI" ) ) ; } } </s>


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

runOnMachineFunction - Emit the function body .


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


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

Return information about object file lowering .


<s> void SparcInstPrinter :: printRegName ( raw_ostream & OS , unsigned RegNo ) const { OS << '%' << StringRef ( getRegisterName ( RegNo ) ) . lower ( ) ; } </s>


<s> void MipsELFStreamer :: emitInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI ) { MCELFStreamer :: emitInstruction ( Inst , STI ) ; MCContext & Context = getContext ( ) ; const MCRegisterInfo * MCRegInfo = Context . getRegisterInfo ( ) ; for ( unsigned OpIndex = 0 ; OpIndex < Inst . getNumOperands ( ) ; ++ OpIndex ) { const MCOperand & Op = Inst . getOperand ( OpIndex ) ; if ( ! Op . isReg ( ) ) continue ; unsigned Reg = Op . getReg ( ) ; RegInfoRecord -> SetPhysRegUsed ( Reg , MCRegInfo ) ; } createPendingLabelRelocs ( ) ; } </s>

Targets should implement this to emit instructions .


<s> static void ix86_adjust_counter ( rtx countreg , HOST_WIDE_INT value ) { rtx ( * gen_add ) ( rtx , rtx , rtx ) = GET_MODE ( countreg ) == DImode ? gen_adddi3 : gen_addsi3 ; emit_insn ( gen_add ( countreg , countreg , GEN_INT ( - value ) ) ) ; } </s>


<s> bool X86TargetLowering :: useStackGuardXorFP ( ) const { return Subtarget . getTargetTriple ( ) . isOSMSVCRT ( ) && ! Subtarget . isTargetMachO ( ) ; } </s>

If this function returns true , stack protection checks should XOR the frame pointer ( or whichever pointer is used to address locals ) into the stack guard value before checking it .


<s> AArch64TargetLowering :: ConstraintType AArch64TargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'z' : return C_Other ; case 'x' : case 'w' : return C_RegisterClass ; case 'Q' : return C_Memory ; case 'S' : return C_Other ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


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

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


<s>
void
SystemZMCAsmBackend
::
relaxInstruction
(
const
MCInst
&
Inst
,
MCInst
&
Res
)
const
{
unsigned
Opcode
=
getRelaxedOpcode
(
Inst
.
getOpcode
(
)
)
;
assert
(
Opcode
&&
"Unexpected insn to relax"
)
;
Res
=
Inst
;
Res
.
setOpcode
(
Opcode
)
;
}
</s>

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

SystemZ
SystemZ
"Unexpected insn to relax"


<s> SDValue LEGTargetLowering :: LowerCallResult ( SDValue Chain , SDValue InGlue , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , SDLoc & dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { assert ( ! isVarArg && "Unsupported" ) ; SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallResult ( Ins , RetCC_LEG ) ; for ( auto & Loc : RVLocs ) { Chain = DAG . getCopyFromReg ( Chain , dl , Loc . getLocReg ( ) , Loc . getValVT ( ) , InGlue ) . getValue ( 1 ) ; InGlue = Chain . getValue ( 2 ) ; InVals . push_back ( Chain . getValue ( 0 ) ) ; } return Chain ; } </s>

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


<s> bool isScalable ( ) const { return Type == PPR || Type == ZPR ; } </s>

Returns true if the LLT is a scalable vector .


<s> const AArch64MCExpr * AArch64MCExpr :: Create ( VariantKind Kind , const MCExpr * Expr , MCContext & Ctx ) { return new ( Ctx ) AArch64MCExpr ( Kind , Expr ) ; } </s>

Construct a unary instruction , given the opcode and an operand .


<s>
void
SystemZHazardRecognizer
::
emitInstruction
(
MachineInstr
*
MI
,
bool
TakenBranch
)
{
SUnit
SU
(
MI
,
0
)
;
SU
.
isCall
=
MI
->
isCall
(
)
;
const
MCSchedClassDesc
*
SC
=
SchedModel
->
resolveSchedClass
(
MI
)
;
for
(
const
MCWriteProcResEntry
&
PRE
:
make_range
(
SchedModel
->
getWriteProcResBegin
(
SC
)
,
SchedModel
->
getWriteProcResEnd
(
SC
)
)
)
{
switch
(
SchedModel
->
getProcResource
(
PRE
.
ProcResourceIdx
)
->
BufferSize
)
{
case
0
:
SU
.
hasReservedResource
=
true
;
break
;
case
1
:
SU
.
isUnbuffered
=
true
;
break
;
default
:
break
;
}
}
EmitInstruction
(
&
SU
)
;
if
(
TakenBranch
&&
CurrGroupSize
>
0
)
nextGroup
(
false
)
;
assert
(
(
!
MI
->
isTerminator
(
)
||
isBranchRetTrap
(
MI
)
)
&&
"Scheduler: unhandled terminator!"
)
;
}
</s>

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


<s> bool sh_small_register_classes_for_mode_p ( machine_mode mode ATTRIBUTE_UNUSED ) { return true ; } </s>

Return true if registers in machine mode MODE will likely be allocated to registers in small register classes .


<s> tree arm_builtin_decl ( unsigned code , bool initialize_p ATTRIBUTE_UNUSED ) { if ( code >= ARM_BUILTIN_MAX ) return error_mark_node ; return arm_builtin_decls [ code ] ; } </s>


<s> SDValue AArch64TargetLowering :: getSqrtInputTest ( SDValue Op , SelectionDAG & DAG , const DenormalMode & Mode ) const { SDLoc DL ( Op ) ; EVT VT = Op . getValueType ( ) ; EVT CCVT = getSetCCResultType ( DAG . getDataLayout ( ) , * DAG . getContext ( ) , VT ) ; SDValue FPZero = DAG . getConstantFP ( 0.0 , DL , VT ) ; return DAG . getSetCC ( DL , CCVT , Op , FPZero , ISD :: SETEQ ) ; } </s>

Return a target-dependent comparison result if the input operand is suitable for use with a square root estimate calculation .


Pass or return a composite value in the FPR pair REGNO and REGNO + 1 . MODE is the mode of the composite . MODE1 and OFFSET1 are the mode and byte offset for the first value , likewise MODE2 and OFFSET2 for the second value .


<s> int reg_or_0_operand ( rtx op , enum machine_mode mode ) { switch ( GET_CODE ( op ) ) { case CONST_INT : return INTVAL ( op ) == 0 ; case REG : case SUBREG : return register_operand ( op , mode ) ; default : break ; } return 0 ; } </s>

Return true if OP is either a register or 0


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

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


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const override { uint64_t NumNops = Count / 4 ; for ( uint64_t i = 0 ; i != NumNops ; ++ i ) OW -> write32 ( 0x60000000 ) ; OW -> WriteZeros ( Count % 4 ) ; return true ; } </s>

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