<s> static std :: unique_ptr < MipsOperand > CreateReg ( unsigned Index , StringRef Str , RegKind RegKind , const MCRegisterInfo * RegInfo , SMLoc S , SMLoc E , MipsAsmParser & Parser ) { auto Op = llvm :: make_unique < MipsOperand > ( k_RegisterIndex , Parser ) ; Op -> RegIdx . Index = Index ; Op -> RegIdx . RegInfo = RegInfo ; Op -> RegIdx . Kind = RegKind ; Op -> RegIdx . Tok . Data = Str . data ( ) ; Op -> RegIdx . Tok . Length = Str . size ( ) ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>

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


"\t%s BEGIN PROLOGUE %s vars= %d, regs= %d, args= %d, extra= %d\n"

Set up the stack and frame pointer ( if desired ) for the function .


"Unknown operand type in WebAssemblyDisassembler"

Returns the disassembly of a single instruction .


<s>
MachineBasicBlock
*
TLCS900TargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
*
MI
,
MachineBasicBlock
*
BB
)
const
{
unsigned
Opc
=
MI
->
getOpcode
(
)
;
if
(
Opc
==
TLCS900
::
Shl8
||
Opc
==
TLCS900
::
Shl16
||
Opc
==
TLCS900
::
Sra8
||
Opc
==
TLCS900
::
Sra16
||
Opc
==
TLCS900
::
Srl8
||
Opc
==
TLCS900
::
Srl16
)
return
EmitShiftInstr
(
MI
,
BB
)
;
const
TargetInstrInfo
&
TII
=
*
getTargetMachine
(
)
.
getInstrInfo
(
)
;
DebugLoc
dl
=
MI
->
getDebugLoc
(
)
;
assert
(
(
Opc
==
TLCS900
::
Select16
||
Opc
==
TLCS900
::
Select8
)
&&
"Unexpected instr type to insert"
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
MachineFunction
::
iterator
I
=
BB
;
++
I
;
MachineBasicBlock
*
thisMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
copy0MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
copy1MBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
F
->
insert
(
I
,
copy0MBB
)
;
F
->
insert
(
I
,
copy1MBB
)
;
copy1MBB
->
splice
(
copy1MBB
->
begin
(
)
,
BB
,
llvm
::
next
(
MachineBasicBlock
::
iterator
(
MI
)
)
,
BB
->
end
(
)
)
;
copy1MBB
->
transferSuccessorsAndUpdatePHIs
(
BB
)
;
BB
->
addSuccessor
(
copy0MBB
)
;
BB
->
addSuccessor
(
copy1MBB
)
;
BuildMI
(
BB
,
dl
,
TII
.
get
(
TLCS900
::
JCC
)
)
.
addMBB
(
copy1MBB
)
.
addImm
(
MI
->
getOperand
(
3
)
.
getImm
(
)
)
;
BB
=
copy0MBB
;
BB
->
addSuccessor
(
copy1MBB
)
;
BB
=
copy1MBB
;
BuildMI
(
*
BB
,
BB
->
begin
(
)
,
dl
,
TII
.
get
(
TLCS900
::
PHI
)
,
MI
->
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
->
getOperand
(
2
)
.
getReg
(
)
)
.
addMBB
(
copy0MBB
)
.
addReg
(
MI
->
getOperand
(
1
)
.
getReg
(
)
)
.
addMBB
(
thisMBB
)
;
MI
->
eraseFromParent
(
)
;
return
BB
;
}
</s>

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


<s>
static
void
write_fn_proto_1
(
std
::
stringstream
&
s
,
bool
is_defn
,
const
char
*
name
,
const_tree
decl
,
bool
force_public
)
{
if
(
lookup_attribute
(
"alias"
,
DECL_ATTRIBUTES
(
decl
)
)
==
)
write_fn_marker
(
s
,
is_defn
,
TREE_PUBLIC
(
decl
)
||
force_public
,
name
)
;
if
(
DECL_EXTERNAL
(
decl
)
)
s
<<
".extern "
;
else
if
(
TREE_PUBLIC
(
decl
)
||
force_public
)
s
<<
(
DECL_WEAK
(
decl
)
".weak "
:
".visible "
)
;
s
<<
(
write_as_kernel
(
DECL_ATTRIBUTES
(
decl
)
)
".entry "
:
".func "
)
;
tree
fntype
=
TREE_TYPE
(
decl
)
;
tree
result_type
=
TREE_TYPE
(
fntype
)
;
int
not_atomic_weak_arg
=
1
;
if
(
DECL_BUILT_IN_CLASS
(
decl
)
==
BUILT_IN_NORMAL
)
switch
(
DECL_FUNCTION_CODE
(
decl
)
)
{
case
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
case
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
case
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
case
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
case
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
not_atomic_weak_arg
=
3
;
break
;
default
:
break
;
}
bool
return_in_mem
=
write_return_type
(
s
,
true
,
result_type
)
;
s
<<
name
;
int
argno
=
0
;
if
(
return_in_mem
)
argno
=
write_arg_type
(
s
,
1
,
argno
,
ptr_type_node
,
true
)
;
tree
args
=
TYPE_ARG_TYPES
(
fntype
)
;
bool
prototyped
=
true
;
if
(
!
args
)
{
args
=
DECL_ARGUMENTS
(
decl
)
;
prototyped
=
false
;
}
for
(
;
args
;
args
=
TREE_CHAIN
(
args
)
,
not_atomic_weak_arg
)
{
tree
type
=
prototyped
TREE_VALUE
(
args
)
:
TREE_TYPE
(
args
)
;
if
(
not_atomic_weak_arg
)
argno
=
write_arg_type
(
s
,
1
,
argno
,
type
,
prototyped
)
;
else
gcc_assert
(
TREE_CODE
(
type
)
==
BOOLEAN_TYPE
)
;
}
if
(
stdarg_p
(
fntype
)
)
argno
=
write_arg_type
(
s
,
1
,
argno
,
ptr_type_node
,
true
)
;
if
(
DECL_STATIC_CHAIN
(
decl
)
)
argno
=
write_arg_type
(
s
,
1
,
argno
,
ptr_type_node
,
true
)
;
if
(
argno
<
2
&&
strcmp
(
name
,
"main"
)
==
0
)
{
if
(
argno
==
0
)
argno
=
write_arg_type
(
s
,
1
,
argno
,
integer_type_node
,
true
)
;
if
(
argno
==
1
)
argno
=
write_arg_type
(
s
,
1
,
argno
,
ptr_type_node
,
true
)
;
}
if
(
argno
)
s
<<
")"
;
s
<<
(
is_defn
"\n"
:
";\n"
)
;
}
</s>


<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 ( 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>
void
AArch64Operand
::
print
(
raw_ostream
&
OS
)
const
{
switch
(
Kind
)
{
case
k_FPImm
:
OS
<<
"<fpimm "
<<
getFPImm
(
)
<<
"("
<<
AArch64_AM
::
getFPImmFloat
(
getFPImm
(
)
)
<<
") >"
;
break
;
case
k_Barrier
:
{
StringRef
Name
=
getBarrierName
(
)
;
if
(
!
Name
.
empty
(
)
)
OS
<<
"<barrier "
<<
Name
<<
">"
;
else
OS
<<
"<barrier invalid #"
<<
getBarrier
(
)
<<
">"
;
break
;
}
case
k_Immediate
:
OS
<<
*
getImm
(
)
;
break
;
case
k_ShiftedImm
:
{
unsigned
Shift
=
getShiftedImmShift
(
)
;
OS
<<
"<shiftedimm "
;
OS
<<
*
getShiftedImmVal
(
)
;
OS
<<
", lsl #"
<<
AArch64_AM
::
getShiftValue
(
Shift
)
<<
">"
;
break
;
}
case
k_CondCode
:
OS
<<
"<condcode "
<<
getCondCode
(
)
<<
">"
;
break
;
case
k_Register
:
OS
<<
"<register "
<<
getReg
(
)
<<
">"
;
break
;
case
k_VectorList
:
{
OS
<<
"<vectorlist "
;
unsigned
Reg
=
getVectorListStart
(
)
;
for
(
unsigned
i
=
0
,
e
=
getVectorListCount
(
)
;
i
!=
e
;
++
i
)
OS
<<
Reg
+
i
<<
" "
;
OS
<<
">"
;
break
;
}
case
k_VectorIndex
:
OS
<<
"<vectorindex "
<<
getVectorIndex
(
)
<<
">"
;
break
;
case
k_SysReg
:
OS
<<
"<sysreg: "
<<
getSysReg
(
)
<<
'>'
;
break
;
case
k_Token
:
OS
<<
"'"
<<
getToken
(
)
<<
"'"
;
break
;
case
k_SysCR
:
OS
<<
"c"
<<
getSysCR
(
)
;
break
;
case
k_Prefetch
:
{
StringRef
Name
=
getPrefetchName
(
)
;
if
(
!
Name
.
empty
(
)
)
OS
<<
"<prfop "
<<
Name
<<
">"
;
else
OS
<<
"<prfop invalid #"
<<
getPrefetch
(
)
<<
">"
;
break
;
}
case
k_ShiftExtend
:
{
OS
<<
"<"
<<
AArch64_AM
::
getShiftExtendName
(
getShiftExtendType
(
)
)
<<
" #"
<<
getShiftExtendAmount
(
)
;
if
(
!
hasShiftExtendAmount
(
)
)
OS
<<
"<imp>"
;
OS
<<
'>'
;
break
;
}
}
}
</s>

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

AArch64
AArch64
"<fpimm "
"("
AArch64_AM::getFPImmFloat
") >"
"<barrier "
">"
"<barrier invalid #"
">"
"<shiftedimm "
", lsl #"
AArch64_AM::getShiftValue
">"
"<condcode "
">"
"<register "
">"
"<vectorlist "
0
" "
">"
"<vectorindex "
">"
"<sysreg: "
"'"
"'"
"c"
"<prfop "
">"
"<prfop invalid #"
">"
"<"
AArch64_AM::getShiftExtendName
" #"
"<imp>"


<s> std :: pair < unsigned , const TargetRegisterClass * > SystemZTargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'd' : case 'r' : if ( VT == MVT :: i64 ) return std :: make_pair ( 0U , & SystemZ :: GR64BitRegClass ) ; else if ( VT == MVT :: i128 ) return std :: make_pair ( 0U , & SystemZ :: GR128BitRegClass ) ; return std :: make_pair ( 0U , & SystemZ :: GR32BitRegClass ) ; case 'a' : if ( VT == MVT :: i64 ) return std :: make_pair ( 0U , & SystemZ :: ADDR64BitRegClass ) ; else if ( VT == MVT :: i128 ) return std :: make_pair ( 0U , & SystemZ :: ADDR128BitRegClass ) ; return std :: make_pair ( 0U , & SystemZ :: ADDR32BitRegClass ) ; case 'f' : if ( VT == MVT :: f64 ) return std :: make_pair ( 0U , & SystemZ :: FP64BitRegClass ) ; else if ( VT == MVT :: f128 ) return std :: make_pair ( 0U , & SystemZ :: FP128BitRegClass ) ; return std :: make_pair ( 0U , & SystemZ :: FP32BitRegClass ) ; } } if ( Constraint [ 0 ] == '{' ) { if ( Constraint [ 1 ] == 'r' ) { if ( VT == MVT :: i32 ) return parseRegisterNumber ( Constraint , & SystemZ :: GR32BitRegClass , SystemZMC :: GR32Regs ) ; if ( VT == MVT :: i128 ) return parseRegisterNumber ( Constraint , & SystemZ :: GR128BitRegClass , SystemZMC :: GR128Regs ) ; return parseRegisterNumber ( Constraint , & SystemZ :: GR64BitRegClass , SystemZMC :: GR64Regs ) ; } if ( Constraint [ 1 ] == 'f' ) { if ( VT == MVT :: f32 ) return parseRegisterNumber ( Constraint , & SystemZ :: FP32BitRegClass , SystemZMC :: FP32Regs ) ; if ( VT == MVT :: f128 ) return parseRegisterNumber ( Constraint , & SystemZ :: FP128BitRegClass , SystemZMC :: FP128Regs ) ; return parseRegisterNumber ( Constraint , & SystemZ :: FP64BitRegClass , SystemZMC :: FP64Regs ) ; } } return TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> bool lowerOperand ( const MachineOperand & MO , MCOperand & MCOp ) const { return LowerRV16KMachineOperandToMCOperand ( MO , MCOp , * this ) ; } </s>

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


<s>
bool
Emitter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
MCE
.
setModuleInfo
(
&
getAnalysis
<
MachineModuleInfo
>
(
)
)
;
II
=
TM
.
getInstrInfo
(
)
;
TD
=
TM
.
getTargetData
(
)
;
Is64BitMode
=
TM
.
getSubtarget
<
X86Subtarget
>
(
)
.
is64Bit
(
)
;
IsPIC
=
TM
.
getRelocationModel
(
)
==
Reloc
::
PIC_
;
do
{
DOUT
<<
"JITTing function '"
<<
MF
.
getFunction
(
)
->
getName
(
)
<<
"'\n"
;
MCE
.
startFunction
(
MF
)
;
for
(
MachineFunction
::
iterator
MBB
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
MBB
!=
E
;
++
MBB
)
{
MCE
.
StartMachineBasicBlock
(
MBB
)
;
for
(
MachineBasicBlock
::
const_iterator
I
=
MBB
->
begin
(
)
,
E
=
MBB
->
end
(
)
;
I
!=
E
;
++
I
)
{
const
TargetInstrDesc
&
Desc
=
I
->
getDesc
(
)
;
emitInstruction
(
*
I
,
&
Desc
)
;
if
(
Desc
.
getOpcode
(
)
==
X86
::
MOVPC32r
)
emitInstruction
(
*
I
,
&
II
->
get
(
X86
::
POP32r
)
)
;
NumEmitted
++
;
}
}
}
while
(
MCE
.
finishFunction
(
MF
)
)
;
return
false
;
}
</s>

runOnMachineFunction - Emit the function body .


<s>
static
void
emit_insn_group_barriers
(
FILE
*
dump
)
{
rtx_insn
*
insn
;
rtx_insn
*
last_label
=
0
;
int
insns_since_last_label
=
0
;
init_insn_group_barriers
(
)
;
for
(
insn
=
get_insns
(
)
;
insn
;
insn
=
NEXT_INSN
(
insn
)
)
{
if
(
LABEL_P
(
insn
)
)
{
if
(
insns_since_last_label
)
last_label
=
insn
;
insns_since_last_label
=
0
;
}
else
if
(
NOTE_P
(
insn
)
&&
NOTE_KIND
(
insn
)
==
NOTE_INSN_BASIC_BLOCK
)
{
if
(
insns_since_last_label
)
last_label
=
insn
;
insns_since_last_label
=
0
;
}
else
if
(
NONJUMP_INSN_P
(
insn
)
&&
GET_CODE
(
PATTERN
(
insn
)
)
==
UNSPEC_VOLATILE
&&
XINT
(
PATTERN
(
insn
)
,
1
)
==
UNSPECV_INSN_GROUP_BARRIER
)
{
init_insn_group_barriers
(
)
;
last_label
=
0
;
}
else
if
(
NONDEBUG_INSN_P
(
insn
)
)
{
insns_since_last_label
=
1
;
if
(
group_barrier_needed
(
insn
)
)
{
if
(
last_label
)
{
if
(
dump
)
fprintf
(
dump
,
"Emitting stop before label %d\n"
,
INSN_UID
(
last_label
)
)
;
emit_insn_before
(
gen_insn_group_barrier
(
GEN_INT
(
3
)
)
,
last_label
)
;
insn
=
last_label
;
init_insn_group_barriers
(
)
;
last_label
=
0
;
}
}
}
}
}
</s>

