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

Returns true if the live-ins should be tracked after register allocation .


<s> unsigned PPCInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : break ; case PPC :: STD : case PPC :: STW : case PPC :: STFS : case PPC :: STFD : case PPC :: SPILL_CR : case PPC :: SPILL_CRBIT : case PPC :: STVX : case PPC :: STXVD2X : case PPC :: STXVX : case PPC :: QVSTFDX : case PPC :: QVSTFSXs : case PPC :: QVSTFDXb : case PPC :: SPILL_VRSAVE : case PPC :: SPILLTOVSR_ST : if ( MI . getOperand ( 1 ) . isImm ( ) && ! MI . getOperand ( 1 ) . getImm ( ) && MI . getOperand ( 2 ) . isFI ( ) ) { FrameIndex = MI . getOperand ( 2 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s> unsigned getExceptionSelectorRegister ( const Constant * PersonalityFn ) const override { return ABI . IsN64 ( ) ? Mips :: A1_64 : Mips :: A1 ; } </s>

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


<s> static void output_indirect_thunk_function ( enum indirect_thunk_prefix need_prefix , unsigned int regno , bool ret_p ) { char name [ 32 ] ; tree decl ; indirect_thunk_name ( name , regno , need_prefix , ret_p ) ; decl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , get_identifier ( name ) , build_function_type_list ( void_type_node , NULL_TREE ) ) ; DECL_RESULT ( decl ) = build_decl ( BUILTINS_LOCATION , RESULT_DECL , NULL_TREE , void_type_node ) ; TREE_PUBLIC ( decl ) = 1 ; TREE_STATIC ( decl ) = 1 ; DECL_IGNORED_P ( decl ) = 1 ; if ( TARGET_MACHO ) { switch_to_section ( darwin_sections [ picbase_thunk_section ] ) ; fputs ( "\t.weak_definition\t" , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; fputs ( "\n\t.private_extern\t" , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; DECL_WEAK ( decl ) = 1 ; } else if ( USE_HIDDEN_LINKONCE ) { cgraph_node :: create ( decl ) -> set_comdat_group ( DECL_ASSEMBLER_NAME ( decl ) ) ; targetm . asm_out . unique_section ( decl , 0 ) ; switch_to_section ( get_named_section ( decl , NULL , 0 ) ) ; targetm . asm_out . globalize_label ( asm_out_file , name ) ; fputs ( "\t.hidden\t" , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_DECLARE_FUNCTION_NAME ( asm_out_file , name , decl ) ; } else { switch_to_section ( text_section ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; } DECL_INITIAL ( decl ) = make_node ( BLOCK ) ; current_function_decl = decl ; allocate_struct_function ( decl , false ) ; init_function_start ( decl ) ; cfun -> is_thunk = true ; first_function_block_is_cold = false ; final_start_function ( emit_barrier ( ) , asm_out_file , 1 ) ; output_indirect_thunk ( need_prefix , regno ) ; final_end_function ( ) ; init_insn_lengths ( ) ; free_after_compilation ( cfun ) ; set_cfun ( NULL ) ; current_function_decl = NULL ; } </s>

Output a funtion with a call and return thunk for indirect branch . If BND_P is true , the BND prefix is needed . If REGNO ! = UNVALID_REGNUM , the function address is in REGNO . Otherwise , the function address is on the top of stack . Thunk is used for function return if RET_P is true .


<s>
static
tree
bpf_resolve_overloaded_builtin
(
location_t
loc
,
tree
fndecl
,
void
*
arglist
)
{
if
(
DECL_MD_FUNCTION_CODE
(
fndecl
)
!=
BPF_BUILTIN_PRESERVE_ACCESS_INDEX
)
return
NULL_TREE
;
vec
<
tree
,
va_gc
>
*
params
=
static_cast
<
vec
<
tree
,
va_gc
>
*
>
(
arglist
)
;
unsigned
n_params
=
params
params
->
length
(
)
:
0
;
if
(
n_params
!=
1
)
{
error_at
(
loc
,
"expected exactly 1 argument"
)
;
return
NULL_TREE
;
}
tree
param
=
(
*
params
)
[
0
]
;
if
(
!
TARGET_BPF_CORE
)
return
param
;
if
(
TREE_CODE
(
param
)
==
C_MAYBE_CONST_EXPR
)
param
=
C_MAYBE_CONST_EXPR_EXPR
(
param
)
;
walk_tree
(
&
param
,
bpf_core_walk
,
(
void
*
)
&
loc
,
)
;
return
param
;
}
</s>

Implement TARGET_RESOLVE_OVERLOADED_BUILTIN ( see gccint manual section Target Macros : :Misc. ) . Used for CO-RE support builtins such as __builtin_preserve_access_index and __builtin_preserve_field_info . FNDECL is the declaration of the builtin , and ARGLIST is the list of arguments passed to it , and is really a vec < tree , _ > * .


"Trying RISCV32Only_16 table (16-bit Instruction):\n"

"Trying RVBC32 table (BitManip 16-bit Instruction):\n"

"Trying RISCV_C table (16-bit Instruction):\n"

Returns the disassembly of a single instruction .


<s>
SDValue
AMDGPUTargetLowering
::
LowerCall
(
CallLoweringInfo
&
CLI
,
SmallVectorImpl
<
SDValue
>
&
InVals
)
const
{
SDValue
Callee
=
CLI
.
Callee
;
SelectionDAG
&
DAG
=
CLI
.
DAG
;
const
Function
&
Fn
=
*
DAG
.
getMachineFunction
(
)
.
getFunction
(
)
;
StringRef
FuncName
(
"<unknown>"
)
;
if
(
const
ExternalSymbolSDNode
*
G
=
dyn_cast
<
ExternalSymbolSDNode
>
(
Callee
)
)
FuncName
=
G
->
getSymbol
(
)
;
else
if
(
const
GlobalAddressSDNode
*
G
=
dyn_cast
<
GlobalAddressSDNode
>
(
Callee
)
)
FuncName
=
G
->
getGlobal
(
)
->
getName
(
)
;
DiagnosticInfoUnsupported
NoCalls
(
Fn
,
"unsupported call to function "
+
FuncName
,
CLI
.
DL
.
getDebugLoc
(
)
)
;
DAG
.
getContext
(
)
->
diagnose
(
NoCalls
)
;
for
(
unsigned
I
=
0
,
E
=
CLI
.
Ins
.
size
(
)
;
I
!=
E
;
++
I
)
InVals
.
push_back
(
DAG
.
getUNDEF
(
CLI
.
Ins
[
I
]
.
VT
)
)
;
return
DAG
.
getEntryNode
(
)
;
}
</s>

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

AMDGPU
AMDGPU
"<unknown>"
"unsupported call to function "
0


<s> int romp_pushes_stack ( ) { return ( frame_pointer_needed || write_symbols != NO_DEBUG || ( romp_sa_size ( ) + get_frame_size ( ) ) > 100 || romp_makes_calls ( ) ) ; } </s>

Return non-zero if this function needs to push space on the stack .


<s> void ix86_expand_binary_operator ( enum rtx_code code , machine_mode mode , rtx operands [ ] ) { rtx src1 , src2 , dst , op , clob ; dst = ix86_fixup_binary_operands ( code , mode , operands ) ; src1 = operands [ 1 ] ; src2 = operands [ 2 ] ; op = gen_rtx_SET ( VOIDmode , dst , gen_rtx_fmt_ee ( code , mode , src1 , src2 ) ) ; if ( reload_in_progress ) { gcc_assert ( code == PLUS ) ; emit_insn ( op ) ; } else if ( reload_completed && code == PLUS && ! rtx_equal_p ( dst , src1 ) ) { emit_insn ( op ) ; } else { clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , op , clob ) ) ) ; } if ( dst != operands [ 0 ] ) emit_move_insn ( operands [ 0 ] , dst ) ; } </s>

Attempt to expand a binary operator . Make the expansion closer to the actual machine , then just general_operand , which will allow 3 separate memory references ( one output , two input ) in a single insn .


<s>
static
const
char
*
output_branch
(
rtx
label
,
const
char
*
cond
,
rtx_insn
*
insn
)
{
char
str
[
64
]
;
rtx
operands
[
2
]
;
gcc_assert
(
cond
)
;
operands
[
0
]
=
label
;
if
(
get_attr_length
(
insn
)
>
8
)
{
bool
spilled
;
if
(
current_function_saves_lr
(
)
)
{
operands
[
1
]
=
regno_reg_rtx
[
LINK_REGNUM
]
;
spilled
=
false
;
}
else
if
(
!
df_regs_ever_live_p
(
long_branch_regnum
)
)
{
operands
[
1
]
=
regno_reg_rtx
[
long_branch_regnum
]
;
spilled
=
false
;
}
else
{
operands
[
1
]
=
regno_reg_rtx
[
long_branch_regnum
]
;
spilled
=
true
;
gcc_assert
(
current_function_has_lr_slot
(
)
)
;
}
if
(
spilled
)
{
if
(
final_sequence
)
{
rtx_insn
*
delay
=
NEXT_INSN
(
insn
)
;
int
seen
;
gcc_assert
(
delay
)
;
final_scan_insn
(
delay
,
asm_out_file
,
optimize
,
0
,
&
seen
)
;
PATTERN
(
delay
)
=
gen_blockage
(
)
;
INSN_CODE
(
delay
)
=
1
;
}
if
(
current_function_saves_fp
(
)
)
output_asm_insn
(
"write.l 1(sp),%1"
,
operands
)
;
else
output_asm_insn
(
"write.l (sp),%1"
,
operands
)
;
}
output_asm_insn
(
"moviu   %1,%%u %0"
,
operands
)
;
output_asm_insn
(
"movil   %1,%%l %0"
,
operands
)
;
strcpy
(
str
,
"bra     "
)
;
strcat
(
str
,
cond
)
;
strcat
(
str
,
",%1,%1"
)
;
if
(
!
spilled
)
strcat
(
str
,
"%#"
)
;
strcat
(
str
,
"\t\t;long branch"
)
;
output_asm_insn
(
str
,
operands
)
;
if
(
spilled
)
{
if
(
current_function_saves_fp
(
)
)
output_asm_insn
(
" read.l %1,1(sp)"
,
operands
)
;
else
output_asm_insn
(
" read.l %1,(sp)"
,
operands
)
;
}
}
else
if
(
label
==
pc_rtx
)
{
strcpy
(
str
,
"bra     "
)
;
strcat
(
str
,
cond
)
;
strcat
(
str
,
",r21,r0%#\t\t;return"
)
;
output_asm_insn
(
str
,
operands
)
;
}
else
{
strcpy
(
str
,
"brr     "
)
;
strcat
(
str
,
cond
)
;
strcat
(
str
,
",%0%#"
)
;
output_asm_insn
(
str
,
operands
)
;
}
return
""
;
}
</s>

Output a conditional/unconditional branch to LABEL . COND is the string condition . INSN is the instruction .


<s>
bool
PIC16AsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
this
->
MF
=
&
MF
;
SetupMachineFunction
(
MF
)
;
const
Function
*
F
=
MF
.
getFunction
(
)
;
CurrentFnName
=
Mang
->
getMangledName
(
F
)
;
EmitFunctionFrame
(
MF
)
;
DbgInfo
.
BeginFunction
(
MF
)
;
EmitAutos
(
CurrentFnName
)
;
const
MCSection
*
fCodeSection
=
getObjFileLowering
(
)
.
getSectionForFunction
(
CurrentFnName
)
;
O
<<
"\n"
;
OutStreamer
.
SwitchSection
(
fCodeSection
)
;
O
<<
"\tretlw  low("
<<
PAN
::
getFrameLabel
(
CurrentFnName
)
<<
")\n"
;
O
<<
"\tretlw  high("
<<
PAN
::
getFrameLabel
(
CurrentFnName
)
<<
")\n"
;
O
<<
CurrentFnName
<<
":\n"
;
DebugLoc
CurDL
;
O
<<
"\n"
;
for
(
MachineFunction
::
const_iterator
I
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
I
!=
E
;
++
I
)
{
if
(
I
!=
MF
.
begin
(
)
)
{
printBasicBlockLabel
(
I
,
true
)
;
O
<<
'\n'
;
}
for
(
MachineBasicBlock
::
const_iterator
II
=
I
->
begin
(
)
,
E
=
I
->
end
(
)
;
II
!=
E
;
++
II
)
{
const
DebugLoc
DL
=
II
->
getDebugLoc
(
)
;
if
(
!
DL
.
isUnknown
(
)
&&
DL
!=
CurDL
)
{
DbgInfo
.
ChangeDebugLoc
(
MF
,
DL
)
;
CurDL
=
DL
;
}
printMachineInstruction
(
II
)
;
}
}
DbgInfo
.
EndFunction
(
MF
)
;
return
false
;
}
</s>

runOnMachineFunction - Emit the function body .

PIC16
PIC16
"\n"
"\tretlw  low("
")\n"
"\tretlw  high("
")\n"
":\n"
"\n"


<s> void or1k_expand_move ( machine_mode mode , rtx op0 , rtx op1 ) { if ( MEM_P ( op0 ) ) { if ( ! const0_operand ( op1 , mode ) ) op1 = force_reg ( mode , op1 ) ; } else if ( mode == QImode || mode == HImode ) { } else { switch ( GET_CODE ( op1 ) ) { case CONST_INT : if ( ! input_operand ( op1 , mode ) ) { HOST_WIDE_INT i = INTVAL ( op1 ) ; HOST_WIDE_INT lo = i & 0xffff ; HOST_WIDE_INT hi = i ^ lo ; rtx subtarget = op0 ; if ( ! cse_not_expected && can_create_pseudo_p ( ) ) subtarget = gen_reg_rtx ( SImode ) ; emit_insn ( gen_rtx_SET ( subtarget , GEN_INT ( hi ) ) ) ; emit_insn ( gen_iorsi3 ( op0 , subtarget , GEN_INT ( lo ) ) ) ; return ; } break ; case CONST : case SYMBOL_REF : case LABEL_REF : op1 = or1k_legitimize_address_1 ( op1 , op0 ) ; break ; default : break ; } } emit_insn ( gen_rtx_SET ( op0 , op1 ) ) ; } </s>

Expand the patterns `` movqi '' , `` movqi '' and `` movsi '' . The argument OP0 is the destination and OP1 is the source . This expands to set OP0 to OP1 . OpenRISC can not do memory to memory assignments so for those cases we force one argument to a register . Constants that ca n't fit into a 16-bit immediate are split . Symbols are legitimized using split relocations .


<s> void R600InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const DebugLoc & DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { unsigned VectorComponents = 0 ; if ( ( R600 :: R600_Reg128RegClass . contains ( DestReg ) || R600 :: R600_Reg128VerticalRegClass . contains ( DestReg ) ) && ( R600 :: R600_Reg128RegClass . contains ( SrcReg ) || R600 :: R600_Reg128VerticalRegClass . contains ( SrcReg ) ) ) { VectorComponents = 4 ; } else if ( ( R600 :: R600_Reg64RegClass . contains ( DestReg ) || R600 :: R600_Reg64VerticalRegClass . contains ( DestReg ) ) && ( R600 :: R600_Reg64RegClass . contains ( SrcReg ) || R600 :: R600_Reg64VerticalRegClass . contains ( SrcReg ) ) ) { VectorComponents = 2 ; } if ( VectorComponents > 0 ) { for ( unsigned I = 0 ; I < VectorComponents ; I ++ ) { unsigned SubRegIndex = AMDGPURegisterInfo :: getSubRegFromChannel ( I ) ; buildDefaultInstruction ( MBB , MI , R600 :: MOV , RI . getSubReg ( DestReg , SubRegIndex ) , RI . getSubReg ( SrcReg , SubRegIndex ) ) . addReg ( DestReg , RegState :: Define | RegState :: Implicit ) ; } } else { MachineInstr * NewMI = buildDefaultInstruction ( MBB , MI , R600 :: MOV , DestReg , SrcReg ) ; NewMI -> getOperand ( getOperandIdx ( * NewMI , R600 :: OpName :: src0 ) ) . setIsKill ( KillSrc ) ; } } </s>


<s>
void
X86ATTInstPrinter
::
printPCRelImm
(
const
MCInst
*
MI
,
unsigned
OpNo
,
raw_ostream
&
O
)
{
const
MCOperand
&
Op
=
MI
->
getOperand
(
OpNo
)
;
if
(
Op
.
isImm
(
)
)
O
<<
formatImm
(
Op
.
getImm
(
)
)
;
else
{
assert
(
Op
.
isExpr
(
)
&&
"unknown pcrel immediate operand"
)
;
const
MCConstantExpr
*
BranchTarget
=
dyn_cast
<
MCConstantExpr
>
(
Op
.
getExpr
(
)
)
;
int64_t
Address
;
if
(
BranchTarget
&&
BranchTarget
->
EvaluateAsAbsolute
(
Address
)
)
{
O
<<
formatHex
(
(
uint64_t
)
Address
)
;
}
else
{
O
<<
*
Op
.
getExpr
(
)
;
}
}
}
</s>


"Can only insert epilog into returning blocks"


<s>
void
HexagonHazardRecognizer
::
AdvanceCycle
(
)
{
DEBUG
(
dbgs
(
)
<<
"Advance cycle, clear state\n"
)
;
Resources
->
clearResources
(
)
;
if
(
DotCurPNum
!=
1
&&
DotCurPNum
!=
(
int
)
PacketNum
)
{
UsesDotCur
=
nullptr
;
DotCurPNum
=
1
;
}
PacketNum
++
;
RegDefs
.
clear
(
)
;
}
</s>

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


<s> static rtx cris_function_arg ( cumulative_args_t ca , const function_arg_info & arg ) { return cris_function_arg_1 ( ca , arg , false ) ; } </s>

Worker function for TARGET_FUNCTION_ARG . The void_type_node is sent as a `` closing '' call .


<s>
void
RISCVInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MBBI
,
const
DebugLoc
&
DL
,
unsigned
DstReg
,
unsigned
SrcReg
,
bool
KillSrc
)
const
{
assert
(
RISCV
::
GPRRegClass
.
contains
(
DstReg
,
SrcReg
)
&&
"Impossible reg-to-reg copy"
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
get
(
RISCV
::
ADDI
)
,
DstReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
.
addImm
(
0
)
;
}
</s>

RISCV
RISCV
RISCV::GPRRegClass
"Impossible reg-to-reg copy"
RISCV::ADDI
0


<s> bool MMIXAsmParser :: ParseDirective ( AsmToken DirectiveID ) { return true ; } </s>

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


<s> const MCExpr * AMDGPUAsmPrinter :: lowerConstant ( const Constant * CV ) { auto * AT = static_cast < AMDGPUTargetMachine * > ( & TM ) ; auto * CE = dyn_cast < ConstantExpr > ( CV ) ; if ( CE && CE -> getOpcode ( ) == Instruction :: AddrSpaceCast ) { auto Op = CE -> getOperand ( 0 ) ; auto SrcAddr = Op -> getType ( ) -> getPointerAddressSpace ( ) ; if ( Op -> isNullValue ( ) && AT -> getNullPointerValue ( SrcAddr ) == 0 ) { auto DstAddr = CE -> getType ( ) -> getPointerAddressSpace ( ) ; return MCConstantExpr :: create ( AT -> getNullPointerValue ( DstAddr ) , OutContext ) ; } } return AsmPrinter :: lowerConstant ( CV ) ; } </s>

Lower the specified LLVM Constant to an MCExpr .


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

Print the specified MCInst to the specified raw_ostream .


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


<s> const unsigned * MSP430RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { const TargetFrameLowering * TFI = MF -> getTarget ( ) . getFrameLowering ( ) ; const Function * F = MF -> getFunction ( ) ; static const unsigned CalleeSavedRegs [ ] = { MSP430 :: FPW , MSP430 :: R5W , MSP430 :: R6W , MSP430 :: R7W , MSP430 :: R8W , MSP430 :: R9W , MSP430 :: R10W , MSP430 :: R11W , 0 } ; static const unsigned CalleeSavedRegsFP [ ] = { MSP430 :: R5W , MSP430 :: R6W , MSP430 :: R7W , MSP430 :: R8W , MSP430 :: R9W , MSP430 :: R10W , MSP430 :: R11W , 0 } ; static const unsigned CalleeSavedRegsIntr [ ] = { MSP430 :: FPW , MSP430 :: R5W , MSP430 :: R6W , MSP430 :: R7W , MSP430 :: R8W , MSP430 :: R9W , MSP430 :: R10W , MSP430 :: R11W , MSP430 :: R12W , MSP430 :: R13W , MSP430 :: R14W , MSP430 :: R15W , 0 } ; static const unsigned CalleeSavedRegsIntrFP [ ] = { MSP430 :: R5W , MSP430 :: R6W , MSP430 :: R7W , MSP430 :: R8W , MSP430 :: R9W , MSP430 :: R10W , MSP430 :: R11W , MSP430 :: R12W , MSP430 :: R13W , MSP430 :: R14W , MSP430 :: R15W , 0 } ; if ( TFI -> hasFP ( * MF ) ) return ( F -> getCallingConv ( ) == CallingConv :: MSP430_INTR ? CalleeSavedRegsIntrFP : CalleeSavedRegsFP ) ; else return ( F -> getCallingConv ( ) == CallingConv :: MSP430_INTR ? CalleeSavedRegsIntr : CalleeSavedRegs ) ; } </s>


<s> SDValue AArch64TargetLowering :: getGOT ( NodeTy * N , SelectionDAG & DAG , unsigned Flags ) const { LLVM_DEBUG ( dbgs ( ) << "AArch64TargetLowering::getGOT\n" ) ; SDLoc DL ( N ) ; EVT Ty = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue GotAddr = getTargetNode ( N , Ty , DAG , AArch64II :: MO_GOT | Flags ) ; return DAG . getNode ( AArch64ISD :: LOADgot , DL , Ty , GotAddr ) ; } </s>

Return a pseudo source value referencing the global offset table ( or something the like ) .


<s> bool supportSplitCSR ( MachineFunction * MF ) const override { return MF -> getFunction ( ) -> getCallingConv ( ) == CallingConv :: CXX_FAST_TLS && MF -> getFunction ( ) -> hasFnAttribute ( Attribute :: NoUnwind ) ; } </s>

Return true if the target supports that a subset of CSRs for the given machine function is handled explicitly via copies .


<s> ScheduleDAGInstrs * createMachineScheduler ( MachineSchedContext * C ) const override { ScheduleDAGMILive * DAG = createGenericSchedLive ( C ) ; 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> int barrier_align ( rtx_insn * barrier_or_label ) { rtx next , pat ; if ( ! barrier_or_label ) return 0 ; if ( LABEL_P ( barrier_or_label ) && NEXT_INSN ( barrier_or_label ) && JUMP_TABLE_DATA_P ( NEXT_INSN ( barrier_or_label ) ) ) return 2 ; if ( BARRIER_P ( barrier_or_label ) && PREV_INSN ( barrier_or_label ) && JUMP_TABLE_DATA_P ( PREV_INSN ( barrier_or_label ) ) ) { pat = PATTERN ( PREV_INSN ( barrier_or_label ) ) ; return ( ( optimize_size || ( ( unsigned ) XVECLEN ( pat , 1 ) * GET_MODE_SIZE ( GET_MODE ( pat ) ) <= ( unsigned ) 1 << ( CACHE_LOG - 2 ) ) ) ? 1 << TARGET_SHMEDIA : align_jumps_log ) ; } next = next_active_insn ( barrier_or_label ) ; if ( ! next ) return 0 ; pat = PATTERN ( next ) ; if ( GET_CODE ( pat ) == UNSPEC_VOLATILE && XINT ( pat , 1 ) == UNSPECV_ALIGN ) return 0 ; if ( optimize_size ) return 0 ; if ( ! TARGET_SH2 || ! optimize ) return align_jumps_log ; if ( mdep_reorg_phase > SH_FIXUP_PCLOAD ) { int slot , credit ; bool jump_to_next = false ; rtx_insn * prev = prev_real_insn ( prev_active_insn ( barrier_or_label ) ) ; for ( slot = 2 , credit = ( 1 << ( CACHE_LOG - 2 ) ) + 2 ; credit >= 0 && prev && NONJUMP_INSN_P ( prev ) ; prev = prev_real_insn ( prev ) ) { jump_to_next = false ; if ( GET_CODE ( PATTERN ( prev ) ) == USE || GET_CODE ( PATTERN ( prev ) ) == CLOBBER ) continue ; if ( rtx_sequence * prev_seq = dyn_cast < rtx_sequence * > ( PATTERN ( prev ) ) ) { prev = prev_seq -> insn ( 1 ) ; if ( INSN_UID ( prev ) == INSN_UID ( next ) ) { jump_to_next = true ; continue ; } } if ( slot && get_attr_in_delay_slot ( prev ) == IN_DELAY_SLOT_YES ) slot = 0 ; credit -= get_attr_length ( prev ) ; } if ( prev && jump_to_label_p ( prev ) ) { rtx_insn * x ; if ( jump_to_next || next_real_insn ( JUMP_LABEL ( prev ) ) == next || JUMP_LABEL ( prev ) == next_nonnote_insn ( next ) || ( x = ( NEXT_INSN ( NEXT_INSN ( PREV_INSN ( prev ) ) ) ) , ( INSN_P ( x ) && ( INSN_CODE ( x ) == CODE_FOR_block_branch_redirect || INSN_CODE ( x ) == CODE_FOR_indirect_jump_scratch || INSN_CODE ( x ) == CODE_FOR_stuff_delay_slot ) ) ) ) { rtx pat = PATTERN ( prev ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , 0 , 0 ) ; if ( credit - slot >= ( GET_CODE ( SET_SRC ( pat ) ) == PC ? 2 : 0 ) ) return 0 ; } } } return align_jumps_log ; } </s>

BARRIER_OR_LABEL is either a BARRIER or a CODE_LABEL immediately following a barrier . Return the base 2 logarithm of the desired alignment .


<s>
void
MCS51RegisterInfo
::
splitReg
(
Register
Reg
,
Register
&
LoReg
,
Register
&
HiReg
)
const
{
assert
(
MCS51
::
DREGSRegClass
.
contains
(
Reg
)
&&
"can only split 16-bit registers"
)
;
LoReg
=
getSubReg
(
Reg
,
MCS51
::
sub_lo
)
;
HiReg
=
getSubReg
(
Reg
,
MCS51
::
sub_hi
)
;
}
</s>

Splits a 16-bit DREGS register into the lo/hi register pair .


Keep track of some information about varargs for the prolog .


<s> unsigned ARMInstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { switch ( MI -> getOpcode ( ) ) { default : break ; case ARM :: LDR : if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isReg ( ) && MI -> getOperand ( 3 ) . isImm ( ) && MI -> getOperand ( 2 ) . getReg ( ) == 0 && MI -> getOperand ( 3 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: FLDD : case ARM :: FLDS : if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isImm ( ) && MI -> getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: tRestore : if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isImm ( ) && MI -> getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s> static section * avr_asm_function_rodata_section ( tree decl ) { unsigned int flags ; section * frodata ; { int fdata = flag_data_sections ; flag_data_sections = flag_function_sections ; frodata = default_function_rodata_section ( decl ) ; flag_data_sections = fdata ; flags = frodata -> common . flags ; } if ( frodata != readonly_data_section && flags & SECTION_NAMED ) { unsigned int i ; static const char * const prefix [ ] = { ".rodata" , ".progmem.gcc_sw_table" , ".gnu.linkonce.r." , ".gnu.linkonce.t." } ; for ( i = 0 ; i < sizeof ( prefix ) / sizeof ( * prefix ) ; i += 2 ) { const char * old_prefix = prefix [ i ] ; const char * new_prefix = prefix [ i + 1 ] ; const char * name = frodata -> named . name ; if ( STR_PREFIX_P ( name , old_prefix ) ) { const char * rname = ACONCAT ( ( new_prefix , name + strlen ( old_prefix ) , NULL ) ) ; flags &= ~ SECTION_CODE ; flags |= AVR_HAVE_JMP_CALL ? 0 : SECTION_CODE ; return get_section ( rname , flags , frodata -> named . decl ) ; } } } return progmem_swtable_section ; } </s>

Implement ` TARGET_ASM_FUNCTION_RODATA_SECTION ' .


<s> static rtx avr_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int bytes = avr_num_arg_regs ( mode , type ) ; if ( cum -> nregs && bytes <= cum -> nregs ) return gen_rtx_REG ( mode , cum -> regno - bytes ) ; return NULL_RTX ; } </s>

Controls whether a function argument is passed in a register , and which register .


<s> void AArch64PassConfig :: addPreLegalizeMachineIR ( ) { addPass ( createAArch64PreLegalizeCombiner ( ) ) ; } </s>

This method may be implemented by targets that want to run passes immediately before legalization .


<s> bool AMDGPUPromoteAllocaImpl :: run ( Function & F ) { Mod = F . getParent ( ) ; DL = & Mod -> getDataLayout ( ) ; const Triple & TT = TM . getTargetTriple ( ) ; IsAMDGCN = TT . getArch ( ) == Triple :: amdgcn ; IsAMDHSA = TT . getOS ( ) == Triple :: AMDHSA ; const AMDGPUSubtarget & ST = AMDGPUSubtarget :: get ( TM , F ) ; if ( ! ST . isPromoteAllocaEnabled ( ) ) return false ; if ( IsAMDGCN ) { const GCNSubtarget & ST = TM . getSubtarget < GCNSubtarget > ( F ) ; MaxVGPRs = ST . getMaxNumVGPRs ( ST . getWavesPerEU ( F ) . first ) ; } else { MaxVGPRs = 128 ; } bool SufficientLDS = hasSufficientLocalMem ( F ) ; bool Changed = false ; BasicBlock & EntryBB = * F . begin ( ) ; SmallVector < AllocaInst * , 16 > Allocas ; for ( Instruction & I : EntryBB ) { if ( AllocaInst * AI = dyn_cast < AllocaInst > ( & I ) ) Allocas . push_back ( AI ) ; } for ( AllocaInst * AI : Allocas ) { if ( handleAlloca ( * AI , SufficientLDS ) ) Changed = true ; } return Changed ; } </s>

Run the analysis pass over a function and produce a dominator tree .


runOnMachineFunction - Emit the function body .


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

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


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

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


<s> void WebAssemblyPassConfig :: addIRPasses ( ) { addPass ( new CoalesceFeaturesAndStripAtomics ( & getWebAssemblyTargetMachine ( ) ) ) ; addPass ( createAtomicExpandPass ( ) ) ; addPass ( createWebAssemblyAddMissingPrototypes ( ) ) ; addPass ( createWebAssemblyLowerGlobalDtors ( ) ) ; addPass ( createWebAssemblyFixFunctionBitcasts ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createWebAssemblyOptimizeReturned ( ) ) ; checkSanityForEHAndSjLj ( TM ) ; if ( ! WasmEnableEmEH && ! WasmEnableEH ) { addPass ( createLowerInvokePass ( ) ) ; addPass ( createUnreachableBlockEliminationPass ( ) ) ; } if ( WasmEnableEmEH || WasmEnableEmSjLj || WasmEnableSjLj ) addPass ( createWebAssemblyLowerEmscriptenEHSjLj ( ) ) ; addPass ( createIndirectBrExpandPass ( ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>

Add common target configurable passes that perform LLVM IR to IR transforms following machine independent optimization .

WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly WebAssembly


<s> static void nios2_init_libfuncs ( void ) { if ( TARGET_LINUX_ABI ) init_sync_libfuncs ( UNITS_PER_WORD ) ; } </s>


<s> bool mips_expand_block_move ( rtx dest , rtx src , rtx length ) { if ( ! ISA_HAS_LWL_LWR && ( MEM_ALIGN ( src ) < MIPS_MIN_MOVE_MEM_ALIGN || MEM_ALIGN ( dest ) < MIPS_MIN_MOVE_MEM_ALIGN ) ) return false ; if ( CONST_INT_P ( length ) ) { if ( INTVAL ( length ) <= MIPS_MAX_MOVE_BYTES_STRAIGHT ) { mips_block_move_straight ( dest , src , INTVAL ( length ) ) ; return true ; } else if ( optimize ) { mips_block_move_loop ( dest , src , INTVAL ( length ) , MIPS_MAX_MOVE_BYTES_PER_LOOP_ITER ) ; return true ; } } return false ; } </s>

Expand a movmemsi instruction , which copies LENGTH bytes from memory reference SRC to memory reference DEST .


<s> void loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , Register DestReg , int FrameIndex , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const override { loadRegFromStack ( MBB , MBBI , DestReg , FrameIndex , RC , TRI , 0 ) ; } </s>

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


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

getPassName - Return a nice clean name for a pass .


<s> bool prepare_move_operands ( rtx * operands , machine_mode mode ) { if ( 1 ) { if ( ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ 0 ] , Pmode ) ) operands [ 0 ] = arc_rewrite_small_data ( operands [ 0 ] ) ; else if ( mode == SImode && flag_pic && SYMBOLIC_CONST ( operands [ 1 ] ) ) { emit_pic_move ( operands , SImode ) ; } else if ( GET_CODE ( operands [ 0 ] ) != MEM && ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ 1 ] , Pmode ) ) { operands [ 1 ] = arc_rewrite_small_data ( operands [ 1 ] ) ; emit_insn ( gen_rtx_SET ( operands [ 0 ] , operands [ 1 ] ) ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , operands [ 1 ] ) ; emit_move_insn ( operands [ 0 ] , operands [ 0 ] ) ; return true ; } } if ( MEM_P ( operands [ 0 ] ) && ! ( reload_in_progress || reload_completed ) ) { operands [ 1 ] = force_reg ( mode , operands [ 1 ] ) ; if ( ! move_dest_operand ( operands [ 0 ] , mode ) ) { rtx addr = copy_to_mode_reg ( Pmode , XEXP ( operands [ 0 ] , 0 ) ) ; rtx pat = change_address ( operands [ 0 ] , mode , addr ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ 0 ] ) ; operands [ 0 ] = pat ; } if ( ! cse_not_expected ) { rtx pat = XEXP ( operands [ 0 ] , 0 ) ; pat = arc_legitimize_address_0 ( pat , pat , mode ) ; if ( pat ) { pat = change_address ( operands [ 0 ] , mode , pat ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ 0 ] ) ; operands [ 0 ] = pat ; } } } if ( MEM_P ( operands [ 1 ] ) && ! cse_not_expected ) { rtx pat = XEXP ( operands [ 1 ] , 0 ) ; pat = arc_legitimize_address_0 ( pat , pat , mode ) ; if ( pat ) { pat = change_address ( operands [ 1 ] , mode , pat ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ 1 ] ) ; operands [ 1 ] = pat ; } } return false ; } </s>

Prepare operands for a move define_expand in MODE .


<s> static rtx pdp11_function_arg ( cumulative_args_t cum ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED , const_tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { return NULL_RTX ; } </s>

Worker function for TARGET_FUNCTION_ARG . Determine where to put an argument to a function . Value is zero to push the argument on the stack , or a hard register in which to store the argument . MODE is the argument 's machine mode . TYPE is the data type of the argument ( as a tree ) . This is null for libcalls where that information may not be available . CUM is a variable of type CUMULATIVE_ARGS which gives info about the preceding args and about the function being called . NAMED is nonzero if this argument is a named parameter ( otherwise it is an extra parameter matching an ellipsis ) .


<s> std :: pair < unsigned , const TargetRegisterClass * > SITargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { const TargetRegisterClass * RC = nullptr ; if ( Constraint . size ( ) == 1 ) { const unsigned BitWidth = VT . getSizeInBits ( ) ; switch ( Constraint [ 0 ] ) { default : return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; case 's' : case 'r' : switch ( BitWidth ) { case 16 : RC = & AMDGPU :: SReg_32RegClass ; break ; case 64 : RC = & AMDGPU :: SGPR_64RegClass ; break ; default : RC = SIRegisterInfo :: getSGPRClassForBitWidth ( BitWidth ) ; if ( ! RC ) return std :: make_pair ( 0U , nullptr ) ; break ; } break ; case 'v' : switch ( BitWidth ) { case 16 : RC = & AMDGPU :: VGPR_32RegClass ; break ; default : RC = SIRegisterInfo :: getVGPRClassForBitWidth ( BitWidth ) ; if ( ! RC ) return std :: make_pair ( 0U , nullptr ) ; break ; } break ; case 'a' : if ( ! Subtarget -> hasMAIInsts ( ) ) break ; switch ( BitWidth ) { case 16 : RC = & AMDGPU :: AGPR_32RegClass ; break ; default : RC = SIRegisterInfo :: getAGPRClassForBitWidth ( BitWidth ) ; if ( ! RC ) return std :: make_pair ( 0U , nullptr ) ; break ; } break ; } if ( RC && ( isTypeLegal ( VT ) || VT . SimpleTy == MVT :: i128 || VT . SimpleTy == MVT :: i16 || VT . SimpleTy == MVT :: f16 ) ) return std :: make_pair ( 0U , RC ) ; } if ( Constraint . size ( ) > 1 ) { if ( Constraint [ 1 ] == 'v' ) { RC = & AMDGPU :: VGPR_32RegClass ; } else if ( Constraint [ 1 ] == 's' ) { RC = & AMDGPU :: SGPR_32RegClass ; } else if ( Constraint [ 1 ] == 'a' ) { RC = & AMDGPU :: AGPR_32RegClass ; } if ( RC ) { uint32_t Idx ; bool Failed = Constraint . substr ( 2 ) . getAsInteger ( 10 , Idx ) ; if ( ! Failed && Idx < RC -> getNumRegs ( ) ) return std :: make_pair ( RC -> getRegister ( Idx ) , RC ) ; } } return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> void RISCVInstrInfo :: buildOutlinedFrame ( MachineBasicBlock & MBB , MachineFunction & MF , const outliner :: OutlinedFunction & OF ) const { bool Changed = true ; while ( Changed ) { Changed = false ; auto I = MBB . begin ( ) ; auto E = MBB . end ( ) ; for ( ; I != E ; ++ I ) { if ( I -> isCFIInstruction ( ) ) { I -> removeFromParent ( ) ; Changed = true ; break ; } } } MBB . addLiveIn ( RISCV :: X5 ) ; MBB . insert ( MBB . end ( ) , BuildMI ( MF , DebugLoc ( ) , get ( RISCV :: JALR ) ) . addReg ( RISCV :: X0 , RegState :: Define ) . addReg ( RISCV :: X5 ) . addImm ( 0 ) ) ; } </s>

Insert a custom frame for outlined functions .


<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_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_PSBHint
:
OS
<<
getPSBHintName
(
)
;
break
;
case
k_Register
:
OS
<<
"<register "
<<
getReg
(
)
<<
">"
;
if
(
!
getShiftExtendAmount
(
)
&&
!
hasShiftExtendAmount
(
)
)
break
;
LLVM_FALLTHROUGH
;
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 "
">"
"<vectorlist "
0
" "
">"
"<vectorindex "
">"
"<sysreg: "
"'"
"'"
"c"
"<prfop "
">"
"<prfop invalid #"
">"
"<register "
">"
"<"
AArch64_AM::getShiftExtendName
" #"
"<imp>"


<s> bool X86ExpandPseudo :: runOnMachineFunction ( MachineFunction & MF ) { STI = & static_cast < const X86Subtarget & > ( MF . getSubtarget ( ) ) ; TII = STI -> getInstrInfo ( ) ; TRI = STI -> getRegisterInfo ( ) ; X86FI = MF . getInfo < X86MachineFunctionInfo > ( ) ; X86FL = STI -> getFrameLowering ( ) ; bool Modified = ExpandPseudosWhichAffectControlFlow ( MF ) ; for ( MachineBasicBlock & MBB : MF ) Modified |= ExpandMBB ( MBB ) ; return Modified ; } </s>


"Second offset should be larger than first offset!"

shouldScheduleLoadsNear - This is a used by the pre-regalloc scheduler to determine ( in conjunction with areLoadsFromSameBasePtr ) if two loads should be scheduled togther .


<s> void PPCLinuxAsmPrinter :: emitFunctionEntryLabel ( ) { if ( ! Subtarget -> isPPC64 ( ) && ( ! isPositionIndependent ( ) || MF -> getFunction ( ) . getParent ( ) -> getPICLevel ( ) == PICLevel :: SmallPIC ) ) return AsmPrinter :: emitFunctionEntryLabel ( ) ; if ( ! Subtarget -> isPPC64 ( ) ) { const PPCFunctionInfo * PPCFI = MF -> getInfo < PPCFunctionInfo > ( ) ; if ( PPCFI -> usesPICBase ( ) && ! Subtarget -> isSecurePlt ( ) ) { MCSymbol * RelocSymbol = PPCFI -> getPICOffsetSymbol ( ) ; MCSymbol * PICBase = MF -> getPICBaseSymbol ( ) ; OutStreamer -> emitLabel ( RelocSymbol ) ; const MCExpr * OffsExpr = MCBinaryExpr :: createSub ( MCSymbolRefExpr :: create ( OutContext . getOrCreateSymbol ( Twine ( ".LTOC" ) ) , OutContext ) , MCSymbolRefExpr :: create ( PICBase , OutContext ) , OutContext ) ; OutStreamer -> emitValue ( OffsExpr , 4 ) ; OutStreamer -> emitLabel ( CurrentFnSym ) ; return ; } else return AsmPrinter :: emitFunctionEntryLabel ( ) ; } if ( Subtarget -> isELFv2ABI ( ) ) { if ( TM . getCodeModel ( ) == CodeModel :: Large && ! MF -> getRegInfo ( ) . use_empty ( PPC :: X2 ) ) { const PPCFunctionInfo * PPCFI = MF -> getInfo < PPCFunctionInfo > ( ) ; MCSymbol * TOCSymbol = OutContext . getOrCreateSymbol ( StringRef ( ".TOC." ) ) ; MCSymbol * GlobalEPSymbol = PPCFI -> getGlobalEPSymbol ( ) ; const MCExpr * TOCDeltaExpr = MCBinaryExpr :: createSub ( MCSymbolRefExpr :: create ( TOCSymbol , OutContext ) , MCSymbolRefExpr :: create ( GlobalEPSymbol , OutContext ) , OutContext ) ; OutStreamer -> emitLabel ( PPCFI -> getTOCOffsetSymbol ( ) ) ; OutStreamer -> emitValue ( TOCDeltaExpr , 8 ) ; } return AsmPrinter :: emitFunctionEntryLabel ( ) ; } MCSectionSubPair Current = OutStreamer -> getCurrentSection ( ) ; MCSectionELF * Section = OutStreamer -> getContext ( ) . getELFSection ( ".opd" , ELF :: SHT_PROGBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ; OutStreamer -> SwitchSection ( Section ) ; OutStreamer -> emitLabel ( CurrentFnSym ) ; OutStreamer -> emitValueToAlignment ( 8 ) ; MCSymbol * Symbol1 = CurrentFnSymForSize ; OutStreamer -> emitValue ( MCSymbolRefExpr :: create ( Symbol1 , OutContext ) , 8 ) ; MCSymbol * Symbol2 = OutContext . getOrCreateSymbol ( StringRef ( ".TOC." ) ) ; OutStreamer -> emitValue ( MCSymbolRefExpr :: create ( Symbol2 , MCSymbolRefExpr :: VK_PPC_TOCBASE , OutContext ) , 8 ) ; OutStreamer -> emitIntValue ( 0 , 8 ) ; OutStreamer -> SwitchSection ( Current . first , Current . second ) ; } </s>

EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function .


<s> static int rs6000_hard_regno_nregs_internal ( int regno , machine_mode mode ) { unsigned HOST_WIDE_INT reg_size ; if ( FP_REGNO_P ( regno ) ) reg_size = ( VECTOR_MEM_VSX_P ( mode ) || FLOAT128_VECTOR_P ( mode ) ? UNITS_PER_VSX_WORD : UNITS_PER_FP_WORD ) ; else if ( SPE_SIMD_REGNO_P ( regno ) && TARGET_SPE && SPE_VECTOR_MODE ( mode ) ) reg_size = UNITS_PER_SPE_WORD ; else if ( ALTIVEC_REGNO_P ( regno ) ) reg_size = UNITS_PER_ALTIVEC_WORD ; else if ( TARGET_E500_DOUBLE && FLOAT_MODE_P ( mode ) && mode != SCmode && ! DECIMAL_FLOAT_MODE_P ( mode ) && SPE_SIMD_REGNO_P ( regno ) ) reg_size = UNITS_PER_FP_WORD ; else reg_size = UNITS_PER_WORD ; return ( GET_MODE_SIZE ( mode ) + reg_size - 1 ) / reg_size ; } </s>

Return number of consecutive hard regs needed starting at reg REGNO to hold something of mode MODE . This is ordinarily the length in words of a value of mode MODE but can be less for certain modes in special long registers . POWER and PowerPC GPRs hold 32 bits worth ; PowerPC64 GPRs and FPRs point register holds 64 bits worth .


<s> static bool aarch64_evpc_reencode ( struct expand_vec_perm_d * d ) { expand_vec_perm_d newd ; unsigned HOST_WIDE_INT nelt ; if ( d -> vec_flags != VEC_ADVSIMD ) return false ; poly_uint64 vec_bits = GET_MODE_BITSIZE ( d -> vmode ) ; unsigned int new_elt_bits = GET_MODE_UNIT_BITSIZE ( d -> vmode ) * 2 ; auto new_elt_mode = int_mode_for_size ( new_elt_bits , false ) . require ( ) ; machine_mode new_mode = aarch64_simd_container_mode ( new_elt_mode , vec_bits ) ; if ( new_mode == word_mode ) return false ; nelt = d -> perm . length ( ) . to_constant ( ) ; vec_perm_builder newpermconst ; newpermconst . new_vector ( nelt / 2 , nelt / 2 , 1 ) ; for ( unsigned int i = 0 ; i < nelt ; i += 2 ) { poly_int64 elt0 = d -> perm [ i ] ; poly_int64 elt1 = d -> perm [ i + 1 ] ; poly_int64 newelt ; if ( ! multiple_p ( elt0 , 2 , & newelt ) || maybe_ne ( elt0 + 1 , elt1 ) ) return false ; newpermconst . quick_push ( newelt . to_constant ( ) ) ; } newpermconst . finalize ( ) ; newd . vmode = new_mode ; newd . vec_flags = VEC_ADVSIMD ; newd . target = d -> target ? gen_lowpart ( new_mode , d -> target ) : NULL ; newd . op0 = d -> op0 ? gen_lowpart ( new_mode , d -> op0 ) : NULL ; newd . op1 = d -> op1 ? gen_lowpart ( new_mode , d -> op1 ) : NULL ; newd . testing_p = d -> testing_p ; newd . one_vector_p = d -> one_vector_p ; newd . perm . new_vector ( newpermconst , newd . one_vector_p ? 1 : 2 , nelt / 2 ) ; return aarch64_expand_vec_perm_const_1 ( & newd ) ; } </s>

Try to re-encode the PERM constant so it combines odd and even elements . This rewrites constants such as { 0 , 1 , 4 , 5 } /V4SF to { 0 , 2 } /V2DI . We retry with this new constant with the full suite of patterns .


<s> static int riscv_address_cost ( rtx addr , enum machine_mode mode , addr_space_t as ATTRIBUTE_UNUSED , bool speed ATTRIBUTE_UNUSED ) { return riscv_address_insns ( addr , mode , false ) ; } </s>


<s>
bool
FixupBWInstPass
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
if
(
!
FixupBWInsts
||
skipFunction
(
MF
.
getFunction
(
)
)
)
return
false
;
this
->
MF
=
&
MF
;
TII
=
MF
.
getSubtarget
<
X86Subtarget
>
(
)
.
getInstrInfo
(
)
;
TRI
=
MF
.
getRegInfo
(
)
.
getTargetRegisterInfo
(
)
;
MLI
=
&
getAnalysis
<
MachineLoopInfo
>
(
)
;
PSI
=
&
getAnalysis
<
ProfileSummaryInfoWrapperPass
>
(
)
.
getPSI
(
)
;
MBFI
=
(
PSI
&&
PSI
->
hasProfileSummary
(
)
)
&
getAnalysis
<
LazyMachineBlockFrequencyInfoPass
>
(
)
.
getBFI
(
)
:
nullptr
;
LiveRegs
.
init
(
TII
->
getRegisterInfo
(
)
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"Start X86FixupBWInsts\n"
;
)
;
for
(
auto
&
MBB
:
MF
)
processBasicBlock
(
MF
,
MBB
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"End X86FixupBWInsts\n"
;
)
;
return
true
;
}
</s>


<s> const RegisterBankInfo :: InstructionMapping & MipsRegisterBankInfo :: getInstrMapping ( const MachineInstr & MI ) const { unsigned Opc = MI . getOpcode ( ) ; const RegisterBankInfo :: InstructionMapping & Mapping = getInstrMappingImpl ( MI ) ; if ( Mapping . isValid ( ) ) return Mapping ; using namespace TargetOpcode ; unsigned NumOperands = MI . getNumOperands ( ) ; const ValueMapping * OperandsMapping = & Mips :: ValueMappings [ Mips :: GPRIdx ] ; switch ( Opc ) { case G_ADD : case G_LOAD : case G_STORE : case G_GEP : case G_AND : case G_OR : case G_XOR : case G_SHL : case G_ASHR : case G_LSHR : case G_SDIV : case G_UDIV : case G_SREM : case G_UREM : OperandsMapping = & Mips :: ValueMappings [ Mips :: GPRIdx ] ; break ; case G_CONSTANT : case G_FRAME_INDEX : case G_GLOBAL_VALUE : OperandsMapping = getOperandsMapping ( { & Mips :: ValueMappings [ Mips :: GPRIdx ] , nullptr } ) ; break ; case G_ICMP : OperandsMapping = getOperandsMapping ( { & Mips :: ValueMappings [ Mips :: GPRIdx ] , nullptr , & Mips :: ValueMappings [ Mips :: GPRIdx ] , & Mips :: ValueMappings [ Mips :: GPRIdx ] } ) ; break ; case G_SELECT : OperandsMapping = getOperandsMapping ( { & Mips :: ValueMappings [ Mips :: GPRIdx ] , & Mips :: ValueMappings [ Mips :: GPRIdx ] , & Mips :: ValueMappings [ Mips :: GPRIdx ] , & Mips :: ValueMappings [ Mips :: GPRIdx ] } ) ; break ; default : return getInvalidInstructionMapping ( ) ; } return getInstructionMapping ( DefaultMappingID , 1 , OperandsMapping , NumOperands ) ; } </s>

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

Mips Mips Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx Mips::ValueMappings Mips::GPRIdx 1


<s> bool X86AsmBackend :: writeNopData ( uint64_t Count , MCObjectWriter * OW ) const { static const uint8_t Nops [ 10 ] [ 10 ] = { { 0x90 } , { 0x66 , 0x90 } , { 0x0f , 0x1f , 0x00 } , { 0x0f , 0x1f , 0x40 , 0x00 } , { 0x0f , 0x1f , 0x44 , 0x00 , 0x00 } , { 0x66 , 0x0f , 0x1f , 0x44 , 0x00 , 0x00 } , { 0x0f , 0x1f , 0x80 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x0f , 0x1f , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x66 , 0x0f , 0x1f , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 } , { 0x66 , 0x2e , 0x0f , 0x1f , 0x84 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 } , } ; const uint64_t OptimalCount = ( Count < 16 ) ? Count : 15 ; const uint64_t Prefixes = OptimalCount <= 10 ? 0 : OptimalCount - 10 ; for ( uint64_t i = 0 , e = Prefixes ; i != e ; i ++ ) OW -> Write8 ( 0x66 ) ; const uint64_t Rest = OptimalCount - Prefixes ; for ( uint64_t i = 0 , e = Rest ; i != e ; i ++ ) OW -> Write8 ( Nops [ Rest - 1 ] [ i ] ) ; for ( uint64_t i = OptimalCount , e = Count ; i != e ; ++ i ) OW -> Write8 ( 0x90 ) ; return true ; } </s>

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


<s> rtx spu_float_const ( const char * string , machine_mode mode ) { REAL_VALUE_TYPE value ; value = REAL_VALUE_ATOF ( string , mode ) ; return const_double_from_real_value ( value , mode ) ; } </s>


<s> static int arm_compute_static_chain_stack_bytes ( void ) { if ( IS_NESTED ( arm_current_func_type ( ) ) && ( ( TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM ) || ( flag_stack_check == STATIC_BUILTIN_STACK_CHECK && ! df_regs_ever_live_p ( LR_REGNUM ) ) ) && arm_r3_live_at_start_p ( ) && crtl -> args . pretend_args_size == 0 ) return 4 ; return 0 ; } </s>

Compute the number of bytes used to store the static chain register on the stack , above the stack frame . We need to know this accurately to get the alignment of the rest of the stack frame correct .


<s> int direct_return ( void ) { return ( reload_completed && xstormy16_compute_stack_layout ( ) . frame_size == 0 && ! xstormy16_interrupt_function_p ( ) ) ; } </s>

Return non-zero if this function is known to have a null epilogue .


"  not dead because the phi node has a user that is not MI\n"

isDead - Returns true if this is a dead def kill slot .


<s> bool TeakRegisterInfo :: requiresFrameIndexScavenging ( const MachineFunction & MF ) const { return false ; } </s>

Returns true if the target requires post PEI scavenging of registers for materializing frame index constants .


<s> void ARMPassConfig :: addPreEmitPass ( ) { addPass ( createThumb2SizeReductionPass ( ) ) ; if ( getARMSubtarget ( ) . isThumb2 ( ) ) addPass ( & UnpackMachineBundlesID ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createARMOptimizeBarriersPass ( ) ) ; addPass ( createARMConstantIslandPass ( ) ) ; } </s>

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


<s> virtual const InstrItineraryData getInstrItineraryData ( ) const { return InstrItins ; } </s>

getInstrItineraryData - Returns instruction itinerary data for the target or specific subtarget .


<s> void RISCVPassConfig :: addIRPasses ( ) { addPass ( createAtomicExpandPass ( ) ) ; TargetPassConfig :: addIRPasses ( ) ; } </s>

Add common target configurable passes that perform LLVM IR to IR transforms following machine independent optimization .


" is allocatable: function has no frame pointer"

Return the register ID of the name passed in .


<s> void LanaiTargetLowering :: LowerAsmOperandForConstraint ( SDValue Op , std :: string & Constraint , std :: vector < SDValue > & Ops , SelectionDAG & DAG ) const { SDValue Result ; if ( Constraint . length ( ) > 1 ) return ; char ConstraintLetter = Constraint [ 0 ] ; switch ( ConstraintLetter ) { case 'I' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( isInt < 16 > ( C -> getSExtValue ( ) ) ) { Result = DAG . getTargetConstant ( C -> getSExtValue ( ) , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'J' : case 'O' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( C -> getZExtValue ( ) == 0 ) { Result = DAG . getTargetConstant ( 0 , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'K' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( isUInt < 16 > ( C -> getZExtValue ( ) ) ) { Result = DAG . getTargetConstant ( C -> getSExtValue ( ) , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'L' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { if ( C -> getZExtValue ( ) <= 31 ) { Result = DAG . getTargetConstant ( C -> getZExtValue ( ) , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'M' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { int64_t Val = C -> getSExtValue ( ) ; if ( ( isInt < 32 > ( Val ) ) && ( ( Val & 0xffff ) == 0 ) ) { Result = DAG . getTargetConstant ( Val , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; case 'N' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { int64_t Val = C -> getSExtValue ( ) ; if ( ( Val >= - 33554432 ) && ( Val <= 33554431 ) ) { Result = DAG . getTargetConstant ( Val , SDLoc ( C ) , Op . getValueType ( ) ) ; break ; } } return ; default : break ; } if ( Result . getNode ( ) ) { Ops . push_back ( Result ) ; return ; } TargetLowering :: LowerAsmOperandForConstraint ( Op , Constraint , Ops , DAG ) ; } </s>

Lower the specified operand into the Ops vector .


<s> const InstrItineraryData * getInstrItineraryData ( ) const override { return & InstrItins ; } </s>


<s> bool CopyPropagation :: processBlock ( MachineBasicBlock & B , const RegisterSet & ) { std :: vector < MachineInstr * > Instrs ; for ( MachineInstr & MI : llvm :: reverse ( B ) ) Instrs . push_back ( & MI ) ; bool Changed = false ; for ( auto I : Instrs ) { unsigned Opc = I -> getOpcode ( ) ; if ( ! CopyPropagation :: isCopyReg ( Opc , true ) ) continue ; Changed |= propagateRegCopy ( * I ) ; } return Changed ; } </s>

processBlock - If there are any predecessors whose control can be threaded through to a successor , transform them now .


<s>
bool
SystemZInstrInfo
::
verifyInstruction
(
const
MachineInstr
&
MI
,
StringRef
&
ErrInfo
)
const
{
const
MCInstrDesc
&
MCID
=
MI
.
getDesc
(
)
;
for
(
unsigned
I
=
0
,
E
=
MI
.
getNumOperands
(
)
;
I
!=
E
;
++
I
)
{
if
(
I
>=
MCID
.
getNumOperands
(
)
)
break
;
const
MachineOperand
&
Op
=
MI
.
getOperand
(
I
)
;
const
MCOperandInfo
&
MCOI
=
MCID
.
OpInfo
[
I
]
;
if
(
MCOI
.
OperandType
==
MCOI
::
OPERAND_MEMORY
&&
(
(
MCOI
.
RegClass
!=
1
&&
!
Op
.
isReg
(
)
&&
!
Op
.
isFI
(
)
)
||
(
MCOI
.
RegClass
==
1
&&
!
Op
.
isImm
(
)
)
)
)
{
ErrInfo
=
"Addressing mode operands corrupt!"
;
return
false
;
}
}
return
true
;
}
</s>

Perform target-specific instruction verification .


<s>
bool
Z80AsmPrinter
::
doInitialization
(
Module
&
M
)
{
OutStreamer
.
setAutoInitSections
(
false
)
;
SmallString
<
128
>
Str1
;
raw_svector_ostream
OS1
(
Str1
)
;
MMI
=
getAnalysisIfAvailable
<
MachineModuleInfo
>
(
)
;
MMI
->
AnalyzeModule
(
M
)
;
const_cast
<
TargetLoweringObjectFile
&
>
(
getObjFileLowering
(
)
)
.
Initialize
(
OutContext
,
TM
)
;
Mang
=
new
Mangler
(
&
TM
)
;
emitHeader
(
M
,
OS1
)
;
OutStreamer
.
EmitRawText
(
OS1
.
str
(
)
)
;
if
(
!
M
.
getModuleInlineAsm
(
)
.
empty
(
)
)
{
OutStreamer
.
AddComment
(
"Start of file scope inline assembly"
)
;
OutStreamer
.
AddBlankLine
(
)
;
OutStreamer
.
EmitRawText
(
StringRef
(
M
.
getModuleInlineAsm
(
)
)
)
;
OutStreamer
.
AddBlankLine
(
)
;
OutStreamer
.
AddComment
(
"End of file scope inline assembly"
)
;
OutStreamer
.
AddBlankLine
(
)
;
}
return
false
;
}
</s>

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


<s> auto HexagonVectorCombine :: getNullValue ( Type * Ty ) const -> Constant * { assert ( Ty -> isIntOrIntVectorTy ( ) ) ; auto Zero = ConstantInt :: get ( Ty -> getScalarType ( ) , 0 ) ; if ( auto * VecTy = dyn_cast < VectorType > ( Ty ) ) return ConstantVector :: getSplat ( VecTy -> getElementCount ( ) , Zero ) ; return Zero ; } </s>

Constructor to create a ' 0 ' constant of arbitrary type .


<s> rtx mn10300_legitimize_pic_address ( rtx orig , rtx reg ) { rtx x ; rtx_insn * insn ; if ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && ( CONSTANT_POOL_ADDRESS_P ( orig ) || ! MN10300_GLOBAL_P ( orig ) ) ) ) { if ( reg == NULL ) reg = gen_reg_rtx ( Pmode ) ; x = gen_rtx_UNSPEC ( SImode , gen_rtvec ( 1 , orig ) , UNSPEC_GOTOFF ) ; x = gen_rtx_CONST ( SImode , x ) ; emit_move_insn ( reg , x ) ; insn = emit_insn ( gen_addsi3 ( reg , reg , pic_offset_table_rtx ) ) ; } else if ( GET_CODE ( orig ) == SYMBOL_REF ) { if ( reg == NULL ) reg = gen_reg_rtx ( Pmode ) ; x = gen_rtx_UNSPEC ( SImode , gen_rtvec ( 1 , orig ) , UNSPEC_GOT ) ; x = gen_rtx_CONST ( SImode , x ) ; x = gen_rtx_PLUS ( SImode , pic_offset_table_rtx , x ) ; x = gen_const_mem ( SImode , x ) ; insn = emit_move_insn ( reg , x ) ; } else return orig ; set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ; } </s>

Convert a non-PIC address in ` orig ' to a PIC address using @ GOT or @ GOTOFF in ` reg ' .


<s> void mips_emit_save_slot_move ( rtx dest , rtx src , rtx temp ) { unsigned int regno ; rtx mem ; if ( REG_P ( src ) ) { regno = REGNO ( src ) ; mem = dest ; } else { regno = REGNO ( dest ) ; mem = src ; } if ( regno == cfun -> machine -> global_pointer && ! mips_must_initialize_gp_p ( ) ) { if ( TARGET_64BIT ) emit_insn ( gen_move_gpdi ( dest , src ) ) ; else emit_insn ( gen_move_gpsi ( dest , src ) ) ; return ; } if ( regno == HI_REGNUM ) { if ( REG_P ( dest ) ) { mips_emit_move ( temp , src ) ; if ( TARGET_64BIT ) emit_insn ( gen_mthidi_ti ( gen_rtx_REG ( TImode , MD_REG_FIRST ) , temp , gen_rtx_REG ( DImode , LO_REGNUM ) ) ) ; else emit_insn ( gen_mthisi_di ( gen_rtx_REG ( DImode , MD_REG_FIRST ) , temp , gen_rtx_REG ( SImode , LO_REGNUM ) ) ) ; } else { if ( TARGET_64BIT ) emit_insn ( gen_mfhidi_ti ( temp , gen_rtx_REG ( TImode , MD_REG_FIRST ) ) ) ; else emit_insn ( gen_mfhisi_di ( temp , gen_rtx_REG ( DImode , MD_REG_FIRST ) ) ) ; mips_emit_move ( dest , temp ) ; } } else if ( mips_direct_save_slot_move_p ( regno , mem , mem == src ) ) mips_emit_move ( dest , src ) ; else { gcc_assert ( ! reg_overlap_mentioned_p ( dest , temp ) ) ; mips_emit_move ( temp , src ) ; mips_emit_move ( dest , temp ) ; } if ( MEM_P ( dest ) ) mips_set_frame_expr ( mips_frame_set ( dest , src ) ) ; } </s>

Emit a move from SRC to DEST , given that one of them is a register save slot and that the other is a register . TEMP is a temporary GPR of the same mode that is available if need be .


<s>
Printable
print
(
)
const
{
return
Printable
(
[
this
]
(
raw_ostream
&
OS
)
{
OS
<<
"Value: "
<<
*
V
<<
'\n'
<<
"Base: "
<<
*
Base
<<
" Offset: "
<<
Offset
<<
'\n'
;
}
)
;
}
</s>

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


<s> SDNode * MipsDAGToDAGISel :: getGlobalBaseReg ( ) { Register GlobalBaseReg = MF -> getInfo < MipsFunctionInfo > ( ) -> getGlobalBaseReg ( ) ; return CurDAG -> getRegister ( GlobalBaseReg , getTargetLowering ( ) -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) . getNode ( ) ; } </s>

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


<s> void X86PassConfig :: addPreEmitPass ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( createExecutionDependencyFixPass ( & X86 :: VR128RegClass ) ) ; if ( UseVZeroUpper ) addPass ( createX86IssueVZeroUpperPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86FixupBWInsts ( ) ) ; addPass ( createX86PadShortFunctions ( ) ) ; addPass ( createX86FixupLEAs ( ) ) ; } } </s>


<s> void Z80oldAsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { Z80oldMCInstLower MCInstLowering ( * MF , * this ) ; MCInst TmpInst ; MCInstLowering . Lower ( MI , TmpInst ) ; EmitToStreamer ( * OutStreamer , TmpInst ) ; } </s>

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


"  Copied r%d to a scalar register r%d for insn %d\n"

Convert all definitions of register REGNO and fix its uses . Scalar copies may be created in case register is used in not convertible insn .


<s> bool NVPTXAsmPrinter :: doInitialization ( Module & M ) { SmallString < 128 > Str1 ; raw_svector_ostream OS1 ( Str1 ) ; MMI = getAnalysisIfAvailable < MachineModuleInfo > ( ) ; MMI -> AnalyzeModule ( M ) ; const_cast < TargetLoweringObjectFile & > ( getObjFileLowering ( ) ) . Initialize ( OutContext , TM ) ; Mang = new Mangler ( OutContext , * TM . getDataLayout ( ) ) ; emitHeader ( M , OS1 ) ; OutStreamer . EmitRawText ( OS1 . str ( ) ) ; if ( nvptxSubtarget . getDrvInterface ( ) == NVPTX :: CUDA ) recordAndEmitFilenames ( M ) ; SmallString < 128 > Str2 ; raw_svector_ostream OS2 ( Str2 ) ; emitDeclarations ( M , OS2 ) ; for ( Module :: global_iterator I = M . global_begin ( ) , E = M . global_end ( ) ; I != E ; ++ I ) printModuleLevelGV ( I , OS2 ) ; OS2 << '\n' ; OutStreamer . EmitRawText ( OS2 . str ( ) ) ; return false ; } </s>


<s> static bool classof ( const ARM64MCExpr * ) { return true ; } </s>

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


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

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


<s>
bool
RISCVAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
{
if
(
getSTI
(
)
.
getFeatureBits
(
)
[
RISCV
::
FeatureRelax
]
)
{
auto
*
Assembler
=
getTargetStreamer
(
)
.
getStreamer
(
)
.
getAssemblerPtr
(
)
;
if
(
Assembler
!=
nullptr
)
{
RISCVAsmBackend
&
MAB
=
static_cast
<
RISCVAsmBackend
&
>
(
Assembler
->
getBackend
(
)
)
;
MAB
.
setForceRelocs
(
)
;
}
}
Operands
.
push_back
(
RISCVOperand
::
createToken
(
Name
,
NameLoc
,
isRV64
(
)
)
)
;
if
(
getLexer
(
)
.
is
(
AsmToken
::
EndOfStatement
)
)
{
getParser
(
)
.
Lex
(
)
;
return
false
;
}
if
(
parseOperand
(
Operands
,
Name
)
)
return
true
;
while
(
getLexer
(
)
.
is
(
AsmToken
::
Comma
)
)
{
getLexer
(
)
.
Lex
(
)
;
if
(
parseOperand
(
Operands
,
Name
)
)
return
true
;
}
if
(
getLexer
(
)
.
isNot
(
AsmToken
::
EndOfStatement
)
)
{
SMLoc
Loc
=
getLexer
(
)
.
getLoc
(
)
;
getParser
(
)
.
eatToEndOfStatement
(
)
;
return
Error
(
Loc
,
"unexpected token"
)
;
}
getParser
(
)
.
Lex
(
)
;
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .

RISCV
RISCV
RISCV::FeatureRelax
RISCV
RISCV
RISCV
"unexpected token"


"No offset range is defined for this opcode. "

"Please define it in the above switch statement!"


"********** ARM MVE VPT Optimisations **********\n"

runOnMachineFunction - Emit the function body .


<s>
void
MFMAIGroupLPDAGMutation
::
apply
(
ScheduleDAGInstrs
*
DAGInstrs
)
{
const
GCNSubtarget
&
ST
=
DAGInstrs
->
MF
.
getSubtarget
<
GCNSubtarget
>
(
)
;
TII
=
ST
.
getInstrInfo
(
)
;
if
(
!
ST
.
hasMAIInsts
(
)
)
return
;
DAG
=
static_cast
<
ScheduleDAGMI
*
>
(
DAGInstrs
)
;
const
TargetSchedModel
*
TSchedModel
=
DAGInstrs
->
getSchedModel
(
)
;
if
(
!
TSchedModel
||
DAG
->
SUnits
.
empty
(
)
)
return
;
const
IsInstructionType
isMFMAFn
=
[
this
]
(
const
MachineInstr
&
MI
)
{
if
(
TII
->
isMAI
(
MI
)
&&
MI
.
getOpcode
(
)
!=
AMDGPU
::
V_ACCVGPR_WRITE_B32_e64
&&
MI
.
getOpcode
(
)
!=
AMDGPU
::
V_ACCVGPR_READ_B32_e64
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"Found MFMA\n"
;
)
;
return
true
;
}
return
false
;
}
;
InstructionClass
MFMASUnits
(
isMFMAFn
,
MFMAGroupMaxSize
)
;
const
IsInstructionType
isVMEMReadFn
=
[
this
]
(
const
MachineInstr
&
MI
)
{
if
(
(
(
TII
->
isFLAT
(
MI
)
&&
!
TII
->
isDS
(
MI
)
)
||
TII
->
isVMEM
(
MI
)
)
&&
MI
.
mayLoad
(
)
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"Found VMEM read\n"
;
)
;
return
true
;
}
return
false
;
}
;
InstructionClass
VMEMReadSUnits
(
isVMEMReadFn
,
VMEMGroupMaxSize
)
;
const
IsInstructionType
isDSWriteFn
=
[
this
]
(
const
MachineInstr
&
MI
)
{
if
(
TII
->
isDS
(
MI
)
&&
MI
.
mayStore
(
)
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"Found DS Write\n"
;
)
;
return
true
;
}
return
false
;
}
;
InstructionClass
DSWriteSUnits
(
isDSWriteFn
,
LDWGroupMaxSize
)
;
const
IsInstructionType
isDSReadFn
=
[
this
]
(
const
MachineInstr
&
MI
)
{
if
(
TII
->
isDS
(
MI
)
&&
MI
.
mayLoad
(
)
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"Found DS Read\n"
;
)
;
return
true
;
}
return
false
;
}
;
InstructionClass
DSReadSUnits
(
isDSReadFn
,
LDRGroupMaxSize
)
;
SmallVector
<
InstructionClass
*
,
4
>
PipelineOrder
=
{
&
VMEMReadSUnits
,
&
DSReadSUnits
,
&
MFMASUnits
,
&
DSWriteSUnits
}
;
collectSUnits
(
PipelineOrder
,
TII
,
DAG
)
;
addPipelineEdges
(
PipelineOrder
,
DAG
)
;
}
</s>

