<s> bool ARMBaseRegisterInfo :: canRealignStack ( const MachineFunction & MF ) const { const MachineRegisterInfo * MRI = & MF . getRegInfo ( ) ; const ARMFrameLowering * TFI = getFrameLowering ( MF ) ; if ( ! TargetRegisterInfo :: canRealignStack ( MF ) ) return false ; if ( ! MRI -> canReserveReg ( getFramePointerReg ( MF . getSubtarget < ARMSubtarget > ( ) ) ) ) return false ; if ( TFI -> hasReservedCallFrame ( MF ) ) return true ; return MRI -> canReserveReg ( BasePtr ) ; } </s>

True if the stack can be realigned for the target .


<s>
void
apply
(
ScheduleDAGInstrs
*
DAGInstrs
)
override
{
const
GCNSubtarget
&
ST
=
DAGInstrs
->
MF
.
getSubtarget
<
GCNSubtarget
>
(
)
;
if
(
!
ST
.
hasMAIInsts
(
)
||
DisablePowerSched
)
return
;
DAG
=
static_cast
<
ScheduleDAGMI
*
>
(
DAGInstrs
)
;
const
TargetSchedModel
*
TSchedModel
=
DAGInstrs
->
getSchedModel
(
)
;
if
(
!
TSchedModel
||
DAG
->
SUnits
.
empty
(
)
)
return
;
auto
LastSALU
=
DAG
->
SUnits
.
begin
(
)
;
auto
E
=
DAG
->
SUnits
.
end
(
)
;
SmallPtrSet
<
SUnit
*
,
32
>
Visited
;
for
(
SUnit
&
SU
:
DAG
->
SUnits
)
{
MachineInstr
&
MAI
=
*
SU
.
getInstr
(
)
;
if
(
!
TII
->
isMAI
(
MAI
)
||
MAI
.
getOpcode
(
)
==
AMDGPU
::
V_ACCVGPR_WRITE_B32
||
MAI
.
getOpcode
(
)
==
AMDGPU
::
V_ACCVGPR_READ_B32
)
continue
;
unsigned
Lat
=
TSchedModel
->
computeInstrLatency
(
&
MAI
)
1
;
LLVM_DEBUG
(
dbgs
(
)
<<
"Found MFMA: "
;
DAG
->
dumpNode
(
SU
)
;
dbgs
(
)
<<
"Need "
<<
Lat
<<
" instructions to cover latency.\n"
)
;
for
(
;
Lat
&&
LastSALU
!=
E
;
++
LastSALU
)
{
if
(
Visited
.
count
(
&
*
LastSALU
)
)
continue
;
if
(
!
isSALU
(
&
*
LastSALU
)
||
!
canAddEdge
(
&
*
LastSALU
,
&
SU
)
)
continue
;
Lat
-=
linkSALUChain
(
&
SU
,
&
*
LastSALU
,
Lat
,
Visited
)
;
}
}
}
</s>

Apply the profile inference algorithm for a given function .


<s> const char * MandarinTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return 0 ; case MDISD :: RET_FLAG : return "MDISD::RET_FLAG" ; case MDISD :: CMP : return "MDISD::CMP" ; case MDISD :: ICMP : return "MDISD::ICMP" ; case MDISD :: FCMP : return "MDISD::FCMP" ; case MDISD :: BR_CC : return "MDISD::BR_CC" ; case MDISD :: SELECT_CC : return "MDISD::SELECT_CC" ; case MDISD :: HIGH : return "MDISD::HIGH" ; case MDISD :: LOW : return "MDISD::LOW" ; case MDISD :: CALL : return "MDISD::CALL" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


<s>
SUnit
*
ConvergingVLIWScheduler
::
pickNode
(
bool
&
IsTopNode
)
{
if
(
DAG
->
top
(
)
==
DAG
->
bottom
(
)
)
{
assert
(
Top
.
Available
.
empty
(
)
&&
Top
.
Pending
.
empty
(
)
&&
Bot
.
Available
.
empty
(
)
&&
Bot
.
Pending
.
empty
(
)
&&
"ReadyQ garbage"
)
;
return
nullptr
;
}
SUnit
*
SU
;
if
(
llvm
::
ForceTopDown
)
{
SU
=
Top
.
pickOnlyChoice
(
)
;
if
(
!
SU
)
{
SchedCandidate
TopCand
;
CandResult
TopResult
=
pickNodeFromQueue
(
Top
.
Available
,
DAG
->
getTopRPTracker
(
)
,
TopCand
)
;
assert
(
TopResult
!=
NoCand
&&
"failed to find the first candidate"
)
;
(
void
)
TopResult
;
SU
=
TopCand
.
SU
;
}
IsTopNode
=
true
;
}
else
if
(
llvm
::
ForceBottomUp
)
{
SU
=
Bot
.
pickOnlyChoice
(
)
;
if
(
!
SU
)
{
SchedCandidate
BotCand
;
CandResult
BotResult
=
pickNodeFromQueue
(
Bot
.
Available
,
DAG
->
getBotRPTracker
(
)
,
BotCand
)
;
assert
(
BotResult
!=
NoCand
&&
"failed to find the first candidate"
)
;
(
void
)
BotResult
;
SU
=
BotCand
.
SU
;
}
IsTopNode
=
false
;
}
else
{
SU
=
pickNodeBidrectional
(
IsTopNode
)
;
}
if
(
SU
->
isTopReady
(
)
)
Top
.
removeReady
(
SU
)
;
if
(
SU
->
isBottomReady
(
)
)
Bot
.
removeReady
(
SU
)
;
DEBUG
(
dbgs
(
)
<<
"*** "
<<
(
IsTopNode
"Top"
:
"Bottom"
)
<<
" Scheduling Instruction in cycle "
<<
(
IsTopNode
Top
.
CurrCycle
:
Bot
.
CurrCycle
)
<<
'\n'
;
SU
->
dump
(
DAG
)
)
;
return
SU
;
}
</s>

Pick the next node to schedule , or return NULL .

Hexagon
"ReadyQ garbage"
"failed to find the first candidate"
"failed to find the first candidate"
"*** "
"Top"
"Bottom"
" Scheduling Instruction in cycle "


<s> bool R600InstrInfo :: analyzeBranch ( MachineBasicBlock & MBB , MachineBasicBlock * & TBB , MachineBasicBlock * & FBB , SmallVectorImpl < MachineOperand > & Cond , bool AllowModify ) const { MachineBasicBlock :: iterator I = MBB . getLastNonDebugInstr ( ) ; if ( I == MBB . end ( ) ) return false ; if ( isBranch ( I -> getOpcode ( ) ) ) return true ; if ( ! isJump ( I -> getOpcode ( ) ) ) { return false ; } while ( I != MBB . begin ( ) && std :: prev ( I ) -> getOpcode ( ) == R600 :: JUMP ) { MachineBasicBlock :: iterator PriorI = std :: prev ( I ) ; if ( AllowModify ) I -> removeFromParent ( ) ; I = PriorI ; } MachineInstr & LastInst = * I ; unsigned LastOpc = LastInst . getOpcode ( ) ; if ( I == MBB . begin ( ) || ! isJump ( ( -- I ) -> getOpcode ( ) ) ) { if ( LastOpc == R600 :: JUMP ) { TBB = LastInst . getOperand ( 0 ) . getMBB ( ) ; return false ; } else if ( LastOpc == R600 :: JUMP_COND ) { auto predSet = I ; while ( ! isPredicateSetter ( predSet -> getOpcode ( ) ) ) { predSet = -- I ; } TBB = LastInst . getOperand ( 0 ) . getMBB ( ) ; Cond . push_back ( predSet -> getOperand ( 1 ) ) ; Cond . push_back ( predSet -> getOperand ( 2 ) ) ; Cond . push_back ( MachineOperand :: CreateReg ( R600 :: PRED_SEL_ONE , false ) ) ; return false ; } return true ; } MachineInstr & SecondLastInst = * I ; unsigned SecondLastOpc = SecondLastInst . getOpcode ( ) ; if ( SecondLastOpc == R600 :: JUMP_COND && LastOpc == R600 :: JUMP ) { auto predSet = -- I ; while ( ! isPredicateSetter ( predSet -> getOpcode ( ) ) ) { predSet = -- I ; } TBB = SecondLastInst . getOperand ( 0 ) . getMBB ( ) ; FBB = LastInst . getOperand ( 0 ) . getMBB ( ) ; Cond . push_back ( predSet -> getOperand ( 1 ) ) ; Cond . push_back ( predSet -> getOperand ( 2 ) ) ; Cond . push_back ( MachineOperand :: CreateReg ( R600 :: PRED_SEL_ONE , false ) ) ; return false ; } return true ; } </s>

analyzeBranch - Analyze the branching code at the end of MBB , returning true if it can not be understood ( e.g .


<s> Liveness ( MachineRegisterInfo & mri , const DataFlowGraph & g ) : DFG ( g ) , TRI ( g . getTRI ( ) ) , MDT ( g . getDT ( ) ) , MDF ( g . getDF ( ) ) , RAI ( g . getRAI ( ) ) , MRI ( mri ) , Empty ( ) , Trace ( false ) { } </s>

During our initial pass over the program , we determine that things are either alive or maybe alive . More ...


"PIC16 Does not have any return address register"

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


<s> bool SICAsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { SICFI = MF . getInfo < SICFunctionInfo > ( ) ; AsmPrinter :: runOnMachineFunction ( MF ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> TargetLowering :: ConstraintWeight Cpu0TargetLowering :: getSingleConstraintMatchWeight ( AsmOperandInfo & Info , const char * Constraint ) const { ConstraintWeight Weight = CW_Invalid ; Value * CallOperandVal = Info . CallOperandVal ; if ( ! CallOperandVal ) return CW_Default ; Type * T = CallOperandVal -> getType ( ) ; switch ( * Constraint ) { default : Weight = TargetLowering :: getSingleConstraintMatchWeight ( Info , Constraint ) ; break ; case 'c' : if ( T -> isIntegerTy ( ) ) Weight = CW_SpecificReg ; break ; case 'I' : case 'J' : case 'K' : case 'L' : case 'N' : case 'O' : case 'P' : if ( isa < ConstantInt > ( CallOperandVal ) ) Weight = CW_Constant ; break ; case 'R' : Weight = CW_Memory ; break ; } return Weight ; } </s>

Examine constraint string and operand type and determine a weight value .


<s>
SDValue
ARCompactTargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
const
SmallVectorImpl
<
SDValue
>
&
OutVals
,
DebugLoc
dl
,
SelectionDAG
&
DAG
)
const
{
MachineFunction
&
MF
=
DAG
.
getMachineFunction
(
)
;
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
DAG
.
getMachineFunction
(
)
,
DAG
.
getTarget
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_ARCompact32
)
;
if
(
MF
.
getRegInfo
(
)
.
liveout_empty
(
)
)
{
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
if
(
RVLocs
[
i
]
.
isRegLoc
(
)
)
{
MF
.
getRegInfo
(
)
.
addLiveOut
(
RVLocs
[
i
]
.
getLocReg
(
)
)
;
}
}
SDValue
Flag
;
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
OutVals
[
i
]
,
Flag
)
;
Flag
=
Chain
.
getValue
(
1
)
;
}
unsigned
int
RetAddrOffset
=
8
;
SDValue
RetAddrOffsetNode
=
DAG
.
getConstant
(
RetAddrOffset
,
MVT
::
i32
)
;
if
(
Flag
.
getNode
(
)
)
{
return
DAG
.
getNode
(
ARCISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
Chain
,
RetAddrOffsetNode
,
Flag
)
;
}
return
DAG
.
getNode
(
ARCISD
::
RET_FLAG
,
dl
,
MVT
::
Other
,
Chain
,
RetAddrOffsetNode
)
;
}
</s>

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


<s> int mmix_asm_preferred_eh_data_format ( int code ATTRIBUTE_UNUSED , int global ATTRIBUTE_UNUSED ) { return DW_EH_PE_absptr ; } </s>


<s>
const
char
*
getPassName
(
)
const
override
{
return
"WebAssembly Instruction Selection"
;
}
</s>

getPassName - Return a nice clean name for a pass .

WebAssembly
"WebAssembly Instruction Selection"


<s> static void union_defs ( swap_web_entry * insn_entry , rtx insn , df_ref use ) { struct df_link * link = DF_REF_CHAIN ( use ) ; if ( ! link ) insn_entry [ INSN_UID ( insn ) ] . is_live_in = 1 ; while ( link ) { if ( DF_REF_IS_ARTIFICIAL ( link -> ref ) ) insn_entry [ INSN_UID ( insn ) ] . is_live_in = 1 ; if ( DF_REF_INSN_INFO ( link -> ref ) ) { rtx def_insn = DF_REF_INSN ( link -> ref ) ; gcc_assert ( NONDEBUG_INSN_P ( def_insn ) ) ; unionfind_union ( insn_entry + INSN_UID ( insn ) , insn_entry + INSN_UID ( def_insn ) ) ; } link = link -> next ; } } </s>

Union INSN with all insns containing definitions that reach USE . Detect whether USE is live-in to the current function .


"Successfully decoded 64-bit instruction."

"Not a 64-bit instruction, falling back to 32-bit."

"Successfully decoded 16-bit instruction with limm."

"Not a 16-bit instruction with limm, try without it."

Returns the disassembly of a single instruction .