INSNS is an chain of instructions . Scan the chain , and insert stop bits as necessary to eliminate dependendencies . This function assumes that a final instruction scheduling pass has been run which has already inserted most of the necessary stop bits . This function only inserts new ones at basic block boundaries , since these are invisible to the scheduler .


<s> void assignValueToReg ( unsigned ValVReg , unsigned PhysReg , CCValAssign & VA ) override { markPhysRegUsed ( PhysReg ) ; MIRBuilder . buildCopy ( ValVReg , PhysReg ) ; } </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 .


Output the assembly for a call instruction .


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


<s> bool avr_float_lib_compare_returns_bool ( machine_mode mode , enum rtx_code ) { if ( mode == DFmode ) { return true ; } return false ; } </s>

Worker function for ` FLOAT_LIB_COMPARE_RETURNS_BOOL ' .


<s> static void xstormy16_print_operand_address ( FILE * file , rtx address ) { HOST_WIDE_INT offset ; int pre_dec , post_inc ; if ( CONST_INT_P ( address ) ) { fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( address ) & 0xFFFF ) ; return ; } if ( CONSTANT_P ( address ) || LABEL_P ( address ) ) { output_addr_const ( file , address ) ; return ; } if ( GET_CODE ( address ) == PLUS ) { gcc_assert ( CONST_INT_P ( XEXP ( address , 1 ) ) ) ; offset = INTVAL ( XEXP ( address , 1 ) ) ; address = XEXP ( address , 0 ) ; } else offset = 0 ; pre_dec = ( GET_CODE ( address ) == PRE_DEC ) ; post_inc = ( GET_CODE ( address ) == POST_INC ) ; if ( pre_dec || post_inc ) address = XEXP ( address , 0 ) ; gcc_assert ( REG_P ( address ) ) ; fputc ( '(' , file ) ; if ( pre_dec ) fputs ( "--" , file ) ; fputs ( reg_names [ REGNO ( address ) ] , file ) ; if ( post_inc ) fputs ( "++" , file ) ; if ( offset != 0 ) fprintf ( file , "," HOST_WIDE_INT_PRINT_DEC , offset ) ; fputc ( ')' , file ) ; } </s>

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


<s> MCInst Thumb2InstrInfo :: getNop ( ) const { return MCInstBuilder ( ARM :: tHINT ) . addImm ( 0 ) . addImm ( ARMCC :: AL ) . addReg ( 0 ) ; } </s>

Return the noop instruction to use for a noop .


"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have "


<s> static const char * section_for_decl ( const_tree decl ) { return section_for_sym ( XEXP ( DECL_RTL ( CONST_CAST ( tree , decl ) ) , 0 ) ) ; } </s>


<s> SDValue AMDGPUTargetLowering :: WidenOrSplitVectorLoad ( SDValue Op , SelectionDAG & DAG ) const { LoadSDNode * Load = cast < LoadSDNode > ( Op ) ; EVT VT = Op . getValueType ( ) ; SDValue BasePtr = Load -> getBasePtr ( ) ; EVT MemVT = Load -> getMemoryVT ( ) ; SDLoc SL ( Op ) ; const MachinePointerInfo & SrcValue = Load -> getMemOperand ( ) -> getPointerInfo ( ) ; unsigned BaseAlign = Load -> getAlignment ( ) ; unsigned NumElements = MemVT . getVectorNumElements ( ) ; if ( NumElements != 3 || ( BaseAlign < 8 && ! SrcValue . isDereferenceable ( 16 , * DAG . getContext ( ) , DAG . getDataLayout ( ) ) ) ) return SplitVectorLoad ( Op , DAG ) ; assert ( NumElements == 3 ) ; EVT WideVT = EVT :: getVectorVT ( * DAG . getContext ( ) , VT . getVectorElementType ( ) , 4 ) ; EVT WideMemVT = EVT :: getVectorVT ( * DAG . getContext ( ) , MemVT . getVectorElementType ( ) , 4 ) ; SDValue WideLoad = DAG . getExtLoad ( Load -> getExtensionType ( ) , SL , WideVT , Load -> getChain ( ) , BasePtr , SrcValue , WideMemVT , BaseAlign , Load -> getMemOperand ( ) -> getFlags ( ) ) ; return DAG . getMergeValues ( { DAG . getNode ( ISD :: EXTRACT_SUBVECTOR , SL , VT , WideLoad , DAG . getVectorIdxConstant ( 0 , SL ) ) , WideLoad . getValue ( 1 ) } , SL ) ; } </s>


<s> static bool virt_or_elim_regno_p ( unsigned regno ) { return ( ( regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_POINTER_REGISTER ) || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) ; } </s>

Return true if REGNO is a virtual pointer register , or an eliminable `` soft '' frame register . Like REGNO_PTR_FRAME_P except that we do n't include stack_pointer or hard_frame_pointer .


<s> ScheduleDAGInstrs * createMachineScheduler ( MachineSchedContext * C ) const override { const AArch64Subtarget & ST = C -> MF -> getSubtarget < AArch64Subtarget > ( ) ; ScheduleDAGMILive * DAG = createGenericSchedLive ( C ) ; DAG -> addMutation ( createLoadClusterDAGMutation ( DAG -> TII , DAG -> TRI ) ) ; DAG -> addMutation ( createStoreClusterDAGMutation ( DAG -> TII , DAG -> TRI ) ) ; if ( ST . hasFusion ( ) ) DAG -> addMutation ( createAArch64MacroFusionDAGMutation ( ) ) ; return DAG ; } </s>

Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this function and target at the current optimization level .


<s> static bool aarch64_rtx_arith_op_extract_p ( rtx x ) { if ( GET_CODE ( x ) == SIGN_EXTEND || GET_CODE ( x ) == ZERO_EXTEND ) return REG_P ( XEXP ( x , 0 ) ) ; return false ; } </s>

Return true if X is a zero or sign extract usable in an ADD or SUB ( extended register ) instruction .


<s> static bool mips_rewrite_small_data_p ( rtx x , enum mips_symbol_context context ) { enum mips_symbol_type symbol_type ; return ( mips_lo_relocs [ SYMBOL_GP_RELATIVE ] && ! mips_split_p [ SYMBOL_GP_RELATIVE ] && mips_symbolic_constant_p ( x , context , & symbol_type ) && symbol_type == SYMBOL_GP_RELATIVE ) ; } </s>

Return true if X is a small data address that can be rewritten as a LO_SUM .


<s> static tree s390_handle_vectorbool_attribute ( tree * node , tree name ATTRIBUTE_UNUSED , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { tree type = * node , result = NULL_TREE ; machine_mode mode ; while ( POINTER_TYPE_P ( type ) || TREE_CODE ( type ) == FUNCTION_TYPE || TREE_CODE ( type ) == METHOD_TYPE || TREE_CODE ( type ) == ARRAY_TYPE ) type = TREE_TYPE ( type ) ; mode = TYPE_MODE ( type ) ; switch ( mode ) { case DImode : case V2DImode : result = s390_builtin_types [ BT_BV2DI ] ; break ; case SImode : case V4SImode : result = s390_builtin_types [ BT_BV4SI ] ; break ; case HImode : case V8HImode : result = s390_builtin_types [ BT_BV8HI ] ; break ; case QImode : case V16QImode : result = s390_builtin_types [ BT_BV16QI ] ; default : break ; } * no_add_attrs = true ; if ( result ) * node = lang_hooks . types . reconstruct_complex_type ( * node , result ) ; return NULL_TREE ; } </s>

Expand the s390_vector_bool type attribute .


<s> TargetLowering :: AtomicExpansionKind ARMTargetLowering :: shouldExpandAtomicRMWInIR ( AtomicRMWInst * AI ) const { if ( AI -> isFloatingPointOperation ( ) ) return AtomicExpansionKind :: CmpXChg ; if ( getTargetMachine ( ) . getOptLevel ( ) == CodeGenOpt :: None ) return AtomicExpansionKind :: CmpXChg ; unsigned Size = AI -> getType ( ) -> getPrimitiveSizeInBits ( ) ; bool hasAtomicRMW = ! Subtarget -> isThumb ( ) || Subtarget -> hasV8MBaselineOps ( ) ; return ( Size <= ( Subtarget -> isMClass ( ) ? 32U : 64U ) && hasAtomicRMW ) ? AtomicExpansionKind :: LLSC : AtomicExpansionKind :: None ; } </s>

Returns how the IR-level AtomicExpand pass should expand the given AtomicRMW , if at all .


"SPUTargetLowering::ReplaceNodeResults(): need to fix this!\n"

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


<s> void mips_split_msa_fill_d ( rtx dest , rtx src ) { gcc_assert ( ( GET_MODE ( dest ) == V2DImode && ( GET_MODE ( src ) == DImode || src == const0_rtx ) ) || ( GET_MODE ( dest ) == V2DFmode && GET_MODE ( src ) == DFmode ) ) ; rtx low , high ; if ( src == const0_rtx ) { low = src ; high = src ; } else { low = mips_subword ( src , false ) ; high = mips_subword ( src , true ) ; } rtx new_dest = simplify_gen_subreg ( V4SImode , dest , GET_MODE ( dest ) , 0 ) ; emit_insn ( gen_msa_fill_w ( new_dest , low ) ) ; emit_insn ( gen_msa_insert_w ( new_dest , high , new_dest , GEN_INT ( 1 << 1 ) ) ) ; emit_insn ( gen_msa_insert_w ( new_dest , high , new_dest , GEN_INT ( 1 << 3 ) ) ) ; } </s>


<s> RISCVSubtarget & RISCVSubtarget :: initializeSubtargetDependencies ( const Triple & TT , StringRef CPU , StringRef FS , StringRef ABIName ) { bool Is64Bit = TT . isArch64Bit ( ) ; std :: string CPUName = std :: string ( CPU ) ; if ( CPUName . empty ( ) ) CPUName = Is64Bit ? "generic-rv64" : "generic-rv32" ; ParseSubtargetFeatures ( CPUName , FS ) ; if ( Is64Bit ) { XLenVT = MVT :: i64 ; XLen = 64 ; } TargetABI = RISCVABI :: computeTargetABI ( TT , getFeatureBits ( ) , ABIName ) ; RISCVFeatures :: validate ( TT , getFeatureBits ( ) ) ; return * this ; } </s>

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


<s> bool csky_emit_compare_float ( enum rtx_code code , rtx op0 , rtx op1 ) { rtx cc_reg = gen_rtx_REG ( CCmode , CSKY_CC_REGNUM ) ; bool invert ; machine_mode mode = GET_MODE ( op1 ) ; if ( op1 != CONST0_RTX ( mode ) ) op1 = force_reg ( mode , op1 ) ; invert = false ; switch ( code ) { case EQ : code = NE ; invert = true ; break ; case GT : case LT : case LE : if ( op1 == CONST0_RTX ( mode ) && TARGET_SUPPORT_FPV2 ) op1 = force_reg ( mode , op1 ) ; break ; case ORDERED : code = UNORDERED ; invert = true ; break ; default : break ; } emit_insn ( gen_rtx_SET ( cc_reg , gen_rtx_fmt_ee ( code , CCmode , op0 , op1 ) ) ) ; return invert ; } </s>

Emit a comparison insn for float values . Return true if the comparison is inverted .


<s> unsigned MOSAsmBackend :: getNumFixupKinds ( ) const { return MOS :: Fixups :: NumTargetFixupKinds ; } </s>

Get the number of target specific fixup kinds .


<s> const unsigned * AlphaRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const unsigned CalleeSavedRegs [ ] = { Alpha :: R9 , Alpha :: R10 , Alpha :: R11 , Alpha :: R12 , Alpha :: R13 , Alpha :: R14 , Alpha :: F2 , Alpha :: F3 , Alpha :: F4 , Alpha :: F5 , Alpha :: F6 , Alpha :: F7 , Alpha :: F8 , Alpha :: F9 , 0 } ; return CalleeSavedRegs ; } </s>


<s> void cr16_expand_epilogue ( void ) { rtx insn ; int only_popret_RA = ( current_frame_info . save_regs [ RETURN_ADDRESS_REGNUM ] && ( current_frame_info . reg_size == CR16_UNITS_PER_DWORD ) ) ; if ( frame_pointer_needed ) { insn = emit_move_insn ( stack_pointer_rtx , frame_pointer_rtx ) ; } if ( current_frame_info . total_size > 0 ) { insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( current_frame_info . total_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } if ( crtl -> calls_eh_return ) { insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , EH_RETURN_STACKADJ_RTX ) ) ; } if ( cr16_interrupt_function_p ( ) ) { insn = emit_jump_insn ( gen_interrupt_return ( ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } else if ( crtl -> calls_eh_return ) { insn = emit_jump_insn ( gen_pop_and_popret_return ( GEN_INT ( current_frame_info . reg_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } else if ( current_frame_info . last_reg_to_save == - 1 ) emit_jump_insn ( gen_jump_return ( ) ) ; else if ( only_popret_RA ) { insn = emit_jump_insn ( gen_popret_RA_return ( ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } else { insn = emit_jump_insn ( gen_pop_and_popret_return ( GEN_INT ( current_frame_info . reg_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; } } </s>

Generate insn that updates the stack for local variables and padding for registers we save . - Generate the appropriate return insn .


<s> void MSP430AsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { MSP430MCInstLower MCInstLowering ( OutContext , * Mang , * this ) ; MCInst TmpInst ; MCInstLowering . Lower ( MI , TmpInst ) ; OutStreamer . EmitInstruction ( TmpInst ) ; } </s>

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


<s> void PPCPassConfig :: addPreSched2 ( ) { addPass ( createPPCVSXCopyCleanupPass ( ) , false ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( & IfConverterID ) ; } </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>
std
::
unique_ptr
<
LanaiOperand
>
LanaiAsmParser
::
parseIdentifier
(
)
{
SMLoc
Start
=
Parser
.
getTok
(
)
.
getLoc
(
)
;
SMLoc
End
=
SMLoc
::
getFromPointer
(
Parser
.
getTok
(
)
.
getLoc
(
)
.
getPointer
(
)
1
)
;
const
MCExpr
*
Res
,
*
RHS
=
0
;
LanaiMCExpr
::
VariantKind
Kind
=
LanaiMCExpr
::
VK_Lanai_None
;
if
(
Lexer
.
getKind
(
)
!=
AsmToken
::
Identifier
)
return
0
;
StringRef
Identifier
;
if
(
Parser
.
parseIdentifier
(
Identifier
)
)
return
0
;
if
(
Identifier
.
equals_lower
(
"hi"
)
)
Kind
=
LanaiMCExpr
::
VK_Lanai_ABS_HI
;
else
if
(
Identifier
.
equals_lower
(
"lo"
)
)
Kind
=
LanaiMCExpr
::
VK_Lanai_ABS_LO
;
if
(
Kind
!=
LanaiMCExpr
::
VK_Lanai_None
)
{
if
(
Lexer
.
getKind
(
)
!=
AsmToken
::
LParen
)
{
Error
(
Lexer
.
getLoc
(
)
,
"Expected '('"
)
;
return
0
;
}
Lexer
.
Lex
(
)
;
if
(
Parser
.
parseIdentifier
(
Identifier
)
)
return
0
;
}
if
(
Lexer
.
getKind
(
)
==
AsmToken
::
Plus
&&
Parser
.
parseExpression
(
RHS
)
)
return
0
;
if
(
Kind
!=
LanaiMCExpr
::
VK_Lanai_None
)
{
if
(
Lexer
.
getKind
(
)
!=
AsmToken
::
RParen
)
{
Error
(
Lexer
.
getLoc
(
)
,
"Expected ')'"
)
;
return
0
;
}
Lexer
.
Lex
(
)
;
}
End
=
SMLoc
::
getFromPointer
(
Parser
.
getTok
(
)
.
getLoc
(
)
.
getPointer
(
)
1
)
;
MCSymbol
*
Sym
=
getContext
(
)
.
getOrCreateSymbol
(
Identifier
)
;
const
MCExpr
*
Expr
=
MCSymbolRefExpr
::
create
(
Sym
,
getContext
(
)
)
;
Res
=
LanaiMCExpr
::
create
(
Kind
,
Expr
,
getContext
(
)
)
;
if
(
RHS
)
Res
=
MCBinaryExpr
::
createAdd
(
Res
,
RHS
,
getContext
(
)
)
;
return
LanaiOperand
::
createImm
(
Res
,
Start
,
End
)
;
}
</s>

Parse an identifier or string ( as a quoted identifier ) and set Res to the identifier contents .

Lanai
Lanai
Lanai
1
0
Lanai
Lanai
Lanai
0
0
"hi"
Lanai
Lanai
"lo"
Lanai
Lanai
Lanai
Lanai
"Expected '('"
0
0
0
Lanai
Lanai
"Expected ')'"
0
1
Lanai
LanaiOperand::createImm


<s> const MCExpr * ARMElfTargetObjectFile :: getDebugThreadLocalSymbol ( const MCSymbol * Sym ) const { return MCSymbolRefExpr :: create ( Sym , MCSymbolRefExpr :: VK_ARM_TLSLDO , getContext ( ) ) ; } </s>

Describe a TLS variable address within debug info .


<s> int getSize ( ) { return size ; } </s>

Return the number of bytes in the encoding of this instruction , or zero if the encoding size can not be known from the opcode .


<s> static unsigned estimateStackSize ( MachineFunction & MF ) { const MachineFrameInfo * FFI = MF . getFrameInfo ( ) ; int Offset = 0 ; for ( int i = FFI -> getObjectIndexBegin ( ) ; i != 0 ; ++ i ) { int FixedOff = - FFI -> getObjectOffset ( i ) ; if ( FixedOff > Offset ) Offset = FixedOff ; } for ( unsigned i = 0 , e = FFI -> getObjectIndexEnd ( ) ; i != e ; ++ i ) { if ( FFI -> isDeadObjectIndex ( i ) ) continue ; Offset += FFI -> getObjectSize ( i ) ; unsigned Align = FFI -> getObjectAlignment ( i ) ; Offset = ( Offset + Align - 1 ) / Align * Align ; } return ( unsigned ) Offset ; } </s>

Estimate and return the size of the stack frame .


<s>
bool
HexagonFrameLowering
::
spillCalleeSavedRegisters
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
std
::
vector
<
CalleeSavedInfo
>
&
CSI
,
const
TargetRegisterInfo
*
TRI
)
const
{
MachineFunction
*
MF
=
MBB
.
getParent
(
)
;
const
TargetInstrInfo
&
TII
=
*
MF
->
getTarget
(
)
.
getInstrInfo
(
)
;
if
(
CSI
.
empty
(
)
)
{
return
false
;
}
bool
ContiguousRegs
=
true
;
for
(
unsigned
i
=
0
;
i
<
CSI
.
size
(
)
;
++
i
)
{
unsigned
Reg
=
CSI
[
i
]
.
getReg
(
)
;
const
unsigned
*
SuperReg
=
TRI
->
getSuperRegisters
(
Reg
)
;
assert
(
SuperReg
[
0
]
&&
!
SuperReg
[
1
]
&&
"Expected exactly one superreg"
)
;
bool
CanUseDblStore
=
false
;
const
TargetRegisterClass
*
SuperRegClass
=
0
;
if
(
ContiguousRegs
&&
(
i
<
CSI
.
size
(
)
1
)
)
{
const
unsigned
*
SuperRegNext
=
TRI
->
getSuperRegisters
(
CSI
[
i
+
1
]
.
getReg
(
)
)
;
assert
(
SuperRegNext
[
0
]
&&
!
SuperRegNext
[
1
]
&&
"Expected exactly one superreg"
)
;
SuperRegClass
=
TRI
->
getMinimalPhysRegClass
(
SuperReg
[
0
]
)
;
CanUseDblStore
=
(
SuperRegNext
[
0
]
==
SuperReg
[
0
]
)
;
}
if
(
CanUseDblStore
)
{
TII
.
storeRegToStackSlot
(
MBB
,
MI
,
SuperReg
[
0
]
,
true
,
CSI
[
i
+
1
]
.
getFrameIdx
(
)
,
SuperRegClass
,
TRI
)
;
MBB
.
addLiveIn
(
SuperReg
[
0
]
)
;
++
i
;
}
else
{
ContiguousRegs
=
false
;
const
TargetRegisterClass
*
RC
=
TRI
->
getMinimalPhysRegClass
(
Reg
)
;
TII
.
storeRegToStackSlot
(
MBB
,
MI
,
Reg
,
true
,
CSI
[
i
]
.
getFrameIdx
(
)
,
RC
,
TRI
)
;
MBB
.
addLiveIn
(
Reg
)
;
}
}
return
true
;
}
</s>

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


<s>
bool
AArch64PostSelectOptimize
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
if
(
MF
.
getProperties
(
)
.
hasProperty
(
MachineFunctionProperties
::
Property
::
FailedISel
)
)
return
false
;
assert
(
MF
.
getProperties
(
)
.
hasProperty
(
MachineFunctionProperties
::
Property
::
Selected
)
&&
"Expected a selected MF"
)
;
bool
Changed
=
false
;
for
(
auto
&
BB
:
MF
)
Changed
|=
optimizeNZCVDefs
(
BB
)
;
return
Changed
;
}
</s>

runOnMachineFunction - Emit the function body .


<s> FunctionCallee AMDGPULibFunc :: getOrInsertFunction ( Module * M , const AMDGPULibFunc & fInfo ) { std :: string const FuncName = fInfo . mangle ( ) ; Function * F = dyn_cast_or_null < Function > ( M -> getValueSymbolTable ( ) . lookup ( FuncName ) ) ; if ( F && ! F -> isDeclaration ( ) && ! F -> isVarArg ( ) && F -> arg_size ( ) == fInfo . getNumArgs ( ) ) { return F ; } FunctionType * FuncTy = fInfo . getFunctionType ( * M ) ; bool hasPtr = false ; for ( FunctionType :: param_iterator PI = FuncTy -> param_begin ( ) , PE = FuncTy -> param_end ( ) ; PI != PE ; ++ PI ) { const Type * argTy = static_cast < const Type * > ( * PI ) ; if ( argTy -> isPointerTy ( ) ) { hasPtr = true ; break ; } } FunctionCallee C ; if ( hasPtr ) { C = M -> getOrInsertFunction ( FuncName , FuncTy ) ; } else { AttributeList Attr ; LLVMContext & Ctx = M -> getContext ( ) ; Attr = Attr . addFnAttribute ( Ctx , Attribute :: ReadOnly ) ; Attr = Attr . addFnAttribute ( Ctx , Attribute :: NoUnwind ) ; C = M -> getOrInsertFunction ( FuncName , FuncTy , Attr ) ; } return C ; } </s>

Look up the specified function in the module symbol table .


<s>
TargetTransformInfo
::
PopcntSupportKind
RISCVTTIImpl
::
getPopcntSupport
(
unsigned
TyWidth
)
{
assert
(
isPowerOf2_32
(
TyWidth
)
&&
"Ty width must be power of 2"
)
;
return
ST
->
hasStdExtZbb
(
)
TTI
::
PSK_FastHardware
:
TTI
::
PSK_Software
;
}
</s>

Return hardware support for population count .

RISCV
RISCV
"Ty width must be power of 2"


<s> static sbitmap rs6000_get_separate_components ( void ) { rs6000_stack_t * info = rs6000_stack_info ( ) ; if ( WORLD_SAVE_P ( info ) ) return NULL ; if ( TARGET_SPE_ABI ) return NULL ; gcc_assert ( ! ( info -> savres_strategy & SAVE_MULTIPLE ) && ! ( info -> savres_strategy & REST_MULTIPLE ) ) ; cfun -> machine -> n_components = 64 ; sbitmap components = sbitmap_alloc ( cfun -> machine -> n_components ) ; bitmap_clear ( components ) ; int reg_size = TARGET_32BIT ? 4 : 8 ; int fp_reg_size = 8 ; if ( ( info -> savres_strategy & SAVE_INLINE_GPRS ) && ( info -> savres_strategy & REST_INLINE_GPRS ) ) { int offset = info -> gp_save_offset ; if ( info -> push_p ) offset += info -> total_size ; for ( unsigned regno = info -> first_gp_reg_save ; regno < 32 ; regno ++ ) { if ( IN_RANGE ( offset , - 0x8000 , 0x7fff ) && rs6000_reg_live_or_pic_offset_p ( regno ) ) bitmap_set_bit ( components , regno ) ; offset += reg_size ; } } if ( frame_pointer_needed ) bitmap_clear_bit ( components , HARD_FRAME_POINTER_REGNUM ) ; if ( ( TARGET_TOC && TARGET_MINIMAL_TOC ) || ( flag_pic == 1 && DEFAULT_ABI == ABI_V4 ) || ( flag_pic && DEFAULT_ABI == ABI_DARWIN ) ) bitmap_clear_bit ( components , RS6000_PIC_OFFSET_TABLE_REGNUM ) ; if ( ( info -> savres_strategy & SAVE_INLINE_FPRS ) && ( info -> savres_strategy & REST_INLINE_FPRS ) ) { int offset = info -> fp_save_offset ; if ( info -> push_p ) offset += info -> total_size ; for ( unsigned regno = info -> first_fp_reg_save ; regno < 64 ; regno ++ ) { if ( IN_RANGE ( offset , - 0x8000 , 0x7fff ) && save_reg_p ( regno ) ) bitmap_set_bit ( components , regno ) ; offset += fp_reg_size ; } } if ( info -> lr_save_p && ! ( flag_pic && ( DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_DARWIN ) ) && ( info -> savres_strategy & SAVE_INLINE_GPRS ) && ( info -> savres_strategy & REST_INLINE_GPRS ) && ( info -> savres_strategy & SAVE_INLINE_FPRS ) && ( info -> savres_strategy & REST_INLINE_FPRS ) && ( info -> savres_strategy & SAVE_INLINE_VRS ) && ( info -> savres_strategy & REST_INLINE_VRS ) ) { int offset = info -> lr_save_offset ; if ( info -> push_p ) offset += info -> total_size ; if ( IN_RANGE ( offset , - 0x8000 , 0x7fff ) ) bitmap_set_bit ( components , 0 ) ; } return components ; } </s>


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

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


<s> static bool rs6000_parm_needs_stack ( cumulative_args_t args_so_far , tree type ) { machine_mode mode ; int unsignedp ; rtx entry_parm ; if ( type == NULL || type == error_mark_node ) return true ; if ( TYPE_MODE ( type ) == VOIDmode ) return false ; if ( TREE_CODE ( type ) == COMPLEX_TYPE ) return ( rs6000_parm_needs_stack ( args_so_far , TREE_TYPE ( type ) ) || rs6000_parm_needs_stack ( args_so_far , TREE_TYPE ( type ) ) ) ; if ( ( TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == RECORD_TYPE ) && TYPE_TRANSPARENT_AGGR ( type ) ) type = TREE_TYPE ( first_field ( type ) ) ; if ( pass_by_reference ( get_cumulative_args ( args_so_far ) , TYPE_MODE ( type ) , type , true ) ) type = build_pointer_type ( type ) ; unsignedp = TYPE_UNSIGNED ( type ) ; mode = promote_mode ( type , TYPE_MODE ( type ) , & unsignedp ) ; if ( rs6000_must_pass_in_stack ( mode , type ) ) return true ; entry_parm = rs6000_function_arg ( args_so_far , mode , type , true ) ; if ( entry_parm == NULL ) return true ; if ( GET_CODE ( entry_parm ) == PARALLEL && XEXP ( XVECEXP ( entry_parm , 0 , 0 ) , 0 ) == NULL_RTX ) return true ; if ( rs6000_arg_partial_bytes ( args_so_far , mode , type , true ) != 0 ) return true ; rs6000_function_arg_advance ( args_so_far , mode , type , true ) ; return false ; } </s>

Process parameter of type TYPE after ARGS_SO_FAR parameters were already processes . Return true if the parameter must be passed ( fully or partially ) on the stack .


<s> static void emit_unlikely_jump ( rtx insn ) { int very_unlikely = REG_BR_PROB_BASE / 100 - 1 ; insn = emit_jump_insn ( insn ) ; add_int_reg_note ( insn , REG_BR_PROB , very_unlikely ) ; } </s>

Mark the previous jump instruction as unlikely .


<s>
SUnit
*
SystemZPostRASchedStrategy
::
pickNode
(
bool
&
IsTopNode
)
{
IsTopNode
=
true
;
if
(
Available
.
empty
(
)
)
return
nullptr
;
if
(
Available
.
size
(
)
==
1
)
{
DEBUG
(
dbgs
(
)
<<
"+++ Only one: "
;
HazardRec
->
dumpSU
(
*
Available
.
begin
(
)
,
dbgs
(
)
)
;
dbgs
(
)
<<
"\n"
;
)
;
return
*
Available
.
begin
(
)
;
}
DEBUG
(
dbgs
(
)
<<
"+++ Available: "
;
Available
.
dump
(
*
HazardRec
)
;
)
;
Candidate
Best
;
for
(
auto
*
SU
:
Available
)
{
Candidate
c
(
SU
,
*
HazardRec
)
;
if
(
Best
.
SU
==
nullptr
||
c
<
Best
)
{
Best
=
c
;
DEBUG
(
dbgs
(
)
<<
"+++ Best sofar: "
;
HazardRec
->
dumpSU
(
Best
.
SU
,
dbgs
(
)
)
;
if
(
Best
.
GroupingCost
!=
0
)
dbgs
(
)
<<
"\tGrouping cost:"
<<
Best
.
GroupingCost
;
if
(
Best
.
ResourcesCost
!=
0
)
dbgs
(
)
<<
" Resource cost:"
<<
Best
.
ResourcesCost
;
dbgs
(
)
<<
" Height:"
<<
Best
.
SU
->
getHeight
(
)
;
dbgs
(
)
<<
"\n"
;
)
;
}
if
(
!
SU
->
isScheduleHigh
&&
Best
.
noCost
(
)
)
break
;
}
assert
(
Best
.
SU
!=
nullptr
)
;
return
Best
.
SU
;
}
</s>

Pick the next node to schedule , or return NULL .

SystemZ
SystemZ
1
"+++ Only one: "
"\n"
"+++ Available: "
"+++ Best sofar: "
0
"\tGrouping cost:"
0
" Resource cost:"
" Height:"
"\n"


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

Get a TargetTransformInfo implementation for the target .


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

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


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


<s> static int thumb2_legitimate_address_p ( machine_mode mode , rtx x , int strict_p ) { bool use_ldrd ; enum rtx_code code = GET_CODE ( x ) ; if ( TARGET_HAVE_MVE && VALID_MVE_PRED_MODE ( mode ) ) mode = HImode ; if ( TARGET_HAVE_MVE && VALID_MVE_MODE ( mode ) ) return mve_vector_mem_operand ( mode , x , strict_p ) ; if ( arm_address_register_rtx_p ( x , strict_p ) ) return 1 ; use_ldrd = ( TARGET_LDRD && ( mode == DImode || mode == DFmode ) ) ; if ( code == POST_INC || code == PRE_DEC || ( ( code == PRE_INC || code == POST_DEC ) && ( use_ldrd || GET_MODE_SIZE ( mode ) <= 4 ) ) ) return arm_address_register_rtx_p ( XEXP ( x , 0 ) , strict_p ) ; else if ( ( code == POST_MODIFY || code == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( x , 0 ) , strict_p ) && GET_CODE ( XEXP ( x , 1 ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( x , 1 ) , 0 ) , XEXP ( x , 0 ) ) ) { rtx addend = XEXP ( XEXP ( x , 1 ) , 1 ) ; HOST_WIDE_INT offset ; if ( ! CONST_INT_P ( addend ) ) return 0 ; offset = INTVAL ( addend ) ; if ( GET_MODE_SIZE ( mode ) <= 4 ) return ( offset > - 256 && offset < 256 ) ; return ( use_ldrd && offset > - 1024 && offset < 1024 && ( offset & 3 ) == 0 ) ; } else if ( reload_completed && ( code == LABEL_REF || ( code == CONST && GET_CODE ( XEXP ( x , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , 0 ) , 0 ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( x , 0 ) , 1 ) ) ) ) ) return 1 ; else if ( mode == TImode || ( TARGET_NEON && VALID_NEON_STRUCT_MODE ( mode ) ) || ( TARGET_HAVE_MVE && VALID_MVE_STRUCT_MODE ( mode ) ) ) return 0 ; else if ( code == PLUS ) { rtx xop0 = XEXP ( x , 0 ) ; rtx xop1 = XEXP ( x , 1 ) ; return ( ( arm_address_register_rtx_p ( xop0 , strict_p ) && ( thumb2_legitimate_index_p ( mode , xop1 , strict_p ) || ( ! strict_p && will_be_in_index_register ( xop1 ) ) ) ) || ( arm_address_register_rtx_p ( xop1 , strict_p ) && thumb2_legitimate_index_p ( mode , xop0 , strict_p ) ) ) ; } else if ( can_avoid_literal_pool_for_label_p ( x ) ) return 0 ; else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && code == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) && ! ( flag_pic && symbol_mentioned_p ( get_pool_constant ( x ) ) && ! pcrel_constant_p ( get_pool_constant ( x ) ) ) ) return 1 ; return 0 ; } </s>

Return nonzero if X is a valid Thumb-2 address operand .


<s> bool SIInstrInfo :: findCommutedOpIndices ( MachineInstr & MI , unsigned & SrcOpIdx0 , unsigned & SrcOpIdx1 ) const { const MCInstrDesc & MCID = MI . getDesc ( ) ; if ( ! MCID . isCommutable ( ) ) return false ; unsigned Opc = MI . getOpcode ( ) ; int Src0Idx = AMDGPU :: getNamedOperandIdx ( Opc , AMDGPU :: OpName :: src0 ) ; if ( Src0Idx == - 1 ) return false ; if ( ! MI . getOperand ( Src0Idx ) . isReg ( ) ) return false ; int Src1Idx = AMDGPU :: getNamedOperandIdx ( Opc , AMDGPU :: OpName :: src1 ) ; if ( Src1Idx == - 1 ) return false ; MachineOperand & Src1 = MI . getOperand ( Src1Idx ) ; if ( Src1 . isImm ( ) ) { if ( ! isVOP2 ( MI . getOpcode ( ) ) && ! isVOP3 ( MI . getOpcode ( ) ) ) return false ; } else if ( Src1 . isReg ( ) ) { if ( hasModifiersSet ( MI , AMDGPU :: OpName :: src0_modifiers ) || hasModifiersSet ( MI , AMDGPU :: OpName :: src1_modifiers ) ) return false ; } else return false ; return fixCommutedOpIndices ( SrcOpIdx0 , SrcOpIdx1 , Src0Idx , Src1Idx ) ; } </s>

Returns true iff the routine could find two commutable operands in the given machine instruction .

AMDGPU SI AMDGPU::getNamedOperandIdx AMDGPU::OpName 1 AMDGPU::getNamedOperandIdx AMDGPU::OpName 1 AMDGPU::OpName AMDGPU::OpName


<s> bool RISCVTargetLowering :: isFMAFasterThanFMulAndFAdd ( const MachineFunction & MF , EVT VT ) const { VT = VT . getScalarType ( ) ; if ( ! VT . isSimple ( ) ) return false ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { case MVT :: f16 : return Subtarget . hasStdExtZfh ( ) ; case MVT :: f32 : return Subtarget . hasStdExtF ( ) ; case MVT :: f64 : return Subtarget . hasStdExtD ( ) ; default : break ; } return false ; } </s>

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


<s> bool exp2_immediate_p ( rtx op , machine_mode mode , int low , int high ) { machine_mode int_mode ; HOST_WIDE_INT val ; unsigned char arr [ 16 ] ; int bytes , i , j ; gcc_assert ( GET_CODE ( op ) == CONST_INT || GET_CODE ( op ) == CONST_DOUBLE || GET_CODE ( op ) == CONST_VECTOR ) ; if ( GET_CODE ( op ) == CONST_VECTOR && ! const_vector_immediate_p ( op ) ) return 0 ; if ( GET_MODE ( op ) != VOIDmode ) mode = GET_MODE ( op ) ; constant_to_array ( mode , op , arr ) ; if ( VECTOR_MODE_P ( mode ) ) mode = GET_MODE_INNER ( mode ) ; bytes = GET_MODE_SIZE ( mode ) ; int_mode = mode_for_size ( GET_MODE_BITSIZE ( mode ) , MODE_INT , 0 ) ; for ( i = bytes ; i < 16 ; i += bytes ) for ( j = 0 ; j < bytes ; j ++ ) if ( arr [ j ] != arr [ i + j ] ) return 0 ; val = arr [ 0 ] ; for ( j = 1 ; j < bytes ; j ++ ) val = ( val << 8 ) | arr [ j ] ; val = trunc_int_for_mode ( val , int_mode ) ; gcc_assert ( mode == SFmode ) ; if ( mode == SFmode ) { int exp = ( val >> 23 ) - 127 ; return val > 0 && ( val & 0x007fffff ) == 0 && exp >= low && exp <= high ; } return FALSE ; } </s>

TRUE when op is an immediate and an exact power of 2 , and given that OP is 2^scale , scale > = LOW & & scale < = HIGH . When OP is a vector , all entries must be the same .


<s> int 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 ) ; int 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 ( 1 , Cost ) ; } </s>

Calculate the cost of materializing a 64-bit value .


<s> rtx h8300_return_addr_rtx ( int count , rtx frame ) { rtx ret ; if ( count == 0 ) ret = gen_rtx_MEM ( Pmode , gen_rtx_REG ( Pmode , RETURN_ADDRESS_POINTER_REGNUM ) ) ; else if ( flag_omit_frame_pointer ) return ( rtx ) 0 ; else ret = gen_rtx_MEM ( Pmode , memory_address ( Pmode , plus_constant ( Pmode , frame , UNITS_PER_WORD ) ) ) ; set_mem_alias_set ( ret , get_frame_alias_set ( ) ) ; return ret ; } </s>


<s> X86TargetMachine :: X86TargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , Optional < CodeModel :: Model > CM , CodeGenOpt :: Level OL , bool JIT ) : LLVMTargetMachine ( T , computeDataLayout ( TT ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , JIT , RM ) , getEffectiveX86CodeModel ( CM , JIT , TT . getArch ( ) == Triple :: x86_64 ) , OL ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) { if ( TT . isPS4 ( ) || TT . isOSBinFormatMachO ( ) ) { this -> Options . TrapUnreachable = true ; this -> Options . NoTrapAfterNoreturn = TT . isOSBinFormatMachO ( ) ; } setMachineOutliner ( true ) ; initAsmInfo ( ) ; } </s>


<s> bool mips_legitimize_move ( machine_mode mode , rtx dest , rtx src ) { if ( ! register_operand ( dest , mode ) && ! reg_or_0_operand ( src , mode ) ) { mips_emit_move ( dest , force_reg ( mode , src ) ) ; return true ; } if ( CONSTANT_P ( src ) && ! move_operand ( src , mode ) ) { mips_legitimize_const_move ( mode , dest , src ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , copy_rtx ( src ) ) ; return true ; } return false ; } </s>

If ( set DEST SRC ) is not a valid instruction , emit an equivalent sequence that is valid .


<s> void ARMBaseRegisterInfo :: emitLoadConstPool ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , const DebugLoc & dl , unsigned DestReg , unsigned SubIdx , int Val , ARMCC :: CondCodes Pred , unsigned PredReg , unsigned MIFlags ) const { MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MachineConstantPool * ConstantPool = MF . getConstantPool ( ) ; const Constant * C = ConstantInt :: get ( Type :: getInt32Ty ( MF . getFunction ( ) . getContext ( ) ) , Val ) ; unsigned Idx = ConstantPool -> getConstantPoolIndex ( C , 4 ) ; BuildMI ( MBB , MBBI , dl , TII . get ( ARM :: LDRcp ) ) . addReg ( DestReg , getDefRegState ( true ) , SubIdx ) . addConstantPoolIndex ( Idx ) . addImm ( 0 ) . add ( predOps ( Pred , PredReg ) ) . setMIFlags ( MIFlags ) ; } </s>

emitLoadConstPool - Emits a load from constpool to materialize the specified immediate .


"parameter passing for argument of type "

Implement FUNCTION_ARG_BOUNDARY . Every parameter gets at least PARM_BOUNDARY bits of alignment , but will be given anything up to STACK_BOUNDARY bits if the type requires it . This makes sure that both before and after the layout of each argument , the Next Stacked Argument Address ( NSAA ) will have a minimum alignment of 8 bytes .


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


<s> SDValue WebAssemblyTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { default : return SDValue ( ) ; case ISD :: VECTOR_SHUFFLE : return performVECTOR_SHUFFLECombine ( N , DCI ) ; case ISD :: SIGN_EXTEND : case ISD :: ZERO_EXTEND : return performVectorExtendCombine ( N , DCI ) ; case ISD :: FP_TO_SINT_SAT : case ISD :: FP_TO_UINT_SAT : case ISD :: FP_ROUND : case ISD :: CONCAT_VECTORS : return performVectorTruncZeroCombine ( N , DCI ) ; } } </s>

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


<s> bool s390_extzv_shift_ok ( int bitsize , int rotl , unsigned HOST_WIDE_INT contig ) { int start , end ; bool ok ; ok = s390_contiguous_bitmask_nowrap_p ( contig , bitsize , & start , & end ) ; gcc_assert ( ok ) ; if ( rotl >= 0 ) return ( 64 - end >= rotl ) ; else { rotl = - rotl + ( 64 - bitsize ) ; return ( start >= rotl ) ; } } </s>

Check whether a rotate of ROTL followed by an AND of CONTIG is equivalent to a shift followed by the AND . In particular , CONTIG should not overlap the ( rotated ) bit 0/bit 63 gap . Negative values for ROTL indicate a rotate to the right .


<s> X86TargetMachine :: X86TargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) : LLVMTargetMachine ( T , computeDataLayout ( Triple ( TT ) ) , TT , CPU , FS , Options , RM , CM , OL ) , TLOF ( createTLOF ( Triple ( getTargetTriple ( ) ) ) ) , Subtarget ( TT , CPU , FS , * this , Options . StackAlignmentOverride ) { if ( Options . FloatABIType == FloatABI :: Default ) this -> Options . FloatABIType = FloatABI :: Hard ; if ( Subtarget . isTargetWin64 ( ) ) this -> Options . TrapUnreachable = true ; initAsmInfo ( ) ; } </s>


<s> bool isImm ( ) const override { return Kind == Integer || Kind == Float || Kind == Symbol ; } </s>


<s> bool Cpu0TargetObjectFile :: IsGlobalInSmallSection ( const GlobalValue * GV , const TargetMachine & TM , SectionKind Kind ) const { const Cpu0Subtarget & Subtarget = TM . getSubtarget < Cpu0Subtarget > ( ) ; if ( ! Subtarget . useSmallSection ( ) ) return false ; const GlobalVariable * GVA = dyn_cast < GlobalVariable > ( GV ) ; if ( ! GVA ) return false ; if ( ! Kind . isBSS ( ) && ! Kind . isDataRel ( ) ) return false ; if ( Kind . isMergeable1ByteCString ( ) ) return false ; Type * Ty = GV -> getType ( ) -> getElementType ( ) ; return IsInSmallSection ( TM . getDataLayout ( ) -> getTypeAllocSize ( Ty ) ) ; } </s>

Return true if this global address should be placed into small data/bss section .


<s>
void
scalar_chain
::
build
(
bitmap
candidates
,
unsigned
insn_uid
)
{
queue
=
BITMAP_ALLOC
(
)
;
bitmap_set_bit
(
queue
,
insn_uid
)
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Building chain #%d...\n"
,
chain_id
)
;
while
(
!
bitmap_empty_p
(
queue
)
)
{
insn_uid
=
bitmap_first_set_bit
(
queue
)
;
bitmap_clear_bit
(
queue
,
insn_uid
)
;
bitmap_clear_bit
(
candidates
,
insn_uid
)
;
add_insn
(
candidates
,
insn_uid
)
;
}
if
(
dump_file
)
{
fprintf
(
dump_file
,
"Collected chain #%d...\n"
,
chain_id
)
;
fprintf
(
dump_file
,
"  insns: "
)
;
dump_bitmap
(
dump_file
,
insns
)
;
if
(
!
bitmap_empty_p
(
defs_conv
)
)
{
bitmap_iterator
bi
;
unsigned
id
;
const
char
*
comma
=
""
;
fprintf
(
dump_file
,
"  defs to convert: "
)
;
EXECUTE_IF_SET_IN_BITMAP
(
defs_conv
,
0
,
id
,
bi
)
{
fprintf
(
dump_file
,
"%sr%d"
,
comma
,
id
)
;
comma
=
", "
;
}
fprintf
(
dump_file
,
"\n"
)
;
}
}
BITMAP_FREE
(
queue
)
;
}
</s>

Build new chain starting from insn INSN_UID recursively adding all dependent uses and definitions . Return true if OK , false if the chain discovery was aborted .

i386
"Building chain #%d...\n"
"Collected chain #%d...\n"
"  insns: "
""
"  defs to convert: "
0
"%sr%d"
", "
"\n"


"\nrs6000_adjust_cost, final cost = %d, orig cost = %d, "


<s>
const
char
*
getPassName
(
)
const
override
{
return
"SI Lower control flow instructions"
;
}
</s>

getPassName - Return a nice clean name for a pass .

AMDGPU
"SI Lower control flow instructions"


<s>
StringRef
getPassName
(
)
const
override
{
return
"MSP430 Assembly Printer"
;
}
</s>


<s> StringRef getPassName ( ) const override { return RISCV_EXPAND_ATOMIC_PSEUDO_NAME ; } </s>


<s> static bool has_part_mult ( rtx_insn * insn ) { rtx body = PATTERN ( insn ) ; if ( GET_CODE ( body ) != SET ) return false ; rtx src = SET_SRC ( body ) ; if ( GET_CODE ( src ) != SUBREG ) return false ; rtx inner = XEXP ( src , 0 ) ; return ( GET_CODE ( inner ) == MULT ) ; } </s>

INSN is known to contain a SUBREG , which we can normally handle , but if the SUBREG itself contains a MULT then we need to leave it alone to avoid turning a mult_hipart into a mult_lopart , for example .


<s> void rs6000_emit_cbranch ( enum rtx_code code , rtx loc ) { rtx condition_rtx , loc_ref ; condition_rtx = rs6000_generate_compare ( code ) ; loc_ref = gen_rtx_LABEL_REF ( VOIDmode , loc ) ; emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , condition_rtx , loc_ref , pc_rtx ) ) ) ; } </s>

Emit a branch of kind CODE to location LOC .


"Instr doesn't have FrameIndex operand!"

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


<s> BitVector MBlazeRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( MBlaze :: R0 ) ; Reserved . set ( MBlaze :: R1 ) ; Reserved . set ( MBlaze :: R2 ) ; Reserved . set ( MBlaze :: R13 ) ; Reserved . set ( MBlaze :: R14 ) ; Reserved . set ( MBlaze :: R15 ) ; Reserved . set ( MBlaze :: R16 ) ; Reserved . set ( MBlaze :: R17 ) ; Reserved . set ( MBlaze :: R18 ) ; Reserved . set ( MBlaze :: R19 ) ; return Reserved ; } </s>

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


<s> static bool hasDependence ( const SUnit * SUd , const SUnit * SUu , const HexagonInstrInfo & QII ) { if ( SUd -> Succs . size ( ) == 0 ) return false ; if ( QII . mayBeCurLoad ( * SUd -> getInstr ( ) ) ) return false ; if ( QII . canExecuteInBundle ( * SUd -> getInstr ( ) , * SUu -> getInstr ( ) ) ) return false ; for ( const auto & S : SUd -> Succs ) { if ( S . isCtrl ( ) ) continue ; if ( S . getSUnit ( ) == SUu && S . getLatency ( ) > 0 ) return true ; } return false ; } </s>

Return true if there is a dependence between SUd and SUu .


<s> static std :: string getGraphName ( const agraph & G ) { return G . MF -> getFunction ( ) -> getName ( ) ; } </s>

Generate a title for the graph in DOT format .


<s>
bool
ARMPassConfig
::
addPreSched2
(
)
{
if
(
getOptLevel
(
)
!=
CodeGenOpt
::
)
{
if
(
!
getARMSubtarget
(
)
.
isThumb1Only
(
)
)
{
PM
.
add
(
createARMLoadStoreOptimizationPass
(
)
)
;
printAndVerify
(
"After ARM load / store optimizer"
)
;
}
if
(
getARMSubtarget
(
)
.
hasNEON
(
)
)
PM
.
add
(
createExecutionDependencyFixPass
(
&
ARM
::
DPRRegClass
)
)
;
}
PM
.
add
(
createARMExpandPseudoPass
(
)
)
;
if
(
getOptLevel
(
)
!=
CodeGenOpt
::
)
{
if
(
!
getARMSubtarget
(
)
.
isThumb1Only
(
)
)
addPass
(
IfConverterID
)
;
}
if
(
getARMSubtarget
(
)
.
isThumb2
(
)
)
PM
.
add
(
createThumb2ITBlockPass
(
)
)
;
return
true
;
}
</s>

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

ARM
ARM
ARM
ARM
"After ARM load / store optimizer"
ARM
ARM::DPRRegClass
ARM
ARM
ARM


<s> static int alpha_adjust_cost ( rtx insn , rtx link , rtx dep_insn , int cost ) { enum attr_type insn_type , dep_insn_type ; if ( REG_NOTE_KIND ( link ) != 0 ) return cost ; if ( recog_memoized ( insn ) < 0 || recog_memoized ( dep_insn ) < 0 ) return cost ; insn_type = get_attr_type ( insn ) ; dep_insn_type = get_attr_type ( dep_insn ) ; if ( dep_insn_type == TYPE_ILD || dep_insn_type == TYPE_FLD || dep_insn_type == TYPE_LDSYM ) cost += alpha_memory_latency - 1 ; return cost ; } </s>

Adjust the cost of a scheduling dependency . Return the new cost of a dependency LINK or INSN on DEP_INSN . COST is the current cost .


"Callee should be an llvm::Function object."

"failed to perform tail call elimination on a call "

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


<s>
SDValue
AVRTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Don't know how to custom lower this!"
)
;
case
ISD
::
SHL
:
case
ISD
::
SRA
:
case
ISD
::
SRL
:
case
ISD
::
ROTL
:
case
ISD
::
ROTR
:
return
LowerShifts
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
LowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
BR_CC
:
return
LowerBR_CC
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
)
;
case
ISD
::
SETCC
:
return
LowerSETCC
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
)
;
case
ISD
::
SDIVREM
:
case
ISD
::
UDIVREM
:
return
LowerDivRem
(
Op
,
DAG
)
;
}
return
SDValue
(
)
;
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .

AVR
AVR
"Don't know how to custom lower this!"
ISD::SHL
ISD::SRA
ISD::SRL
ISD::ROTL
ISD::ROTR
ISD::GlobalAddress
ISD::BlockAddress
ISD::BR_CC
ISD::SELECT_CC
ISD::SETCC
ISD::VASTART
ISD::SDIVREM
ISD::UDIVREM


<s> void PPCTTIImpl :: getUnrollingPreferences ( Loop * L , ScalarEvolution & SE , TTI :: UnrollingPreferences & UP ) { if ( ST -> getDarwinDirective ( ) == PPC :: DIR_A2 ) { UP . Partial = UP . Runtime = true ; UP . AllowExpensiveTripCount = true ; } BaseT :: getUnrollingPreferences ( L , SE , UP ) ; } </s>

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


<s> static rtx mips_find_pic_call_symbol ( rtx_insn * insn , rtx reg , bool recurse_p ) { df_ref use ; struct df_link * defs ; rtx symbol ; use = df_find_use ( insn , regno_reg_rtx [ REGNO ( reg ) ] ) ; if ( ! use ) return NULL_RTX ; defs = DF_REF_CHAIN ( use ) ; if ( ! defs ) return NULL_RTX ; symbol = mips_pic_call_symbol_from_set ( defs -> ref , reg , recurse_p ) ; if ( ! symbol ) return NULL_RTX ; for ( defs = defs -> next ; defs ; defs = defs -> next ) { rtx other ; other = mips_pic_call_symbol_from_set ( defs -> ref , reg , recurse_p ) ; if ( ! rtx_equal_p ( symbol , other ) ) return NULL_RTX ; } return symbol ; } </s>

Find the definition of the use of REG in INSN . See if the definition is one of the ways we load a register with a symbol address for a mips_use_pic_fn_addr_reg_p call . If it is return the symbol reference of the function , otherwise return NULL_RTX . RECURSE_P is as for mips_pic_call_symbol_from_set .


<s> bool SIInstrInfo :: isInlineConstant ( const MachineOperand & MO ) const { if ( MO . isImm ( ) ) { return MO . getImm ( ) >= - 16 && MO . getImm ( ) <= 64 ; } if ( MO . isFPImm ( ) ) { return MO . getFPImm ( ) -> isExactlyValue ( 0.0 ) || MO . getFPImm ( ) -> isExactlyValue ( 0.5 ) || MO . getFPImm ( ) -> isExactlyValue ( - 0.5 ) || MO . getFPImm ( ) -> isExactlyValue ( 1.0 ) || MO . getFPImm ( ) -> isExactlyValue ( - 1.0 ) || MO . getFPImm ( ) -> isExactlyValue ( 2.0 ) || MO . getFPImm ( ) -> isExactlyValue ( - 2.0 ) || MO . getFPImm ( ) -> isExactlyValue ( 4.0 ) || MO . getFPImm ( ) -> isExactlyValue ( - 4.0 ) ; } return false ; } </s>

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


<s> static void ia64_setup_incoming_varargs ( cumulative_args_t cum , machine_mode mode , tree type , int * pretend_size , int second_time ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS next_cum = * get_cumulative_args ( cum ) ; ia64_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , 1 ) ; if ( next_cum . words < MAX_ARGUMENT_SLOTS ) { int n = MAX_ARGUMENT_SLOTS - next_cum . words ; * pretend_size = n * UNITS_PER_WORD ; cfun -> machine -> n_varargs = n ; } } </s>

Do any needed setup for a variadic function . CUM has not been updated for the last named argument which has type TYPE and mode MODE . We generate the actual spill instructions during prologue generation .


<s> static bool insn_true_dependent_p ( rtx x , rtx y ) { rtx tmp ; if ( ! INSN_P ( x ) || ! INSN_P ( y ) ) return 0 ; tmp = PATTERN ( y ) ; note_stores ( PATTERN ( x ) , insn_dependent_p_1 , & tmp ) ; return ( tmp == NULL_RTX ) ; } </s>

Return true if anything in insn X is true dependent on anything in insn Y .


<s>
bool
ARMCallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
ArrayRef
<
Register
>
VRegs
)
const
{
assert
(
!
Val
==
VRegs
.
empty
(
)
&&
"Return value without a vreg"
)
;
auto
const
&
ST
=
MIRBuilder
.
getMF
(
)
.
getSubtarget
<
ARMSubtarget
>
(
)
;
unsigned
Opcode
=
ST
.
getReturnOpcode
(
)
;
auto
Ret
=
MIRBuilder
.
buildInstrNoInsert
(
Opcode
)
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
if
(
!
lowerReturnVal
(
MIRBuilder
,
Val
,
VRegs
,
Ret
)
)
return
false
;
MIRBuilder
.
insertInstr
(
Ret
)
;
return
true
;
}
</s>

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

ARM
ARM
"Return value without a vreg"
ARM
ARMCC::AL


<s> static void ATTRIBUTE_UNUSED c6x_elf_unique_section ( tree decl , int reloc ) { const char * prefix = NULL ; bool one_only = DECL_COMDAT_GROUP ( decl ) && ! HAVE_COMDAT_GROUP ; if ( c6x_in_small_data_p ( decl ) ) { switch ( categorize_decl_for_section ( decl , reloc ) ) { case SECCAT_SDATA : prefix = one_only ? ".s" : ".neardata" ; break ; case SECCAT_SBSS : prefix = one_only ? ".sb" : ".bss" ; break ; case SECCAT_SRODATA : prefix = one_only ? ".s2" : ".rodata" ; break ; case SECCAT_RODATA_MERGE_STR : case SECCAT_RODATA_MERGE_STR_INIT : case SECCAT_RODATA_MERGE_CONST : case SECCAT_RODATA : case SECCAT_DATA : case SECCAT_DATA_REL : case SECCAT_DATA_REL_LOCAL : case SECCAT_DATA_REL_RO : case SECCAT_DATA_REL_RO_LOCAL : gcc_unreachable ( ) ; default : break ; } } else { switch ( categorize_decl_for_section ( decl , reloc ) ) { case SECCAT_DATA : case SECCAT_DATA_REL : case SECCAT_DATA_REL_LOCAL : case SECCAT_DATA_REL_RO : case SECCAT_DATA_REL_RO_LOCAL : prefix = one_only ? ".fd" : ".fardata" ; break ; case SECCAT_BSS : prefix = one_only ? ".fb" : ".far" ; break ; case SECCAT_RODATA : case SECCAT_RODATA_MERGE_STR : case SECCAT_RODATA_MERGE_STR_INIT : case SECCAT_RODATA_MERGE_CONST : prefix = one_only ? ".fr" : ".const" ; break ; case SECCAT_SRODATA : case SECCAT_SDATA : case SECCAT_SBSS : gcc_unreachable ( ) ; default : break ; } } if ( prefix ) { const char * name , * linkonce ; char * string ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = targetm . strip_name_encoding ( name ) ; linkonce = one_only ? ".gnu.linkonce" : "" ; string = ACONCAT ( ( linkonce , prefix , "." , name , NULL ) ) ; set_decl_section_name ( decl , string ) ; return ; } default_unique_section ( decl , reloc ) ; } </s>

Build up a unique section name , expressed as a STRING_CST node , and assign it to DECL_SECTION_NAME ( decl ) . RELOC indicates whether the initial value of EXP requires link-time relocations .


<s> int M680x0FrameLowering :: mergeSPUpdates ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , bool doMergeWithPrevious ) const { if ( ( doMergeWithPrevious && MBBI == MBB . begin ( ) ) || ( ! doMergeWithPrevious && MBBI == MBB . end ( ) ) ) return 0 ; MachineBasicBlock :: iterator PI = doMergeWithPrevious ? std :: prev ( MBBI ) : MBBI ; MachineBasicBlock :: iterator NI = doMergeWithPrevious ? nullptr : std :: next ( MBBI ) ; unsigned Opc = PI -> getOpcode ( ) ; int Offset = 0 ; if ( ! doMergeWithPrevious && NI != MBB . end ( ) && NI -> getOpcode ( ) == TargetOpcode :: CFI_INSTRUCTION ) { return Offset ; } if ( Opc == M680x0 :: ADD32ri && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { assert ( PI -> getOperand ( 1 ) . getReg ( ) == StackPtr ) ; Offset += PI -> getOperand ( 2 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } else if ( Opc == M680x0 :: SUB32ri && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { assert ( PI -> getOperand ( 1 ) . getReg ( ) == StackPtr ) ; Offset -= PI -> getOperand ( 2 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } return Offset ; } </s>

Check the instruction before/after the passed instruction .


<s>
bool
ARMCallLowering
::
lowerReturn
(
MachineIRBuilder
&
MIRBuilder
,
const
Value
*
Val
,
ArrayRef
<
Register
>
VRegs
,
FunctionLoweringInfo
&
FLI
)
const
{
assert
(
!
Val
==
VRegs
.
empty
(
)
&&
"Return value without a vreg"
)
;
auto
const
&
ST
=
MIRBuilder
.
getMF
(
)
.
getSubtarget
<
ARMSubtarget
>
(
)
;
unsigned
Opcode
=
ST
.
getReturnOpcode
(
)
;
auto
Ret
=
MIRBuilder
.
buildInstrNoInsert
(
Opcode
)
.
add
(
predOps
(
ARMCC
::
AL
)
)
;
if
(
!
lowerReturnVal
(
MIRBuilder
,
Val
,
VRegs
,
Ret
)
)
return
false
;
MIRBuilder
.
insertInstr
(
Ret
)
;
return
true
;
}
</s>


<s> bool PPCTargetLowering :: IsEligibleForTailCallOptimization ( CallSDNode * TheCall , SDValue Ret , SelectionDAG & DAG ) const { if ( ! PerformTailCallOpt || TheCall -> isVarArg ( ) ) return false ; if ( CheckTailCallReturnConstraints ( TheCall , Ret ) ) { MachineFunction & MF = DAG . getMachineFunction ( ) ; unsigned CallerCC = MF . getFunction ( ) -> getCallingConv ( ) ; unsigned CalleeCC = TheCall -> getCallingConv ( ) ; if ( CalleeCC == CallingConv :: Fast && CallerCC == CalleeCC ) { for ( unsigned i = 0 ; i != TheCall -> getNumArgs ( ) ; i ++ ) { ISD :: ArgFlagsTy Flags = TheCall -> getArgFlags ( i ) ; if ( Flags . isByVal ( ) ) return false ; } SDValue Callee = TheCall -> getCallee ( ) ; if ( getTargetMachine ( ) . getRelocationModel ( ) != Reloc :: PIC_ ) return true ; if ( GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( Callee ) ) return G -> getGlobal ( ) -> hasHiddenVisibility ( ) || G -> getGlobal ( ) -> hasProtectedVisibility ( ) ; } } return false ; } </s>

IsEligibleForTailCallOptimization - Check whether the call is eligible for tail call optimization .


<s> unsigned char AArch64Subtarget :: ClassifyGlobalReference ( const GlobalValue * GV , const TargetMachine & TM ) const { if ( TM . getCodeModel ( ) == CodeModel :: Large && isTargetMachO ( ) ) return AArch64II :: MO_GOT ; if ( ! TM . shouldAssumeDSOLocal ( * GV -> getParent ( ) , GV ) ) return AArch64II :: MO_GOT ; if ( TM . getCodeModel ( ) == CodeModel :: Small && GV -> hasExternalWeakLinkage ( ) ) return AArch64II :: MO_GOT ; return AArch64II :: MO_NO_FLAG ; } </s>

ClassifyGlobalReference - Find the target operand flags that describe how a global value should be referenced for the current subtarget .


<s>
static
void
record_loads
(
tag_map_t
&
tag_map
,
struct
loop
*
loop
)
{
rtx_insn
*
insn
;
basic_block
*
body
,
bb
;
body
=
get_loop_body
(
loop
)
;
for
(
unsigned
i
=
0
;
i
<
loop
->
num_nodes
;
i
++
)
{
bb
=
body
[
i
]
;
FOR_BB_INSNS
(
bb
,
insn
)
{
rtx
base
=
NULL_RTX
;
rtx
dest
=
NULL_RTX
;
rtx
offset
=
NULL_RTX
;
bool
writeback
=
false
;
bool
ldp
=
false
;
if
(
!
INSN_P
(
insn
)
||
DEBUG_INSN_P
(
insn
)
)
continue
;
if
(
get_load_info
(
insn
,
loop
,
&
dest
,
&
base
,
&
offset
,
&
writeback
,
&
ldp
)
)
{
tag_insn_info
*
i
=
new
tag_insn_info
(
insn
,
dest
,
base
,
offset
,
writeback
,
ldp
)
;
rtx
tag
=
GEN_INT
(
i
->
tag
(
)
)
;
tag_map
.
get_or_insert
(
tag
)
.
safe_push
(
i
)
;
}
}
}
if
(
dump_file
)
{
fprintf
(
dump_file
,
"Loop %d: Tag map generated.\n"
,
loop
->
num
)
;
tag_map
.
traverse
<
void
*
,
dump_insn_list
>
(
)
;
}
tag_map
.
traverse
<
void
*
,
single_dest_per_chain
>
(
)
;
}
</s>

Record all loads in LOOP into TAG_MAP indexed by the falkor hardware prefetcher memory tags .


<s> static enum reg_class init_unavailable ( tag_insn_info * insn_info , tag_map_t & tag_map , du_head_p head , HARD_REG_SET * unavailable ) { unsigned dest = head -> regno ; enum reg_class super_class = NO_REGS ; machine_mode mode = GET_MODE ( insn_info -> dest ) ; CLEAR_HARD_REG_SET ( * unavailable ) ; for ( struct du_chain * tmp = head -> first ; tmp ; tmp = tmp -> next_use ) { if ( DEBUG_INSN_P ( tmp -> insn ) ) continue ; * unavailable |= ~ reg_class_contents [ tmp -> cl ] ; super_class = reg_class_superunion [ ( int ) super_class ] [ ( int ) tmp -> cl ] ; } for ( unsigned i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( fixed_regs [ i ] || global_regs [ i ] ) add_to_hard_reg_set ( unavailable , mode , i ) ; arg_pair_t arg = arg_pair_t ( insn_info , unavailable ) ; tag_map . traverse < arg_pair_t * , check_colliding_tags > ( & arg ) ; ignore_all_aliases ( unavailable , mode , dest & 0xf ) ; return super_class ; } </s>

Initialize and build a set of hard register numbers UNAVAILABLE to avoid for renaming . INSN_INFO is the original insn , TAG_MAP is the map of the list of insns indexed by their tags , HEAD is the def/use chain head of the destination register of the original insn . The routine returns the super class of register classes that may be used during the renaming .


<s> static bool r10k_needs_protection_p ( rtx_insn * insn ) { if ( CALL_P ( insn ) ) return r10k_needs_protection_p_call ( PATTERN ( insn ) ) ; if ( mips_r10k_cache_barrier == R10K_CACHE_BARRIER_STORE ) { note_stores ( PATTERN ( insn ) , r10k_needs_protection_p_store , & insn ) ; return insn == NULL_RTX ; } return r10k_needs_protection_p_1 ( PATTERN ( insn ) , insn ) ; } </s>

Return true if instruction INSN needs to be protected by an R10K cache barrier .


<s>
static
void
rs6000_output_savres_externs
(
FILE
*
file
)
{
rs6000_stack_t
*
info
=
rs6000_stack_info
(
)
;
if
(
TARGET_DEBUG_STACK
)
debug_stack_info
(
info
)
;
if
(
info
->
first_fp_reg_save
<
64
&&
!
TARGET_MACHO
&&
!
TARGET_ELF
)
{
char
*
name
;
int
regno
=
info
->
first_fp_reg_save
32
;
if
(
(
info
->
savres_strategy
&
SAVE_INLINE_FPRS
)
==
0
)
{
bool
lr
=
(
info
->
savres_strategy
&
SAVE_NOINLINE_FPRS_SAVES_LR
)
!=
0
;
int
sel
=
SAVRES_SAVE
|
SAVRES_FPR
|
(
lr
SAVRES_LR
:
0
)
;
name
=
rs6000_savres_routine_name
(
info
,
regno
,
sel
)
;
fprintf
(
file
,
"\t.extern %s\n"
,
name
)
;
}
if
(
(
info
->
savres_strategy
&
REST_INLINE_FPRS
)
==
0
)
{
bool
lr
=
(
info
->
savres_strategy
&
REST_NOINLINE_FPRS_DOESNT_RESTORE_LR
)
==
0
;
int
sel
=
SAVRES_FPR
|
(
lr
SAVRES_LR
:
0
)
;
name
=
rs6000_savres_routine_name
(
info
,
regno
,
sel
)
;
fprintf
(
file
,
"\t.extern %s\n"
,
name
)
;
}
}
}
</s>

Output .extern statements for the save/restore routines we use .


<s> static bool rs6000_builtin_type_compatible ( tree parmtype , tree argtype ) { if ( parmtype == error_mark_node ) return false ; if ( INTEGRAL_TYPE_P ( parmtype ) && INTEGRAL_TYPE_P ( argtype ) ) return true ; if ( TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128 && is_float128_p ( parmtype ) && is_float128_p ( argtype ) ) return true ; if ( POINTER_TYPE_P ( parmtype ) && POINTER_TYPE_P ( argtype ) ) { parmtype = TREE_TYPE ( parmtype ) ; argtype = TREE_TYPE ( argtype ) ; if ( TYPE_READONLY ( argtype ) ) parmtype = build_qualified_type ( parmtype , TYPE_QUAL_CONST ) ; } return lang_hooks . types_compatible_p ( parmtype , argtype ) ; } </s>

Return true iff ARGTYPE can be compatibly passed as PARMTYPE .


"frame pointer should not have been eliminated"


<s> bool SystemZInstrInfo :: isPredicable ( const MachineInstr & MI ) const { unsigned Opcode = MI . getOpcode ( ) ; if ( Opcode == SystemZ :: Return || Opcode == SystemZ :: Trap || Opcode == SystemZ :: CallJG || Opcode == SystemZ :: CallBR ) return true ; return false ; } </s>

Return true if the specified instruction can be predicated .

SystemZ SystemZ SystemZ::Return SystemZ::Trap SystemZ::CallJG SystemZ::CallBR


<s> static void mips_save_reg ( rtx reg , rtx mem ) { if ( GET_MODE ( reg ) == DFmode && ! TARGET_FLOAT64 ) { rtx x1 , x2 ; if ( mips_split_64bit_move_p ( mem , reg ) ) mips_split_64bit_move ( mem , reg ) ; else emit_move_insn ( mem , reg ) ; x1 = mips_frame_set ( mips_subword ( mem , 0 ) , mips_subword ( reg , 0 ) ) ; x2 = mips_frame_set ( mips_subword ( mem , 1 ) , mips_subword ( reg , 1 ) ) ; mips_set_frame_expr ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , x1 , x2 ) ) ) ; } else { if ( TARGET_MIPS16 && REGNO ( reg ) != GP_REG_FIRST + 31 && ! M16_REG_P ( REGNO ( reg ) ) ) { emit_move_insn ( MIPS_PROLOGUE_TEMP ( GET_MODE ( reg ) ) , reg ) ; emit_move_insn ( mem , MIPS_PROLOGUE_TEMP ( GET_MODE ( reg ) ) ) ; } else emit_move_insn ( mem , reg ) ; mips_set_frame_expr ( mips_frame_set ( mem , reg ) ) ; } } </s>

Save register REG to MEM . Make the instruction frame-related .


"Expected a reg or frame index operand."

Return true if this is a load/store that can be potentially paired/merged .


<s> static unsigned int mips_get_compress_off_flags ( tree attributes ) { unsigned int flags = 0 ; if ( lookup_attribute ( "nocompression" , attributes ) != NULL ) flags |= MASK_MIPS16 | MASK_MICROMIPS ; if ( lookup_attribute ( "nomips16" , attributes ) != NULL ) flags |= MASK_MIPS16 ; if ( lookup_attribute ( "nomicromips" , attributes ) != NULL ) flags |= MASK_MICROMIPS ; return flags ; } </s>

Return the set of compression modes that are explicitly forbidden by the attributes in ATTRIBUTES .


" which expects a vector or pointer base address"

Require the arguments starting at ARGNO to form a gather-style address . There are three possible uses : - for loading into elements of type TYPE ( when LOAD_P is true ) - for storing from elements of type TYPE ( when LOAD_P is false ) - for prefetching data ( when TYPE is NUM_TYPE_SUFFIXES ) The three possible addresses are : - a vector base with no displacement - a vector base and a scalar displacement - a scalar ( pointer ) base and a vector displacement The overloaded function 's mode suffix determines whether there is a displacement , and if so , what units it uses : - MODE_none : no displacement - MODE_offset : the displacement is measured in bytes - MODE_index : the displacement is measured in elements Return the mode of the non-overloaded function on success , otherwise report an error and return MODE_none .


<s>
static
HOST_WIDE_INT
rs6000_disable_incompatible_switches
(
void
)
{
HOST_WIDE_INT
ignore_masks
=
rs6000_isa_flags_explicit
;
size_t
i
,
j
;
static
const
struct
{
const
HOST_WIDE_INT
no_flag
;
const
HOST_WIDE_INT
dep_flags
;
const
char
*
const
name
;
}
flags
[
]
=
{
{
OPTION_MASK_P9_VECTOR
,
OTHER_P9_VECTOR_MASKS
,
"power9-vector"
}
,
{
OPTION_MASK_P8_VECTOR
,
OTHER_P8_VECTOR_MASKS
,
"power8-vector"
}
,
{
OPTION_MASK_VSX
,
OTHER_VSX_VECTOR_MASKS
,
"vsx"
}
,
{
OPTION_MASK_ALTIVEC
,
OTHER_ALTIVEC_MASKS
,
"altivec"
}
,
}
;
for
(
i
=
0
;
i
<
ARRAY_SIZE
(
flags
)
;
i
++
)
{
HOST_WIDE_INT
no_flag
=
flags
[
i
]
.
no_flag
;
if
(
(
rs6000_isa_flags
&
no_flag
)
==
0
&&
(
rs6000_isa_flags_explicit
&
no_flag
)
!=
0
)
{
HOST_WIDE_INT
dep_flags
=
flags
[
i
]
.
dep_flags
;
HOST_WIDE_INT
set_flags
=
(
rs6000_isa_flags_explicit
&
rs6000_isa_flags
&
dep_flags
)
;
if
(
set_flags
)
{
for
(
j
=
0
;
j
<
ARRAY_SIZE
(
rs6000_opt_masks
)
;
j
++
)
if
(
(
set_flags
&
rs6000_opt_masks
[
j
]
.
mask
)
!=
0
)
{
set_flags
&=
~
rs6000_opt_masks
[
j
]
.
mask
;
error
(
"%<-mno-%s%> turns off %<-m%s%>"
,
flags
[
i
]
.
name
,
rs6000_opt_masks
[
j
]
.
name
)
;
}
gcc_assert
(
!
set_flags
)
;
}
rs6000_isa_flags
&=
~
dep_flags
;
ignore_masks
|=
no_flag
|
dep_flags
;
}
}
return
ignore_masks
;
}
</s>

If the user used -mno-vsx , we need turn off all of the implicit ISA 2.06 , 2.07 , and 3.0 options that relate to the vector unit ( -mdirect-move , -mupper-regs-df , etc. ) . If the user used -mno-power8-vector , we need to turn off all of the implicit ISA 2.07 and 3.0 options that relate to the vector unit . If the user used -mno-power9-vector , we need to turn off all of the implicit ISA 3.0 options that relate to the vector unit . This function does not handle explicit options such as the user specifying -mdirect-move . These are handled in rs6000_option_override_internal , and the appropriate error is given if needed . We return a mask of all of the implicit options that should not be enabled by default .


<s> unsigned getOpSize ( const MachineInstr & MI , unsigned OpNo ) const { const MachineOperand & MO = MI . getOperand ( OpNo ) ; if ( MO . isReg ( ) ) { if ( unsigned SubReg = MO . getSubReg ( ) ) { return RI . getSubRegIdxSize ( SubReg ) / 8 ; } } return RI . getRegSizeInBits ( * getOpRegClass ( MI , OpNo ) ) / 8 ; } </s>

This form should usually be preferred since it handles operands with unknown register classes .


<s> static bool visium_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { rtx base ; unsigned int regno ; if ( GET_CODE ( x ) == PLUS ) { if ( ! rtx_ok_for_offset_p ( mode , XEXP ( x , 1 ) ) ) return false ; base = XEXP ( x , 0 ) ; } else base = x ; if ( GET_CODE ( base ) == SUBREG ) base = SUBREG_REG ( base ) ; if ( ! REG_P ( base ) ) return false ; regno = REGNO ( base ) ; if ( strict ) return REGNO_OK_FOR_BASE_P ( regno ) ; return BASE_REGISTER_P ( regno ) || regno >= FIRST_PSEUDO_REGISTER ; } </s>

Return whether X is a legitimate memory address for a memory operand of mode MODE . Legitimate addresses are defined in two variants : a strict variant and a non-strict one . The STRICT parameter chooses which variant is desired by the caller . The strict variant is used in the reload pass . It must be defined so that any pseudo-register that has not been allocated a hard register is considered a memory reference . This is because in contexts where some kind of register is required , a pseudo-register with no hard register must be rejected . For non-hard registers , the strict variant should look up the ` reg_renumber ' array ; it should then proceed using the hard register number in the array , or treat the pseudo as a memory reference if the array holds ` -1 ' . The non-strict variant is used in other passes . It must be defined to accept all pseudo-registers in every context where some kind of register is required .