Apply the profile inference algorithm for a given function .


<s> static int h8300_ldm_stm_regno ( rtx x , int load_p , int index , int nregs ) { int regindex , memindex , offset ; if ( load_p ) regindex = 0 , memindex = 1 , offset = ( nregs - index - 1 ) * 4 ; else memindex = 0 , regindex = 1 , offset = ( index + 1 ) * - 4 ; if ( GET_CODE ( x ) == SET && GET_CODE ( XEXP ( x , regindex ) ) == REG && GET_CODE ( XEXP ( x , memindex ) ) == MEM && h8300_stack_offset_p ( XEXP ( XEXP ( x , memindex ) , 0 ) , offset ) ) return REGNO ( XEXP ( x , regindex ) ) ; return - 1 ; } </s>

A subroutine of h8300_ldm_stm_parallel . X is one pattern in something that may be an ldm or stm instruction . If it fits the required template , return the register it loads or stores , otherwise return -1 . LOAD_P is true if X should be a load , false if it should be a store . NREGS is the number of registers that the whole instruction is expected to load or store . INDEX is the index of the register that X should load or store , relative to the lowest-numbered register .


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"X86 Atom LEA Fixup"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> void rs6000_emit_sISEL ( machine_mode mode ATTRIBUTE_UNUSED , rtx operands [ ] ) { rs6000_emit_int_cmove ( operands [ 0 ] , operands [ 1 ] , const1_rtx , const0_rtx ) ; } </s>