<s>
const
char
*
output_addsi3
(
rtx
*
operands
)
{
if
(
!
operands_match_p
(
operands
[
0
]
,
operands
[
1
]
)
)
{
if
(
!
ADDRESS_REG_P
(
operands
[
1
]
)
)
{
rtx
tmp
=
operands
[
1
]
;
operands
[
1
]
=
operands
[
2
]
;
operands
[
2
]
=
tmp
;
}
if
(
GET_CODE
(
operands
[
2
]
)
==
CONST_INT
&&
(
INTVAL
(
operands
[
2
]
)
<
32768
||
INTVAL
(
operands
[
2
]
)
>
32767
)
)
return
"move%.l %2,%0\n\tadd%.l %1,%0"
;
if
(
GET_CODE
(
operands
[
2
]
)
==
REG
)
return
MOTOROLA
"lea (%1,%2.l),%0"
:
"lea %1@(0,%2:l),%0"
;
return
MOTOROLA
"lea (%c2,%1),%0"
:
"lea %1@(%c2),%0"
;
}
if
(
GET_CODE
(
operands
[
2
]
)
==
CONST_INT
)
{
if
(
INTVAL
(
operands
[
2
]
)
>
0
&&
INTVAL
(
operands
[
2
]
)
<=
8
)
return
"addq%.l %2,%0"
;
if
(
INTVAL
(
operands
[
2
]
)
<
0
&&
INTVAL
(
operands
[
2
]
)
>=
8
)
{
operands
[
2
]
=
GEN_INT
(
INTVAL
(
operands
[
2
]
)
)
;
return
"subq%.l %2,%0"
;
}
if
(
TUNE_CPU32
&&
REG_P
(
operands
[
0
]
)
)
{
if
(
INTVAL
(
operands
[
2
]
)
>
8
&&
INTVAL
(
operands
[
2
]
)
<=
16
)
{
operands
[
2
]
=
GEN_INT
(
INTVAL
(
operands
[
2
]
)
8
)
;
return
"addq%.l #8,%0\n\taddq%.l %2,%0"
;
}
if
(
INTVAL
(
operands
[
2
]
)
<
8
&&
INTVAL
(
operands
[
2
]
)
>=
16
)
{
operands
[
2
]
=
GEN_INT
(
INTVAL
(
operands
[
2
]
)
8
)
;
return
"subq%.l #8,%0\n\tsubq%.l %2,%0"
;
}
}
if
(
ADDRESS_REG_P
(
operands
[
0
]
)
&&
INTVAL
(
operands
[
2
]
)
>=
0x8000
&&
INTVAL
(
operands
[
2
]
)
<
0x8000
)
{
if
(
TUNE_68040
)
return
"add%.w %2,%0"
;
else
return
MOTOROLA
"lea (%c2,%0),%0"
:
"lea %0@(%c2),%0"
;
}
}
return
"add%.l %2,%0"
;
}
</s>

Output assembler code to perform a 32 bit 3 operand add .


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

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


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

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


<s> bool AlphaBSel :: runOnMachineFunction ( MachineFunction & Fn ) { for ( MachineFunction :: iterator MFI = Fn . begin ( ) , E = Fn . end ( ) ; MFI != E ; ++ MFI ) { MachineBasicBlock * MBB = MFI ; for ( MachineBasicBlock :: iterator MBBI = MBB -> begin ( ) , EE = MBB -> end ( ) ; MBBI != EE ; ++ MBBI ) { if ( MBBI -> getOpcode ( ) == Alpha :: COND_BRANCH_I || MBBI -> getOpcode ( ) == Alpha :: COND_BRANCH_F ) { const TargetInstrInfo * TII = Fn . getTarget ( ) . getInstrInfo ( ) ; MBBI -> setDesc ( TII -> get ( MBBI -> getOperand ( 0 ) . getImm ( ) ) ) ; } } } return true ; } </s>


"Should be handled target independently"

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


"Instr doesn't have FrameIndex operand!"

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


<s> void m32r_expand_epilogue ( void ) { int regno ; int noepilogue = FALSE ; int total_size ; gcc_assert ( current_frame_info . initialized ) ; total_size = current_frame_info . total_size ; if ( total_size == 0 ) { rtx_insn * insn = get_last_insn ( ) ; if ( insn && NOTE_P ( insn ) ) insn = prev_nonnote_insn ( insn ) ; if ( insn && BARRIER_P ( insn ) ) noepilogue = TRUE ; } if ( ! noepilogue ) { unsigned int var_size = current_frame_info . var_size ; unsigned int args_size = current_frame_info . args_size ; unsigned int gmask = current_frame_info . gmask ; int can_trust_sp_p = ! cfun -> calls_alloca ; if ( flag_exceptions ) emit_insn ( gen_blockage ( ) ) ; if ( can_trust_sp_p ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == 0 ) ; else if ( reg_offset < 32768 ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else if ( frame_pointer_needed ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == 0 ) emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; else if ( reg_offset < 32768 ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , frame_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else gcc_unreachable ( ) ; if ( current_frame_info . save_lr ) pop ( RETURN_ADDR_REGNUM ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ; for ( regno = M32R_MAX_INT_REGS - 1 ; regno >= 0 ; -- regno ) { if ( ( gmask & ( 1L << regno ) ) != 0 ) pop ( regno ) ; } if ( current_frame_info . save_fp ) pop ( FRAME_POINTER_REGNUM ) ; if ( current_frame_info . pretend_size != 0 ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( current_frame_info . pretend_size ) ) ) ; emit_insn ( gen_blockage ( ) ) ; } } </s>

Expand the m32r epilogue as a series of insns .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


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


<s> static struct machine_function * frv_init_machine_status ( void ) { return ggc_alloc_cleared ( sizeof ( struct machine_function ) ) ; } </s>

Function to set up the backend function structure .


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

Print the specified MCInst to the specified raw_ostream .


<s> bool M68kExpandPseudo :: runOnMachineFunction ( MachineFunction & MF ) { STI = & MF . getSubtarget < M68kSubtarget > ( ) ; TII = STI -> getInstrInfo ( ) ; TRI = STI -> getRegisterInfo ( ) ; MFI = MF . getInfo < M68kMachineFunctionInfo > ( ) ; FL = STI -> getFrameLowering ( ) ; bool Modified = false ; for ( MachineBasicBlock & MBB : MF ) Modified |= ExpandMBB ( MBB ) ; return Modified ; } </s>


<s>
void
applyFixup
(
const
MCAssembler
&
Asm
,
const
MCFixup
&
Fixup
,
const
MCValue
&
Target
,
MutableArrayRef
<
char
>
Data
,
uint64_t
Value
,
bool
IsResolved
,
const
MCSubtargetInfo
*
STI
)
const
override
{
unsigned
Size
=
1
<<
getFixupKindLog2Size
(
Fixup
.
getKind
(
)
)
;
assert
(
Fixup
.
getOffset
(
)
+
Size
<=
Data
.
size
(
)
&&
"Invalid fixup offset!"
)
;
assert
(
isIntN
(
Size
*
8
+
1
,
Value
)
&&
"Value does not fit in the Fixup field"
)
;
for
(
unsigned
i
=
0
;
i
!=
Size
;
++
i
)
Data
[
Fixup
.
getOffset
(
)
+
i
]
=
uint8_t
(
Value
>>
(
(
Size
i
1
)
*
8
)
)
;
}
</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 .


"Altivec is not implemented on AIX yet."

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


"This eliminateFrameIndex does not support Thumb1!"

"This code isn't needed if offset already handled!"

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


"\nrs6000_mode_dependent_address: ret = %s\n"

Debug version of rs6000_mode_dependent_address .


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


<s> bool SICTargetLowering :: CanLowerReturn ( CallingConv :: ID CallConv , MachineFunction & MF , bool IsVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , LLVMContext & Context ) const { SmallVector < CCValAssign , 16 > RVLocs ; CCState CCInfo ( CallConv , IsVarArg , MF , RVLocs , Context ) ; return CCInfo . CheckReturn ( Outs , RetCC_SIC ) ; } </s>

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


<s> bool X86TargetMachine :: addPreEmitPass ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { if ( OptLevel != CodeGenOpt :: None && Subtarget . hasSSE2 ( ) ) { PM . add ( createSSEDomainFixPass ( ) ) ; return true ; } return false ; } </s>

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


<s> bool PPCMCExpr :: evaluateAsConstant ( int64_t & Res ) const { MCValue Value ; if ( ! getSubExpr ( ) -> evaluateAsRelocatable ( Value , nullptr , nullptr ) ) return false ; if ( ! Value . isAbsolute ( ) ) return false ; Res = evaluateAsInt64 ( Value . getConstant ( ) ) ; return true ; } </s>

Evaluates the fixup as a constant value .


<s> int arm_attr_length_move_neon ( rtx_insn * insn ) { rtx reg , mem , addr ; int load ; machine_mode mode ; extract_insn_cached ( insn ) ; if ( REG_P ( recog_data . operand [ 0 ] ) && REG_P ( recog_data . operand [ 1 ] ) ) { mode = GET_MODE ( recog_data . operand [ 0 ] ) ; switch ( mode ) { case E_EImode : case E_OImode : return 8 ; case E_CImode : return 12 ; case E_XImode : return 16 ; default : gcc_unreachable ( ) ; } } load = REG_P ( recog_data . operand [ 0 ] ) ; reg = recog_data . operand [ ! load ] ; mem = recog_data . operand [ load ] ; gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , 0 ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , 0 ) ) == PLUS ) addr = XEXP ( addr , 0 ) ; if ( LABEL_REF_P ( addr ) || GET_CODE ( addr ) == PLUS ) { int insns = REG_NREGS ( reg ) / 2 ; return insns * 4 ; } else return 4 ; } </s>

Compute and return the length of neon_mov < mode > , where < mode > is one of VSTRUCT modes : EI , OI , CI or XI .


<s> static void vector_init_bshuffle ( rtx target , rtx elt , machine_mode mode , machine_mode inner_mode ) { rtx t1 , final_insn , sel ; int bmask ; t1 = gen_reg_rtx ( mode ) ; elt = convert_modes ( SImode , inner_mode , elt , true ) ; emit_move_insn ( gen_lowpart ( SImode , t1 ) , elt ) ; switch ( mode ) { case E_V2SImode : final_insn = gen_bshufflev2si_vis ( target , t1 , t1 ) ; bmask = 0x45674567 ; break ; case E_V4HImode : final_insn = gen_bshufflev4hi_vis ( target , t1 , t1 ) ; bmask = 0x67676767 ; break ; case E_V8QImode : final_insn = gen_bshufflev8qi_vis ( target , t1 , t1 ) ; bmask = 0x77777777 ; break ; default : gcc_unreachable ( ) ; } sel = force_reg ( SImode , GEN_INT ( bmask ) ) ; emit_insn ( gen_bmasksi_vis ( gen_reg_rtx ( SImode ) , sel , const0_rtx ) ) ; emit_insn ( final_insn ) ; } </s>

Subroutine of sparc_expand_vector_init . Emit code to initialize all fields of TARGET to ELT by means of VIS2 BSHUFFLE insn . MODE and INNER_MODE are the modes describing TARGET .


<s> SDValue R600TargetLowering :: LowerFormalArguments ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , SDLoc DL , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { SmallVector < CCValAssign , 16 > ArgLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , ArgLocs , * DAG . getContext ( ) ) ; MachineFunction & MF = DAG . getMachineFunction ( ) ; R600MachineFunctionInfo * MFI = MF . getInfo < R600MachineFunctionInfo > ( ) ; SmallVector < ISD :: InputArg , 8 > LocalIns ; getOriginalFunctionArgs ( DAG , MF . getFunction ( ) , Ins , LocalIns ) ; AnalyzeFormalArguments ( CCInfo , LocalIns ) ; for ( unsigned i = 0 , e = Ins . size ( ) ; i < e ; ++ i ) { CCValAssign & VA = ArgLocs [ i ] ; const ISD :: InputArg & In = Ins [ i ] ; EVT VT = In . VT ; EVT MemVT = VA . getLocVT ( ) ; if ( ! VT . isVector ( ) && MemVT . isVector ( ) ) { MemVT = MemVT . getVectorElementType ( ) ; } if ( MFI -> getShaderType ( ) != ShaderType :: COMPUTE ) { unsigned Reg = MF . addLiveIn ( VA . getLocReg ( ) , & AMDGPU :: R600_Reg128RegClass ) ; SDValue Register = DAG . getCopyFromReg ( Chain , DL , Reg , VT ) ; InVals . push_back ( Register ) ; continue ; } PointerType * PtrTy = PointerType :: get ( VT . getTypeForEVT ( * DAG . getContext ( ) ) , AMDGPUAS :: CONSTANT_BUFFER_0 ) ; ISD :: LoadExtType Ext = ISD :: NON_EXTLOAD ; if ( MemVT . getScalarSizeInBits ( ) != VT . getScalarSizeInBits ( ) ) { Ext = ISD :: SEXTLOAD ; } unsigned ValBase = ArgLocs [ In . getOrigArgIndex ( ) ] . getLocMemOffset ( ) ; unsigned PartOffset = VA . getLocMemOffset ( ) ; unsigned Offset = 36 + VA . getLocMemOffset ( ) ; MachinePointerInfo PtrInfo ( UndefValue :: get ( PtrTy ) , PartOffset - ValBase ) ; SDValue Arg = DAG . getLoad ( ISD :: UNINDEXED , Ext , VT , DL , Chain , DAG . getConstant ( Offset , MVT :: i32 ) , DAG . getUNDEF ( MVT :: i32 ) , PtrInfo , MemVT , false , true , true , 4 ) ; InVals . push_back ( Arg ) ; MFI -> ABIArgOffset = Offset + MemVT . getStoreSize ( ) ; } return Chain ; } </s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by the Ins array , into the specified DAG .


<s> bool ARMTargetLowering :: isZExtFree ( SDValue Val , EVT VT2 ) const { if ( Val . getOpcode ( ) != ISD :: LOAD ) return false ; EVT VT1 = Val . getValueType ( ) ; if ( ! VT1 . isSimple ( ) || ! VT1 . isInteger ( ) || ! VT2 . isSimple ( ) || ! VT2 . isInteger ( ) ) return false ; switch ( VT1 . getSimpleVT ( ) . SimpleTy ) { default : break ; case MVT :: i1 : case MVT :: i8 : case MVT :: i16 : return true ; } return false ; } </s>

Return true if zero-extending the specific node Val to type VT2 is free ( either because it 's implicitly zero-extended such as ARM ldrb / ldrh or because it 's folded such as X86 zero-extending loads ) .


<s> void AArch64PassConfig :: addPreSched2 ( ) { addPass ( createAArch64ExpandPseudoPass ( ) ) ; if ( TM -> getOptLevel ( ) != CodeGenOpt :: None ) { if ( EnableLoadStoreOpt ) addPass ( createAArch64LoadStoreOptimizationPass ( ) ) ; } addPass ( createAArch64SpeculationHardeningPass ( ) ) ; addPass ( createAArch64IndirectThunks ( ) ) ; addPass ( createAArch64SLSHardeningPass ( ) ) ; if ( TM -> getOptLevel ( ) != CodeGenOpt :: None ) { if ( EnableFalkorHWPFFix ) addPass ( createFalkorHWPFFixPass ( ) ) ; } } </s>

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


<s> const TargetRegisterClass * PPCRegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { if ( Subtarget . isPPC64 ( ) ) return & PPC :: G8RCRegClass ; return & PPC :: GPRCRegClass ; } </s>

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .

PowerPC PPC PPC PPC::G8RCRegClass PPC::GPRCRegClass