<s> int get_sequence_length ( rtx_insn * insns ) { int length = 0 ; for ( rtx_insn * insn = insns ; insn ; insn = NEXT_INSN ( insn ) ) length += get_attr_length ( insn ) ; return length ; } </s>


"Store results: call to builtin function with wrong "

optimizeCall - Take the given call instruction and return a more optimal value to replace the instruction with or 0 if a more optimal form ca n't be found .


"Huge values only handled before reg-alloc ."

Emit a series of instructions to load an immediate .


<s> bool Cpu0FrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const TargetRegisterInfo * TRI = STI . getRegisterInfo ( ) ; return MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || MFI . hasVarSizedObjects ( ) || MFI . isFrameAddressTaken ( ) || TRI -> needsStackRealignment ( MF ) ; } </s>

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


<s> static int s390_issue_rate ( void ) { switch ( s390_tune ) { case PROCESSOR_2084_Z990 : case PROCESSOR_2094_Z9_109 : case PROCESSOR_2094_Z9_EC : case PROCESSOR_2817_Z196 : return 3 ; case PROCESSOR_2097_Z10 : return 2 ; case PROCESSOR_9672_G5 : case PROCESSOR_9672_G6 : case PROCESSOR_2064_Z900 : case PROCESSOR_2827_ZEC12 : case PROCESSOR_2964_Z13 : case PROCESSOR_ARCH12 : default : return 1 ; } } </s>