"local variable memory requirements exceed capacity"

Called after register allocation to add any instructions needed for the prologue . Using a prologue insn is favored compared to putting all of the instructions in the TARGET_ASM_FUNCTION_PROLOGUE macro , since it allows the scheduler to intermix instructions with the saves of the caller saved registers . In some cases , it might be necessary to emit a barrier instruction as the last insn to prevent such scheduling . Also any insns generated here should have RTX_FRAME_RELATED_P ( insn ) = 1 so that the debug info generation code can handle them properly .


<s> static tree tilegx_gimplify_va_arg_expr ( tree valist , tree type , gimple_seq * pre_p , gimple_seq * post_p ATTRIBUTE_UNUSED ) { tree f_args , f_skip ; tree args , skip ; HOST_WIDE_INT size , rsize ; tree addr , tmp ; bool pass_by_reference_p ; f_args = TYPE_FIELDS ( va_list_type_node ) ; f_skip = TREE_CHAIN ( f_args ) ; args = build3 ( COMPONENT_REF , TREE_TYPE ( f_args ) , valist , f_args , NULL_TREE ) ; skip = build3 ( COMPONENT_REF , TREE_TYPE ( f_skip ) , valist , f_skip , NULL_TREE ) ; addr = create_tmp_var ( ptr_type_node , "va_arg" ) ; pass_by_reference_p = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( pass_by_reference_p ) type = build_pointer_type ( type ) ; size = int_size_in_bytes ( type ) ; rsize = ( ( size + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ) * UNITS_PER_WORD ; if ( TYPE_ALIGN ( type ) > PARM_BOUNDARY ) { gcc_assert ( STACK_BOUNDARY == PARM_BOUNDARY * 2 ) ; tmp = build2 ( BIT_AND_EXPR , sizetype , fold_convert ( sizetype , unshare_expr ( args ) ) , size_int ( PARM_BOUNDARY / 8 ) ) ; tmp = build2 ( POINTER_PLUS_EXPR , ptr_type_node , unshare_expr ( args ) , tmp ) ; gimplify_assign ( unshare_expr ( args ) , tmp , pre_p ) ; } tmp = fold_build_pointer_plus_hwi ( unshare_expr ( args ) , rsize ) ; tmp = build2 ( TRUTH_AND_EXPR , boolean_type_node , build2 ( GT_EXPR , boolean_type_node , tmp , unshare_expr ( skip ) ) , build2 ( LE_EXPR , boolean_type_node , unshare_expr ( args ) , unshare_expr ( skip ) ) ) ; tmp = build3 ( COND_EXPR , ptr_type_node , tmp , build2 ( POINTER_PLUS_EXPR , ptr_type_node , unshare_expr ( skip ) , size_int ( STACK_POINTER_OFFSET ) ) , unshare_expr ( args ) ) ; if ( BYTES_BIG_ENDIAN && rsize > size ) tmp = fold_build_pointer_plus_hwi ( tmp , rsize - size ) ; gimplify_assign ( addr , tmp , pre_p ) ; if ( BYTES_BIG_ENDIAN && rsize > size ) tmp = fold_build_pointer_plus_hwi ( addr , size ) ; else tmp = fold_build_pointer_plus_hwi ( addr , rsize ) ; gimplify_assign ( unshare_expr ( args ) , tmp , pre_p ) ; addr = fold_convert ( build_pointer_type ( type ) , addr ) ; if ( pass_by_reference_p ) addr = build_va_arg_indirect_ref ( addr ) ; return build_va_arg_indirect_ref ( addr ) ; } </s>

Implement TARGET_GIMPLIFY_VA_ARG_EXPR . Gimplify va_arg by updating the va_list structure VALIST as required to retrieve an argument of type TYPE , and returning that argument . ret = va_arg ( VALIST , TYPE ) ; generates code equivalent to : paddedsize = ( sizeof ( TYPE ) + 7 ) & -8 ; if ( ( VALIST.__args + paddedsize > VALIST.__skip ) & ( VALIST.__args < = VALIST.__skip ) ) addr = VALIST.__skip + STACK_POINTER_OFFSET ; else addr = VALIST.__args ; VALIST.__args = addr + paddedsize ; if ( BYTES_BIG_ENDIAN ) ret = * ( TYPE * ) ( addr + paddedsize - sizeof ( TYPE ) ) ; else ret = * ( TYPE * ) addr ;


<s> bool AArch64FrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const TargetRegisterInfo * RegInfo = MF . getSubtarget ( ) . getRegisterInfo ( ) ; return ( MFI . hasCalls ( ) && MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) ) || MFI . hasVarSizedObjects ( ) || MFI . isFrameAddressTaken ( ) || MFI . hasStackMap ( ) || MFI . hasPatchPoint ( ) || RegInfo -> needsStackRealignment ( MF ) ; } </s>

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