<s> unsigned SystemZTargetLowering :: ComputeNumSignBitsForTargetNode ( SDValue Op , const APInt & DemandedElts , const SelectionDAG & DAG , unsigned Depth ) const { if ( Op . getResNo ( ) != 0 ) return 1 ; unsigned Opcode = Op . getOpcode ( ) ; if ( Opcode == ISD :: INTRINSIC_WO_CHAIN ) { unsigned Id = cast < ConstantSDNode > ( Op . getOperand ( 0 ) ) -> getZExtValue ( ) ; switch ( Id ) { case Intrinsic :: s390_vpksh : case Intrinsic :: s390_vpksf : case Intrinsic :: s390_vpksg : case Intrinsic :: s390_vpkshs : case Intrinsic :: s390_vpksfs : case Intrinsic :: s390_vpksgs : case Intrinsic :: s390_vpklsh : case Intrinsic :: s390_vpklsf : case Intrinsic :: s390_vpklsg : case Intrinsic :: s390_vpklshs : case Intrinsic :: s390_vpklsfs : case Intrinsic :: s390_vpklsgs : case Intrinsic :: s390_vpdi : case Intrinsic :: s390_vsldb : case Intrinsic :: s390_vperm : return computeNumSignBitsBinOp ( Op , DemandedElts , DAG , Depth , 1 ) ; case Intrinsic :: s390_vuphb : case Intrinsic :: s390_vuphh : case Intrinsic :: s390_vuphf : case Intrinsic :: s390_vuplb : case Intrinsic :: s390_vuplhw : case Intrinsic :: s390_vuplf : { SDValue PackedOp = Op . getOperand ( 1 ) ; APInt SrcDemE = getDemandedSrcElements ( Op , DemandedElts , 1 ) ; unsigned Tmp = DAG . ComputeNumSignBits ( PackedOp , SrcDemE , Depth + 1 ) ; EVT VT = Op . getValueType ( ) ; unsigned VTBits = VT . getScalarSizeInBits ( ) ; Tmp += VTBits - PackedOp . getScalarValueSizeInBits ( ) ; return Tmp ; } default : break ; } } else { switch ( Opcode ) { case SystemZISD :: SELECT_CCMASK : return computeNumSignBitsBinOp ( Op , DemandedElts , DAG , Depth , 0 ) ; default : break ; } } return 1 ; } </s>

Determine the number of bits in the operation that are sign bits .


<s> static void arm_function_arg_advance ( cumulative_args_t pcum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * pcum = get_cumulative_args ( pcum_v ) ; if ( pcum -> pcs_variant <= ARM_PCS_AAPCS_LOCAL ) { aapcs_layout_arg ( pcum , arg . mode , arg . type , arg . named ) ; if ( pcum -> aapcs_cprc_slot >= 0 ) { aapcs_cp_arg_layout [ pcum -> aapcs_cprc_slot ] . advance ( pcum , arg . mode , arg . type ) ; pcum -> aapcs_cprc_slot = - 1 ; } pcum -> aapcs_arg_processed = false ; pcum -> aapcs_ncrn = pcum -> aapcs_next_ncrn ; pcum -> aapcs_reg = NULL_RTX ; pcum -> aapcs_partial = 0 ; } else { pcum -> nargs += 1 ; if ( arm_vector_mode_supported_p ( arg . mode ) && pcum -> named_count > pcum -> nargs && TARGET_IWMMXT_ABI ) pcum -> iwmmxt_nregs += 1 ; else pcum -> nregs += ARM_NUM_REGS2 ( arg . mode , arg . type ) ; } } </s>

Update the data in PCUM to advance over an argument of mode MODE and data type TYPE . ( TYPE is null for libcalls where that information may not be available . )


<s> MCELFStreamer & getStreamer ( ) { return static_cast < MCELFStreamer & > ( Streamer ) ; } </s>

Return the output streamer for the assembler .


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


<s> bool HexagonStoreWidening :: runOnMachineFunction ( MachineFunction & MFn ) { if ( skipFunction ( * MFn . getFunction ( ) ) ) return false ; MF = & MFn ; auto & ST = MFn . getSubtarget < HexagonSubtarget > ( ) ; TII = ST . getInstrInfo ( ) ; TRI = ST . getRegisterInfo ( ) ; MRI = & MFn . getRegInfo ( ) ; AA = & getAnalysis < AAResultsWrapperPass > ( ) . getAAResults ( ) ; bool Changed = false ; for ( auto & B : MFn ) Changed |= processBasicBlock ( B ) ; return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s>
bool
AMDGPUAsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
SetupMachineFunction
(
MF
)
;
OutStreamer
.
emitRawComment
(
Twine
(
'@'
)
+
MF
.
getName
(
)
+
Twine
(
':'
)
)
;
MCContext
&
Context
=
getObjFileLowering
(
)
.
getContext
(
)
;
const
MCSectionELF
*
ConfigSection
=
Context
.
getELFSection
(
".AMDGPU.config"
,
ELF
::
SHT_PROGBITS
,
0
,
SectionKind
::
getReadOnly
(
)
)
;
OutStreamer
.
SwitchSection
(
ConfigSection
)
;
const
AMDGPUSubtarget
&
STM
=
TM
.
getSubtarget
<
AMDGPUSubtarget
>
(
)
;
SIProgramInfo
KernelInfo
;
if
(
STM
.
getGeneration
(
)
>
AMDGPUSubtarget
::
NORTHERN_ISLANDS
)
{
findNumUsedRegistersSI
(
MF
,
KernelInfo
.
NumSGPR
,
KernelInfo
.
NumVGPR
)
;
EmitProgramInfoSI
(
MF
,
KernelInfo
)
;
}
else
{
EmitProgramInfoR600
(
MF
)
;
}
DisasmLines
.
clear
(
)
;
HexLines
.
clear
(
)
;
DisasmLineMaxLen
=
0
;
OutStreamer
.
SwitchSection
(
getObjFileLowering
(
)
.
getTextSection
(
)
)
;
EmitFunctionBody
(
)
;
if
(
isVerbose
(
)
)
{
const
MCSectionELF
*
CommentSection
=
Context
.
getELFSection
(
".AMDGPU.csdata"
,
ELF
::
SHT_PROGBITS
,
0
,
SectionKind
::
getReadOnly
(
)
)
;
OutStreamer
.
SwitchSection
(
CommentSection
)
;
if
(
STM
.
getGeneration
(
)
>
AMDGPUSubtarget
::
NORTHERN_ISLANDS
)
{
OutStreamer
.
emitRawComment
(
" Kernel info:"
,
false
)
;
OutStreamer
.
emitRawComment
(
" NumSgprs: "
+
Twine
(
KernelInfo
.
NumSGPR
)
,
false
)
;
OutStreamer
.
emitRawComment
(
" NumVgprs: "
+
Twine
(
KernelInfo
.
NumVGPR
)
,
false
)
;
}
else
{
R600MachineFunctionInfo
*
MFI
=
MF
.
getInfo
<
R600MachineFunctionInfo
>
(
)
;
OutStreamer
.
emitRawComment
(
Twine
(
"SQ_PGM_RESOURCES:STACK_SIZE = "
+
Twine
(
MFI
->
StackSize
)
)
)
;
}
}
if
(
STM
.
dumpCode
(
)
)
{
MF
.
dump
(
)
;
if
(
DisasmEnabled
)
{
OutStreamer
.
SwitchSection
(
Context
.
getELFSection
(
".AMDGPU.disasm"
,
ELF
::
SHT_NOTE
,
0
,
SectionKind
::
getReadOnly
(
)
)
)
;
for
(
size_t
i
=
0
;
i
<
DisasmLines
.
size
(
)
;
++
i
)
{
std
::
string
Comment
(
DisasmLineMaxLen
DisasmLines
[
i
]
.
size
(
)
,
' '
)
;
Comment
+=
" ; "
+
HexLines
[
i
]
+
"\n"
;
OutStreamer
.
EmitBytes
(
StringRef
(
DisasmLines
[
i
]
)
)
;
OutStreamer
.
EmitBytes
(
StringRef
(
Comment
)
)
;
}
}
}
return
false
;
}
</s>


<s> InstructionCost AArch64TTIImpl :: getIntImmCost ( const APInt & Imm , Type * Ty , TTI :: TargetCostKind CostKind ) { assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 ) return ~ 0U ; APInt ImmVal = Imm ; if ( BitSize & 0x3f ) ImmVal = Imm . sext ( ( BitSize + 63 ) & ~ 0x3fU ) ; InstructionCost Cost = 0 ; for ( unsigned ShiftVal = 0 ; ShiftVal < BitSize ; ShiftVal += 64 ) { APInt Tmp = ImmVal . ashr ( ShiftVal ) . sextOrTrunc ( 64 ) ; int64_t Val = Tmp . getSExtValue ( ) ; Cost += getIntImmCost ( Val ) ; } return std :: max < InstructionCost > ( 1 , Cost ) ; } </s>

Calculate the cost of materializing a 64-bit value .


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

Return information about object file lowering .


<s>
void
WaitcntBrackets
::
print
(
raw_ostream
&
OS
)
{
OS
<<
'\n'
;
for
(
auto
T
:
inst_counter_types
(
)
)
{
unsigned
LB
=
getScoreLB
(
T
)
;
unsigned
UB
=
getScoreUB
(
T
)
;
switch
(
T
)
{
case
VM_CNT
:
OS
<<
"    VM_CNT("
<<
UB
LB
<<
"): "
;
break
;
case
LGKM_CNT
:
OS
<<
"    LGKM_CNT("
<<
UB
LB
<<
"): "
;
break
;
case
EXP_CNT
:
OS
<<
"    EXP_CNT("
<<
UB
LB
<<
"): "
;
break
;
case
VS_CNT
:
OS
<<
"    VS_CNT("
<<
UB
LB
<<
"): "
;
break
;
default
:
OS
<<
"    UNKNOWN("
<<
UB
LB
<<
"): "
;
break
;
}
if
(
LB
<
UB
)
{
for
(
int
J
=
0
;
J
<=
VgprUB
;
J
++
)
{
unsigned
RegScore
=
getRegScore
(
J
,
T
)
;
if
(
RegScore
<=
LB
)
continue
;
unsigned
RelScore
=
RegScore
LB
1
;
if
(
J
<
SQ_MAX_PGM_VGPRS
+
EXTRA_VGPR_LDS
)
{
OS
<<
RelScore
<<
":v"
<<
J
<<
" "
;
}
else
{
OS
<<
RelScore
<<
":ds "
;
}
}
if
(
T
==
LGKM_CNT
)
{
for
(
int
J
=
0
;
J
<=
SgprUB
;
J
++
)
{
unsigned
RegScore
=
getRegScore
(
J
+
NUM_ALL_VGPRS
,
LGKM_CNT
)
;
if
(
RegScore
<=
LB
)
continue
;
unsigned
RelScore
=
RegScore
LB
1
;
OS
<<
RelScore
<<
":s"
<<
J
<<
" "
;
}
}
}
OS
<<
'\n'
;
}
OS
<<
'\n'
;
}
</s>

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


<s> unsigned WebAssemblyFastISel :: fastMaterializeConstant ( const Constant * C ) { if ( const GlobalValue * GV = dyn_cast < GlobalValue > ( C ) ) { if ( TLI . isPositionIndependent ( ) ) return 0 ; if ( GV -> isThreadLocal ( ) ) return 0 ; Register ResultReg = createResultReg ( Subtarget -> hasAddr64 ( ) ? & WebAssembly :: I64RegClass : & WebAssembly :: I32RegClass ) ; unsigned Opc = Subtarget -> hasAddr64 ( ) ? WebAssembly :: CONST_I64 : WebAssembly :: CONST_I32 ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , TII . get ( Opc ) , ResultReg ) . addGlobalAddress ( GV ) ; return ResultReg ; } return 0 ; } </s>

Emit a constant in a register using target-specific logic , such as constant pool loads .


<s>
void
AArch64AppleInstPrinter
::
printInst
(
const
MCInst
*
MI
,
raw_ostream
&
O
,
StringRef
Annot
,
const
MCSubtargetInfo
&
STI
)
{
unsigned
Opcode
=
MI
->
getOpcode
(
)
;
StringRef
Layout
,
Mnemonic
;
bool
IsTbx
;
if
(
isTblTbxInstruction
(
MI
->
getOpcode
(
)
,
Layout
,
IsTbx
)
)
{
O
<<
"\t"
<<
(
IsTbx
"tbx"
:
"tbl"
)
<<
Layout
<<
'\t'
<<
getRegisterName
(
MI
->
getOperand
(
0
)
.
getReg
(
)
,
AArch64
::
vreg
)
<<
", "
;
unsigned
ListOpNum
=
IsTbx
2
:
1
;
printVectorList
(
MI
,
ListOpNum
,
STI
,
O
,
""
)
;
O
<<
", "
<<
getRegisterName
(
MI
->
getOperand
(
ListOpNum
+
1
)
.
getReg
(
)
,
AArch64
::
vreg
)
;
printAnnotation
(
O
,
Annot
)
;
return
;
}
if
(
const
LdStNInstrDesc
*
LdStDesc
=
getLdStNInstrDesc
(
Opcode
)
)
{
O
<<
"\t"
<<
LdStDesc
->
Mnemonic
<<
LdStDesc
->
Layout
<<
'\t'
;
int
OpNum
=
LdStDesc
->
ListOperand
;
printVectorList
(
MI
,
OpNum
++
,
STI
,
O
,
""
)
;
if
(
LdStDesc
->
HasLane
)
O
<<
'['
<<
MI
->
getOperand
(
OpNum
++
)
.
getImm
(
)
<<
']'
;
unsigned
AddrReg
=
MI
->
getOperand
(
OpNum
++
)
.
getReg
(
)
;
O
<<
", ["
<<
getRegisterName
(
AddrReg
)
<<
']'
;
if
(
LdStDesc
->
NaturalOffset
!=
0
)
{
unsigned
Reg
=
MI
->
getOperand
(
OpNum
++
)
.
getReg
(
)
;
if
(
Reg
!=
AArch64
::
XZR
)
O
<<
", "
<<
getRegisterName
(
Reg
)
;
else
{
assert
(
LdStDesc
->
NaturalOffset
&&
"no offset on post-inc instruction?"
)
;
O
<<
", #"
<<
LdStDesc
->
NaturalOffset
;
}
}
printAnnotation
(
O
,
Annot
)
;
return
;
}
AArch64InstPrinter
::
printInst
(
MI
,
O
,
Annot
,
STI
)
;
}
</s>

Print the specified MCInst to the specified raw_ostream .