The number of instructions that can be issued per cycle .


<s> bool SystemZLongBranch :: runOnMachineFunction ( MachineFunction & F ) { TII = static_cast < const SystemZInstrInfo * > ( F . getSubtarget ( ) . getInstrInfo ( ) ) ; MF = & F ; uint64_t Size = initMBBInfo ( ) ; if ( Size <= MaxForwardRange || ! mustRelaxABranch ( ) ) return false ; setWorstCaseAddresses ( ) ; relaxBranches ( ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


<s> static rtx F ( rtx r ) { RTX_FRAME_RELATED_P ( r ) = 1 ; return r ; } </s>

We use this to wrap all emitted insns in the prologue , so they get the `` frame-related '' ( /f ) flag set .


<s> static rtx bfin_expand_builtin ( tree exp , rtx target ATTRIBUTE_UNUSED , rtx subtarget ATTRIBUTE_UNUSED , enum machine_mode mode ATTRIBUTE_UNUSED , int ignore ATTRIBUTE_UNUSED ) { tree fndecl = TREE_OPERAND ( TREE_OPERAND ( exp , 0 ) , 0 ) ; unsigned int fcode = DECL_FUNCTION_CODE ( fndecl ) ; switch ( fcode ) { case BFIN_BUILTIN_CSYNC : emit_insn ( gen_csync ( ) ) ; return 0 ; case BFIN_BUILTIN_SSYNC : emit_insn ( gen_ssync ( ) ) ; return 0 ; default : gcc_unreachable ( ) ; } } </s>

Expand an expression EXP that calls a built-in function , with result going to TARGET if that 's convenient ( and in mode MODE if that 's convenient ) . SUBTARGET may be used as the target for computing one of EXP 's operands . IGNORE is nonzero if the value is to be ignored .


<s> void pure_scalable_type_info :: add_piece ( const piece & p ) { if ( ! pieces . is_empty ( ) ) { piece & prev = pieces . last ( ) ; gcc_assert ( VECTOR_MODE_P ( p . mode ) && VECTOR_MODE_P ( prev . mode ) ) ; unsigned int nelems1 , nelems2 ; if ( prev . orig_mode == p . orig_mode && known_eq ( prev . offset + GET_MODE_SIZE ( prev . mode ) , p . offset ) && constant_multiple_p ( GET_MODE_NUNITS ( prev . mode ) , GET_MODE_NUNITS ( p . orig_mode ) , & nelems1 ) && constant_multiple_p ( GET_MODE_NUNITS ( p . mode ) , GET_MODE_NUNITS ( p . orig_mode ) , & nelems2 ) && targetm . array_mode ( p . orig_mode , nelems1 + nelems2 ) . exists ( & prev . mode ) ) { prev . num_zr += p . num_zr ; prev . num_pr += p . num_pr ; return ; } } pieces . quick_push ( p ) ; } </s>

Add P to the list of pieces in the type .


<s> BitVector SIRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( AMDGPU :: INDIRECT_BASE_ADDR ) ; reserveRegisterTuples ( Reserved , AMDGPU :: EXEC ) ; reserveRegisterTuples ( Reserved , AMDGPU :: FLAT_SCR ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SGPR102_SGPR103 ) ; const AMDGPUSubtarget & ST = MF . getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . getGeneration ( ) >= AMDGPUSubtarget :: VOLCANIC_ISLANDS ) { reserveRegisterTuples ( Reserved , AMDGPU :: SGPR96_SGPR97 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SGPR98_SGPR99 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SGPR100_SGPR101 ) ; } if ( ST . hasSGPRInitBug ( ) ) { unsigned NumSGPRs = AMDGPU :: SGPR_32RegClass . getNumRegs ( ) ; unsigned Limit = AMDGPUSubtarget :: FIXED_SGPR_COUNT_FOR_INIT_BUG - 6 ; for ( unsigned i = Limit ; i < NumSGPRs ; ++ i ) { unsigned Reg = AMDGPU :: SGPR_32RegClass . getRegister ( i ) ; reserveRegisterTuples ( Reserved , Reg ) ; } } const SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; unsigned ScratchWaveOffsetReg = MFI -> getScratchWaveOffsetReg ( ) ; if ( ScratchWaveOffsetReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , ScratchWaveOffsetReg ) ; } unsigned ScratchRSrcReg = MFI -> getScratchRSrcReg ( ) ; if ( ScratchRSrcReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , ScratchRSrcReg ) ; assert ( ! isSubRegister ( ScratchRSrcReg , ScratchWaveOffsetReg ) ) ; } return Reserved ; } </s>

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