<s> void AArch64TargetLowering :: insertSSPDeclarations ( Module & M ) const { if ( Subtarget -> getTargetTriple ( ) . isWindowsMSVCEnvironment ( ) ) { M . getOrInsertGlobal ( "__security_cookie" , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ; auto * SecurityCheckCookie = cast < Function > ( M . getOrInsertFunction ( "__security_check_cookie" , Type :: getVoidTy ( M . getContext ( ) ) , Type :: getInt8PtrTy ( M . getContext ( ) ) ) ) ; SecurityCheckCookie -> setCallingConv ( CallingConv :: Win64 ) ; SecurityCheckCookie -> addAttribute ( 1 , Attribute :: AttrKind :: InReg ) ; return ; } TargetLowering :: insertSSPDeclarations ( M ) ; } </s>

Inserts necessary declarations for SSP ( stack protection ) purpose .


";; sched_reorder for cycle %d with %d insns in ready list\n"

";; sched_reorder nothing to reorder as no younger\n"

";; sched_reorder nothing to reorder as no older_only\n"

";; cortexa7_sched_reorder insn %d before %d\n"

Look for an instruction that can dual issue only as an older instruction , and move it in front of any instructions that can dual-issue as younger , while preserving the relative order of all other instructions in the ready list . This is a hueuristic to help dual-issue in later cycles , by postponing issue of more flexible instructions . This heuristic may affect dual issue opportunities in the current cycle .


<s> static const char * rs6000_mangle_type ( const_tree type ) { type = TYPE_MAIN_VARIANT ( type ) ; if ( TREE_CODE ( type ) != VOID_TYPE && TREE_CODE ( type ) != BOOLEAN_TYPE && TREE_CODE ( type ) != INTEGER_TYPE && TREE_CODE ( type ) != REAL_TYPE ) return NULL ; if ( type == bool_char_type_node ) return "U6__boolc" ; if ( type == bool_short_type_node ) return "U6__bools" ; if ( type == pixel_type_node ) return "u7__pixel" ; if ( type == bool_int_type_node ) return "U6__booli" ; if ( type == bool_long_type_node ) return "U6__booll" ; if ( TARGET_FLOAT128_TYPE ) { if ( type == ieee128_float_type_node ) return "U10__float128" ; if ( type == ibm128_float_type_node ) return "g" ; if ( type == long_double_type_node && TARGET_LONG_DOUBLE_128 ) return ( TARGET_IEEEQUAD ) ? "U10__float128" : "g" ; } if ( TYPE_MAIN_VARIANT ( type ) == long_double_type_node && TARGET_ELF && TARGET_LONG_DOUBLE_128 && ! TARGET_IEEEQUAD ) return "g" ; return NULL ; } </s>

AltiVec defines five built-in scalar types that serve as vector elements ; we must teach the compiler how to mangle them . The 128-bit floating point mangling is target-specific as well . MMA defines two built-in types to be used as opaque vector types .


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


<s> static void rs6000_emit_stack_tie ( rtx fp , bool hard_frame_needed ) { rtvec p ; int i ; rtx regs [ 3 ] ; i = 0 ; regs [ i ++ ] = gen_rtx_REG ( Pmode , STACK_POINTER_REGNUM ) ; if ( hard_frame_needed ) regs [ i ++ ] = gen_rtx_REG ( Pmode , HARD_FRAME_POINTER_REGNUM ) ; if ( ! ( REGNO ( fp ) == STACK_POINTER_REGNUM || ( hard_frame_needed && REGNO ( fp ) == HARD_FRAME_POINTER_REGNUM ) ) ) regs [ i ++ ] = fp ; p = rtvec_alloc ( i ) ; while ( -- i >= 0 ) { rtx mem = gen_frame_mem ( BLKmode , regs [ i ] ) ; RTVEC_ELT ( p , i ) = gen_rtx_SET ( mem , const0_rtx ) ; } emit_insn ( gen_stack_tie ( gen_rtx_PARALLEL ( VOIDmode , p ) ) ) ; } </s>

This ties together stack memory ( MEM with an alias set of rs6000_sr_alias_set ) and the change to the stack pointer .


"Cannot store this register to stack slot!"

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


<s> static void s390_optimize_register_info ( ) { char clobbered_regs [ 32 ] ; int i ; gcc_assert ( epilogue_completed ) ; s390_regs_ever_clobbered ( clobbered_regs ) ; for ( i = 0 ; i < 32 ; i ++ ) clobbered_regs [ i ] = clobbered_regs [ i ] && ! global_not_special_regno_p ( i ) ; clobbered_regs [ RETURN_REGNUM ] |= ( TARGET_TPF_PROFILING || cfun_frame_layout . save_return_addr_p || crtl -> calls_eh_return ) ; for ( i = 0 ; i < 16 ; i ++ ) if ( ! clobbered_regs [ i ] || call_used_regs [ i ] ) cfun_gpr_save_slot ( i ) = SAVE_SLOT_NONE ; s390_register_info_set_ranges ( ) ; s390_register_info_arg_gpr ( ) ; } </s>

This function is called by s390_optimize_prologue in order to get rid of unnecessary GPR save/restore instructions . The register info for the GPRs is re-computed and the ranges are re-calculated .


<s> int HexagonInstrInfo :: getMinValue ( const MachineInstr * MI ) const { const uint64_t F = MI -> getDesc ( ) . TSFlags ; unsigned isSigned = ( F >> HexagonII :: ExtentSignedPos ) & HexagonII :: ExtentSignedMask ; unsigned bits = ( F >> HexagonII :: ExtentBitsPos ) & HexagonII :: ExtentBitsMask ; if ( isSigned ) return - 1U << ( bits - 1 ) ; else return 0 ; } </s>

Return the minimal unsigned value possible given these KnownBits .

Hexagon Hexagon HexagonII::ExtentSignedPos HexagonII::ExtentSignedMask HexagonII::ExtentBitsPos HexagonII::ExtentBitsMask 1U 1 0


<s> bool MicroMipsSizeReduce :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & static_cast < const MipsSubtarget & > ( MF . getSubtarget ( ) ) ; if ( ! Subtarget -> inMicroMipsMode ( ) || ! Subtarget -> hasMips32r2 ( ) ) return false ; MipsII = static_cast < const MipsInstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; bool Modified = false ; MachineFunction :: iterator I = MF . begin ( ) , E = MF . end ( ) ; for ( ; I != E ; ++ I ) Modified |= ReduceMBB ( * I ) ; return Modified ; } </s>