<s>
void
XCoreRegisterInfo
::
emitEpilogue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
MachineFrameInfo
*
MFI
=
MF
.
getFrameInfo
(
)
;
MachineBasicBlock
::
iterator
MBBI
=
prior
(
MBB
.
end
(
)
)
;
DebugLoc
dl
=
MBBI
->
getDebugLoc
(
)
;
bool
FP
=
hasFP
(
MF
)
;
if
(
FP
)
{
unsigned
FramePtr
=
XCore
::
R10
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
XCore
::
SETSP_1r
)
)
.
addReg
(
FramePtr
)
;
}
int
FrameSize
=
MFI
->
getStackSize
(
)
;
assert
(
FrameSize
%
4
==
0
&&
"Misaligned frame size"
)
;
FrameSize
/=
4
;
bool
isU6
=
isImmU6
(
FrameSize
)
;
if
(
!
isU6
&&
!
isImmU16
(
FrameSize
)
)
{
report_fatal_error
(
"emitEpilogue Frame size too big: "
+
Twine
(
FrameSize
)
)
;
}
if
(
FrameSize
)
{
XCoreFunctionInfo
*
XFI
=
MF
.
getInfo
<
XCoreFunctionInfo
>
(
)
;
if
(
FP
)
{
int
FPSpillOffset
=
MFI
->
getObjectOffset
(
XFI
->
getFPSpillSlot
(
)
)
;
FPSpillOffset
+=
FrameSize
*
4
;
loadFromStack
(
MBB
,
MBBI
,
XCore
::
R10
,
FPSpillOffset
,
dl
)
;
}
bool
restoreLR
=
XFI
->
getUsesLR
(
)
;
if
(
restoreLR
&&
MFI
->
getObjectOffset
(
XFI
->
getLRSpillSlot
(
)
)
!=
0
)
{
int
LRSpillOffset
=
MFI
->
getObjectOffset
(
XFI
->
getLRSpillSlot
(
)
)
;
LRSpillOffset
+=
FrameSize
*
4
;
loadFromStack
(
MBB
,
MBBI
,
XCore
::
LR
,
LRSpillOffset
,
dl
)
;
restoreLR
=
false
;
}
if
(
restoreLR
)
{
assert
(
MBBI
->
getOpcode
(
)
==
XCore
::
RETSP_u6
||
MBBI
->
getOpcode
(
)
==
XCore
::
RETSP_lu6
)
;
int
Opcode
=
(
isU6
)
XCore
::
RETSP_u6
:
XCore
::
RETSP_lu6
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Opcode
)
)
.
addImm
(
FrameSize
)
;
MBB
.
erase
(
MBBI
)
;
}
else
{
int
Opcode
=
(
isU6
)
XCore
::
LDAWSP_ru6_RRegs
:
XCore
::
LDAWSP_lru6_RRegs
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Opcode
)
,
XCore
::
SP
)
.
addImm
(
FrameSize
)
;
}
}
}
</s>


<s> static void output_decl_chunk ( void ) { begin_decl_field ( ) ; output_address ( gen_int_mode ( init_part , decl_chunk_mode ) ) ; init_part = 0 ; } </s>

Output the currently stored chunk as an initializer value .


<s> int memory_address_length ( rtx addr , bool lea ) { struct ix86_address parts ; rtx base , index , disp ; int len ; int ok ; if ( GET_CODE ( addr ) == PRE_DEC || GET_CODE ( addr ) == POST_INC || GET_CODE ( addr ) == PRE_MODIFY || GET_CODE ( addr ) == POST_MODIFY ) return 0 ; ok = ix86_decompose_address ( addr , & parts ) ; gcc_assert ( ok ) ; len = ( parts . seg == ADDR_SPACE_GENERIC ) ? 0 : 1 ; if ( TARGET_64BIT && ! lea && ( SImode_address_operand ( addr , VOIDmode ) || ( parts . base && GET_MODE ( parts . base ) == SImode ) || ( parts . index && GET_MODE ( parts . index ) == SImode ) ) ) len ++ ; base = parts . base ; index = parts . index ; disp = parts . disp ; if ( base && SUBREG_P ( base ) ) base = SUBREG_REG ( base ) ; if ( index && SUBREG_P ( index ) ) index = SUBREG_REG ( index ) ; gcc_assert ( base == NULL_RTX || REG_P ( base ) ) ; gcc_assert ( index == NULL_RTX || REG_P ( index ) ) ; if ( base && ! index && ! disp ) { if ( base == arg_pointer_rtx || base == frame_pointer_rtx || REGNO ( base ) == SP_REG || REGNO ( base ) == BP_REG || REGNO ( base ) == R12_REG || REGNO ( base ) == R13_REG ) len ++ ; } else if ( disp && ! base && ! index ) { len += 4 ; if ( rip_relative_addr_p ( & parts ) ) len ++ ; } else { if ( disp ) { if ( base && satisfies_constraint_K ( disp ) ) len += 1 ; else len += 4 ; } else if ( base && ( REGNO ( base ) == BP_REG || REGNO ( base ) == R13_REG ) ) len ++ ; if ( index || base == arg_pointer_rtx || base == frame_pointer_rtx || ( base && ( REGNO ( base ) == SP_REG || REGNO ( base ) == R12_REG ) ) ) len ++ ; } return len ; } </s>

Calculate the length of the memory address in the instruction encoding . Does not include the one-byte modrm , opcode , or prefix .


<s>
bool
RISCVAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
{
Operands
.
push_back
(
RISCVOperand
::
createToken
(
Name
,
NameLoc
,
isRV64
(
)
)
)
;
if
(
getLexer
(
)
.
is
(
AsmToken
::
EndOfStatement
)
)
return
false
;
if
(
parseOperand
(
Operands
)
)
return
true
;
while
(
getLexer
(
)
.
is
(
AsmToken
::
Comma
)
)
{
getLexer
(
)
.
Lex
(
)
;
if
(
parseOperand
(
Operands
)
)
return
true
;
}
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
SMLoc
Loc
=
getLexer
(
)
.
getLoc
(
)
;
getParser
(
)
.
eatToEndOfStatement
(
)
;
return
Error
(
Loc
,
"unexpected token"
)
;
}
getParser
(
)
.
Lex
(
)
;
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .


<s> static int ix86_adjust_cost ( rtx insn , rtx link , rtx dep_insn , int cost ) { enum attr_type insn_type , dep_insn_type ; enum attr_memory memory ; rtx set , set2 ; int dep_insn_code_number ; if ( REG_NOTE_KIND ( link ) != 0 ) return 0 ; dep_insn_code_number = recog_memoized ( dep_insn ) ; if ( dep_insn_code_number < 0 || recog_memoized ( insn ) < 0 ) return cost ; insn_type = get_attr_type ( insn ) ; dep_insn_type = get_attr_type ( dep_insn ) ; switch ( ix86_tune ) { case PROCESSOR_PENTIUM : if ( ix86_agi_dependant ( insn , dep_insn , insn_type ) ) cost += 1 ; if ( ix86_flags_dependant ( insn , dep_insn , insn_type ) ) cost = 0 ; if ( insn_type == TYPE_FMOV && get_attr_memory ( insn ) == MEMORY_STORE && ! ix86_agi_dependant ( insn , dep_insn , insn_type ) ) cost += 1 ; break ; case PROCESSOR_PENTIUMPRO : memory = get_attr_memory ( insn ) ; if ( get_attr_fp_int_src ( dep_insn ) ) cost += 5 ; if ( insn_type == TYPE_FMOV && ( set = single_set ( dep_insn ) ) != NULL_RTX && ( set2 = single_set ( insn ) ) != NULL_RTX && rtx_equal_p ( SET_DEST ( set ) , SET_SRC ( set2 ) ) && GET_CODE ( SET_DEST ( set2 ) ) == MEM ) cost += 1 ; if ( ( memory == MEMORY_LOAD || memory == MEMORY_BOTH ) && ! ix86_agi_dependant ( insn , dep_insn , insn_type ) ) { if ( dep_insn_type == TYPE_IMOV || dep_insn_type == TYPE_FMOV ) cost = 1 ; else if ( cost > 1 ) cost -- ; } break ; case PROCESSOR_K6 : memory = get_attr_memory ( insn ) ; if ( ( insn_type == TYPE_PUSH || insn_type == TYPE_POP ) && ( dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP ) ) return 1 ; if ( get_attr_fp_int_src ( dep_insn ) ) cost += 5 ; if ( ( memory == MEMORY_LOAD || memory == MEMORY_BOTH ) && ! ix86_agi_dependant ( insn , dep_insn , insn_type ) ) { if ( dep_insn_type == TYPE_IMOV || dep_insn_type == TYPE_FMOV ) cost = 1 ; else if ( cost > 2 ) cost -= 2 ; else cost = 1 ; } break ; case PROCESSOR_ATHLON : case PROCESSOR_K8 : memory = get_attr_memory ( insn ) ; if ( ( memory == MEMORY_LOAD || memory == MEMORY_BOTH ) && ! ix86_agi_dependant ( insn , dep_insn , insn_type ) ) { enum attr_unit unit = get_attr_unit ( insn ) ; int loadcost = 3 ; if ( unit == UNIT_INTEGER || unit == UNIT_UNKNOWN ) loadcost = 3 ; else loadcost = TARGET_ATHLON ? 2 : 0 ; if ( cost >= loadcost ) cost -= loadcost ; else cost = 0 ; } default : break ; } return cost ; } </s>

This function corrects the value of COST ( latency ) based on the relationship between INSN and DEP_INSN through a dependence of type DEP_TYPE , and strength DW . It should return the new value . On x86 CPUs this is most commonly used to model the fact that valus of registers used to compute address of memory operand needs to be ready earlier than values of registers used in the actual operation .


<s>
void
assignValueToReg
(
unsigned
ValVReg
,
unsigned
PhysReg
,
CCValAssign
&
VA
)
override
{
assert
(
VA
.
isRegLoc
(
)
&&
"Value shouldn't be assigned to reg"
)
;
assert
(
VA
.
getLocReg
(
)
==
PhysReg
&&
"Assigning to the wrong reg?"
)
;
assert
(
VA
.
getValVT
(
)
.
getSizeInBits
(
)
<=
32
&&
"Unsupported value size"
)
;
assert
(
VA
.
getLocVT
(
)
.
getSizeInBits
(
)
==
32
&&
"Unsupported location size"
)
;
assert
(
VA
.
getLocInfo
(
)
!=
CCValAssign
::
SExt
&&
VA
.
getLocInfo
(
)
!=
CCValAssign
::
ZExt
&&
"ABI extensions not supported yet"
)
;
MIRBuilder
.
buildCopy
(
PhysReg
,
ValVReg
)
;
MIB
.
addUse
(
PhysReg
,
RegState
::
Implicit
)
;
}
</s>

The specified value has been assigned to a physical register , handle the appropriate COPY ( either to or from ) and mark any relevant uses/defines as needed .

ARM
"Value shouldn't be assigned to reg"
"Assigning to the wrong reg?"
32
"Unsupported value size"
32
"Unsupported location size"
"ABI extensions not supported yet"


<s>
int
AArch64LoadStoreOpt
::
getMemSize
(
MachineInstr
*
MemMI
)
{
switch
(
MemMI
->
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Opcode has unknown size!"
)
;
case
AArch64
::
STRSui
:
case
AArch64
::
STURSi
:
return
4
;
case
AArch64
::
STRDui
:
case
AArch64
::
STURDi
:
return
8
;
case
AArch64
::
STRQui
:
case
AArch64
::
STURQi
:
return
16
;
case
AArch64
::
STRWui
:
case
AArch64
::
STURWi
:
return
4
;
case
AArch64
::
STRXui
:
case
AArch64
::
STURXi
:
return
8
;
case
AArch64
::
LDRSui
:
case
AArch64
::
LDURSi
:
return
4
;
case
AArch64
::
LDRDui
:
case
AArch64
::
LDURDi
:
return
8
;
case
AArch64
::
LDRQui
:
case
AArch64
::
LDURQi
:
return
16
;
case
AArch64
::
LDRWui
:
case
AArch64
::
LDURWi
:
return
4
;
case
AArch64
::
LDRXui
:
case
AArch64
::
LDURXi
:
return
8
;
case
AArch64
::
LDRSWui
:
case
AArch64
::
LDURSWi
:
return
4
;
}
}
</s>

Returns the size in bytes of the memory access .


<s>
bool
MipsAsmParser
::
ParseDirective
(
AsmToken
DirectiveID
)
{
StringRef
IDVal
=
DirectiveID
.
getString
(
)
;
if
(
IDVal
==
".cpload"
)
return
parseDirectiveCPLoad
(
DirectiveID
.
getLoc
(
)
)
;
if
(
IDVal
==
".dword"
)
{
parseDataDirective
(
8
,
DirectiveID
.
getLoc
(
)
)
;
return
false
;
}
if
(
IDVal
==
".ent"
)
{
Parser
.
Lex
(
)
;
return
false
;
}
if
(
IDVal
==
".end"
)
{
Parser
.
Lex
(
)
;
return
false
;
}
if
(
IDVal
==
".frame"
)
{
Parser
.
eatToEndOfStatement
(
)
;
return
false
;
}
if
(
IDVal
==
".set"
)
{
return
parseDirectiveSet
(
)
;
}
if
(
IDVal
==
".fmask"
)
{
Parser
.
eatToEndOfStatement
(
)
;
return
false
;
}
if
(
IDVal
==
".mask"
)
{
Parser
.
eatToEndOfStatement
(
)
;
return
false
;
}
if
(
IDVal
==
".nan"
)
return
parseDirectiveNaN
(
)
;
if
(
IDVal
==
".gpword"
)
{
parseDirectiveGpWord
(
)
;
return
false
;
}
if
(
IDVal
==
".gpdword"
)
{
parseDirectiveGpDWord
(
)
;
return
false
;
}
if
(
IDVal
==
".word"
)
{
parseDataDirective
(
4
,
DirectiveID
.
getLoc
(
)
)
;
return
false
;
}
if
(
IDVal
==
".option"
)
return
parseDirectiveOption
(
)
;
if
(
IDVal
==
".abicalls"
)
{
getTargetStreamer
(
)
.
emitDirectiveAbiCalls
(
)
;
if
(
Parser
.
getTok
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
Error
(
Parser
.
getTok
(
)
.
getLoc
(
)
,
"unexpected token in directive"
)
;
Parser
.
eatToEndOfStatement
(
)
;
}
return
false
;
}
if
(
IDVal
==
".cpsetup"
)
return
parseDirectiveCPSetup
(
)
;
if
(
IDVal
==
".module"
)
return
parseDirectiveModule
(
)
;
return
true
;
}
</s>

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