<s> bool AMDGPUPassConfig :: addPostRegAlloc ( ) { const AMDGPUSubtarget & ST = TM -> getSubtarget < AMDGPUSubtarget > ( ) ; if ( ST . getGeneration ( ) > AMDGPUSubtarget :: NORTHERN_ISLANDS ) { addPass ( createSIInsertWaits ( * TM ) ) ; } return false ; } </s>

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


<s> bool X86TargetLowering :: isLegalAddressingMode ( const DataLayout & DL , const AddrMode & AM , Type * Ty , unsigned AS ) const { CodeModel :: Model M = getTargetMachine ( ) . getCodeModel ( ) ; Reloc :: Model R = getTargetMachine ( ) . getRelocationModel ( ) ; if ( ! X86 :: isOffsetSuitableForCodeModel ( AM . BaseOffs , M , AM . BaseGV != nullptr ) ) return false ; if ( AM . BaseGV ) { unsigned GVFlags = Subtarget -> ClassifyGlobalReference ( AM . BaseGV , getTargetMachine ( ) ) ; if ( isGlobalStubReference ( GVFlags ) ) return false ; if ( AM . HasBaseReg && isGlobalRelativeToPICBase ( GVFlags ) ) return false ; if ( ( M != CodeModel :: Small || R != Reloc :: Static ) && Subtarget -> is64Bit ( ) && ( AM . BaseOffs || AM . Scale > 1 ) ) return false ; } switch ( AM . Scale ) { case 0 : case 1 : case 2 : case 4 : case 8 : break ; case 3 : case 5 : case 9 : if ( AM . HasBaseReg ) return false ; break ; default : return false ; } return true ; } </s>