<s> static scalar_int_mode rs6000_abi_word_mode ( void ) { return TARGET_32BIT ? SImode : DImode ; } </s>

The mode the ABI uses for a word . This is not the same as word_mode for -m32 -mpowerpc64 . This is used to implement various target hooks .


<s>
void
ATTRIBUTE_UNUSED
ix86_debug_options
(
void
)
{
char
*
opts
=
ix86_target_string
(
ix86_isa_flags
,
ix86_isa_flags2
,
target_flags
,
ix86_target_flags
,
ix86_arch_string
,
ix86_tune_string
,
ix86_fpmath
,
true
,
true
)
;
if
(
opts
)
{
fprintf
(
stderr
,
"%s\n\n"
,
opts
)
;
free
(
opts
)
;
}
else
fputs
(
"<no options>\n\n"
,
stderr
)
;
return
;
}
</s>

Function that is callable from the debugger to print the current options .


<s> unsigned X86InstrInfo :: getOpcodeAfterMemoryUnfold ( unsigned Opc , bool UnfoldLoad , bool UnfoldStore , unsigned * LoadRegIndex ) const { DenseMap < unsigned , std :: pair < unsigned , unsigned > > :: const_iterator I = MemOp2RegOpTable . find ( Opc ) ; if ( I == MemOp2RegOpTable . end ( ) ) return 0 ; bool FoldedLoad = I -> second . second & ( 1 << 4 ) ; bool FoldedStore = I -> second . second & ( 1 << 5 ) ; if ( UnfoldLoad && ! FoldedLoad ) return 0 ; if ( UnfoldStore && ! FoldedStore ) return 0 ; if ( LoadRegIndex ) * LoadRegIndex = I -> second . second & 0xf ; return I -> second . first ; } </s>