<s>
MachineBasicBlock
*
XCoreTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
*
MI
,
MachineBasicBlock
*
BB
,
DenseMap
<
MachineBasicBlock
*
,
MachineBasicBlock
*
>
*
EM
)
const
{
const
TargetInstrInfo
&
TII
=
*
getTargetMachine
(
)
.
getInstrInfo
(
)
;
DebugLoc
dl
=
MI
->
getDebugLoc
(
)
;
assert
(
(
MI
->
getOpcode
(
)
==
XCore
::
SELECT_CC
)
&&
"Unexpected instr type to insert"
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
MachineFunction
::
iterator
It
=
BB
;
++
It
;
MachineBasicBlock
*
thisMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
copy0MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
sinkMBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
XCore
::
BRFT_lru6
)
)
.
addReg
(
MI
->
getOperand
(
1
)
.
getReg
(
)
)
.
addMBB
(
sinkMBB
)
;
F
->
insert
(
It
,
copy0MBB
)
;
F
->
insert
(
It
,
sinkMBB
)
;
for
(
MachineBasicBlock
::
succ_iterator
I
=
BB
->
succ_begin
(
)
,
E
=
BB
->
succ_end
(
)
;
I
!=
E
;
++
I
)
{
EM
->
insert
(
std
::
make_pair
(
*
I
,
sinkMBB
)
)
;
sinkMBB
->
addSuccessor
(
*
I
)
;
}
while
(
!
BB
->
succ_empty
(
)
)
BB
->
removeSuccessor
(
BB
->
succ_begin
(
)
)
;
BB
->
addSuccessor
(
copy0MBB
)
;
BB
->
addSuccessor
(
sinkMBB
)
;
BB
=
copy0MBB
;
BB
->
addSuccessor
(
sinkMBB
)
;
BB
=
sinkMBB
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
XCore
::
PHI
)
,
MI
->
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
->
getOperand
(
3
)
.
getReg
(
)
)
.
addMBB
(
copy0MBB
)
.
addReg
(
MI
->
getOperand
(
2
)
.
getReg
(
)
)
.
addMBB
(
thisMBB
)
;
F
->
DeleteMachineInstr
(
MI
)
;
return
BB
;
}
</s>

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


<s>
bool
ARM64InstrInfo
::
isGPRZero
(
const
MachineInstr
*
MI
)
const
{
switch
(
MI
->
getOpcode
(
)
)
{
default
:
break
;
case
ARM64
::
MOVZWi
:
case
ARM64
::
MOVZXi
:
if
(
MI
->
getOperand
(
1
)
.
isImm
(
)
&&
MI
->
getOperand
(
1
)
.
getImm
(
)
==
0
)
{
assert
(
MI
->
getDesc
(
)
.
getNumOperands
(
)
==
3
&&
MI
->
getOperand
(
2
)
.
getImm
(
)
==
0
&&
"invalid MOVZi operands"
)
;
return
true
;
}
break
;
case
ARM64
::
ANDWri
:
return
MI
->
getOperand
(
1
)
.
getReg
(
)
==
ARM64
::
WZR
;
case
ARM64
::
ANDXri
:
return
MI
->
getOperand
(
1
)
.
getReg
(
)
==
ARM64
::
XZR
;
case
TargetOpcode
::
COPY
:
return
MI
->
getOperand
(
1
)
.
getReg
(
)
==
ARM64
::
WZR
;
}
return
false
;
}
</s>

Does this instruction set its full destination register to zero ?


<s> unsigned SNESInstrInfo :: removeBranch ( MachineBasicBlock & MBB , int * BytesRemoved ) const { if ( BytesRemoved ) * BytesRemoved = 0 ; MachineBasicBlock :: iterator I = MBB . end ( ) ; unsigned Count = 0 ; while ( I != MBB . begin ( ) ) { -- I ; if ( I -> isDebugValue ( ) ) { continue ; } if ( I -> getOpcode ( ) != SNES :: RJMPk && getCondFromBranchOpc ( I -> getOpcode ( ) ) == SNESCC :: COND_INVALID ) { break ; } if ( BytesRemoved ) * BytesRemoved += getInstSizeInBytes ( * I ) ; I -> eraseFromParent ( ) ; I = MBB . end ( ) ; ++ Count ; } return Count ; } </s>

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


<s>
static
void
output_init_frag
(
rtx
sym
)
{
fprintf
(
asm_out_file
,
init_frag
.
started
", "
:
" = { "
)
;
unsigned
HOST_WIDE_INT
val
=
init_frag
.
val
;
init_frag
.
started
=
true
;
init_frag
.
val
=
0
;
init_frag
.
offset
=
0
;
init_frag
.
remaining
;
if
(
sym
)
{
bool
function
=
(
SYMBOL_REF_DECL
(
sym
)
&&
(
TREE_CODE
(
SYMBOL_REF_DECL
(
sym
)
)
==
FUNCTION_DECL
)
)
;
if
(
!
function
)
fprintf
(
asm_out_file
,
"generic("
)
;
output_address
(
VOIDmode
,
sym
)
;
if
(
!
function
)
fprintf
(
asm_out_file
,
")"
)
;
if
(
val
)
fprintf
(
asm_out_file
,
" + "
)
;
}
if
(
!
sym
||
val
)
fprintf
(
asm_out_file
,
HOST_WIDE_INT_PRINT_DEC
,
val
)
;
}
</s>

The current fragment is full , write it out . SYM may provide a symbolic reference we should output , in which case the fragment value is the addend .


<s> void cris_target_asm_named_section ( const char * name , unsigned int flags , tree decl ) { if ( ! TARGET_ELF ) default_no_named_section ( name , flags , decl ) ; else default_elf_asm_named_section ( name , flags , decl ) ; } </s>

The TARGET_ASM_NAMED_SECTION worker . We just dispatch to the functions for ELF and a.out .


<s> bool ARMBaseTargetMachine :: addPreEmitPass ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { if ( OptLevel != CodeGenOpt :: None && ! DisableLdStOpti && ! Subtarget . isThumb1Only ( ) ) PM . add ( createARMLoadStoreOptimizationPass ( ) ) ; if ( OptLevel != CodeGenOpt :: None && ! DisableIfConversion && ! Subtarget . isThumb1Only ( ) ) PM . add ( createIfConverterPass ( ) ) ; if ( Subtarget . isThumb2 ( ) ) { PM . add ( createThumb2ITBlockPass ( ) ) ; PM . add ( createThumb2SizeReductionPass ( ) ) ; } PM . add ( createARMConstantIslandPass ( ) ) ; return true ; } </s>

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


<s> int addr32_operand ( rtx op , enum machine_mode mode ) { rtx sym ; if ( GET_CODE ( op ) == LABEL_REF ) return TARGET_ADDR32 ; if ( GET_CODE ( op ) == SYMBOL_REF ) sym = op ; else if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , 0 ) , 0 ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , 0 ) , 1 ) ) == CONST_INT && ! flag_pic ) sym = XEXP ( XEXP ( op , 0 ) , 0 ) ; else return 0 ; return ( ! addr24_operand ( sym , mode ) && ! small_data_operand ( sym , mode ) ) ; } </s>

Return 1 if OP is a symbol that needs 32 bit addressing .


<s> void initialize ( Attributor & A ) override { Function * F = getAssociatedFunction ( ) ; const bool NeedsImplicit = funcRequiresImplicitArgPtr ( * F ) ; if ( NeedsImplicit ) removeAssumedBits ( IMPLICIT_ARG_PTR ) ; for ( auto Attr : ImplicitAttrs ) { if ( NeedsImplicit && Attr . first == IMPLICIT_ARG_PTR ) continue ; if ( F -> hasFnAttribute ( Attr . second ) ) addKnownBits ( Attr . first ) ; } if ( F -> isDeclaration ( ) ) return ; if ( AMDGPU :: isGraphics ( F -> getCallingConv ( ) ) ) { indicatePessimisticFixpoint ( ) ; return ; } } </s>

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


<s> static unsigned size ( const MCallSubGraph & G ) { return G . Nodes . size ( ) ; } </s>

The number of name/type pairs is returned .


<s> bool PatmosFrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , ArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * STC . getInstrInfo ( ) ; PatmosMachineFunctionInfo & PMFI = * MF . getInfo < PatmosMachineFunctionInfo > ( ) ; unsigned spilledSize = 0 ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; MBB . addLiveIn ( Reg ) ; if ( Patmos :: PRegsRegClass . contains ( Reg ) ) continue ; if ( Reg == Patmos :: S0 && PMFI . getS0SpillReg ( ) ) { TII . copyPhysReg ( MBB , MI , DL , PMFI . getS0SpillReg ( ) , Reg , true ) ; std :: prev ( MI ) -> setFlag ( MachineInstr :: FrameSetup ) ; continue ; } if ( Patmos :: SRegsRegClass . contains ( Reg ) ) { TII . copyPhysReg ( MBB , MI , DL , Patmos :: R9 , Reg , true ) ; std :: prev ( MI ) -> setFlag ( MachineInstr :: FrameSetup ) ; Reg = Patmos :: R9 ; } const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . storeRegToStackSlot ( MBB , MI , Reg , true , CSI [ i - 1 ] . getFrameIdx ( ) , RC , TRI ) ; std :: prev ( MI ) -> setFlag ( MachineInstr :: FrameSetup ) ; spilledSize += 4 ; } 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> static bool nvptx_shared_propagate ( bool pre_p , bool is_call , basic_block block , rtx_insn * insn , bool vector ) { broadcast_data_t data ; data . base = gen_reg_rtx ( Pmode ) ; data . offset = 0 ; data . ptr = NULL_RTX ; bool empty = nvptx_propagate ( is_call , block , insn , pre_p ? PM_read : PM_write , shared_prop_gen , & data , vector ) ; gcc_assert ( empty == ! data . offset ) ; if ( data . offset ) { rtx bcast_sym = oacc_bcast_sym ; if ( vector && nvptx_mach_max_workers ( ) > 1 ) { if ( ! cfun -> machine -> bcast_partition ) { cfun -> machine -> bcast_partition = gen_reg_rtx ( DImode ) ; } if ( ! cfun -> machine -> sync_bar ) cfun -> machine -> sync_bar = gen_reg_rtx ( SImode ) ; bcast_sym = cfun -> machine -> bcast_partition ; } rtx init = gen_rtx_SET ( data . base , bcast_sym ) ; emit_insn_after ( init , insn ) ; unsigned int psize = ROUND_UP ( data . offset , oacc_bcast_align ) ; unsigned int pnum = ( nvptx_mach_vector_length ( ) > PTX_WARP_SIZE ? nvptx_mach_max_workers ( ) + 1 : 1 ) ; oacc_bcast_partition = MAX ( oacc_bcast_partition , psize ) ; oacc_bcast_size = MAX ( oacc_bcast_size , psize * pnum ) ; } return empty ; } </s>

Spill or fill live state that is live at start of BLOCK . PRE_P indicates if this is just before partitioned mode ( do spill ) , or just after it starts ( do fill ) . Sequence is inserted just after INSN . IS_CALL and return as for nvptx_propagate .


<s> bool ldstwm_operation_p ( rtx op , bool load_p ) { int start , i , end = XVECLEN ( op , 0 ) - 1 , last_regno = - 1 ; unsigned int regset = 0 ; rtx base_reg , offset ; rtx first_elt = XVECEXP ( op , 0 , 0 ) ; bool inc_p = true ; bool wb_p = base_reg_adjustment_p ( first_elt , & base_reg , & offset ) ; if ( GET_CODE ( XVECEXP ( op , 0 , end ) ) == RETURN ) end -- ; start = wb_p ? 1 : 0 ; for ( i = start ; i <= end ; i ++ ) { int regno ; rtx reg , mem , elt = XVECEXP ( op , 0 , i ) ; if ( GET_CODE ( elt ) != SET ) return false ; reg = load_p ? SET_DEST ( elt ) : SET_SRC ( elt ) ; mem = load_p ? SET_SRC ( elt ) : SET_DEST ( elt ) ; if ( ! REG_P ( reg ) || ! MEM_P ( mem ) ) return false ; regno = REGNO ( reg ) ; if ( ! nios2_ldstwm_regset_p ( regno , & regset ) ) return false ; if ( wb_p ) inc_p = INTVAL ( offset ) > 0 ; else if ( i == start ) { rtx first_base , first_offset ; if ( ! split_mem_address ( XEXP ( mem , 0 ) , & first_base , & first_offset ) ) return false ; if ( ! REG_P ( first_base ) || ! CONST_INT_P ( first_offset ) ) return false ; base_reg = first_base ; inc_p = INTVAL ( first_offset ) >= 0 ; } if ( load_p && regno == ( int ) REGNO ( base_reg ) ) return false ; if ( last_regno >= 0 ) { if ( inc_p && last_regno >= regno ) return false ; if ( ! inc_p && last_regno <= regno ) return false ; } last_regno = regno ; } return true ; } </s>

Main function to implement ldwm_operation/stwm_operation predicates that check ldwm/stwm insn pattern integrity .


"instruction requires a CPU feature not currently enabled"

MatchAndEmitInstruction - Recognize a series of operands of a parsed instruction as an actual MCInst and emit it to the specified MCStreamer .


<s> static unsigned int aarch64_function_arg_alignment ( machine_mode mode , const_tree type , unsigned int * abi_break ) { * abi_break = 0 ; if ( ! type ) return GET_MODE_ALIGNMENT ( mode ) ; if ( integer_zerop ( TYPE_SIZE ( type ) ) ) return 0 ; gcc_assert ( TYPE_MODE ( type ) == mode ) ; if ( ! AGGREGATE_TYPE_P ( type ) ) return TYPE_ALIGN ( TYPE_MAIN_VARIANT ( type ) ) ; if ( TREE_CODE ( type ) == ARRAY_TYPE ) return TYPE_ALIGN ( TREE_TYPE ( type ) ) ; unsigned int alignment = 0 ; unsigned int bitfield_alignment = 0 ; for ( tree field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL ) { alignment = std :: max ( alignment , DECL_ALIGN ( field ) ) ; if ( DECL_BIT_FIELD_TYPE ( field ) ) bitfield_alignment = std :: max ( bitfield_alignment , TYPE_ALIGN ( DECL_BIT_FIELD_TYPE ( field ) ) ) ; } if ( bitfield_alignment > alignment ) { * abi_break = alignment ; return bitfield_alignment ; } return alignment ; } </s>

Given MODE and TYPE of a function argument , return the alignment in bits . The idea is to suppress any stronger alignment requested by the user and opt for the natural alignment ( specified in AAPCS64 \S 4.1 ) . This is a helper function for local use only .