isLegalAddressingMode - Return true if the addressing mode represented by AM is legal for this target , for a load/store of the specified type .


<s> static bool mips_canonicalize_comparison ( enum rtx_code * code , rtx * cmp1 , enum machine_mode mode ) { HOST_WIDE_INT original , plus_one ; if ( GET_CODE ( * cmp1 ) != CONST_INT ) return false ; original = INTVAL ( * cmp1 ) ; plus_one = trunc_int_for_mode ( ( unsigned HOST_WIDE_INT ) original + 1 , mode ) ; switch ( * code ) { case LE : if ( original < plus_one ) { * code = LT ; * cmp1 = force_reg ( mode , GEN_INT ( plus_one ) ) ; return true ; } break ; case LEU : if ( plus_one != 0 ) { * code = LTU ; * cmp1 = force_reg ( mode , GEN_INT ( plus_one ) ) ; return true ; } break ; default : return false ; } return false ; } </s>

Canonicalize LE or LEU comparisons into LT comparisons when possible to avoid extra instructions or inverting the comparison .


<s>
int
scalar_chain
::
compute_convert_gain
(
)
{
bitmap_iterator
bi
;
unsigned
insn_uid
;
int
gain
=
0
;
int
cost
=
0
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Computing gain for chain #%d...\n"
,
chain_id
)
;
EXECUTE_IF_SET_IN_BITMAP
(
insns
,
0
,
insn_uid
,
bi
)
{
rtx_insn
*
insn
=
DF_INSN_UID_GET
(
insn_uid
)
->
insn
;
rtx
def_set
=
single_set
(
insn
)
;
rtx
src
=
SET_SRC
(
def_set
)
;
rtx
dst
=
SET_DEST
(
def_set
)
;
if
(
REG_P
(
src
)
&&
REG_P
(
dst
)
)
gain
+=
COSTS_N_INSNS
(
2
)
ix86_cost
->
sse_move
;
else
if
(
REG_P
(
src
)
&&
MEM_P
(
dst
)
)
gain
+=
2
*
ix86_cost
->
int_store
[
2
]
ix86_cost
->
sse_store
[
1
]
;
else
if
(
MEM_P
(
src
)
&&
REG_P
(
dst
)
)
gain
+=
2
*
ix86_cost
->
int_load
[
2
]
ix86_cost
->
sse_load
[
1
]
;
else
if
(
GET_CODE
(
src
)
==
PLUS
||
GET_CODE
(
src
)
==
MINUS
||
GET_CODE
(
src
)
==
IOR
||
GET_CODE
(
src
)
==
XOR
||
GET_CODE
(
src
)
==
AND
)
gain
+=
ix86_cost
->
add
;
else
if
(
GET_CODE
(
src
)
==
COMPARE
)
{
}
else
gcc_unreachable
(
)
;
}
if
(
dump_file
)
fprintf
(
dump_file
,
"  Instruction conversion gain: %d\n"
,
gain
)
;
EXECUTE_IF_SET_IN_BITMAP
(
defs_conv
,
0
,
insn_uid
,
bi
)
cost
+=
DF_REG_DEF_COUNT
(
insn_uid
)
*
ix86_cost
->
mmxsse_to_integer
;
if
(
dump_file
)
fprintf
(
dump_file
,
"  Registers conversion cost: %d\n"
,
cost
)
;
gain
-=
cost
;
if
(
dump_file
)
fprintf
(
dump_file
,
"  Total gain: %d\n"
,
gain
)
;
return
gain
;
}
</s>