getOpcodeAfterMemoryUnfold - Returns the opcode of the would be new instruction after load / store are unfolded from an instruction of the specified opcode .


<s> outliner :: OutlinedFunction X86InstrInfo :: getOutliningCandidateInfo ( std :: vector < outliner :: Candidate > & RepeatedSequenceLocs ) const { unsigned SequenceSize = std :: accumulate ( RepeatedSequenceLocs [ 0 ] . front ( ) , std :: next ( RepeatedSequenceLocs [ 0 ] . back ( ) ) , 0 , [ ] ( unsigned Sum , const MachineInstr & MI ) { if ( MI . isDebugInstr ( ) || MI . isKill ( ) ) return Sum ; return Sum + 1 ; } ) ; unsigned CFICount = 0 ; MachineBasicBlock :: iterator MBBI = RepeatedSequenceLocs [ 0 ] . front ( ) ; for ( unsigned Loc = RepeatedSequenceLocs [ 0 ] . getStartIdx ( ) ; Loc < RepeatedSequenceLocs [ 0 ] . getEndIdx ( ) + 1 ; Loc ++ ) { if ( MBBI -> isCFIInstruction ( ) ) CFICount ++ ; MBBI ++ ; } for ( outliner :: Candidate & C : RepeatedSequenceLocs ) { std :: vector < MCCFIInstruction > CFIInstructions = C . getMF ( ) -> getFrameInstructions ( ) ; if ( CFICount > 0 && CFICount != CFIInstructions . size ( ) ) return outliner :: OutlinedFunction ( ) ; } if ( RepeatedSequenceLocs [ 0 ] . back ( ) -> isTerminator ( ) ) { for ( outliner :: Candidate & C : RepeatedSequenceLocs ) C . setCallInfo ( MachineOutlinerTailCall , 1 ) ; return outliner :: OutlinedFunction ( RepeatedSequenceLocs , SequenceSize , 0 , MachineOutlinerTailCall ) ; } if ( CFICount > 0 ) return outliner :: OutlinedFunction ( ) ; for ( outliner :: Candidate & C : RepeatedSequenceLocs ) C . setCallInfo ( MachineOutlinerDefault , 1 ) ; return outliner :: OutlinedFunction ( RepeatedSequenceLocs , SequenceSize , 1 , MachineOutlinerDefault ) ; } </s>