<s> TargetLoweringBase :: AtomicExpansionKind ARMTargetLowering :: shouldExpandAtomicStoreInIR ( StoreInst * SI ) const { bool has64BitAtomicStore ; if ( Subtarget -> isMClass ( ) ) has64BitAtomicStore = false ; else if ( Subtarget -> isThumb ( ) ) has64BitAtomicStore = Subtarget -> hasV7Ops ( ) ; else has64BitAtomicStore = Subtarget -> hasV6Ops ( ) ; unsigned Size = SI -> getValueOperand ( ) -> getType ( ) -> getPrimitiveSizeInBits ( ) ; return Size == 64 && has64BitAtomicStore ? AtomicExpansionKind :: Expand : AtomicExpansionKind :: None ; } </s>

Returns how the given ( atomic ) store should be expanded by the IR-level AtomicExpand pass into .


<s> void MBlazeRegisterInfo :: emitPrologue ( MachineFunction & MF ) const { MachineBasicBlock & MBB = MF . front ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; MBlazeFunctionInfo * MBlazeFI = MF . getInfo < MBlazeFunctionInfo > ( ) ; MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; DebugLoc DL = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; adjustMBlazeStackFrame ( MF ) ; unsigned StackSize = MFI -> getStackSize ( ) ; if ( StackSize == 0 && ! MFI -> hasCalls ( ) ) return ; if ( StackSize < 28 && MFI -> hasCalls ( ) ) StackSize = 28 ; int FPOffset = MBlazeFI -> getFPStackOffset ( ) ; int RAOffset = MBlazeFI -> getRAStackOffset ( ) ; BuildMI ( MBB , MBBI , DL , TII . get ( MBlaze :: ADDI ) , MBlaze :: R1 ) . addReg ( MBlaze :: R1 ) . addImm ( - StackSize ) ; if ( MFI -> hasCalls ( ) ) { BuildMI ( MBB , MBBI , DL , TII . get ( MBlaze :: SWI ) ) . addReg ( MBlaze :: R15 ) . addImm ( RAOffset ) . addReg ( MBlaze :: R1 ) ; } if ( hasFP ( MF ) ) { BuildMI ( MBB , MBBI , DL , TII . get ( MBlaze :: SWI ) ) . addReg ( MBlaze :: R19 ) . addImm ( FPOffset ) . addReg ( MBlaze :: R1 ) ; BuildMI ( MBB , MBBI , DL , TII . get ( MBlaze :: ADD ) , MBlaze :: R19 ) . addReg ( MBlaze :: R1 ) . addReg ( MBlaze :: R0 ) ; } } </s>

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


"Optimize addressing mode of load/store"

getPassName - Return a nice clean name for a pass .


<s>
bool
PPCInstrInfo
::
FoldImmediate
(
MachineInstr
*
UseMI
,
MachineInstr
*
DefMI
,
unsigned
Reg
,
MachineRegisterInfo
*
MRI
)
const
{
unsigned
DefOpc
=
DefMI
->
getOpcode
(
)
;
if
(
DefOpc
!=
PPC
::
LI
&&
DefOpc
!=
PPC
::
LI8
)
return
false
;
if
(
!
DefMI
->
getOperand
(
1
)
.
isImm
(
)
)
return
false
;
if
(
DefMI
->
getOperand
(
1
)
.
getImm
(
)
!=
0
)
return
false
;
const
MCInstrDesc
&
UseMCID
=
UseMI
->
getDesc
(
)
;
if
(
UseMCID
.
isPseudo
(
)
)
return
false
;
unsigned
UseIdx
;
for
(
UseIdx
=
0
;
UseIdx
<
UseMI
->
getNumOperands
(
)
;
++
UseIdx
)
if
(
UseMI
->
getOperand
(
UseIdx
)
.
isReg
(
)
&&
UseMI
->
getOperand
(
UseIdx
)
.
getReg
(
)
==
Reg
)
break
;
assert
(
UseIdx
<
UseMI
->
getNumOperands
(
)
&&
"Cannot find Reg in UseMI"
)
;
assert
(
UseIdx
<
UseMCID
.
getNumOperands
(
)
&&
"No operand description for Reg"
)
;
const
MCOperandInfo
*
UseInfo
=
&
UseMCID
.
OpInfo
[
UseIdx
]
;
if
(
UseInfo
->
isLookupPtrRegClass
(
)
)
{
if
(
UseInfo
->
RegClass
!=
1
)
return
false
;
}
else
{
if
(
UseInfo
->
RegClass
!=
PPC
::
GPRC_NOR0RegClassID
&&
UseInfo
->
RegClass
!=
PPC
::
G8RC_NOX0RegClassID
)
return
false
;
}
if
(
UseInfo
->
Constraints
!=
0
)
return
false
;
unsigned
ZeroReg
;
if
(
UseInfo
->
isLookupPtrRegClass
(
)
)
{
bool
isPPC64
=
Subtarget
.
isPPC64
(
)
;
ZeroReg
=
isPPC64
PPC
::
ZERO8
:
PPC
::
ZERO
;
}
else
{
ZeroReg
=
UseInfo
->
RegClass
==
PPC
::
G8RC_NOX0RegClassID
PPC
::
ZERO8
:
PPC
::
ZERO
;
}
bool
DeleteDef
=
MRI
->
hasOneNonDBGUse
(
Reg
)
;
UseMI
->
getOperand
(
UseIdx
)
.
setReg
(
ZeroReg
)
;
if
(
DeleteDef
)
DefMI
->
eraseFromParent
(
)
;
return
true
;
}
</s>

Reg is known to be defined by a move immediate instruction , try to fold the immediate into the use instruction .


<s> void SPUTargetLowering :: LowerAsmOperandForConstraint ( SDValue Op , char ConstraintLetter , bool hasMemory , std :: vector < SDValue > & Ops , SelectionDAG & DAG ) const { TargetLowering :: LowerAsmOperandForConstraint ( Op , ConstraintLetter , hasMemory , Ops , DAG ) ; } </s>

Lower the specified operand into the Ops vector .


<s>
StringRef
getPassName
(
)
const
override
{
return
"SI Form memory clauses"
;
}
</s>


<s> int ix86_reg_parm_stack_space ( const_tree fndecl ) { enum calling_abi call_abi = SYSV_ABI ; if ( fndecl != NULL_TREE && TREE_CODE ( fndecl ) == FUNCTION_DECL ) call_abi = ix86_function_abi ( fndecl ) ; else call_abi = ix86_function_type_abi ( fndecl ) ; if ( TARGET_64BIT && call_abi == MS_ABI ) return 32 ; return 0 ; } </s>

It returns the size , in bytes , of the area reserved for arguments passed in registers for the function represented by fndecl dependent to the used abi format .


<s> bool X86Subtarget :: enablePostRAScheduler ( CodeGenOpt :: Level OptLevel , TargetSubtargetInfo :: AntiDepBreakMode & Mode , RegClassVector & CriticalPathRCs ) const { Mode = TargetSubtargetInfo :: ANTIDEP_CRITICAL ; CriticalPathRCs . clear ( ) ; return PostRAScheduler && OptLevel >= CodeGenOpt :: Default ; } </s>

True if the subtarget should run a scheduler after register allocation .


<s> virtual bool isVirtualSection ( ) const { return false ; } </s>

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


Count number of GROUP restricted instructions in a dispatch window WINDOW_LIST .


<s> VariantKind getKind ( ) const { return Kind ; } </s>


<s> ArrayRef < MCPhysReg > SIRegisterInfo :: getAllSGPR32 ( const MachineFunction & MF ) const { return makeArrayRef ( AMDGPU :: SGPR_32RegClass . begin ( ) , ST . getMaxNumSGPRs ( MF ) ) ; } </s>

Return all SGPR32 which satisfy the waves per execution unit requirement of the subtarget .


<s> static inline VConstraintType getConstraint ( uint64_t TSFlags ) { return static_cast < VConstraintType > ( ( TSFlags & ConstraintMask ) >> ConstraintShift ) ; } </s>

Fetch condition in the form of PredicateConstraint , if possible .


<s> bool ARMBaseRegisterInfo :: requiresVirtualBaseRegisters ( const MachineFunction & MF ) const { return EnableLocalStackAlloc ; } </s>

Returns true if the target wants the LocalStackAllocation pass to be run and virtual base registers used for more efficient stack access .


<s>
bool
X86LoadValueInjectionRetHardeningPass
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"***** "
<<
getPassName
(
)
<<
" : "
<<
MF
.
getName
(
)
<<
" *****\n"
)
;
const
X86Subtarget
*
Subtarget
=
&
MF
.
getSubtarget
<
X86Subtarget
>
(
)
;
if
(
!
Subtarget
->
useLVIControlFlowIntegrity
(
)
||
!
Subtarget
->
is64Bit
(
)
)
return
false
;
const
Function
&
F
=
MF
.
getFunction
(
)
;
if
(
!
F
.
hasOptNone
(
)
&&
skipFunction
(
F
)
)
return
false
;
++
NumFunctionsConsidered
;
const
X86RegisterInfo
*
TRI
=
Subtarget
->
getRegisterInfo
(
)
;
const
X86InstrInfo
*
TII
=
Subtarget
->
getInstrInfo
(
)
;
bool
Modified
=
false
;
for
(
auto
&
MBB
:
MF
)
{
for
(
auto
MBBI
=
MBB
.
begin
(
)
;
MBBI
!=
MBB
.
end
(
)
;
++
MBBI
)
{
if
(
MBBI
->
getOpcode
(
)
!=
X86
::
RETQ
)
continue
;
unsigned
ClobberReg
=
TRI
->
findDeadCallerSavedReg
(
MBB
,
MBBI
)
;
if
(
ClobberReg
!=
X86
::
NoRegister
)
{
BuildMI
(
MBB
,
MBBI
,
DebugLoc
(
)
,
TII
->
get
(
X86
::
POP64r
)
)
.
addReg
(
ClobberReg
,
RegState
::
Define
)
.
setMIFlag
(
MachineInstr
::
FrameDestroy
)
;
BuildMI
(
MBB
,
MBBI
,
DebugLoc
(
)
,
TII
->
get
(
X86
::
LFENCE
)
)
;
BuildMI
(
MBB
,
MBBI
,
DebugLoc
(
)
,
TII
->
get
(
X86
::
JMP64r
)
)
.
addReg
(
ClobberReg
)
;
MBB
.
erase
(
MBBI
)
;
}
else
{
MachineInstr
*
Fence
=
BuildMI
(
MBB
,
MBBI
,
DebugLoc
(
)
,
TII
->
get
(
X86
::
LFENCE
)
)
;
addRegOffset
(
BuildMI
(
MBB
,
Fence
,
DebugLoc
(
)
,
TII
->
get
(
X86
::
SHL64mi
)
)
,
X86
::
RSP
,
false
,
0
)
.
addImm
(
0
)
->
addRegisterDead
(
X86
::
EFLAGS
,
TRI
)
;
}
++
NumFences
;
Modified
=
true
;
break
;
}
}
if
(
Modified
)
++
NumFunctionsMitigated
;
return
Modified
;
}
</s>

runOnMachineFunction - Emit the function body .


<s> RAInfo :: LocType getType ( ) const { return type ; } </s>

Overload to return most specific vector type .


<s> SDValue Z80TargetLowering :: LowerFormalArguments ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , const SDLoc & dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { return Chain ; } </s>

This hook must be implemented to lower the incoming ( formal ) arguments , described by the Ins array , into the specified DAG .


<s> MachineInstr * SystemZInstrInfo :: foldMemoryOperandImpl ( MachineFunction & MF , MachineInstr * MI , ArrayRef < unsigned > Ops , MachineBasicBlock :: iterator InsertPt , MachineInstr * LoadMI , LiveIntervals * LIS ) const { return nullptr ; } </s>

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


<s> bool HexagonTargetMachine :: addInstSelector ( PassManagerBase & PM ) { PM . add ( createHexagonRemoveExtendOps ( * this ) ) ; PM . add ( createHexagonISelDag ( * this ) ) ; return false ; } </s>

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


<s>
static
void
addPredicate
(
MachineInstr
*
MI
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"ARM Loops: Adding VPT Predicate: "
<<
*
MI
)
;
CurrentPredicates
.
insert
(
MI
)
;
}
</s>


<s> bool AMDGPUAsmParser :: usesConstantBus ( const MCInst & Inst , unsigned OpIdx ) { const MCOperand & MO = Inst . getOperand ( OpIdx ) ; if ( MO . isImm ( ) ) { return ! isInlineConstant ( Inst , OpIdx ) ; } return ! MO . isReg ( ) || isSGPR ( mc2PseudoReg ( MO . getReg ( ) ) , getContext ( ) . getRegisterInfo ( ) ) ; } </s>

Returns true if this operand uses the constant bus .


<s> SparcSubtarget & SparcSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { UseSoftMulDiv = false ; IsV9 = false ; IsLeon = false ; V8DeprecatedInsts = false ; IsVIS = false ; IsVIS2 = false ; IsVIS3 = false ; HasHardQuad = false ; UsePopc = false ; UseSoftFloat = false ; HasNoFSMULD = false ; HasNoFMULS = false ; HasLeonCasa = false ; HasUmacSmac = false ; HasPWRPSR = false ; InsertNOPLoad = false ; FixAllFDIVSQRT = false ; DetectRoundChange = false ; HasLeonCycleCounter = false ; std :: string CPUName = std :: string ( CPU ) ; if ( CPUName . empty ( ) ) CPUName = ( Is64Bit ) ? "v9" : "v8" ; ParseSubtargetFeatures ( CPUName , FS ) ; if ( ! IsV9 ) UsePopc = false ; return * this ; } </s>

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


<s> static int arc_verify_short ( rtx_insn * insn , int , int check_attr ) { enum attr_iscompact iscompact ; if ( check_attr > 0 ) { iscompact = get_attr_iscompact ( insn ) ; if ( iscompact == ISCOMPACT_FALSE ) return 0 ; } return ( get_attr_length ( insn ) & 2 ) != 0 ; } </s>

Return non-zero if INSN should be output as a short insn . UNALIGN is zero if the current insn is aligned to a 4-byte-boundary , two otherwise . If CHECK_ATTR is greater than 0 , check the iscompact attribute first .


<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> bool NVVMReflect :: runOnFunction ( Function & F ) { return runNVVMReflect ( F , SmVersion ) ; } </s>

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