<s> void sparc_expand_epilogue ( bool for_eh ) { HOST_WIDE_INT size = sparc_frame_size ; if ( sparc_n_global_fp_regs > 0 ) emit_save_or_restore_global_fp_regs ( sparc_frame_base_reg , sparc_frame_base_offset - sparc_apparent_frame_size , SORR_RESTORE ) ; if ( size == 0 || for_eh ) ; else if ( sparc_leaf_function_p ) { if ( size <= 4096 ) emit_insn ( gen_stack_pointer_inc ( GEN_INT ( size ) ) ) ; else if ( size <= 8192 ) { emit_insn ( gen_stack_pointer_inc ( GEN_INT ( 4096 ) ) ) ; emit_insn ( gen_stack_pointer_inc ( GEN_INT ( size - 4096 ) ) ) ; } else { rtx reg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( reg , GEN_INT ( size ) ) ; emit_insn ( gen_stack_pointer_inc ( reg ) ) ; } } } </s>

Expand the function epilogue , either normal or part of a sibcall . We emit all the instructions except the return or the call .


<s> static bool sparc_vectorize_vec_perm_const ( machine_mode vmode , machine_mode op_mode , rtx target , rtx op0 , rtx op1 , const vec_perm_indices & sel ) { if ( vmode != op_mode ) return false ; if ( ! TARGET_VIS2 ) return false ; if ( ! target ) return GET_MODE_SIZE ( vmode ) == 8 ; if ( vmode != V8QImode ) return false ; rtx nop0 = force_reg ( vmode , op0 ) ; if ( op0 == op1 ) op1 = nop0 ; op0 = nop0 ; op1 = force_reg ( vmode , op1 ) ; unsigned int i , mask ; for ( i = mask = 0 ; i < 8 ; ++ i ) mask |= ( sel [ i ] & 0xf ) << ( 28 - i * 4 ) ; rtx mask_rtx = force_reg ( SImode , gen_int_mode ( mask , SImode ) ) ; emit_insn ( gen_bmasksi_vis ( gen_reg_rtx ( SImode ) , mask_rtx , const0_rtx ) ) ; emit_insn ( gen_bshufflev8qi_vis ( target , op0 , op1 ) ) ; return true ; } </s>