Returns a outliner : :OutlinedFunction struct containing target-specific information for a set of outlining candidates .


<s> TargetLoweringBase :: LegalizeTypeAction AArch64TargetLowering :: getPreferredVectorAction ( EVT VT ) const { MVT SVT = VT . getSimpleVT ( ) ; if ( SVT == MVT :: v1i8 || SVT == MVT :: v1i16 || SVT == MVT :: v1i32 || SVT == MVT :: v1f32 ) return TypeWidenVector ; return TargetLoweringBase :: getPreferredVectorAction ( VT ) ; } </s>

Customize the preferred legalization strategy for certain types .


<s> bool X86PassConfig :: addInstSelector ( ) { PM -> add ( createX86ISelDag ( getX86TargetMachine ( ) , getOptLevel ( ) ) ) ; if ( ! getX86Subtarget ( ) . is64Bit ( ) ) PM -> add ( createGlobalBaseRegPass ( ) ) ; return false ; } </s>

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


<s> int aarch64_hard_regno_mode_ok ( unsigned regno , machine_mode mode ) { if ( GET_MODE_CLASS ( mode ) == MODE_CC ) return regno == CC_REGNUM ; if ( regno == SP_REGNUM ) return mode == Pmode || mode == ptr_mode ; if ( regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) return mode == Pmode ; if ( GP_REGNUM_P ( regno ) && ! aarch64_vect_struct_mode_p ( mode ) ) return 1 ; if ( FP_REGNUM_P ( regno ) ) { if ( aarch64_vect_struct_mode_p ( mode ) ) return ( regno + aarch64_hard_regno_nregs ( regno , mode ) - 1 ) <= V31_REGNUM ; else return 1 ; } return 0 ; } </s>


<s> void ix86_split_xorsign ( rtx operands [ ] ) { machine_mode mode , vmode ; rtx dest , op0 , mask , x ; dest = operands [ 0 ] ; op0 = operands [ 1 ] ; mask = operands [ 3 ] ; mode = GET_MODE ( dest ) ; vmode = GET_MODE ( mask ) ; dest = lowpart_subreg ( vmode , dest , mode ) ; x = gen_rtx_AND ( vmode , dest , mask ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; op0 = lowpart_subreg ( vmode , op0 , mode ) ; x = gen_rtx_XOR ( vmode , dest , op0 ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; } </s>

Deconstruct an xorsign operation into bit masks .


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

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


<s> void SystemZPostRASchedStrategy :: initialize ( ScheduleDAGMI * dag ) { DAG = dag ; HazardRec . setDAG ( dag ) ; HazardRec . Reset ( ) ; } </s>

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


<s> bool WebAssemblyAsmPrinter :: PrintAsmOperand ( const MachineInstr * MI , unsigned OpNo , const char * ExtraCode , raw_ostream & OS ) { if ( ! AsmPrinter :: PrintAsmOperand ( MI , OpNo , ExtraCode , OS ) ) return false ; if ( ! ExtraCode ) { const MachineOperand & MO = MI -> getOperand ( OpNo ) ; switch ( MO . getType ( ) ) { case MachineOperand :: MO_Immediate : OS << MO . getImm ( ) ; return false ; case MachineOperand :: MO_Register : assert ( MI -> getOpcode ( ) == WebAssembly :: INLINEASM ) ; OS << regToString ( MO ) ; return false ; case MachineOperand :: MO_GlobalAddress : PrintSymbolOperand ( MO , OS ) ; return false ; case MachineOperand :: MO_ExternalSymbol : GetExternalSymbolSymbol ( MO . getSymbolName ( ) ) -> print ( OS , MAI ) ; printOffset ( MO . getOffset ( ) , OS ) ; return false ; case MachineOperand :: MO_MachineBasicBlock : MO . getMBB ( ) -> getSymbol ( ) -> print ( OS , MAI ) ; return false ; default : break ; } } return true ; } </s>

PrintAsmOperand - Print out an operand for an inline asm expression .


<s> bool invalidate ( Function & , const PreservedAnalyses & ) { return false ; } </s>

Handle invalidation events from the new pass manager .


<s> bool mep_reuse_lo_p ( rtx lo , rtx gpr , rtx_insn * insn , bool gpr_dead_p ) { bool result = mep_reuse_lo_p_1 ( lo , gpr , insn , gpr_dead_p ) ; extract_insn ( insn ) ; return result ; } </s>

A wrapper around mep_reuse_lo_p_1 that preserves recog_data .


<s> static bool xtensa_member_type_forces_blk ( const_tree , machine_mode mode ) { return mode == CQImode || mode == CHImode ; } </s>

Disable the use of word-sized or smaller complex modes for structures , and for function arguments in particular , where they cause problems with register a7 . The xtensa_copy_incoming_a7 function assumes that there is a single reference to an argument in a7 , but with small complex modes the real and imaginary components may be extracted separately , leading to two uses of the register , only one of which would be replaced .


<s> ScheduleDAGInstrs * createPostMachineScheduler ( MachineSchedContext * C ) const override { return new ScheduleDAGMI ( C , llvm :: make_unique < SystemZPostRASchedStrategy > ( C ) , true ) ; } </s>

Similar to createMachineScheduler but used when postRA machine scheduling is enabled .


"SelectInlineAsmMemoryOperand not implemented yet!\n"

SelectInlineAsmMemoryOperand - Select the specified address as a target addressing mode , according to the specified constraint .


<s>
SDValue
HexagonTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
assert
(
0
&&
"Should not custom lower this!"
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
assert
(
0
&&
"TLS not implemented for Hexagon."
)
;
case
ISD
::
MEMBARRIER
:
return
LowerMEMBARRIER
(
Op
,
DAG
)
;
case
ISD
::
ATOMIC_FENCE
:
return
LowerATOMIC_FENCE
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGLOBALADDRESS
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
)
;
case
ISD
::
BR_JT
:
return
LowerBR_JT
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
INLINEASM
:
return
LowerINLINEASM
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> void EmitInstruction ( uint32_t Val , raw_ostream & OS ) const { for ( unsigned i = 0 ; i != 4 ; ++ i ) { EmitByte ( Val & 0xff , OS ) ; Val >>= 8 ; } } </s>

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


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

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


<s> void ARMConstantPoolValue :: print ( raw_ostream & O ) const { if ( CVal ) O << CVal -> getName ( ) ; else O << S ; if ( Modifier ) O << "(" << getModifierText ( ) << ")" ; if ( PCAdjust != 0 ) { O << "-(LPC" << LabelId << "+" << ( unsigned ) PCAdjust ; if ( AddCurrentAddress ) O << "-." ; O << ")" ; } } </s>

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


"Can't load this register from stack slot"

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


<s> unsigned SPURegisterInfo :: getFrameRegister ( MachineFunction & MF ) const { return SPU :: R1 ; } </s>


<s>
void
print
(
raw_ostream
&
OS
)
const
{
switch
(
Kind
)
{
case
K_Token
:
OS
<<
"Tok "
;
OS
.
write
(
Tok
.
Data
,
Tok
.
Length
)
;
break
;
case
K_Register
:
OS
<<
"Reg "
<<
Reg
.
RegNum
;
break
;
case
K_Immediate
:
OS
<<
"Imm "
;
OS
<<
*
Imm
.
Val
;
break
;
case
K_Memory
:
OS
<<
"Mem "
<<
Mem
.
BaseReg
<<
" "
;
if
(
Mem
.
Off
)
OS
<<
*
Mem
.
Off
;
else
OS
<<
"0"
;
break
;
}
}
</s>

Nyuzi
"Tok "
"Reg "
"Imm "
"Mem "
" "
"0"


<s>
SDValue
SITargetLowering
::
handleD16VData
(
SDValue
VData
,
SelectionDAG
&
DAG
)
const
{
EVT
StoreVT
=
VData
.
getValueType
(
)
;
SDLoc
DL
(
VData
)
;
if
(
StoreVT
.
isVector
(
)
)
{
assert
(
(
StoreVT
.
getVectorNumElements
(
)
!=
3
)
&&
"Handle v3f16"
)
;
if
(
!
Subtarget
->
hasUnpackedD16VMem
(
)
)
{
if
(
!
isTypeLegal
(
StoreVT
)
)
{
EVT
EquivStoreVT
=
getEquivalentMemType
(
*
DAG
.
getContext
(
)
,
StoreVT
)
;
return
DAG
.
getNode
(
ISD
::
BITCAST
,
DL
,
EquivStoreVT
,
VData
)
;
}
}
else
{
EVT
IntStoreVT
=
StoreVT
.
changeTypeToInteger
(
)
;
SDValue
IntVData
=
DAG
.
getNode
(
ISD
::
BITCAST
,
DL
,
IntStoreVT
,
VData
)
;
EVT
EquivStoreVT
=
(
StoreVT
==
MVT
::
v2f16
)
MVT
::
v2i32
:
MVT
::
v4i32
;
return
DAG
.
getNode
(
ISD
::
ZERO_EXTEND
,
DL
,
EquivStoreVT
,
IntVData
)
;
}
}
return
VData
;
}
</s>

Handle register layout difference for f16 images for some subtargets .


<s> MachineMemOperand :: Flags AArch64TargetLowering :: getTargetMMOFlags ( const Instruction & I ) const { if ( Subtarget -> getProcFamily ( ) == AArch64Subtarget :: Falkor && I . getMetadata ( FALKOR_STRIDED_ACCESS_MD ) != nullptr ) return MOStridedAccess ; return MachineMemOperand :: MONone ; } </s>

This callback is used to inspect load/store instructions and add target-specific MachineMemOperand flags to them .


"RegScavenger required for long branching"

"new block should be inserted for expanding unconditional branch"

Insert an unconditional indirect branch at the end of MBB to NewDestBB .


<s> bool SIInstrInfo :: isOperandLegal ( const MachineInstr * MI , unsigned OpIdx , const MachineOperand * MO ) const { const MachineRegisterInfo & MRI = MI -> getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; const MCInstrDesc & InstDesc = get ( MI -> getOpcode ( ) ) ; const MCOperandInfo & OpInfo = InstDesc . OpInfo [ OpIdx ] ; const TargetRegisterClass * DefinedRC = OpInfo . RegClass != - 1 ? RI . getRegClass ( OpInfo . RegClass ) : nullptr ; if ( ! MO ) MO = & MI -> getOperand ( OpIdx ) ; if ( isVALU ( * MI ) && usesConstantBus ( MRI , * MO , DefinedRC -> getSize ( ) ) ) { unsigned SGPRUsed = MO -> isReg ( ) ? MO -> getReg ( ) : ( unsigned ) AMDGPU :: NoRegister ; for ( unsigned i = 0 , e = MI -> getNumOperands ( ) ; i != e ; ++ i ) { if ( i == OpIdx ) continue ; const MachineOperand & Op = MI -> getOperand ( i ) ; if ( Op . isReg ( ) && Op . getReg ( ) != SGPRUsed && usesConstantBus ( MRI , Op , getOpSize ( * MI , i ) ) ) { return false ; } } } if ( MO -> isReg ( ) ) { assert ( DefinedRC ) ; return isLegalRegOperand ( MRI , OpInfo , * MO ) ; } assert ( MO -> isImm ( ) || MO -> isTargetIndex ( ) || MO -> isFI ( ) ) ; if ( ! DefinedRC ) { return true ; } return isImmOperandLegal ( MI , OpIdx , * MO ) ; } </s>

Check if MO is a legal operand if it was the OpIdx Operand for MI .


<s> bool SHUXIFrameLowering :: hasFP ( const MachineFunction & MF ) const { return true ; } </s>

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


<s>
bool
AMDGPUAsmPrinter
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
MF
.
setAlignment
(
8
)
;
SetupMachineFunction
(
MF
)
;
MCContext
&
Context
=
getObjFileLowering
(
)
.
getContext
(
)
;
MCSectionELF
*
ConfigSection
=
Context
.
getELFSection
(
".AMDGPU.config"
,
ELF
::
SHT_PROGBITS
,
0
)
;
OutStreamer
->
SwitchSection
(
ConfigSection
)
;
const
AMDGPUSubtarget
&
STM
=
MF
.
getSubtarget
<
AMDGPUSubtarget
>
(
)
;
SIProgramInfo
KernelInfo
;
if
(
STM
.
getGeneration
(
)
>=
AMDGPUSubtarget
::
SOUTHERN_ISLANDS
)
{
if
(
!
STM
.
isAmdHsaOS
(
)
)
{
getSIProgramInfo
(
KernelInfo
,
MF
)
;
EmitProgramInfoSI
(
MF
,
KernelInfo
)
;
}
AMDGPUTargetStreamer
*
TS
=
static_cast
<
AMDGPUTargetStreamer
*
>
(
OutStreamer
->
getTargetStreamer
(
)
)
;
TS
->
EmitDirectiveHSACodeObjectVersion
(
1
,
0
)
;
AMDGPU
::
IsaVersion
ISA
=
STM
.
getIsaVersion
(
)
;
TS
->
EmitDirectiveHSACodeObjectISA
(
ISA
.
Major
,
ISA
.
Minor
,
ISA
.
Stepping
,
"AMD"
,
"AMDGPU"
)
;
}
else
{
EmitProgramInfoR600
(
MF
)
;
}
DisasmLines
.
clear
(
)
;
HexLines
.
clear
(
)
;
DisasmLineMaxLen
=
0
;
EmitFunctionBody
(
)
;
if
(
isVerbose
(
)
)
{
MCSectionELF
*
CommentSection
=
Context
.
getELFSection
(
".AMDGPU.csdata"
,
ELF
::
SHT_PROGBITS
,
0
)
;
OutStreamer
->
SwitchSection
(
CommentSection
)
;
if
(
STM
.
getGeneration
(
)
>=
AMDGPUSubtarget
::
SOUTHERN_ISLANDS
)
{
OutStreamer
->
emitRawComment
(
" Kernel info:"
,
false
)
;
OutStreamer
->
emitRawComment
(
" codeLenInByte = "
+
Twine
(
KernelInfo
.
CodeLen
)
,
false
)
;
OutStreamer
->
emitRawComment
(
" NumSgprs: "
+
Twine
(
KernelInfo
.
NumSGPR
)
,
false
)
;
OutStreamer
->
emitRawComment
(
" NumVgprs: "
+
Twine
(
KernelInfo
.
NumVGPR
)
,
false
)
;
OutStreamer
->
emitRawComment
(
" FloatMode: "
+
Twine
(
KernelInfo
.
FloatMode
)
,
false
)
;
OutStreamer
->
emitRawComment
(
" IeeeMode: "
+
Twine
(
KernelInfo
.
IEEEMode
)
,
false
)
;
OutStreamer
->
emitRawComment
(
" ScratchSize: "
+
Twine
(
KernelInfo
.
ScratchSize
)
,
false
)
;
}
else
{
R600MachineFunctionInfo
*
MFI
=
MF
.
getInfo
<
R600MachineFunctionInfo
>
(
)
;
OutStreamer
->
emitRawComment
(
Twine
(
"SQ_PGM_RESOURCES:STACK_SIZE = "
+
Twine
(
MFI
->
StackSize
)
)
)
;
}
}
if
(
STM
.
dumpCode
(
)
)
{
OutStreamer
->
SwitchSection
(
Context
.
getELFSection
(
".AMDGPU.disasm"
,
ELF
::
SHT_NOTE
,
0
)
)
;
for
(
size_t
i
=
0
;
i
<
DisasmLines
.
size
(
)
;
++
i
)
{
std
::
string
Comment
(
DisasmLineMaxLen
DisasmLines
[
i
]
.
size
(
)
,
' '
)
;
Comment
+=
" ; "
+
HexLines
[
i
]
+
"\n"
;
OutStreamer
->
EmitBytes
(
StringRef
(
DisasmLines
[
i
]
)
)
;
OutStreamer
->
EmitBytes
(
StringRef
(
Comment
)
)
;
}
}
return
false
;
}
</s>

runOnMachineFunction - Emit the function body .


<s> void buildLoad ( unsigned Val , unsigned Addr , uint64_t Size , unsigned Alignment , MachinePointerInfo & MPO ) { auto MMO = MIRBuilder . getMF ( ) . getMachineMemOperand ( MPO , MachineMemOperand :: MOLoad , Size , Alignment ) ; MIRBuilder . buildLoad ( Val , Addr , * MMO ) ; } </s>

Build and insert a G_LOAD instruction , while constructing the MachineMemOperand .


<s> void X86InstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , unsigned DestReg , int FrameIdx , const TargetRegisterClass * RC ) const { const MachineFunction & MF = * MBB . getParent ( ) ; bool isAligned = ( RI . getStackAlignment ( ) >= 16 ) || RI . canRealignStack ( MF ) ; unsigned Opc = getLoadRegOpcode ( DestReg , RC , isAligned , TM ) ; DebugLoc DL = MBB . findDebugLoc ( MI ) ; addFrameReference ( BuildMI ( MBB , MI , DL , get ( Opc ) , DestReg ) , FrameIdx ) ; } </s>