<s> Optional < MCFixupKind > X86AsmBackend :: getFixupKind ( StringRef Name ) const { if ( STI . getTargetTriple ( ) . isOSBinFormatELF ( ) ) { unsigned Type ; if ( STI . getTargetTriple ( ) . getArch ( ) == Triple :: x86_64 ) { Type = llvm :: StringSwitch < unsigned > ( Name ) . Case ( "BFD_RELOC_NONE" , ELF :: R_X86_64_NONE ) . Case ( "BFD_RELOC_8" , ELF :: R_X86_64_8 ) . Case ( "BFD_RELOC_16" , ELF :: R_X86_64_16 ) . Case ( "BFD_RELOC_32" , ELF :: R_X86_64_32 ) . Case ( "BFD_RELOC_64" , ELF :: R_X86_64_64 ) . Default ( - 1u ) ; } else { Type = llvm :: StringSwitch < unsigned > ( Name ) . Case ( "BFD_RELOC_NONE" , ELF :: R_386_NONE ) . Case ( "BFD_RELOC_8" , ELF :: R_386_8 ) . Case ( "BFD_RELOC_16" , ELF :: R_386_16 ) . Case ( "BFD_RELOC_32" , ELF :: R_386_32 ) . Default ( - 1u ) ; } if ( Type == - 1u ) return None ; return static_cast < MCFixupKind > ( FirstLiteralRelocationKind + Type ) ; } return MCAsmBackend :: getFixupKind ( Name ) ; } </s>

getFixupKind - Get the fixup kind of this expression .


<s> static void set_reg_plus_d ( int reg , int base , HOST_WIDE_INT disp , int note ) { rtx_insn * insn ; if ( VAL_14_BITS_P ( disp ) ) { insn = emit_move_insn ( gen_rtx_REG ( Pmode , reg ) , plus_constant ( Pmode , gen_rtx_REG ( Pmode , base ) , disp ) ) ; } else if ( TARGET_64BIT && ! VAL_32_BITS_P ( disp ) ) { rtx basereg = gen_rtx_REG ( Pmode , base ) ; rtx delta = GEN_INT ( disp ) ; rtx tmpreg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( tmpreg , delta ) ; insn = emit_move_insn ( gen_rtx_REG ( Pmode , reg ) , gen_rtx_PLUS ( Pmode , tmpreg , basereg ) ) ; if ( DO_FRAME_NOTES ) add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( tmpreg , gen_rtx_PLUS ( Pmode , basereg , delta ) ) ) ; } else { rtx basereg = gen_rtx_REG ( Pmode , base ) ; rtx delta = GEN_INT ( disp ) ; rtx tmpreg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( tmpreg , gen_rtx_PLUS ( Pmode , basereg , gen_rtx_HIGH ( Pmode , delta ) ) ) ; insn = emit_move_insn ( gen_rtx_REG ( Pmode , reg ) , gen_rtx_LO_SUM ( Pmode , tmpreg , delta ) ) ; } if ( DO_FRAME_NOTES && note ) RTX_FRAME_RELATED_P ( insn ) = 1 ; } </s>

Emit RTL to set REG to the value specified by BASE+DISP . Handle case where DISP > 8k by using the add_high_const patterns . Note in DISP > 8k case , we will leave the high part of the address in % r1 . There is code in expand_hppa_ { prologue , epilogue } that knows this .


<s> rtx xtensa_copy_incoming_a7 ( rtx opnd ) { rtx entry_insns = 0 ; rtx reg , tmp ; enum machine_mode mode ; if ( ! cfun -> machine -> need_a7_copy ) return opnd ; gcc_assert ( ! cfun -> machine -> set_frame_ptr_insn ) ; mode = GET_MODE ( opnd ) ; reg = opnd ; if ( GET_CODE ( reg ) == SUBREG ) { gcc_assert ( SUBREG_BYTE ( reg ) == 0 ) ; reg = SUBREG_REG ( reg ) ; } if ( GET_CODE ( reg ) != REG || REGNO ( reg ) > A7_REG || REGNO ( reg ) + HARD_REGNO_NREGS ( A7_REG , mode ) <= A7_REG ) return opnd ; gcc_assert ( REGNO ( reg ) + HARD_REGNO_NREGS ( A7_REG , mode ) - 1 == A7_REG ) ; cfun -> machine -> need_a7_copy = false ; push_to_sequence ( entry_insns ) ; tmp = gen_reg_rtx ( mode ) ; switch ( mode ) { case DFmode : case DImode : emit_insn ( gen_movsi_internal ( gen_rtx_SUBREG ( SImode , tmp , 0 ) , gen_rtx_REG ( SImode , A7_REG - 1 ) ) ) ; emit_insn ( gen_movsi_internal ( gen_rtx_SUBREG ( SImode , tmp , 4 ) , gen_raw_REG ( SImode , A7_REG ) ) ) ; break ; case SFmode : emit_insn ( gen_movsf_internal ( tmp , gen_raw_REG ( mode , A7_REG ) ) ) ; break ; case SImode : emit_insn ( gen_movsi_internal ( tmp , gen_raw_REG ( mode , A7_REG ) ) ) ; break ; case HImode : emit_insn ( gen_movhi_internal ( tmp , gen_raw_REG ( mode , A7_REG ) ) ) ; break ; case QImode : emit_insn ( gen_movqi_internal ( tmp , gen_raw_REG ( mode , A7_REG ) ) ) ; break ; default : gcc_unreachable ( ) ; } cfun -> machine -> set_frame_ptr_insn = emit_insn ( gen_set_frame_ptr ( ) ) ; entry_insns = get_insns ( ) ; end_sequence ( ) ; if ( cfun -> machine -> vararg_a7 ) { emit_insn ( entry_insns ) ; } else { push_topmost_sequence ( ) ; emit_insn_after ( entry_insns , get_insns ( ) ) ; pop_topmost_sequence ( ) ; } return tmp ; } </s>

Check if an incoming argument in a7 is expected to be used soon and if OPND is a register or register pair that includes a7 . If so , create a new pseudo and copy a7 into that pseudo at the very beginning of the function , followed by the special `` set_frame_ptr '' unspec_volatile insn . The return value is either the original operand , if it is not a7 , or the new pseudo containing a copy of the incoming argument . This is necessary because the register allocator will ignore conflicts with a7 and may either assign some other pseudo to a7 or use a7 as the hard_frame_pointer , clobbering the incoming argument in a7 . By copying the argument out of a7 as the very first thing , and then immediately following that with an unspec_volatile to keep the scheduler away , we should avoid any problems . Putting the set_frame_ptr insn at the beginning , with only the a7 copy before it , also makes it easier for the prologue expander to initialize the frame pointer after the a7 copy and to fix up the a7 copy to use the stack pointer instead of the frame pointer .


"getMemOperandWithOffset only supports base "

Get the base operand and byte offset of an instruction that reads/writes memory .


<s>
static
void
arm_option_print
(
FILE
*
file
,
int
indent
,
struct
cl_target_option
*
ptr
)
{
int
flags
=
ptr
->
x_target_flags
;
const
struct
arm_fpu_desc
*
fpu_desc
=
&
all_fpus
[
ptr
->
x_arm_fpu_index
]
;
fprintf
(
file
,
"%*sselected arch %s\n"
,
indent
,
""
,
TARGET_THUMB2_P
(
flags
)
"thumb2"
:
TARGET_THUMB_P
(
flags
)
"thumb1"
:
"arm"
)
;
fprintf
(
file
,
"%*sselected fpu %s\n"
,
indent
,
""
,
fpu_desc
->
name
)
;
}
</s>

arm
"%*sselected arch %s\n"
""
"thumb2"
"thumb1"
"arm"
"%*sselected fpu %s\n"
""


<s> static tree pa_d_handle_target_object_format ( void ) { const char * objfmt = NULL ; if ( TARGET_SOM ) objfmt = "som" ; if ( objfmt == NULL ) return NULL_TREE ; return build_string_literal ( strlen ( objfmt ) + 1 , objfmt ) ; } </s>