<s> static HOST_WIDE_INT ix86_get_frame_size ( void ) { if ( cfun -> machine -> stack_frame_required ) return get_frame_size ( ) ; else return 0 ; } </s>

Return stack frame size . get_frame_size ( ) returns used stack slots during compilation , which may be optimized out later . If stack frame is needed , stack_frame_required should be true .


<s>
const
MCPhysReg
*
X86RegisterInfo
::
getCalleeSavedRegs
(
const
MachineFunction
*
MF
)
const
{
assert
(
MF
&&
"MachineFunction required"
)
;
const
X86Subtarget
&
Subtarget
=
MF
->
getSubtarget
<
X86Subtarget
>
(
)
;
bool
HasSSE
=
Subtarget
.
hasSSE1
(
)
;
bool
HasAVX
=
Subtarget
.
hasAVX
(
)
;
bool
HasAVX512
=
Subtarget
.
hasAVX512
(
)
;
bool
CallsEHReturn
=
MF
->
callsEHReturn
(
)
;
CallingConv
::
ID
CC
=
MF
->
getFunction
(
)
->
getCallingConv
(
)
;
if
(
MF
->
getFunction
(
)
->
hasFnAttribute
(
"no_caller_saved_registers"
)
)
CC
=
CallingConv
::
X86_INTR
;
switch
(
CC
)
{
case
CallingConv
::
GHC
:
case
CallingConv
::
HiPE
:
return
CSR_NoRegs_SaveList
;
case
CallingConv
::
AnyReg
:
if
(
HasAVX
)
return
CSR_64_AllRegs_AVX_SaveList
;
return
CSR_64_AllRegs_SaveList
;
case
CallingConv
::
PreserveMost
:
return
CSR_64_RT_MostRegs_SaveList
;
case
CallingConv
::
PreserveAll
:
if
(
HasAVX
)
return
CSR_64_RT_AllRegs_AVX_SaveList
;
return
CSR_64_RT_AllRegs_SaveList
;
case
CallingConv
::
CXX_FAST_TLS
:
if
(
Is64Bit
)
return
MF
->
getInfo
<
X86MachineFunctionInfo
>
(
)
->
isSplitCSR
(
)
CSR_64_CXX_TLS_Darwin_PE_SaveList
:
CSR_64_TLS_Darwin_SaveList
;
break
;
case
CallingConv
::
Intel_OCL_BI
:
{
if
(
HasAVX512
&&
IsWin64
)
return
CSR_Win64_Intel_OCL_BI_AVX512_SaveList
;
if
(
HasAVX512
&&
Is64Bit
)
return
CSR_64_Intel_OCL_BI_AVX512_SaveList
;
if
(
HasAVX
&&
IsWin64
)
return
CSR_Win64_Intel_OCL_BI_AVX_SaveList
;
if
(
HasAVX
&&
Is64Bit
)
return
CSR_64_Intel_OCL_BI_AVX_SaveList
;
if
(
!
HasAVX
&&
!
IsWin64
&&
Is64Bit
)
return
CSR_64_Intel_OCL_BI_SaveList
;
break
;
}
case
CallingConv
::
HHVM
:
return
CSR_64_HHVM_SaveList
;
case
CallingConv
::
X86_RegCall
:
if
(
Is64Bit
)
{
if
(
IsWin64
)
{
return
(
HasSSE
CSR_Win64_RegCall_SaveList
:
CSR_Win64_RegCall_NoSSE_SaveList
)
;
}
else
{
return
(
HasSSE
CSR_SysV64_RegCall_SaveList
:
CSR_SysV64_RegCall_NoSSE_SaveList
)
;
}
}
else
{
return
(
HasSSE
CSR_32_RegCall_SaveList
:
CSR_32_RegCall_NoSSE_SaveList
)
;
}
case
CallingConv
::
Cold
:
if
(
Is64Bit
)
return
CSR_64_MostRegs_SaveList
;
break
;
case
CallingConv
::
X86_64_Win64
:
if
(
!
HasSSE
)
return
CSR_Win64_NoSSE_SaveList
;
return
CSR_Win64_SaveList
;
case
CallingConv
::
X86_64_SysV
:
if
(
CallsEHReturn
)
return
CSR_64EHRet_SaveList
;
return
CSR_64_SaveList
;
case
CallingConv
::
X86_INTR
:
if
(
Is64Bit
)
{
if
(
HasAVX512
)
return
CSR_64_AllRegs_AVX512_SaveList
;
if
(
HasAVX
)
return
CSR_64_AllRegs_AVX_SaveList
;
if
(
HasSSE
)
return
CSR_64_AllRegs_SaveList
;
return
CSR_64_AllRegs_NoSSE_SaveList
;
}
else
{
if
(
HasAVX512
)
return
CSR_32_AllRegs_AVX512_SaveList
;
if
(
HasAVX
)
return
CSR_32_AllRegs_AVX_SaveList
;
if
(
HasSSE
)
return
CSR_32_AllRegs_SSE_SaveList
;
return
CSR_32_AllRegs_SaveList
;
}
default
:
break
;
}
if
(
Is64Bit
)
{
if
(
IsWin64
)
{
if
(
!
HasSSE
)
return
CSR_Win64_NoSSE_SaveList
;
return
CSR_Win64_SaveList
;
}
if
(
CallsEHReturn
)
return
CSR_64EHRet_SaveList
;
if
(
Subtarget
.
getTargetLowering
(
)
->
supportSwiftError
(
)
&&
MF
->
getFunction
(
)
->
getAttributes
(
)
.
hasAttrSomewhere
(
Attribute
::
SwiftError
)
)
return
CSR_64_SwiftError_SaveList
;
return
CSR_64_SaveList
;
}
if
(
CallsEHReturn
)
return
CSR_32EHRet_SaveList
;
return
CSR_32_SaveList
;
}
</s>


"Unexpected operand in reassociable instruction"

Return true when \P Inst has reassociable operands in the same \P MBB .


<s>
bool
PIC16AsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
this
->
MF
=
&
MF
;
SetupMachineFunction
(
MF
)
;
const
Function
*
F
=
MF
.
getFunction
(
)
;
CurrentFnName
=
Mang
->
getValueName
(
F
)
;
emitFunctionData
(
MF
)
;
std
::
string
codeSection
;
codeSection
=
"code."
+
CurrentFnName
+
".# "
+
"CODE"
;
const
Section
*
fCodeSection
=
TAI
->
getNamedSection
(
codeSection
.
c_str
(
)
,
SectionFlags
::
Code
)
;
O
<<
"\n"
;
SwitchToSection
(
fCodeSection
)
;
for
(
MachineFunction
::
const_iterator
I
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
I
!=
E
;
++
I
)
{
if
(
I
!=
MF
.
begin
(
)
)
{
printBasicBlockLabel
(
I
,
true
)
;
O
<<
'\n'
;
}
else
O
<<
CurrentFnName
<<
":\n"
;
CurBank
=
""
;
for
(
MachineBasicBlock
::
const_iterator
II
=
I
->
begin
(
)
,
E
=
I
->
end
(
)
;
II
!=
E
;
++
II
)
{
printMachineInstruction
(
II
)
;
}
}
return
false
;
}
</s>


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
{
const
static
MCFixupKindInfo
Infos
[
Cpu0
::
NumTargetFixupKinds
]
=
{
{
"fixup_Cpu0_16"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_32"
,
0
,
32
,
0
}
,
{
"fixup_Cpu0_REL32"
,
0
,
32
,
0
}
,
{
"fixup_Cpu0_24"
,
0
,
24
,
0
}
,
{
"fixup_Cpu0_HI16"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_LO16"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_GPREL16"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_LITERAL"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_GOT_Global"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_GOT_Local"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_PC16"
,
0
,
16
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_Cpu0_PC24"
,
0
,
24
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_Cpu0_CALL24"
,
0
,
24
,
0
}
,
{
"fixup_Cpu0_GPREL32"
,
0
,
32
,
0
}
,
{
"fixup_Cpu0_SHIFT5"
,
6
,
5
,
0
}
,
{
"fixup_Cpu0_SHIFT6"
,
6
,
5
,
0
}
,
{
"fixup_Cpu0_64"
,
0
,
64
,
0
}
,
{
"fixup_Cpu0_TLSGD"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_GOTTPREL"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_TPREL_HI"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_TPREL_LO"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_TLSLDM"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_DTPREL_HI"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_DTPREL_LO"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_Branch_PCRel"
,
0
,
16
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"fixup_Cpu0_GOT_HI16"
,
0
,
16
,
0
}
,
{
"fixup_Cpu0_GOT_LO16"
,
0
,
16
,
0
}
}
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s> void MipsDAGToDAGISel :: getAnalysisUsage ( AnalysisUsage & AU ) const { AU . addPreserved < StackProtector > ( ) ; SelectionDAGISel :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> unsigned PPCFrameLowering :: determineFrameLayout ( MachineFunction & MF , bool UpdateMF , bool UseEstimate ) const { MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; unsigned FrameSize = UseEstimate ? MFI -> estimateStackSize ( MF ) : MFI -> getStackSize ( ) ; unsigned TargetAlign = getStackAlignment ( ) ; unsigned MaxAlign = MFI -> getMaxAlignment ( ) ; unsigned AlignMask = std :: max ( MaxAlign , TargetAlign ) - 1 ; const PPCRegisterInfo * RegInfo = static_cast < const PPCRegisterInfo * > ( Subtarget . getRegisterInfo ( ) ) ; bool DisableRedZone = MF . getFunction ( ) -> hasFnAttribute ( Attribute :: NoRedZone ) ; unsigned LR = RegInfo -> getRARegister ( ) ; if ( ! DisableRedZone && ( Subtarget . isPPC64 ( ) || ! Subtarget . isSVR4ABI ( ) || FrameSize == 0 ) && FrameSize <= 224 && ! MFI -> hasVarSizedObjects ( ) && ! MFI -> adjustsStack ( ) && ! MustSaveLR ( MF , LR ) && ! RegInfo -> hasBasePointer ( MF ) ) { if ( UpdateMF ) MFI -> setStackSize ( 0 ) ; return 0 ; } unsigned maxCallFrameSize = MFI -> getMaxCallFrameSize ( ) ; unsigned minCallFrameSize = getLinkageSize ( ) ; maxCallFrameSize = std :: max ( maxCallFrameSize , minCallFrameSize ) ; if ( MFI -> hasVarSizedObjects ( ) ) maxCallFrameSize = ( maxCallFrameSize + AlignMask ) & ~ AlignMask ; if ( UpdateMF ) MFI -> setMaxCallFrameSize ( maxCallFrameSize ) ; FrameSize += maxCallFrameSize ; FrameSize = ( FrameSize + AlignMask ) & ~ AlignMask ; if ( UpdateMF ) MFI -> setStackSize ( FrameSize ) ; return FrameSize ; } </s>

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


<s> bool AMDGPUInstructionSelector :: select ( MachineInstr & I , CodeGenCoverage & CoverageInfo ) const { if ( ! isPreISelGenericOpcode ( I . getOpcode ( ) ) ) { if ( I . isCopy ( ) ) return selectCOPY ( I ) ; return true ; } switch ( I . getOpcode ( ) ) { default : return selectImpl ( I , CoverageInfo ) ; case TargetOpcode :: G_ADD : return selectG_ADD ( I ) ; case TargetOpcode :: G_INTTOPTR : case TargetOpcode :: G_BITCAST : return selectCOPY ( I ) ; case TargetOpcode :: G_CONSTANT : case TargetOpcode :: G_FCONSTANT : return selectG_CONSTANT ( I ) ; case TargetOpcode :: G_GEP : return selectG_GEP ( I ) ; case TargetOpcode :: G_IMPLICIT_DEF : return selectG_IMPLICIT_DEF ( I ) ; case TargetOpcode :: G_INTRINSIC : return selectG_INTRINSIC ( I , CoverageInfo ) ; case TargetOpcode :: G_INTRINSIC_W_SIDE_EFFECTS : return selectG_INTRINSIC_W_SIDE_EFFECTS ( I , CoverageInfo ) ; case TargetOpcode :: G_LOAD : return selectG_LOAD ( I ) ; case TargetOpcode :: G_STORE : return selectG_STORE ( I ) ; } return false ; } </s>

Select the ( possibly generic ) instruction I to only use target-specific opcodes .


<s> static void riscv_prepare_builtin_arg ( struct expand_operand * op , tree exp , unsigned argno ) { tree arg = CALL_EXPR_ARG ( exp , argno ) ; create_input_operand ( op , expand_normal ( arg ) , TYPE_MODE ( TREE_TYPE ( arg ) ) ) ; } </s>

Take argument ARGNO from EXP 's argument list and convert it into an expand operand . Store the operand in * OP .


<s> static bool ia64_expand_vec_perm_const_1 ( struct expand_vec_perm_d * d ) { if ( expand_vec_perm_1 ( d ) ) return true ; if ( expand_vec_perm_broadcast ( d ) ) return true ; if ( expand_vec_perm_interleave_2 ( d ) ) return true ; if ( expand_vec_perm_v4hi_5 ( d ) ) return true ; return false ; } </s>

The guts of ia64_expand_vec_perm_const , also used by the ok hook . With all of the interface bits taken care of , perform the expansion in D and return true on success .


<s> MipsSubtarget & MipsSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS , const TargetMachine * TM ) { std :: string CPUName = selectMipsCPU ( TargetTriple , CPU ) ; ParseSubtargetFeatures ( CPUName , FS ) ; InstrItins = getInstrItineraryForCPU ( CPUName ) ; if ( InMips16Mode && ! TM -> Options . UseSoftFloat ) InMips16HardFloat = true ; return * this ; } </s>

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


<s> void Reset ( ) { TentativelyCommuting = false ; Declined = false ; } </s>


<s> const RegisterBank & MOSRegisterBankInfo :: getRegBankFromRegClass ( const TargetRegisterClass & RC , LLT Ty ) const { return MOS :: AnyRegBank ; } </s>