<s> void notice_update_cc ( rtx body , rtx insn ) { switch ( get_attr_cc ( insn ) ) { case CC_NONE : break ; case CC_NONE_0HIT : if ( cc_status . value1 != 0 && reg_overlap_mentioned_p ( recog_data . operand [ 0 ] , cc_status . value1 ) ) cc_status . value1 = 0 ; break ; case CC_SET_ZN : CC_STATUS_INIT ; cc_status . flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY ; cc_status . value1 = recog_data . operand [ 0 ] ; break ; case CC_SET_ZNV : CC_STATUS_INIT ; cc_status . flags |= CC_NO_CARRY ; cc_status . value1 = recog_data . operand [ 0 ] ; break ; case CC_COMPARE : CC_STATUS_INIT ; cc_status . value1 = SET_SRC ( body ) ; break ; case CC_CLOBBER : CC_STATUS_INIT ; break ; } } </s>

On the 68000 , all the insns to store in an address register fail to set the cc 's . However , in some cases these instructions can make it possibly invalid to use the saved cc 's . In those cases we clear out some or all of the saved cc 's so they wo n't be used .


<s> bool ok_for_simple_move_strict_operands ( rtx * operands , enum machine_mode mode ) { if ( visium_flags_exposed && gpc_reg_operand ( operands [ 0 ] , mode ) && ( gpc_reg_operand ( operands [ 1 ] , mode ) || ( mode == QImode && operands [ 1 ] == const0_rtx ) ) ) return false ; return true ; } </s>

Return true if the operands are valid for a simple move strict insn .


<s> bool convertSelectOfConstantsToMath ( ) const override { return true ; } </s>

Return true if a select of constants ( select Cond , C1 , C2 ) should be transformed into simple math ops with the condition value .


<s> static void mips_set_frame_expr ( rtx frame_pattern ) { rtx_insn * insn ; insn = get_last_insn ( ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_FRAME_RELATED_EXPR , frame_pattern , REG_NOTES ( insn ) ) ; } </s>

Make the last instruction frame related and note that it performs the operation described by FRAME_PATTERN .


<s>
SDValue
MCS51TargetLowering
::
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>

MCS51
MCS51
"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
AArch64TargetLowering
::
computeKnownBitsForTargetNode
(
const
SDValue
Op
,
KnownBits
&
Known
,
const
APInt
&
DemandedElts
,
const
SelectionDAG
&
DAG
,
unsigned
Depth
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
break
;
case
AArch64ISD
::
CSEL
:
{
KnownBits
Known2
;
Known
=
DAG
.
computeKnownBits
(
Op
->
getOperand
(
0
)
,
Depth
+
1
)
;
Known2
=
DAG
.
computeKnownBits
(
Op
->
getOperand
(
1
)
,
Depth
+
1
)
;
Known
=
KnownBits
::
commonBits
(
Known
,
Known2
)
;
break
;
}
case
AArch64ISD
::
LOADgot
:
case
AArch64ISD
::
ADDlow
:
{
if
(
!
Subtarget
->
isTargetILP32
(
)
)
break
;
Known
.
Zero
=
APInt
::
getHighBitsSet
(
64
,
32
)
;
break
;
}
case
ISD
::
INTRINSIC_W_CHAIN
:
{
ConstantSDNode
*
CN
=
cast
<
ConstantSDNode
>
(
Op
->
getOperand
(
1
)
)
;
Intrinsic
::
ID
IntID
=
static_cast
<
Intrinsic
::
ID
>
(
CN
->
getZExtValue
(
)
)
;
switch
(
IntID
)
{
default
:
return
;
case
Intrinsic
::
aarch64_ldaxr
:
case
Intrinsic
::
aarch64_ldxr
:
{
unsigned
BitWidth
=
Known
.
getBitWidth
(
)
;
EVT
VT
=
cast
<
MemIntrinsicSDNode
>
(
Op
)
->
getMemoryVT
(
)
;
unsigned
MemBits
=
VT
.
getScalarSizeInBits
(
)
;
Known
.
Zero
|=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
MemBits
)
;
return
;
}
}
break
;
}
case
ISD
::
INTRINSIC_WO_CHAIN
:
case
ISD
::
INTRINSIC_VOID
:
{
unsigned
IntNo
=
cast
<
ConstantSDNode
>
(
Op
.
getOperand
(
0
)
)
->
getZExtValue
(
)
;
switch
(
IntNo
)
{
default
:
break
;
case
Intrinsic
::
aarch64_neon_umaxv
:
case
Intrinsic
::
aarch64_neon_uminv
:
{
MVT
VT
=
Op
.
getOperand
(
1
)
.
getValueType
(
)
.
getSimpleVT
(
)
;
unsigned
BitWidth
=
Known
.
getBitWidth
(
)
;
if
(
VT
==
MVT
::
v8i8
||
VT
==
MVT
::
v16i8
)
{
assert
(
BitWidth
>=
8
&&
"Unexpected width!"
)
;
APInt
Mask
=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
8
)
;
Known
.
Zero
|=
Mask
;
}
else
if
(
VT
==
MVT
::
v4i16
||
VT
==
MVT
::
v8i16
)
{
assert
(
BitWidth
>=
16
&&
"Unexpected width!"
)
;
APInt
Mask
=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
16
)
;
Known
.
Zero
|=
Mask
;
}
break
;
}
break
;
}
}
}
}
</s>

Determine which of the bits specified in Mask are known to be either zero or one and return them in the KnownZero/KnownOne bitsets .


<s> void MipsInstrInfo :: insertNoop ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI ) const { DebugLoc DL ; } </s>

Insert a noop into the instruction stream at the specified point .


<s> unsigned RISCVInstrInfo :: isStoreToStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { switch ( MI . getOpcode ( ) ) { default : return 0 ; case RISCV :: SB : case RISCV :: SH : case RISCV :: SW : case RISCV :: FSH : case RISCV :: FSW : case RISCV :: SD : case RISCV :: FSD : break ; } if ( MI . getOperand ( 1 ) . isFI ( ) && MI . getOperand ( 2 ) . isImm ( ) && MI . getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI . getOperand ( 1 ) . getIndex ( ) ; return MI . getOperand ( 0 ) . getReg ( ) ; } return 0 ; } </s>

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


<s> BitVector AGCRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; 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 AArch64TargetLowering :: hasPairedLoad ( EVT LoadedType , Align & RequiredAligment ) const { if ( ! LoadedType . isSimple ( ) || ( ! LoadedType . isInteger ( ) && ! LoadedType . isFloatingPoint ( ) ) ) return false ; RequiredAligment = Align ( 1 ) ; unsigned NumBits = LoadedType . getSizeInBits ( ) ; return NumBits == 32 || NumBits == 64 ; } </s>

Return true if the target supplies and combines to a paired load two loaded values of type LoadedType next to each other in memory .


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

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


<s> unsigned DCPU16InstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { if ( MI -> getOpcode ( ) == DCPU16 :: MOV16rm ) { if ( MI -> getOperand ( 1 ) . isFI ( ) ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } } return 0 ; } </s>

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


<s> uint64_t R600MCCodeEmitter :: getMachineOpValue ( const MCInst & MI , const MCOperand & MO , SmallVectorImpl < MCFixup > & Fixup ) const { if ( MO . isReg ( ) ) { if ( HAS_NATIVE_OPERANDS ( MCII . get ( MI . getOpcode ( ) ) . TSFlags ) ) { return MRI . getEncodingValue ( MO . getReg ( ) ) ; } else { return getHWReg ( MO . getReg ( ) ) ; } } else if ( MO . isImm ( ) ) { return MO . getImm ( ) ; } else { assert ( 0 ) ; return 0 ; } } </s>

getMachineOpValue - Return binary encoding of operand .