Handle a call to ` __traits ( getTargetInfo , `` objectFormat '' ) ' .


"Instr doesn't have FrameIndex operand!"

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


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

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


<s> static rtx frv_dwarf_store ( rtx reg , int offset ) { rtx set = gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( GET_MODE ( reg ) , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , reg ) ; RTX_FRAME_RELATED_P ( set ) = 1 ; return set ; } </s>

Generate a frame-related expression : ( set REG ( mem ( plus ( sp ) ( const_int OFFSET ) ) ) ) . Such expressions are used in FRAME_RELATED_EXPR notes for more complex instructions . Marking the expressions as frame-related is superfluous if the note contains just a single set . But if the note contains a PARALLEL or SEQUENCE that has several sets , each set must be individually marked as frame-related .


<s> static bool expand_vselect_vconcat ( rtx target , rtx op0 , rtx op1 , const unsigned char * perm , unsigned nelt ) { machine_mode v2mode ; rtx x ; if ( ! GET_MODE_2XWIDER_MODE ( GET_MODE ( op0 ) ) . exists ( & v2mode ) ) return false ; x = gen_rtx_VEC_CONCAT ( v2mode , op0 , op1 ) ; return expand_vselect ( target , x , perm , nelt ) ; } </s>

Similar , but generate a vec_concat from op0 and op1 as well .


<s> bool RISCVTargetLowering :: isCheapToSpeculateCtlz ( ) const { return Subtarget . hasStdExtZbb ( ) ; } </s>

Return true if it is cheap to speculate a call to intrinsic ctlz .


<s> void msp430_split_movsi ( rtx * operands ) { rtx op00 , op02 , op10 , op12 ; op00 = msp430_subreg ( HImode , operands [ 0 ] , SImode , 0 ) ; op02 = msp430_subreg ( HImode , operands [ 0 ] , SImode , 2 ) ; if ( GET_CODE ( operands [ 1 ] ) == CONST || GET_CODE ( operands [ 1 ] ) == SYMBOL_REF ) { op10 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ 1 ] , GEN_INT ( 16 ) , GEN_INT ( 0 ) ) ; op10 = gen_rtx_CONST ( HImode , op10 ) ; op12 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ 1 ] , GEN_INT ( 16 ) , GEN_INT ( 16 ) ) ; op12 = gen_rtx_CONST ( HImode , op12 ) ; } else { op10 = msp430_subreg ( HImode , operands [ 1 ] , SImode , 0 ) ; op12 = msp430_subreg ( HImode , operands [ 1 ] , SImode , 2 ) ; } if ( rtx_equal_p ( operands [ 0 ] , operands [ 1 ] ) ) { operands [ 2 ] = op02 ; operands [ 4 ] = op12 ; operands [ 3 ] = op00 ; operands [ 5 ] = op10 ; } else if ( rtx_equal_p ( op00 , op12 ) || ( REG_P ( op00 ) && reg_mentioned_p ( op00 , op10 ) ) || ( REG_P ( op10 ) && reg_mentioned_p ( op10 , op00 ) ) ) { operands [ 2 ] = op02 ; operands [ 4 ] = op12 ; operands [ 3 ] = op00 ; operands [ 5 ] = op10 ; } else { operands [ 2 ] = op00 ; operands [ 4 ] = op10 ; operands [ 3 ] = op02 ; operands [ 5 ] = op12 ; } } </s>

Called by movsi_x to generate the HImode operands .


<s> bool bfin_expand_movmem ( rtx dst , rtx src , rtx count_exp , rtx align_exp ) { rtx srcreg , destreg , countreg ; HOST_WIDE_INT align = 0 ; unsigned HOST_WIDE_INT count = 0 ; if ( GET_CODE ( align_exp ) == CONST_INT ) align = INTVAL ( align_exp ) ; if ( GET_CODE ( count_exp ) == CONST_INT ) { count = INTVAL ( count_exp ) ; if ( ! TARGET_INLINE_ALL_STRINGOPS && count > 64 ) return false ; } if ( optimize_size ) { if ( count == 2 && align < 2 ) return false ; if ( count == 4 && align < 4 ) return false ; if ( count != 1 && count != 2 && count != 4 ) return false ; } if ( align < 2 && count != 1 ) return false ; destreg = copy_to_mode_reg ( Pmode , XEXP ( dst , 0 ) ) ; if ( destreg != XEXP ( dst , 0 ) ) dst = replace_equiv_address_nv ( dst , destreg ) ; srcreg = copy_to_mode_reg ( Pmode , XEXP ( src , 0 ) ) ; if ( srcreg != XEXP ( src , 0 ) ) src = replace_equiv_address_nv ( src , srcreg ) ; if ( count != 0 && align >= 2 ) { unsigned HOST_WIDE_INT offset = 0 ; if ( align >= 4 ) { if ( ( count & ~ 3 ) == 4 ) { single_move_for_movmem ( dst , src , SImode , offset ) ; offset = 4 ; } else if ( count & ~ 3 ) { HOST_WIDE_INT new_count = ( ( count >> 2 ) & 0x3fffffff ) - 1 ; countreg = copy_to_mode_reg ( Pmode , GEN_INT ( new_count ) ) ; emit_insn ( gen_rep_movsi ( destreg , srcreg , countreg , destreg , srcreg ) ) ; cfun -> machine -> has_loopreg_clobber = true ; } if ( count & 2 ) { single_move_for_movmem ( dst , src , HImode , offset ) ; offset += 2 ; } } else { if ( ( count & ~ 1 ) == 2 ) { single_move_for_movmem ( dst , src , HImode , offset ) ; offset = 2 ; } else if ( count & ~ 1 ) { HOST_WIDE_INT new_count = ( ( count >> 1 ) & 0x7fffffff ) - 1 ; countreg = copy_to_mode_reg ( Pmode , GEN_INT ( new_count ) ) ; emit_insn ( gen_rep_movhi ( destreg , srcreg , countreg , destreg , srcreg ) ) ; cfun -> machine -> has_loopreg_clobber = true ; } } if ( count & 1 ) { single_move_for_movmem ( dst , src , QImode , offset ) ; } return true ; } return false ; } </s>

Expand a string move operation of COUNT_EXP bytes from SRC to DST , with alignment ALIGN_EXP . Return true if successful , false if we should fall back on a different method .


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"Local Dynamic TLS Access Clean-up"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> bool ARMBaseInstrInfo :: SubsumesPredicate ( ArrayRef < MachineOperand > Pred1 , ArrayRef < MachineOperand > Pred2 ) const { if ( Pred1 . size ( ) > 2 || Pred2 . size ( ) > 2 ) return false ; ARMCC :: CondCodes CC1 = ( ARMCC :: CondCodes ) Pred1 [ 0 ] . getImm ( ) ; ARMCC :: CondCodes CC2 = ( ARMCC :: CondCodes ) Pred2 [ 0 ] . getImm ( ) ; if ( CC1 == CC2 ) return true ; switch ( CC1 ) { default : return false ; case ARMCC :: AL : return true ; case ARMCC :: HS : return CC2 == ARMCC :: HI ; case ARMCC :: LS : return CC2 == ARMCC :: LO || CC2 == ARMCC :: EQ ; case ARMCC :: GE : return CC2 == ARMCC :: GT ; case ARMCC :: LE : return CC2 == ARMCC :: LT ; } } </s>

Returns true if the first specified predicate subsumes the second , e.g .

ARM ARM 2 2 ARMCC::CondCodes ARMCC::CondCodes 0 ARMCC::CondCodes ARMCC::CondCodes 0 ARMCC::AL ARMCC::HS ARMCC::HI ARMCC::LS ARMCC::LO ARMCC::EQ ARMCC::GE ARMCC::GT ARMCC::LE ARMCC::LT


<s> bool emit ( MCInst & Inst , SMLoc const & Loc , MCStreamer & Out ) const { Inst . setLoc ( Loc ) ; Out . emitInstruction ( Inst , STI ) ; return false ; } </s>

Output the remark via the diagnostic handler and to the optimization record file .


"PTX DAG->DAG Pattern Instruction Selection"


<s> rtx extract_nth_ls2_access_reg ( rtx_insn * insn , int n ) { rtx reg ; machine_mode mode ; if ( post_update_insn_p ( insn ) ) { memory_access_direction direction = determine_access_direction ( insn ) ; gcc_assert ( direction != MEM_ACCESS_DIR_UNKNOWN ) ; if ( direction == MEM_ACCESS_DIR_NEG ) n = - 1 * n - 1 ; } if ( n < - 2 || n > 1 ) return NULL_RTX ; if ( n < 0 ) n = 2 + n ; switch ( get_attr_type ( insn ) ) { case TYPE_LOAD : reg = SET_DEST ( PATTERN ( insn ) ) ; break ; case TYPE_STORE : reg = SET_SRC ( PATTERN ( insn ) ) ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( REG_P ( reg ) || GET_CODE ( reg ) == SUBREG ) ; switch ( GET_MODE ( reg ) ) { case E_DImode : mode = SImode ; break ; case E_DFmode : mode = SFmode ; break ; default : gcc_unreachable ( ) ; } if ( n == 0 ) return gen_lowpart ( mode , reg ) ; else return gen_highpart ( mode , reg ) ; } </s>

Returns the register operated by the nth load/store operation in the real micro-operation accessing order . This function assumes INSN must be a double-word load/store insn .


<s> static void pa_function_arg_advance ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int arg_size = pa_function_arg_size ( mode , type ) ; cum -> nargs_prototype -- ; cum -> words += ( arg_size + ( ( cum -> words & 01 ) && type != NULL_TREE && arg_size > 1 ) ) ; } </s>

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


<s> void SIRegisterInfo :: materializeFrameBaseRegister ( MachineBasicBlock * MBB , Register BaseReg , int FrameIdx , int64_t Offset ) const { MachineBasicBlock :: iterator Ins = MBB -> begin ( ) ; DebugLoc DL ; if ( Ins != MBB -> end ( ) ) DL = Ins -> getDebugLoc ( ) ; MachineFunction * MF = MBB -> getParent ( ) ; const SIInstrInfo * TII = ST . getInstrInfo ( ) ; if ( Offset == 0 ) { BuildMI ( * MBB , Ins , DL , TII -> get ( AMDGPU :: V_MOV_B32_e32 ) , BaseReg ) . addFrameIndex ( FrameIdx ) ; return ; } MachineRegisterInfo & MRI = MF -> getRegInfo ( ) ; Register OffsetReg = MRI . createVirtualRegister ( & AMDGPU :: SReg_32_XM0RegClass ) ; Register FIReg = MRI . createVirtualRegister ( & AMDGPU :: VGPR_32RegClass ) ; BuildMI ( * MBB , Ins , DL , TII -> get ( AMDGPU :: S_MOV_B32 ) , OffsetReg ) . addImm ( Offset ) ; BuildMI ( * MBB , Ins , DL , TII -> get ( AMDGPU :: V_MOV_B32_e32 ) , FIReg ) . addFrameIndex ( FrameIdx ) ; TII -> getAddNoCarry ( * MBB , Ins , DL , BaseReg ) . addReg ( OffsetReg , RegState :: Kill ) . addReg ( FIReg ) . addImm ( 0 ) ; } </s>

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


<s> static void computeKnownBits ( SelectionDAG & DAG , SDValue Op , APInt & KnownZero , APInt & KnownOne ) { if ( Op . getOpcode ( ) == ARMISD :: BFI ) { computeKnownBits ( DAG , Op . getOperand ( 0 ) , KnownZero , KnownOne ) ; ConstantSDNode * CI = cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; const APInt & Mask = CI -> getAPIntValue ( ) ; KnownZero &= Mask ; KnownOne &= Mask ; return ; } if ( Op . getOpcode ( ) == ARMISD :: CMOV ) { APInt KZ2 ( KnownZero . getBitWidth ( ) , 0 ) ; APInt KO2 ( KnownOne . getBitWidth ( ) , 0 ) ; computeKnownBits ( DAG , Op . getOperand ( 0 ) , KnownZero , KnownOne ) ; computeKnownBits ( DAG , Op . getOperand ( 1 ) , KZ2 , KO2 ) ; KnownZero &= KZ2 ; KnownOne &= KO2 ; return ; } return DAG . computeKnownBits ( Op , KnownZero , KnownOne ) ; } </s>

Determine which bits of Op are known to be either zero or one and return them in Known .


<s> rtx find_addr_reg ( rtx addr ) { while ( GET_CODE ( addr ) == PLUS ) { if ( GET_CODE ( XEXP ( addr , 0 ) ) == REG && REGNO ( XEXP ( addr , 0 ) ) != 0 ) addr = XEXP ( addr , 0 ) ; else if ( GET_CODE ( XEXP ( addr , 1 ) ) == REG && REGNO ( XEXP ( addr , 1 ) ) != 0 ) addr = XEXP ( addr , 1 ) ; else if ( CONSTANT_P ( XEXP ( addr , 0 ) ) ) addr = XEXP ( addr , 1 ) ; else if ( CONSTANT_P ( XEXP ( addr , 1 ) ) ) addr = XEXP ( addr , 0 ) ; else gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( addr ) == REG && REGNO ( addr ) != 0 ) ; return addr ; } </s>

Return a REG that occurs in ADDR with coefficient 1 . ADDR can be effectively incremented by incrementing REG . r0 is special and we must not select it as an address register by this routine since our caller will try to increment the returned register via an `` la '' instruction .


"Save/restore libcall not implemented for purecap"

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>
unsigned
AArch64MCCodeEmitter
::
getMachineOpValue
(
const
MCInst
&
MI
,
const
MCOperand
&
MO
,
SmallVectorImpl
<
MCFixup
>
&
Fixups
,
const
MCSubtargetInfo
&
STI
)
const
{
if
(
MO
.
isReg
(
)
)
return
Ctx
.
getRegisterInfo
(
)
->
getEncodingValue
(
MO
.
getReg
(
)
)
;
assert
(
MO
.
isImm
(
)
&&
"did not expect relocated expression"
)
;
return
static_cast
<
unsigned
>
(
MO
.
getImm
(
)
)
;
}
</s>

getMachineOpValue - Return binary encoding of operand .


<s> static void nds32_emit_stack_v3pop ( rtx Rb , rtx Re , rtx En4 ATTRIBUTE_UNUSED , rtx imm8u ) { int regno ; int num_use_regs ; int par_index ; int offset ; rtx reg ; rtx mem ; rtx pop_rtx ; rtx adjust_sp_rtx ; rtx parallel_insn ; rtx dwarf = NULL_RTX ; num_use_regs = REGNO ( Re ) - REGNO ( Rb ) + 1 + 3 ; parallel_insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_use_regs + 1 ) ) ; par_index = 0 ; offset = 0 ; for ( regno = REGNO ( Rb ) ; regno <= ( int ) REGNO ( Re ) ; regno ++ ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; pop_rtx = gen_rtx_SET ( reg , mem ) ; XVECEXP ( parallel_insn , 0 , par_index ) = pop_rtx ; RTX_FRAME_RELATED_P ( pop_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; } reg = gen_rtx_REG ( SImode , FP_REGNUM ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; pop_rtx = gen_rtx_SET ( reg , mem ) ; XVECEXP ( parallel_insn , 0 , par_index ) = pop_rtx ; RTX_FRAME_RELATED_P ( pop_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; reg = gen_rtx_REG ( SImode , GP_REGNUM ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; pop_rtx = gen_rtx_SET ( reg , mem ) ; XVECEXP ( parallel_insn , 0 , par_index ) = pop_rtx ; RTX_FRAME_RELATED_P ( pop_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; reg = gen_rtx_REG ( SImode , LP_REGNUM ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; pop_rtx = gen_rtx_SET ( reg , mem ) ; XVECEXP ( parallel_insn , 0 , par_index ) = pop_rtx ; RTX_FRAME_RELATED_P ( pop_rtx ) = 1 ; offset = offset + 4 ; par_index ++ ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; adjust_sp_rtx = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , offset + INTVAL ( imm8u ) ) ) ; XVECEXP ( parallel_insn , 0 , par_index ) = adjust_sp_rtx ; dwarf = alloc_reg_note ( REG_CFA_ADJUST_CFA , copy_rtx ( adjust_sp_rtx ) , dwarf ) ; parallel_insn = emit_insn ( parallel_insn ) ; RTX_FRAME_RELATED_P ( parallel_insn ) = 1 ; REG_NOTES ( parallel_insn ) = dwarf ; } </s>

Function to create a parallel rtx pattern which presents stack v3pop behavior . The overall concept are : `` pop registers from memory '' , `` adjust stack pointer '' .


<s> static rtx nios2_legitimize_address ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED ) { rtx op0 , op1 ; if ( CONSTANT_P ( x ) ) return nios2_legitimize_constant_address ( x ) ; if ( GET_CODE ( x ) != PLUS ) return x ; op0 = XEXP ( x , 0 ) ; op1 = XEXP ( x , 1 ) ; if ( nios2_valid_addr_offset_p ( op1 ) ) return gen_rtx_PLUS ( Pmode , force_reg ( Pmode , op0 ) , copy_rtx ( op1 ) ) ; else if ( nios2_symbolic_constant_p ( op1 ) ) { if ( nios2_large_constant_allowed ( ) ) return gen_rtx_PLUS ( Pmode , force_reg ( Pmode , op0 ) , copy_rtx ( op1 ) ) ; else return nios2_split_plus_large_constant ( op0 , op1 ) ; } else if ( GET_CODE ( op1 ) == CONST ) { rtx unspec , offset ; split_const ( op1 , & unspec , & offset ) ; if ( GET_CODE ( unspec ) == UNSPEC && ! nios2_large_offset_p ( XINT ( unspec , 1 ) ) && offset != const0_rtx ) { rtx reg = force_reg ( Pmode , op0 ) ; unspec = copy_rtx ( unspec ) ; XVECEXP ( unspec , 0 , 0 ) = plus_constant ( Pmode , XVECEXP ( unspec , 0 , 0 ) , INTVAL ( offset ) ) ; return gen_rtx_PLUS ( Pmode , reg , gen_rtx_CONST ( Pmode , unspec ) ) ; } } return x ; } </s>


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


"cannot emit unaligned pointers in ptx assembly"

Target hook for assembling integer object X of size SIZE .


<s> static rtx ix86_expand_sse_fabs ( rtx op0 , rtx * smask ) { machine_mode vmode , mode = GET_MODE ( op0 ) ; rtx xa , mask ; xa = gen_reg_rtx ( mode ) ; if ( mode == SFmode ) vmode = V4SFmode ; else if ( mode == DFmode ) vmode = V2DFmode ; else vmode = mode ; mask = ix86_build_signbit_mask ( vmode , VECTOR_MODE_P ( mode ) , true ) ; if ( ! VECTOR_MODE_P ( mode ) ) { rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 1 , const0_rtx ) ) ; tmp = gen_rtx_VEC_SELECT ( mode , mask , tmp ) ; mask = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( mask , tmp ) ) ; } emit_insn ( gen_rtx_SET ( xa , gen_rtx_AND ( mode , op0 , mask ) ) ) ; if ( smask ) * smask = mask ; return xa ; } </s>

Expand fabs ( OP0 ) and return a new rtx that holds the result . The mask for masking out the sign-bit is stored in * SMASK , if that is non-null .


<s> int num_insns_constant ( rtx op , machine_mode mode ) { HOST_WIDE_INT low , high ; switch ( GET_CODE ( op ) ) { case CONST_INT : if ( ( INTVAL ( op ) >> 31 ) != 0 && ( INTVAL ( op ) >> 31 ) != - 1 && rs6000_is_valid_and_mask ( op , mode ) ) return 2 ; else return num_insns_constant_wide ( INTVAL ( op ) ) ; case CONST_WIDE_INT : { int i ; int ins = CONST_WIDE_INT_NUNITS ( op ) - 1 ; for ( i = 0 ; i < CONST_WIDE_INT_NUNITS ( op ) ; i ++ ) ins += num_insns_constant_wide ( CONST_WIDE_INT_ELT ( op , i ) ) ; return ins ; } case CONST_DOUBLE : if ( mode == SFmode || mode == SDmode ) { long l ; if ( DECIMAL_FLOAT_MODE_P ( mode ) ) REAL_VALUE_TO_TARGET_DECIMAL32 ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; else REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; return num_insns_constant_wide ( ( HOST_WIDE_INT ) l ) ; } long l [ 2 ] ; if ( DECIMAL_FLOAT_MODE_P ( mode ) ) REAL_VALUE_TO_TARGET_DECIMAL64 ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; else REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; high = l [ WORDS_BIG_ENDIAN == 0 ] ; low = l [ WORDS_BIG_ENDIAN != 0 ] ; if ( TARGET_32BIT ) return ( num_insns_constant_wide ( low ) + num_insns_constant_wide ( high ) ) ; else { if ( ( high == 0 && low >= 0 ) || ( high == - 1 && low < 0 ) ) return num_insns_constant_wide ( low ) ; else if ( rs6000_is_valid_and_mask ( op , mode ) ) return 2 ; else if ( low == 0 ) return num_insns_constant_wide ( high ) + 1 ; else return ( num_insns_constant_wide ( high ) + num_insns_constant_wide ( low ) + 1 ) ; } default : gcc_unreachable ( ) ; } } </s>

Return the number of instructions it takes to form a constant in as many gprs are needed for MODE .