<s> static void arc_init_reg_tables ( void ) { int i ; for ( i = 0 ; i < NUM_MACHINE_MODES ; i ++ ) { switch ( GET_MODE_CLASS ( i ) ) { case MODE_INT : case MODE_PARTIAL_INT : case MODE_COMPLEX_INT : if ( GET_MODE_SIZE ( i ) <= 4 ) arc_mode_class [ i ] = 1 << ( int ) S_MODE ; else if ( GET_MODE_SIZE ( i ) == 8 ) arc_mode_class [ i ] = 1 << ( int ) D_MODE ; else if ( GET_MODE_SIZE ( i ) == 16 ) arc_mode_class [ i ] = 1 << ( int ) T_MODE ; else if ( GET_MODE_SIZE ( i ) == 32 ) arc_mode_class [ i ] = 1 << ( int ) O_MODE ; else arc_mode_class [ i ] = 0 ; break ; case MODE_FLOAT : case MODE_COMPLEX_FLOAT : if ( GET_MODE_SIZE ( i ) <= 4 ) arc_mode_class [ i ] = 1 << ( int ) SF_MODE ; else if ( GET_MODE_SIZE ( i ) == 8 ) arc_mode_class [ i ] = 1 << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( i ) == 16 ) arc_mode_class [ i ] = 1 << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( i ) == 32 ) arc_mode_class [ i ] = 1 << ( int ) OF_MODE ; else arc_mode_class [ i ] = 0 ; break ; case MODE_CC : arc_mode_class [ i ] = 1 << ( int ) C_MODE ; break ; default : arc_mode_class [ i ] = 0 ; break ; } } for ( i = 0 ; i < FIRST_PSEUDO_REGISTER ; i ++ ) { if ( i < 60 ) arc_regno_reg_class [ i ] = GENERAL_REGS ; else if ( i == 60 ) arc_regno_reg_class [ i ] = LPCOUNT_REG ; else if ( i == 61 ) arc_regno_reg_class [ i ] = NO_REGS ; else arc_regno_reg_class [ i ] = NO_REGS ; } } </s>


<s> void TeeRISCFrameLowering :: emitPrologue ( MachineFunction & MF ) const { MachineBasicBlock & MBB = MF . front ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const TeeRISCInstrInfo & TII = * static_cast < const TeeRISCInstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; TeeRISCMachineFunctionInfo * TFI = MF . getInfo < TeeRISCMachineFunctionInfo > ( ) ; MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; DebugLoc DL = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; determineFrameLayout ( MF ) ; unsigned StackSize = MFI -> getStackSize ( ) ; if ( StackSize == 0 && ! MFI -> adjustsStack ( ) ) return ; int FPOffset = TFI -> getFPStackOffset ( ) ; int RAOffset = TFI -> getRAStackOffset ( ) ; BuildMI ( MBB , MBBI , DL , TII . get ( TeeRISC :: ADD_IMM ) , TeeRISC :: SP ) . addReg ( TeeRISC :: SP ) . addImm ( StackSize ) ; if ( MFI -> adjustsStack ( ) ) { BuildMI ( MBB , MBBI , DL , TII . get ( TeeRISC :: ST ) , TeeRISC :: SP ) . addReg ( TeeRISC :: LR ) . addImm ( RAOffset ) ; } if ( hasFP ( MF ) ) { BuildMI ( MBB , MBBI , DL , TII . get ( TeeRISC :: ST ) , TeeRISC :: FP ) . addReg ( TeeRISC :: SP ) . addImm ( FPOffset ) ; BuildMI ( MBB , MBBI , DL , TII . get ( TeeRISC :: ADD ) , TeeRISC :: FP ) . addReg ( TeeRISC :: SP ) . addReg ( TeeRISC :: ZERO ) ; } } </s>

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

TeeRISC TeeRISC TeeRISC TeeRISC TeeRISC TeeRISC 0 TeeRISC::ADD_IMM TeeRISC::SP TeeRISC::SP TeeRISC::ST TeeRISC::SP TeeRISC::LR TeeRISC::ST TeeRISC::FP TeeRISC::SP TeeRISC::ADD TeeRISC::FP TeeRISC::SP TeeRISC::ZERO


<s> bool SparcFrameLowering :: hasReservedCallFrame ( const MachineFunction & MF ) const { return ! MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ; } </s>

hasReservedCallFrame - Under normal circumstances , when a frame pointer is not required , we reserve argument space for call sites in the function immediately on entry to the current function .


<s> static bool rs6000_discover_homogeneous_aggregate ( machine_mode mode , const_tree type , machine_mode * elt_mode , int * n_elts ) { if ( DEFAULT_ABI == ABI_ELFv2 && type && AGGREGATE_TYPE_P ( type ) ) { machine_mode field_mode = VOIDmode ; int field_count = rs6000_aggregate_candidate ( type , & field_mode ) ; if ( field_count > 0 ) { int n_regs = ( SCALAR_FLOAT_MODE_P ( field_mode ) ? ( GET_MODE_SIZE ( field_mode ) + 7 ) >> 3 : 1 ) ; if ( field_count * n_regs <= AGGR_ARG_NUM_REG ) { if ( elt_mode ) * elt_mode = field_mode ; if ( n_elts ) * n_elts = field_count ; return true ; } } } if ( elt_mode ) * elt_mode = mode ; if ( n_elts ) * n_elts = 1 ; return false ; } </s>

If an argument , whose type is described by TYPE and MODE , is a homogeneous float or vector aggregate that shall be passed in FP/vector registers according to the ELFv2 ABI , return the homogeneous element mode in * ELT_MODE and the number of elements in * N_ELTS , and return TRUE . Otherwise , set * ELT_MODE to MODE and * N_ELTS to 1 , and return FALSE .


<s>
void
HexagonEarlyIfConversion
::
removeBlock
(
MachineBasicBlock
*
B
)
{
DEBUG
(
dbgs
(
)
<<
"Removing block "
<<
PrintMB
(
B
)
<<
"\n"
)
;
MachineDomTreeNode
*
N
=
MDT
->
getNode
(
B
)
;
MachineDomTreeNode
*
IDN
=
N
->
getIDom
(
)
;
if
(
IDN
)
{
MachineBasicBlock
*
IDB
=
IDN
->
getBlock
(
)
;
using
GTN
=
GraphTraits
<
MachineDomTreeNode
*
>
;
using
DTNodeVectType
=
SmallVector
<
MachineDomTreeNode
*
,
4
>
;
DTNodeVectType
Cn
(
GTN
::
child_begin
(
N
)
,
GTN
::
child_end
(
N
)
)
;
for
(
DTNodeVectType
::
iterator
I
=
Cn
.
begin
(
)
,
E
=
Cn
.
end
(
)
;
I
!=
E
;
++
I
)
{
MachineBasicBlock
*
SB
=
(
*
I
)
->
getBlock
(
)
;
MDT
->
changeImmediateDominator
(
SB
,
IDB
)
;
}
}
while
(
B
->
succ_size
(
)
>
0
)
B
->
removeSuccessor
(
B
->
succ_begin
(
)
)
;
for
(
auto
I
=
B
->
pred_begin
(
)
,
E
=
B
->
pred_end
(
)
;
I
!=
E
;
++
I
)
(
*
I
)
->
removeSuccessor
(
B
,
true
)
;
Deleted
.
insert
(
B
)
;
MDT
->
eraseNode
(
B
)
;
MFN
->
erase
(
B
->
getIterator
(
)
)
;
}
</s>

This method completely removes BB from all data structures , including all of the Loop objects it is nested in and our mapping from MachineBasicBlocks to loops .

Hexagon
Hexagon
"Removing block "
"\n"
4
0


<s> static opt_machine_mode aarch64_vectorize_related_mode ( machine_mode vector_mode , scalar_mode element_mode , poly_uint64 nunits ) { unsigned int vec_flags = aarch64_classify_vector_mode ( vector_mode ) ; poly_uint64 sve_nunits ; if ( ( vec_flags & VEC_SVE_DATA ) && multiple_p ( BYTES_PER_SVE_VECTOR , GET_MODE_SIZE ( element_mode ) , & sve_nunits ) ) { machine_mode sve_mode ; if ( maybe_ne ( nunits , 0U ) ) { if ( multiple_p ( sve_nunits , nunits ) && aarch64_sve_data_mode ( element_mode , nunits ) . exists ( & sve_mode ) ) return sve_mode ; } else { sve_nunits = ordered_min ( sve_nunits , GET_MODE_SIZE ( vector_mode ) ) ; if ( aarch64_sve_data_mode ( element_mode , sve_nunits ) . exists ( & sve_mode ) ) return sve_mode ; } } if ( ( vec_flags & VEC_ADVSIMD ) && known_eq ( nunits , 0U ) && known_eq ( GET_MODE_BITSIZE ( vector_mode ) , 64U ) && maybe_ge ( GET_MODE_BITSIZE ( element_mode ) * GET_MODE_NUNITS ( vector_mode ) , 128U ) ) { machine_mode res = aarch64_simd_container_mode ( element_mode , 128 ) ; if ( VECTOR_MODE_P ( res ) ) return res ; } return default_vectorize_related_mode ( vector_mode , element_mode , nunits ) ; } </s>


<s> void PPCPassConfig :: addMachineSSAOptimization ( ) { TargetPassConfig :: addMachineSSAOptimization ( ) ; if ( Triple ( TM -> getTargetTriple ( ) ) . getArch ( ) == Triple :: ppc64le && ! DisableVSXSwapRemoval ) addPass ( createPPCVSXSwapRemovalPass ( ) ) ; } </s>

Methods with trivial inline returns are convenient points in the common codegen pass pipeline where targets may insert passes .


<s> const char * getPassName ( ) const override { return AARCH64_DEAD_REG_DEF_NAME ; } </s>

getPassName - Return a nice clean name for a pass .


<s> static int stackSlotSize ( ) { return 4 ; } </s>


<s>
bool
TeakInstrInfo
::
isProfitableToIfCvt
(
MachineBasicBlock
&
TBB
,
unsigned
TCycles
,
unsigned
TExtra
,
MachineBasicBlock
&
FBB
,
unsigned
FCycles
,
unsigned
FExtra
,
BranchProbability
Probability
)
const
{
dbgs
(
)
<<
"isProfitableToIfCvt TF\n"
;
return
true
;
}
</s>


<s> SMLoc getEndLoc ( ) const override { return EndLoc ; } </s>

getEndLoc - Get the location of the last token of this operand .


<s> int rs6000_loop_align ( rtx label ) { basic_block bb ; int ninsns ; if ( ! can_override_loop_align ) return align_loops_log ; bb = BLOCK_FOR_INSN ( label ) ; ninsns = num_loop_insns ( bb -> loop_father ) ; if ( ninsns > 4 && ninsns <= 8 && ( rs6000_cpu == PROCESSOR_POWER4 || rs6000_cpu == PROCESSOR_POWER5 || rs6000_cpu == PROCESSOR_POWER6 || rs6000_cpu == PROCESSOR_POWER7 || rs6000_cpu == PROCESSOR_POWER8 || rs6000_cpu == PROCESSOR_POWER9 ) ) return 5 ; else return align_loops_log ; } </s>


<s>
bool
AArch64InstrInfo
::
shouldClusterMemOps
(
MachineInstr
*
FirstLdSt
,
MachineInstr
*
SecondLdSt
,
unsigned
NumLoads
)
const
{
if
(
NumLoads
>
1
)
return
false
;
unsigned
FirstOpc
=
FirstLdSt
->
getOpcode
(
)
;
unsigned
SecondOpc
=
SecondLdSt
->
getOpcode
(
)
;
if
(
!
canPairLdStOpc
(
FirstOpc
,
SecondOpc
)
)
return
false
;
if
(
!
isCandidateToMergeOrPair
(
FirstLdSt
)
||
!
isCandidateToMergeOrPair
(
SecondLdSt
)
)
return
false
;
int64_t
Offset1
=
FirstLdSt
->
getOperand
(
2
)
.
getImm
(
)
;
if
(
isUnscaledLdSt
(
FirstOpc
)
&&
!
scaleOffset
(
FirstOpc
,
Offset1
)
)
return
false
;
int64_t
Offset2
=
SecondLdSt
->
getOperand
(
2
)
.
getImm
(
)
;
if
(
isUnscaledLdSt
(
SecondOpc
)
&&
!
scaleOffset
(
SecondOpc
,
Offset2
)
)
return
false
;
if
(
Offset1
>
63
||
Offset1
<
64
)
return
false
;
assert
(
Offset1
<=
Offset2
&&
"Caller should have ordered offsets."
)
;
return
Offset1
+
1
==
Offset2
;
}
</s>

Returns true if the two given memory operations should be scheduled adjacent .


<s> bool AArch64TargetLowering :: isIntDivCheap ( EVT VT , AttributeList Attr ) const { bool OptSize = Attr . hasFnAttr ( Attribute :: MinSize ) ; return OptSize && ! VT . isVector ( ) ; } </s>

Return true if integer divide is usually cheaper than a sequence of several shifts , adds , and multiplies for this target .


<s> static int first_jump_index ( int clock_var ) { int retval = - 1 ; int n = 0 ; for ( ; ; ) { int t = get_jump_cycle ( n ) ; if ( t <= clock_var ) break ; retval = n ; n ++ ; } return retval ; } </s>

Return the index of the first jump that occurs after CLOCK_VAR . If no jump has delay slots beyond CLOCK_VAR , return -1 .


<s>
static
void
write_function_decl_and_comment
(
std
::
stringstream
&
s
,
const
char
*
name
,
const_tree
decl
)
{
s
<<
"// BEGIN"
;
if
(
TREE_PUBLIC
(
decl
)
)
s
<<
" GLOBAL"
;
s
<<
" FUNCTION DECL: "
;
if
(
name
[
0
]
==
'*'
)
s
<<
(
name
+
1
)
;
else
s
<<
name
;
s
<<
"\n"
;
nvptx_write_function_decl
(
s
,
name
,
decl
)
;
s
<<
";\n"
;
}
</s>

Write a .func or .kernel declaration ( not a definition ) along with a helper comment for use by ld . S is the stream to write to , DECL the decl for the function with name NAME .

nvptx
"// BEGIN"
" GLOBAL"
" FUNCTION DECL: "
0
1
"\n"
";\n"


<s> rtx avr_incoming_return_addr_rtx ( void ) { return gen_frame_mem ( HImode , plus_constant ( Pmode , stack_pointer_rtx , 1 ) ) ; } </s>

Implement ` INCOMING_RETURN_ADDR_RTX ' .


<s> bool EvexToVexInstPass :: runOnMachineFunction ( MachineFunction & MF ) { TII = MF . getSubtarget < X86Subtarget > ( ) . getInstrInfo ( ) ; ST = & MF . getSubtarget < X86Subtarget > ( ) ; if ( ! ST -> hasAVX512 ( ) ) return false ; bool Changed = false ; for ( MachineBasicBlock & MBB : MF ) { for ( MachineInstr & MI : MBB ) Changed |= CompressEvexToVexImpl ( MI ) ; } return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> void MBlazeAsmPrinter :: emitFrameDirective ( ) { const TargetRegisterInfo & RI = * TM . getRegisterInfo ( ) ; unsigned stackReg = RI . getFrameRegister ( * MF ) ; unsigned returnReg = RI . getRARegister ( ) ; unsigned stackSize = MF -> getFrameInfo ( ) -> getStackSize ( ) ; OutStreamer . EmitRawText ( "\t.frame\t" + Twine ( getRegisterName ( stackReg ) ) + "," + Twine ( stackSize ) + "," + Twine ( getRegisterName ( returnReg ) ) ) ; } </s>


<s> static rtx s390_emit_compare_and_swap ( enum rtx_code code , rtx old , rtx mem , rtx cmp , rtx new_rtx ) { emit_insn ( gen_atomic_compare_and_swapsi_internal ( old , mem , cmp , new_rtx ) ) ; return s390_emit_compare ( code , gen_rtx_REG ( CCZ1mode , CC_REGNUM ) , const0_rtx ) ; } </s>

Emit a SImode compare and swap instruction setting MEM to NEW_RTX if OLD matches CMP . Return the correct condition RTL to be placed in the IF_THEN_ELSE of the conditional branch testing the result .


<s> static int microblaze_must_save_register ( int regno ) { if ( pic_offset_table_rtx && ( regno == MB_ABI_PIC_ADDR_REGNUM ) && df_regs_ever_live_p ( regno ) ) return 1 ; if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return 1 ; if ( frame_pointer_needed && ( regno == HARD_FRAME_POINTER_REGNUM ) ) return 1 ; if ( ! crtl -> is_leaf ) { if ( regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return 1 ; if ( ( microblaze_is_interrupt_variant ( ) || save_volatiles ) && ( regno >= 3 && regno <= 12 ) ) return 1 ; } if ( microblaze_is_interrupt_variant ( ) ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_MSR_SAVE_REG || ( interrupt_handler && ( regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) ) ) return 1 ; } if ( save_volatiles ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) return 1 ; } return 0 ; } </s>

Determine of register must be saved/restored in call .


<s> static bool arc_cannot_force_const_mem ( machine_mode mode , rtx x ) { return ! arc_legitimate_constant_p ( mode , x ) ; } </s>

Determine if it 's legal to put X into the constant pool .


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

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


<s>
Optional
<
MCDisassembler
::
DecodeStatus
>
WebAssemblyDisassembler
::
onSymbolStart
(
SymbolInfoTy
&
Symbol
,
uint64_t
&
Size
,
ArrayRef
<
uint8_t
>
Bytes
,
uint64_t
Address
,
raw_ostream
&
CStream
)
const
{
Size
=
0
;
if
(
Address
==
0
)
{
int64_t
FunctionCount
;
if
(
!
nextLEB
(
FunctionCount
,
Bytes
,
Size
,
false
)
)
return
;
outs
(
)
<<
"        # "
<<
FunctionCount
<<
" functions in section."
;
}
else
{
int64_t
BodySize
,
LocalEntryCount
;
if
(
!
nextLEB
(
BodySize
,
Bytes
,
Size
,
false
)
||
!
nextLEB
(
LocalEntryCount
,
Bytes
,
Size
,
false
)
)
return
;
if
(
LocalEntryCount
)
{
outs
(
)
<<
"        .local "
;
for
(
int64_t
I
=
0
;
I
<
LocalEntryCount
;
I
++
)
{
int64_t
Count
,
Type
;
if
(
!
nextLEB
(
Count
,
Bytes
,
Size
,
false
)
||
!
nextLEB
(
Type
,
Bytes
,
Size
,
false
)
)
return
;
for
(
int64_t
J
=
0
;
J
<
Count
;
J
++
)
{
if
(
I
||
J
)
outs
(
)
<<
", "
;
outs
(
)
<<
WebAssembly
::
anyTypeToString
(
Type
)
;
}
}
}
}
outs
(
)
<<
"\n"
;
return
MCDisassembler
::
Success
;
}
</s>

Used to perform separate target specific disassembly for a particular symbol .

WebAssembly
WebAssembly
0
0
"        # "
" functions in section."
"        .local "
0
0
", "
WebAssembly::anyTypeToString
"\n"


<s> static tree rs6000_builtin_mask_for_load ( void ) { if ( TARGET_ALTIVEC || TARGET_VSX ) return altivec_builtin_mask_for_load ; else return 0 ; } </s>


<s> void AMDGPUAsmPrinter :: emitStartOfAsmFile ( Module & M ) { if ( getTargetStreamer ( ) && ! getTargetStreamer ( ) -> getTargetID ( ) ) initializeTargetID ( M ) ; if ( TM . getTargetTriple ( ) . getOS ( ) != Triple :: AMDHSA && TM . getTargetTriple ( ) . getOS ( ) != Triple :: AMDPAL ) return ; if ( isHsaAbiVersion3Or4 ( getGlobalSTI ( ) ) ) getTargetStreamer ( ) -> EmitDirectiveAMDGCNTarget ( ) ; if ( TM . getTargetTriple ( ) . getOS ( ) == Triple :: AMDHSA ) HSAMetadataStream -> begin ( M , * getTargetStreamer ( ) -> getTargetID ( ) ) ; if ( TM . getTargetTriple ( ) . getOS ( ) == Triple :: AMDPAL ) getTargetStreamer ( ) -> getPALMetadata ( ) -> readFromIR ( M ) ; if ( isHsaAbiVersion3Or4 ( getGlobalSTI ( ) ) ) return ; if ( TM . getTargetTriple ( ) . getOS ( ) == Triple :: AMDHSA ) getTargetStreamer ( ) -> EmitDirectiveHSACodeObjectVersion ( 2 , 1 ) ; IsaVersion Version = getIsaVersion ( getGlobalSTI ( ) -> getCPU ( ) ) ; getTargetStreamer ( ) -> EmitDirectiveHSACodeObjectISAV2 ( Version . Major , Version . Minor , Version . Stepping , "AMD" , "AMDGPU" ) ; } </s>

This virtual method can be overridden by targets that want to emit something at the start of their file .


<s>
SDNode
*
MipsDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
unsigned
Opcode
=
Node
->
getOpcode
(
)
;
DEBUG
(
errs
(
)
<<
"Selecting: "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
if
(
Node
->
isMachineOpcode
(
)
)
{
DEBUG
(
errs
(
)
<<
"== "
;
Node
->
dump
(
CurDAG
)
;
errs
(
)
<<
"\n"
)
;
Node
->
setNodeId
(
1
)
;
return
nullptr
;
}
std
::
pair
<
bool
,
SDNode
*
>
Ret
=
selectNode
(
Node
)
;
if
(
Ret
.
first
)
return
Ret
.
second
;
switch
(
Opcode
)
{
default
:
break
;
case
ISD
::
GLOBAL_OFFSET_TABLE
:
return
getGlobalBaseReg
(
)
;
case
ISD
::
LOAD
:
case
ISD
::
STORE
:
assert
(
(
Subtarget
.
systemSupportsUnalignedAccess
(
)
||
cast
<
MemSDNode
>
(
Node
)
->
getMemoryVT
(
)
.
getSizeInBits
(
)
/
8
<=
cast
<
MemSDNode
>
(
Node
)
->
getAlignment
(
)
)
&&
"Unexpected unaligned loads/stores."
)
;
break
;
}
SDNode
*
ResNode
=
SelectCode
(
Node
)
;
DEBUG
(
errs
(
)
<<
"=> "
)
;
if
(
ResNode
==
nullptr
||
ResNode
==
Node
)
DEBUG
(
Node
->
dump
(
CurDAG
)
)
;
else
DEBUG
(
ResNode
->
dump
(
CurDAG
)
)
;
DEBUG
(
errs
(
)
<<
"\n"
)
;
return
ResNode
;
}
</s>

Main hook for targets to transform nodes into machine nodes .

Mips
Mips
"Selecting: "
"\n"
"== "
"\n"
1
ISD::GLOBAL_OFFSET_TABLE
ISD::LOAD
ISD::STORE
8
"Unexpected unaligned loads/stores."
"=> "
"\n"


<s> static bool mips_no_speculation_in_delay_slots_p ( ) { return TARGET_CB_MAYBE ; } </s>


<s> static void c4x_file_start ( void ) { default_file_start ( ) ; fprintf ( asm_out_file , "\t.version\t%d\n" , c4x_cpu_version ) ; fputs ( "\n\t.data\ndata_sec:\n" , asm_out_file ) ; } </s>

We need to have a data section we can identify so that we can set the DP register back to a data pointer in the small memory model . This is only required for ISRs if we are paranoid that someone may have quietly changed this register on the sly .


<s>
void
HexagonHazardRecognizer
::
AdvanceCycle
(
)
{
DEBUG
(
dbgs
(
)
<<
"Advance cycle, clear state\n"
)
;
Resources
->
clearResources
(
)
;
if
(
DotCurPNum
!=
1
&&
DotCurPNum
!=
(
int
)
PacketNum
)
{
UsesDotCur
=
nullptr
;
DotCurPNum
=
1
;
}
UsesLoad
=
false
;
PrefVectorStoreNew
=
nullptr
;
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> bool MipsTargetELFStreamer :: emitDirectiveCpRestore ( int Offset , function_ref < unsigned ( ) > GetATReg , SMLoc IDLoc , const MCSubtargetInfo * STI ) { MipsTargetStreamer :: emitDirectiveCpRestore ( Offset , GetATReg , IDLoc , STI ) ; if ( ! Pic || ( getABI ( ) . IsN32 ( ) || getABI ( ) . IsN64 ( ) ) ) return true ; emitStoreWithImmOffset ( Mips :: SW , Mips :: GP , Mips :: SP , Offset , GetATReg , IDLoc , STI ) ; return true ; } </s>

Mips Mips Mips Mips::SW Mips::GP Mips::SP


<s> bool X86TargetLowering :: isVectorClearMaskLegal ( ArrayRef < int > Mask , EVT VT ) const { if ( ! Subtarget . hasAVX2 ( ) ) if ( VT == MVT :: v32i8 || VT == MVT :: v16i16 ) return false ; return isShuffleMaskLegal ( Mask , VT ) ; } </s>


<s>
SDValue
AMDGPUTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
Op
->
dump
(
&
DAG
)
;
llvm_unreachable
(
"Custom lowering code for this"
"instruction is not implemented yet!"
)
;
break
;
case
ISD
::
SIGN_EXTEND_INREG
:
return
LowerSIGN_EXTEND_INREG
(
Op
,
DAG
)
;
case
ISD
::
CONCAT_VECTORS
:
return
LowerCONCAT_VECTORS
(
Op
,
DAG
)
;
case
ISD
::
EXTRACT_SUBVECTOR
:
return
LowerEXTRACT_SUBVECTOR
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
UDIVREM
:
return
LowerUDIVREM
(
Op
,
DAG
)
;
case
ISD
::
SDIVREM
:
return
LowerSDIVREM
(
Op
,
DAG
)
;
case
ISD
::
FREM
:
return
LowerFREM
(
Op
,
DAG
)
;
case
ISD
::
FCEIL
:
return
LowerFCEIL
(
Op
,
DAG
)
;
case
ISD
::
FTRUNC
:
return
LowerFTRUNC
(
Op
,
DAG
)
;
case
ISD
::
FRINT
:
return
LowerFRINT
(
Op
,
DAG
)
;
case
ISD
::
FNEARBYINT
:
return
LowerFNEARBYINT
(
Op
,
DAG
)
;
case
ISD
::
FROUND
:
return
LowerFROUND
(
Op
,
DAG
)
;
case
ISD
::
FFLOOR
:
return
LowerFFLOOR
(
Op
,
DAG
)
;
case
ISD
::
SINT_TO_FP
:
return
LowerSINT_TO_FP
(
Op
,
DAG
)
;
case
ISD
::
UINT_TO_FP
:
return
LowerUINT_TO_FP
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_FP16
:
return
LowerFP_TO_FP16
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_SINT
:
return
LowerFP_TO_SINT
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_UINT
:
return
LowerFP_TO_UINT
(
Op
,
DAG
)
;
case
ISD
::
CTLZ
:
case
ISD
::
CTLZ_ZERO_UNDEF
:
return
LowerCTLZ
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
}
return
Op
;
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> AVRTargetLowering :: ConstraintType AVRTargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'a' : case 'b' : case 'd' : case 'l' : case 'e' : case 'q' : case 'r' : case 'w' : return C_RegisterClass ; case 't' : case 'x' : case 'X' : case 'y' : case 'Y' : case 'z' : case 'Z' : return C_Register ; case 'Q' : return C_Memory ; case 'G' : case 'I' : case 'J' : case 'K' : case 'L' : case 'M' : case 'N' : case 'O' : case 'P' : case 'R' : return C_Immediate ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s> static bool prologue_saved_reg_p ( unsigned regno ) { gcc_assert ( GP_REG_P ( regno ) ) ; if ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) return true ; if ( regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed ) return true ; if ( regno == PIC_OFFSET_TABLE_REGNUM && crtl -> uses_pic_offset_table ) return true ; if ( regno == RA_REGNO && df_regs_ever_live_p ( RA_REGNO ) ) return true ; return false ; } </s>

Return true if REGNO should be saved in the prologue .


<s> int pa_attr_length_call ( rtx_insn * insn , int sibcall ) { int local_call ; rtx call , call_dest ; tree call_decl ; int length = 0 ; rtx pat = PATTERN ( insn ) ; unsigned long distance = - 1 ; gcc_assert ( CALL_P ( insn ) ) ; if ( INSN_ADDRESSES_SET_P ( ) ) { unsigned long total ; total = IN_NAMED_SECTION_P ( cfun -> decl ) ? 0 : total_code_bytes ; distance = ( total + insn_current_reference_address ( insn ) ) ; if ( distance < total ) distance = - 1 ; } gcc_assert ( GET_CODE ( pat ) == PARALLEL ) ; call = XVECEXP ( pat , 0 , 0 ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; gcc_assert ( GET_CODE ( call ) == CALL ) ; call_dest = XEXP ( XEXP ( call , 0 ) , 0 ) ; call_decl = SYMBOL_REF_DECL ( call_dest ) ; local_call = call_decl && targetm . binds_local_p ( call_decl ) ; if ( ! TARGET_LONG_CALLS && ( ( TARGET_PA_20 && ! sibcall && distance < 7600000 ) || distance < MAX_PCREL17F_OFFSET ) ) length += 8 ; else if ( TARGET_64BIT && ! local_call ) length += sibcall ? 28 : 24 ; else if ( ( TARGET_LONG_ABS_CALL || local_call ) && ! flag_pic ) length += 12 ; else if ( TARGET_LONG_PIC_SDIFF_CALL || ( TARGET_GAS && ! TARGET_SOM && local_call ) ) { length += 20 ; if ( ! TARGET_PA_20 && ! TARGET_NO_SPACE_REGS && ( ! local_call || flag_pic ) ) length += 8 ; } else { length += 32 ; if ( TARGET_SOM ) length += length_fp_args ( insn ) ; if ( flag_pic ) length += 4 ; if ( ! TARGET_PA_20 ) { if ( ! sibcall ) length += 8 ; if ( ! TARGET_NO_SPACE_REGS && ( ! local_call || flag_pic ) ) length += 8 ; } } return length ; } </s>

Return the attribute length of the call instruction INSN . The SIBCALL flag indicates whether INSN is a regular call or a sibling call . The length returned must be longer than the code actually generated by pa_output_call . Since branch shortening is done before delay branch sequencing , there is no way to determine whether or not the delay slot will be filled during branch shortening . Even when the delay slot is filled , we may have to add a nop if the delay slot contains a branch that ca n't reach its target . Thus , we always have to include the delay slot in the length estimate . This used to be done in pa_adjust_insn_length but we do it here now as some sequences always fill the delay slot and we can save four bytes in the estimate for these sequences .


<s> void ARMPassConfig :: addPreSched2 ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) { if ( EnableARMLoadStoreOpt ) addPass ( createARMLoadStoreOptimizationPass ( ) ) ; addPass ( new ARMExecutionDepsFix ( ) ) ; } addPass ( createARMExpandPseudoPass ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createThumb2SizeReductionPass ( [ this ] ( const Function & F ) { return this -> TM -> getSubtarget < ARMSubtarget > ( F ) . restrictIT ( ) ; } ) ) ; addPass ( createIfConverter ( [ ] ( const MachineFunction & MF ) { return ! MF . getSubtarget < ARMSubtarget > ( ) . isThumb1Only ( ) ; } ) ) ; } addPass ( createThumb2ITBlockPass ( ) ) ; } </s>


<s>
SDValue
MSP430TargetLowering
::
LowerReturn
(
SDValue
Chain
,
CallingConv
::
ID
CallConv
,
bool
isVarArg
,
const
SmallVectorImpl
<
ISD
::
OutputArg
>
&
Outs
,
const
SmallVectorImpl
<
SDValue
>
&
OutVals
,
DebugLoc
dl
,
SelectionDAG
&
DAG
)
const
{
SmallVector
<
CCValAssign
,
16
>
RVLocs
;
if
(
CallConv
==
CallingConv
::
MSP430_INTR
&&
!
Outs
.
empty
(
)
)
report_fatal_error
(
"ISRs cannot return any value"
)
;
CCState
CCInfo
(
CallConv
,
isVarArg
,
DAG
.
getMachineFunction
(
)
,
getTargetMachine
(
)
,
RVLocs
,
*
DAG
.
getContext
(
)
)
;
CCInfo
.
AnalyzeReturn
(
Outs
,
RetCC_MSP430
)
;
SDValue
Flag
;
SmallVector
<
SDValue
,
4
>
RetOps
(
1
,
Chain
)
;
for
(
unsigned
i
=
0
;
i
!=
RVLocs
.
size
(
)
;
++
i
)
{
CCValAssign
&
VA
=
RVLocs
[
i
]
;
assert
(
VA
.
isRegLoc
(
)
&&
"Can only return in registers!"
)
;
Chain
=
DAG
.
getCopyToReg
(
Chain
,
dl
,
VA
.
getLocReg
(
)
,
OutVals
[
i
]
,
Flag
)
;
Flag
=
Chain
.
getValue
(
1
)
;
RetOps
.
push_back
(
DAG
.
getRegister
(
VA
.
getLocReg
(
)
,
VA
.
getLocVT
(
)
)
)
;
}
unsigned
Opc
=
(
CallConv
==
CallingConv
::
MSP430_INTR
MSP430ISD
::
RETI_FLAG
:
MSP430ISD
::
RET_FLAG
)
;
RetOps
[
0
]
=
Chain
;
if
(
Flag
.
getNode
(
)
)
RetOps
.
push_back
(
Flag
)
;
return
DAG
.
getNode
(
Opc
,
dl
,
MVT
::
Other
,
&
RetOps
[
0
]
,
RetOps
.
size
(
)
)
;
}
</s>

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


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

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


Add a function to the list of static constructors .


<s> void PPCTargetLowering :: initializeSplitCSR ( MachineBasicBlock * Entry ) const { if ( ! Subtarget . isPPC64 ( ) ) return ; PPCFunctionInfo * PFI = Entry -> getParent ( ) -> getInfo < PPCFunctionInfo > ( ) ; PFI -> setIsSplitCSR ( true ) ; } </s>

Perform necessary initialization to handle a subset of CSRs explicitly via copies .


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { Subtarget = & MF . getSubtarget < VESubtarget > ( ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ; } </s>

runOnMachineFunction - Emit the function body .


<s>
bool
SITargetLowering
::
isLegalAddressingMode
(
const
DataLayout
&
DL
,
const
AddrMode
&
AM
,
Type
*
Ty
,
unsigned
AS
)
const
{
if
(
AM
.
BaseGV
)
return
false
;
if
(
AS
==
AMDGPUASI
.
GLOBAL_ADDRESS
)
{
if
(
Subtarget
->
getGeneration
(
)
>=
SISubtarget
::
VOLCANIC_ISLANDS
)
{
return
isLegalFlatAddressingMode
(
AM
)
;
}
return
isLegalMUBUFAddressingMode
(
AM
)
;
}
else
if
(
AS
==
AMDGPUASI
.
CONSTANT_ADDRESS
)
{
if
(
AM
.
BaseOffs
%
4
!=
0
)
return
isLegalMUBUFAddressingMode
(
AM
)
;
if
(
DL
.
getTypeStoreSize
(
Ty
)
<
4
)
return
isLegalMUBUFAddressingMode
(
AM
)
;
if
(
Subtarget
->
getGeneration
(
)
==
SISubtarget
::
SOUTHERN_ISLANDS
)
{
if
(
!
isUInt
<
8
>
(
AM
.
BaseOffs
/
4
)
)
return
false
;
}
else
if
(
Subtarget
->
getGeneration
(
)
==
SISubtarget
::
SEA_ISLANDS
)
{
if
(
!
isUInt
<
32
>
(
AM
.
BaseOffs
/
4
)
)
return
false
;
}
else
if
(
Subtarget
->
getGeneration
(
)
>=
SISubtarget
::
VOLCANIC_ISLANDS
)
{
if
(
!
isUInt
<
20
>
(
AM
.
BaseOffs
)
)
return
false
;
}
else
llvm_unreachable
(
"unhandled generation"
)
;
if
(
AM
.
Scale
==
0
)
return
true
;
if
(
AM
.
Scale
==
1
&&
AM
.
HasBaseReg
)
return
true
;
return
false
;
}
else
if
(
AS
==
AMDGPUASI
.
PRIVATE_ADDRESS
)
{
return
isLegalMUBUFAddressingMode
(
AM
)
;
}
else
if
(
AS
==
AMDGPUASI
.
LOCAL_ADDRESS
||
AS
==
AMDGPUASI
.
REGION_ADDRESS
)
{
if
(
!
isUInt
<
16
>
(
AM
.
BaseOffs
)
)
return
false
;
if
(
AM
.
Scale
==
0
)
return
true
;
if
(
AM
.
Scale
==
1
&&
AM
.
HasBaseReg
)
return
true
;
return
false
;
}
else
if
(
AS
==
AMDGPUASI
.
FLAT_ADDRESS
||
AS
==
AMDGPUASI
.
UNKNOWN_ADDRESS_SPACE
)
{
return
isLegalFlatAddressingMode
(
AM
)
;
}
else
{
llvm_unreachable
(
"unhandled address space"
)
;
}
}
</s>

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


<s> bool AArch64TargetLowering :: shouldSinkOperands ( Instruction * I , SmallVectorImpl < Use * > & Ops ) const { if ( ! I -> getType ( ) -> isVectorTy ( ) ) return false ; if ( IntrinsicInst * II = dyn_cast < IntrinsicInst > ( I ) ) { switch ( II -> getIntrinsicID ( ) ) { case Intrinsic :: aarch64_neon_umull : if ( ! areExtractShuffleVectors ( II -> getOperand ( 0 ) , II -> getOperand ( 1 ) ) ) return false ; Ops . push_back ( & II -> getOperandUse ( 0 ) ) ; Ops . push_back ( & II -> getOperandUse ( 1 ) ) ; return true ; case Intrinsic :: aarch64_neon_pmull64 : if ( ! areOperandsOfVmullHighP64 ( II -> getArgOperand ( 0 ) , II -> getArgOperand ( 1 ) ) ) return false ; Ops . push_back ( & II -> getArgOperandUse ( 0 ) ) ; Ops . push_back ( & II -> getArgOperandUse ( 1 ) ) ; return true ; default : return false ; } } switch ( I -> getOpcode ( ) ) { case Instruction :: Sub : case Instruction :: Add : { if ( ! areExtractExts ( I -> getOperand ( 0 ) , I -> getOperand ( 1 ) ) ) return false ; auto Ext1 = cast < Instruction > ( I -> getOperand ( 0 ) ) ; auto Ext2 = cast < Instruction > ( I -> getOperand ( 1 ) ) ; if ( areExtractShuffleVectors ( Ext1 , Ext2 ) ) { Ops . push_back ( & Ext1 -> getOperandUse ( 0 ) ) ; Ops . push_back ( & Ext2 -> getOperandUse ( 0 ) ) ; } Ops . push_back ( & I -> getOperandUse ( 0 ) ) ; Ops . push_back ( & I -> getOperandUse ( 1 ) ) ; return true ; } default : return false ; } return false ; } </s>

Return true if sinking I 's operands to the same basic block as I is profitable , e.g .


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


<s> bool Z80oldTargetLowering :: isLegalICmpImmediate ( int64_t Imm ) const { return isInt < 8 > ( Imm ) ; } </s>

Return true if the specified immediate is legal icmp immediate , that is the target has icmp instructions which can compare a register against the immediate without having to materialize the immediate into a register .


<s> bool HexagonConstEvaluator :: evaluate ( const MachineInstr & BrI , const CellMap & Inputs , SetVector < const MachineBasicBlock * > & Targets , bool & FallsThru ) { unsigned Opc = BrI . getOpcode ( ) ; bool SimpleBranch = false ; bool Negated = false ; switch ( Opc ) { case Hexagon :: J2_jumpf : case Hexagon :: J2_jumpfnew : case Hexagon :: J2_jumpfnewpt : Negated = true ; case Hexagon :: J2_jumpt : case Hexagon :: J2_jumptnew : case Hexagon :: J2_jumptnewpt : SimpleBranch = true ; break ; case Hexagon :: J2_jump : Targets . insert ( BrI . getOperand ( 0 ) . getMBB ( ) ) ; FallsThru = false ; return true ; default : Undetermined : FallsThru = ! BrI . isUnconditionalBranch ( ) ; return false ; } if ( SimpleBranch ) { const MachineOperand & MD = BrI . getOperand ( 0 ) ; Register PR ( MD ) ; if ( PR . SubReg ) goto Undetermined ; assert ( Inputs . has ( PR . Reg ) ) ; const LatticeCell & PredC = Inputs . get ( PR . Reg ) ; if ( PredC . isBottom ( ) ) goto Undetermined ; uint32_t Props = PredC . properties ( ) ; bool CTrue = false , CFalse = false ; if ( Props & ConstantProperties :: Zero ) CFalse = true ; else if ( Props & ConstantProperties :: NonZero ) CTrue = true ; if ( ! CTrue && ! CFalse ) goto Undetermined ; const MachineBasicBlock * BranchTarget = BrI . getOperand ( 1 ) . getMBB ( ) ; FallsThru = false ; if ( ( ! Negated && CTrue ) || ( Negated && CFalse ) ) Targets . insert ( BranchTarget ) ; else if ( ( ! Negated && CFalse ) || ( Negated && CTrue ) ) FallsThru = true ; else goto Undetermined ; } return true ; } </s>

evaluate - Evaluate Expr and append the resulting set to Elts .


"rs6000_secondary_memory_needed, return: %s, from_class = %s, "

Debug version of rs6000_secondary_memory_needed .


<s> bool isToken ( ) const { return Kind == k_Token ; } </s>


<s> int arm_const_double_inline_cost ( rtx val ) { rtx lowpart , highpart ; enum machine_mode mode ; mode = GET_MODE ( val ) ; if ( mode == VOIDmode ) mode = DImode ; gcc_assert ( GET_MODE_SIZE ( mode ) == 8 ) ; lowpart = gen_lowpart ( SImode , val ) ; highpart = gen_highpart_mode ( SImode , mode , val ) ; gcc_assert ( GET_CODE ( lowpart ) == CONST_INT ) ; gcc_assert ( GET_CODE ( highpart ) == CONST_INT ) ; return ( arm_gen_constant ( SET , SImode , NULL_RTX , INTVAL ( lowpart ) , NULL_RTX , NULL_RTX , 0 , 0 ) + arm_gen_constant ( SET , SImode , NULL_RTX , INTVAL ( highpart ) , NULL_RTX , NULL_RTX , 0 , 0 ) ) ; } </s>

Return the cost of synthesizing a 64-bit constant VAL inline . Returns the number of insns needed , or 99 if we do n't know how to do it .


<s> static unsigned riscv_save_libcall_count ( unsigned mask ) { for ( unsigned n = GP_REG_LAST ; n > GP_REG_FIRST ; n -- ) if ( BITSET_P ( mask , n ) ) return CALLEE_SAVED_REG_NUMBER ( n ) + 1 ; abort ( ) ; } </s>

Determine which GPR save/restore routine to call .


<s> bool SPIRVPreTranslationLegalizer :: runOnModule ( Module & M ) { std :: vector < Function * > FuncsWorklist ; bool Changed = false ; for ( auto & F : M ) FuncsWorklist . push_back ( & F ) ; for ( auto * Func : FuncsWorklist ) { auto * F = processFunctionSignature ( Func ) ; bool CreatedNewF = F != Func ; if ( Func -> isDeclaration ( ) ) { Changed |= CreatedNewF ; continue ; } if ( CreatedNewF ) Func -> eraseFromParent ( ) ; } return Changed ; } </s>

runOnModule - Virtual method overriden by subclasses to process the module being operated on .


<s> bool TPCTargetLowering :: isLegalAddressingMode ( const DataLayout & DL , const AddrMode & AM , Type * Ty , unsigned AddrSpace , Instruction * I ) const { if ( AM . BaseGV ) return false ; switch ( AM . Scale ) { case 0 : break ; case 1 : if ( AM . HasBaseReg && AM . BaseOffs ) return false ; if ( AM . BaseOffs && ! ( Subtarget -> getFeatureBits ( ) [ TPC :: FeatureAddr2 ] && AddrSpace == LOCAL_VECTOR ) ) return false ; break ; case 2 : if ( AM . HasBaseReg || AM . BaseOffs ) return false ; if ( ! Subtarget -> getFeatureBits ( ) [ TPC :: FeatureAddr2 ] || AddrSpace != LOCAL_VECTOR ) return false ; break ; default : return false ; } return true ; } </s>


<s> void ix86_expand_trunc ( rtx operand0 , rtx operand1 ) { machine_mode mode = GET_MODE ( operand0 ) ; rtx xa , xi , TWO52 , res , mask ; rtx_code_label * label ; TWO52 = ix86_gen_TWO52 ( mode ) ; res = copy_to_reg ( operand1 ) ; xa = ix86_expand_sse_fabs ( res , & mask ) ; label = ix86_expand_sse_compare_and_jump ( UNLE , TWO52 , xa , false ) ; xi = gen_reg_rtx ( int_mode_for_mode ( mode ) . require ( ) ) ; expand_fix ( xi , res , 0 ) ; expand_float ( xa , xi , 0 ) ; if ( HONOR_SIGNED_ZEROS ( mode ) ) ix86_sse_copysign_to_positive ( xa , xa , res , mask ) ; emit_move_insn ( res , xa ) ; emit_label ( label ) ; LABEL_NUSES ( label ) = 1 ; emit_move_insn ( operand0 , res ) ; } </s>

Expand SSE sequence for computing trunc from OPERAND1 storing into OPERAND0 .


<s> static bool pru_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) { if ( to == STACK_POINTER_REGNUM ) return ! frame_pointer_needed ; return true ; } </s>


<s> bool mprocInstrInfo :: isUnpredicatedTerminator ( const MachineInstr * MI ) const { if ( ! MI -> isTerminator ( ) ) return false ; if ( MI -> isBranch ( ) && ! MI -> isBarrier ( ) ) return true ; if ( ! MI -> isPredicable ( ) ) return true ; return ! isPredicated ( MI ) ; } </s>

Returns true if the instruction is a terminator instruction that has not been predicated .


<s> static int write_arg_type ( std :: stringstream & s , int for_reg , int argno , tree type , bool prototyped ) { machine_mode mode = TYPE_MODE ( type ) ; if ( mode == VOIDmode ) return argno ; if ( pass_in_memory ( mode , type , false ) ) mode = Pmode ; else { bool split = TREE_CODE ( type ) == COMPLEX_TYPE ; if ( split ) { type = TREE_TYPE ( type ) ; mode = TYPE_MODE ( type ) ; prototyped = true ; } mode = promote_arg ( mode , prototyped ) ; if ( split ) argno = write_arg_mode ( s , for_reg , argno , mode ) ; } return write_arg_mode ( s , for_reg , argno , mode ) ; } </s>

Process function parameter TYPE to emit one or more PTX arguments . S , FOR_REG and ARGNO as for write_arg_mode . PROTOTYPED is true , if this is a prototyped function , rather than an old-style C declaration . Returns the next argument number to use . The promotion behavior here must match the regular GCC function parameter marshalling machinery .


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

Get the number of target specific fixup kinds .


<s> bool R600InstrInfo :: PredicateInstruction ( MachineInstr & MI , ArrayRef < MachineOperand > Pred ) const { int PIdx = MI . findFirstPredOperandIdx ( ) ; if ( MI . getOpcode ( ) == AMDGPU :: CF_ALU ) { MI . getOperand ( 8 ) . setImm ( 0 ) ; return true ; } if ( MI . getOpcode ( ) == AMDGPU :: DOT_4 ) { MI . getOperand ( getOperandIdx ( MI , AMDGPU :: OpName :: pred_sel_X ) ) . setReg ( Pred [ 2 ] . getReg ( ) ) ; MI . getOperand ( getOperandIdx ( MI , AMDGPU :: OpName :: pred_sel_Y ) ) . setReg ( Pred [ 2 ] . getReg ( ) ) ; MI . getOperand ( getOperandIdx ( MI , AMDGPU :: OpName :: pred_sel_Z ) ) . setReg ( Pred [ 2 ] . getReg ( ) ) ; MI . getOperand ( getOperandIdx ( MI , AMDGPU :: OpName :: pred_sel_W ) ) . setReg ( Pred [ 2 ] . getReg ( ) ) ; MachineInstrBuilder MIB ( * MI . getParent ( ) -> getParent ( ) , MI ) ; MIB . addReg ( AMDGPU :: PREDICATE_BIT , RegState :: Implicit ) ; return true ; } if ( PIdx != - 1 ) { MachineOperand & PMO = MI . getOperand ( PIdx ) ; PMO . setReg ( Pred [ 2 ] . getReg ( ) ) ; MachineInstrBuilder MIB ( * MI . getParent ( ) -> getParent ( ) , MI ) ; MIB . addReg ( AMDGPU :: PREDICATE_BIT , RegState :: Implicit ) ; return true ; } return false ; } </s>

Convert the instruction into a predicated instruction .


<s> void nvptx_expand_oacc_fork ( unsigned mode ) { nvptx_emit_forking ( GOMP_DIM_MASK ( mode ) , false ) ; } </s>

Expand the oacc fork & join primitive into ptx-required unspecs .


<s> bool isPredicate ( ) const { return Kind == OpKind :: Predicate ; } </s>

Set if this is one of the operands that made up of the predicate operand that controls an isPredicable ( ) instruction .


<s> rtx alpha_emit_setcc ( enum rtx_code code ) { enum rtx_code cmp_code ; rtx op0 = alpha_compare . op0 , op1 = alpha_compare . op1 ; int fp_p = alpha_compare . fp_p ; rtx tmp ; memset ( & alpha_compare , 0 , sizeof ( alpha_compare ) ) ; if ( fp_p && GET_MODE ( op0 ) == TFmode ) { op0 = alpha_emit_xfloating_compare ( & code , op0 , op1 ) ; op1 = const0_rtx ; fp_p = 0 ; } if ( fp_p && ! TARGET_FIX ) return NULL_RTX ; cmp_code = UNKNOWN ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : if ( fp_p ) cmp_code = code , code = NE ; break ; case NE : if ( ! fp_p && op1 == const0_rtx ) break ; case ORDERED : cmp_code = reverse_condition ( code ) ; code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( ! fp_p && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( fp_p ) cmp_code = code , code = NE ; tmp = op0 , op0 = op1 , op1 = tmp ; break ; default : gcc_unreachable ( ) ; } if ( ! fp_p ) { if ( ! register_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( cmp_code != UNKNOWN ) { enum machine_mode mode = fp_p ? DFmode : DImode ; tmp = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp , gen_rtx_fmt_ee ( cmp_code , mode , op0 , op1 ) ) ) ; op0 = fp_p ? gen_lowpart ( DImode , tmp ) : tmp ; op1 = const0_rtx ; } return gen_rtx_fmt_ee ( code , DImode , op0 , op1 ) ; } </s>

Certain simplifications can be done to make invalid setcc operations valid . Return the final comparison , or NULL if we ca n't work .


<s> void split_subsi ( rtx * operands ) { int val = INTVAL ( operands [ 1 ] ) ; if ( satisfies_constraint_Rcq ( operands [ 0 ] ) && satisfies_constraint_Rcq ( operands [ 2 ] ) ) { if ( val >= - 31 && val <= 127 ) { operands [ 3 ] = gen_rtx_NEG ( SImode , operands [ 2 ] ) ; operands [ 4 ] = gen_rtx_PLUS ( SImode , operands [ 0 ] , operands [ 1 ] ) ; return ; } else if ( val >= 0 && val < 255 ) { operands [ 3 ] = operands [ 1 ] ; operands [ 4 ] = gen_rtx_MINUS ( SImode , operands [ 0 ] , operands [ 2 ] ) ; return ; } } operands [ 3 ] = operands [ 2 ] ; operands [ 4 ] = gen_rtx_MINUS ( SImode , operands [ 1 ] , operands [ 0 ] ) ; } </s>

Operands 0 .. 2 are the operands of a subsi which uses a 12 bit constant in operand 1 , but which would require a LIMM because of operand mismatch . operands 3 and 4 are new SET_SRCs for operands 0 .


<s> static bool nds32_legitimate_index_p ( machine_mode outer_mode , rtx index , bool strict ) { int regno ; rtx op0 ; rtx op1 ; switch ( GET_CODE ( index ) ) { case REG : regno = REGNO ( index ) ; if ( strict ) return REGNO_OK_FOR_INDEX_P ( regno ) ; else return true ; case CONST_INT : switch ( GET_MODE_SIZE ( outer_mode ) ) { case 1 : if ( satisfies_constraint_Is15 ( index ) ) return true ; break ; case 2 : if ( satisfies_constraint_Is16 ( index ) ) { if ( ! cfun -> machine -> strict_aligned_p ) return true ; else if ( NDS32_HALF_WORD_ALIGN_P ( INTVAL ( index ) ) ) return true ; } break ; case 4 : if ( satisfies_constraint_Is17 ( index ) ) { if ( ( TARGET_FPU_SINGLE || TARGET_FPU_DOUBLE ) ) { if ( ! satisfies_constraint_Is14 ( index ) ) return false ; } if ( ! cfun -> machine -> strict_aligned_p ) return true ; else if ( NDS32_SINGLE_WORD_ALIGN_P ( INTVAL ( index ) ) ) return true ; } break ; case 8 : if ( satisfies_constraint_Is17 ( gen_int_mode ( INTVAL ( index ) + 4 , SImode ) ) ) { if ( ( TARGET_FPU_SINGLE || TARGET_FPU_DOUBLE ) ) { if ( ! satisfies_constraint_Is14 ( index ) ) return false ; } if ( ! cfun -> machine -> strict_aligned_p ) return true ; else if ( NDS32_SINGLE_WORD_ALIGN_P ( INTVAL ( index ) ) ) return true ; } break ; default : return false ; } return false ; case MULT : op0 = XEXP ( index , 0 ) ; op1 = XEXP ( index , 1 ) ; if ( REG_P ( op0 ) && CONST_INT_P ( op1 ) ) { int multiplier ; multiplier = INTVAL ( op1 ) ; if ( multiplier != 1 && multiplier != 2 && multiplier != 4 && multiplier != 8 ) return false ; regno = REGNO ( op0 ) ; if ( strict ) return REGNO_OK_FOR_INDEX_P ( regno ) ; else return true ; } return false ; case ASHIFT : op0 = XEXP ( index , 0 ) ; op1 = XEXP ( index , 1 ) ; if ( REG_P ( op0 ) && CONST_INT_P ( op1 ) ) { int sv ; sv = INTVAL ( op1 ) ; if ( sv != 0 && sv != 1 && sv != 2 && sv != 3 ) return false ; regno = REGNO ( op0 ) ; if ( strict ) return REGNO_OK_FOR_INDEX_P ( regno ) ; else return true ; } return false ; default : return false ; } } </s>

Function that check if 'INDEX ' is valid to be a index rtx for address . OUTER_MODE : Machine mode of outer address rtx . INDEX : Check if this rtx is valid to be a index for address . STRICT : If it is true , we are in reload pass or after reload pass .


<s> static void s390_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == VAR_DECL ) { if ( DECL_USER_ALIGN ( decl ) && DECL_ALIGN ( decl ) < 16 ) SYMBOL_REF_FLAGS ( XEXP ( rtl , 0 ) ) |= SYMBOL_FLAG_ALIGN1 ; if ( ! DECL_SIZE ( decl ) || ! DECL_ALIGN ( decl ) || ! tree_fits_shwi_p ( DECL_SIZE ( decl ) ) || ( DECL_ALIGN ( decl ) <= 64 && DECL_ALIGN ( decl ) != tree_to_shwi ( DECL_SIZE ( decl ) ) ) ) SYMBOL_REF_FLAGS ( XEXP ( rtl , 0 ) ) |= SYMBOL_FLAG_NOT_NATURALLY_ALIGNED ; } if ( MEM_P ( rtl ) && GET_CODE ( XEXP ( rtl , 0 ) ) == SYMBOL_REF && TREE_CONSTANT_POOL_ADDRESS_P ( XEXP ( rtl , 0 ) ) && ( MEM_ALIGN ( rtl ) == 0 || GET_MODE_BITSIZE ( GET_MODE ( rtl ) ) == 0 || MEM_ALIGN ( rtl ) < GET_MODE_BITSIZE ( GET_MODE ( rtl ) ) ) ) SYMBOL_REF_FLAGS ( XEXP ( rtl , 0 ) ) |= SYMBOL_FLAG_NOT_NATURALLY_ALIGNED ; } </s>

Encode symbol attributes ( local vs. global , tls model ) of a SYMBOL_REF into its SYMBOL_REF_FLAGS .


<s> bool PPCRegisterInfo :: hasReservedSpillSlot ( const MachineFunction & MF , unsigned Reg , int & FrameIdx ) const { const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; if ( Subtarget . isSVR4ABI ( ) && PPC :: CR2 <= Reg && Reg <= PPC :: CR4 ) { if ( TM . isPPC64 ( ) ) FrameIdx = 0 ; else { const PPCFunctionInfo * FI = MF . getInfo < PPCFunctionInfo > ( ) ; FrameIdx = FI -> getCRSpillFrameIndex ( ) ; } return true ; } return false ; } </s>

Return true if target has reserved a spill slot in the stack frame of the given function for the specified register .

PowerPC PPC PPC PPC PPC::CR2 PPC::CR4 PPC 0 PPC PPC


<s> rtx function_expander :: use_vcond_mask_insn ( insn_code icode , unsigned int merge_argno ) { machine_mode mode = vector_mode ( 0 ) ; unsigned int opno = 0 ; rtx false_arg = get_fallback_value ( mode , 1 , merge_argno , opno ) ; rtx pred_arg = args [ opno ++ ] ; rtx true_arg = args [ opno ++ ] ; add_output_operand ( icode ) ; add_input_operand ( icode , true_arg ) ; add_input_operand ( icode , false_arg ) ; add_input_operand ( icode , pred_arg ) ; return generate_insn ( icode ) ; } </s>

Implement the call using instruction ICODE , which is a select-like operation with the following operands : 0 : output 1 : true value 2 : false value 3 : predicate MERGE_ARGNO is the argument that provides the `` false '' value for _m functions , or DEFAULT_MERGE_ARGNO if we should apply the usual rules .


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

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


<s> const char * sh_symbian_strip_name_encoding ( const char * name ) { int skip ; while ( ( skip = sh_symbian_get_strip_length ( * name ) ) ) name += skip ; return name ; } </s>

Return a pointer to a function 's name with any and all prefix encodings stripped from it .


<s> bool SIAnnotateControlFlow :: runOnFunction ( Function & F ) { DT = & getAnalysis < DominatorTree > ( ) ; for ( df_iterator < BasicBlock * > I = df_begin ( & F . getEntryBlock ( ) ) , E = df_end ( & F . getEntryBlock ( ) ) ; I != E ; ++ I ) { BranchInst * Term = dyn_cast < BranchInst > ( ( * I ) -> getTerminator ( ) ) ; if ( ! Term || Term -> isUnconditional ( ) ) { if ( isTopOfStack ( * I ) ) closeControlFlow ( * I ) ; continue ; } if ( I . nodeVisited ( Term -> getSuccessor ( 1 ) ) ) { if ( isTopOfStack ( * I ) ) closeControlFlow ( * I ) ; handleLoop ( Term ) ; continue ; } if ( isTopOfStack ( * I ) ) { PHINode * Phi = dyn_cast < PHINode > ( Term -> getCondition ( ) ) ; if ( Phi && Phi -> getParent ( ) == * I && isElse ( Phi ) ) { insertElse ( Term ) ; eraseIfUnused ( Phi ) ; continue ; } closeControlFlow ( * I ) ; } openIf ( Term ) ; } assert ( Stack . empty ( ) ) ; return true ; } </s>

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


<s> bool pa_modes_tieable_p ( machine_mode mode1 , machine_mode mode2 ) { if ( GET_MODE_CLASS ( mode1 ) != GET_MODE_CLASS ( mode2 ) ) return false ; return true ; } </s>

Returns TRUE if it is a good idea to tie two pseudo registers when one has mode MODE1 and one has mode MODE2 . If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2 , for any hard reg , then this must be FALSE for correct output . We should return FALSE for QImode and HImode because these modes are not ok in the floating-point registers . However , this prevents tieing these modes to SImode and DImode in the general registers . So , this is n't a good idea . We rely on HARD_REGNO_MODE_OK and CANNOT_CHANGE_MODE_CLASS to prevent these modes from being used in the floating-point registers .


<s> bool Z80TargetLowering :: isLegalAddressingMode ( const AddrMode & AM , Type * Ty ) const { if ( AM . BaseGV ) return false ; switch ( AM . Scale ) { case 0 : break ; case 1 : if ( ! AM . HasBaseReg ) break ; return false ; default : return false ; } return true ; } </s>

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


"switch %<-mcustom-%s%> value %d must be between 0 and 255"

Check individual FPU insn options , and register custom code .


<s> int X86FrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , unsigned & FrameReg ) const { const X86RegisterInfo * RegInfo = static_cast < const X86RegisterInfo * > ( MF . getTarget ( ) . getRegisterInfo ( ) ) ; if ( RegInfo -> hasBasePointer ( MF ) ) FrameReg = RegInfo -> getBaseRegister ( ) ; else if ( RegInfo -> needsStackRealignment ( MF ) ) FrameReg = RegInfo -> getStackRegister ( ) ; else FrameReg = RegInfo -> getFrameRegister ( MF ) ; return getFrameIndexOffset ( MF , FI ) ; } </s>

getFrameIndexReference - This method should return the base register and offset used to reference a frame index location .


<s> tree xstormy16_build_va_list ( ) { tree f_1 , f_2 , record , type_decl ; record = make_lang_type ( RECORD_TYPE ) ; type_decl = build_decl ( TYPE_DECL , get_identifier ( "__va_list_tag" ) , record ) ; f_1 = build_decl ( FIELD_DECL , get_identifier ( "base" ) , ptr_type_node ) ; f_2 = build_decl ( FIELD_DECL , get_identifier ( "count" ) , unsigned_type_node ) ; DECL_FIELD_CONTEXT ( f_1 ) = record ; DECL_FIELD_CONTEXT ( f_2 ) = record ; TREE_CHAIN ( record ) = type_decl ; TYPE_NAME ( record ) = type_decl ; TYPE_FIELDS ( record ) = f_1 ; TREE_CHAIN ( f_1 ) = f_2 ; layout_type ( record ) ; return record ; } </s>

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


<s>
unsigned
getReg
(
)
const
override
{
assert
(
(
Kind
==
k_Register
||
Kind
==
k_CCOut
)
&&
"Invalid access!"
)
;
return
Reg
.
RegNum
;
}
</s>

Returns the register associated with this edge .


<s> tree s390_valid_target_attribute_tree ( tree args , struct gcc_options * opts , const struct gcc_options * opts_set , bool force_pragma ) { tree t = NULL_TREE ; struct gcc_options new_opts_set ; memset ( & new_opts_set , 0 , sizeof ( new_opts_set ) ) ; if ( ! s390_valid_target_attribute_inner_p ( args , opts , & new_opts_set , force_pragma ) ) return error_mark_node ; if ( new_opts_set . x_target_flags || new_opts_set . x_s390_arch || new_opts_set . x_s390_tune || new_opts_set . x_s390_stack_guard || new_opts_set . x_s390_stack_size || new_opts_set . x_s390_branch_cost || new_opts_set . x_s390_warn_framesize || new_opts_set . x_s390_warn_dynamicstack_p ) { const unsigned char * src = ( const unsigned char * ) opts_set ; unsigned char * dest = ( unsigned char * ) & new_opts_set ; unsigned int i ; for ( i = 0 ; i < sizeof ( * opts_set ) ; i ++ ) dest [ i ] |= src [ i ] ; s390_option_override_internal ( false , opts , & new_opts_set ) ; t = build_target_option_node ( opts ) ; } return t ; } </s>

Return a TARGET_OPTION_NODE tree of the target options listed or NULL .


<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 } , } ; if ( ! HasNopl ) { for ( uint64_t i = 0 ; i < Count ; ++ i ) OW -> write8 ( 0x90 ) ; return true ; } do { const uint8_t ThisNopLength = ( uint8_t ) std :: min ( Count , MaxNopLength ) ; const uint8_t Prefixes = ThisNopLength <= 10 ? 0 : ThisNopLength - 10 ; for ( uint8_t i = 0 ; i < Prefixes ; i ++ ) OW -> write8 ( 0x66 ) ; const uint8_t Rest = ThisNopLength - Prefixes ; for ( uint8_t i = 0 ; i < Rest ; i ++ ) OW -> write8 ( Nops [ Rest - 1 ] [ i ] ) ; Count -= ThisNopLength ; } while ( Count != 0 ) ; return true ; } </s>

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


<s> static void arm_sched_fusion_priority ( rtx_insn * insn , int max_pri , int * fusion_pri , int * pri ) { int tmp , off_val ; bool is_load ; rtx base , offset ; gcc_assert ( INSN_P ( insn ) ) ; tmp = max_pri - 1 ; if ( ! fusion_load_store ( insn , & base , & offset , & is_load ) ) { * pri = tmp ; * fusion_pri = tmp ; return ; } if ( is_load ) * fusion_pri = tmp - 1 ; else * fusion_pri = tmp - 2 ; tmp /= 2 ; tmp -= ( ( REGNO ( base ) & 0xff ) << 20 ) ; off_val = ( int ) ( INTVAL ( offset ) ) ; if ( off_val >= 0 ) tmp -= ( off_val & 0xfffff ) ; else tmp += ( ( - off_val ) & 0xfffff ) ; * pri = tmp ; return ; } </s>

Implement the TARGET_SCHED_FUSION_PRIORITY hook . Currently we only support to fuse ldr or str instructions , so FUSION_PRI and PRI are only calculated for these instructions . For other instruction , FUSION_PRI and PRI are simply set to MAX_PRI . In the future , other kind instruction fusion can be supported by returning different priorities . It 's important that irrelevant instructions get the largest FUSION_PRI .


<s> bool isBlockAddress ( ) const { return Kind == CSKYCP :: CPBlockAddress ; } </s>

isBlockAddress - Tests if this is a MO_BlockAddress operand .


<s>
const
char
*
output_ubranch
(
rtx
dest
,
rtx_insn
*
insn
)
{
static
char
string
[
64
]
;
bool
v9_form
=
false
;
int
delta
;
char
*
p
;
delta
=
5000000
;
if
(
!
CROSSING_JUMP_P
(
insn
)
&&
INSN_ADDRESSES_SET_P
(
)
)
delta
=
(
INSN_ADDRESSES
(
INSN_UID
(
dest
)
)
INSN_ADDRESSES
(
INSN_UID
(
insn
)
)
)
;
if
(
TARGET_V9
&&
delta
>=
260000
&&
delta
<
260000
)
v9_form
=
true
;
if
(
TARGET_CBCOND
)
{
bool
emit_nop
=
emit_cbcond_nop
(
insn
)
;
bool
far
=
false
;
const
char
*
rval
;
if
(
delta
<
500
||
delta
>
500
)
far
=
true
;
if
(
far
)
{
if
(
v9_form
)
rval
=
"ba,a,pt\t%%xcc, %l0"
;
else
rval
=
"b,a\t%l0"
;
}
else
{
if
(
emit_nop
)
rval
=
"cwbe\t%%g0, %%g0, %l0\n\tnop"
;
else
rval
=
"cwbe\t%%g0, %%g0, %l0"
;
}
return
rval
;
}
if
(
v9_form
)
strcpy
(
string
,
"ba%*,pt\t%%xcc, "
)
;
else
strcpy
(
string
,
"b%*\t"
)
;
p
=
strchr
(
string
,
'\0'
)
;
*
p
++
=
'%'
;
*
p
++
=
'l'
;
*
p
++
=
'0'
;
*
p
++
=
'%'
;
*
p
++
=
'('
;
*
p
=
'\0'
;
return
string
;
}
</s>

Output an unconditional branch to LABEL . INSN is the instruction .


<s> static int compute_movmem_length ( rtx_insn * insn ) { rtx pat = PATTERN ( insn ) ; unsigned int align = INTVAL ( XEXP ( XVECEXP ( pat , 0 , 7 ) , 0 ) ) ; unsigned long n_bytes = INTVAL ( XEXP ( XVECEXP ( pat , 0 , 6 ) , 0 ) ) ; unsigned int n_insns = 0 ; if ( align > ( TARGET_64BIT ? 8 : 4 ) ) align = ( TARGET_64BIT ? 8 : 4 ) ; n_insns = 6 ; if ( n_bytes % ( 2 * align ) != 0 ) { if ( ( n_bytes % ( 2 * align ) ) >= align ) n_insns += 2 ; if ( ( n_bytes % align ) != 0 ) n_insns += 2 ; } return n_insns * 4 ; } </s>

Count the number of insns necessary to handle this block move . Basic structure is the same as emit_block_move , except that we count insns rather than emit them .


processFunctionBeforeFrameFinalized - This method is called immediately before the specified function 's frame layout ( MF.getFrameInfo ( ) ) is finalized .


<s> static bool IsDef ( const NodeAddr < NodeBase * > BA ) { return BA . Addr -> getType ( ) == NodeAttrs :: Ref && BA . Addr -> getKind ( ) == NodeAttrs :: Def ; } </s>

Tests if this MemDepResult represents a query that is an instruction definition dependency .


"End of MachineConstPropagator (Changed="

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


<s> unsigned char M68kSubtarget :: classifyBlockAddressReference ( ) const { return M68kII :: MO_PC_RELATIVE_ADDRESS ; } </s>

Classify a blockaddress reference for the current subtarget according to how we should reference it in a non-pcrel context .


<s> bool AMDGPUPropagateAttributesEarly :: runOnFunction ( Function & F ) { if ( ! TM ) { auto * TPC = getAnalysisIfAvailable < TargetPassConfig > ( ) ; if ( ! TPC ) return false ; TM = & TPC -> getTM < TargetMachine > ( ) ; } if ( ! AMDGPU :: isEntryFunctionCC ( F . getCallingConv ( ) ) ) return false ; return AMDGPUPropagateAttributes ( TM , false ) . process ( F ) ; } </s>

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

AMDGPU AMDGPU AMDGPU::isEntryFunctionCC AMDGPU


"LowerFormalArguments Unhandled argument type: "

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


<s>
virtual
const
char
*
getPassName
(
)
const
{
return
"X86 DAG->DAG Instruction Selection"
;
}
</s>

getPassName - Return a nice clean name for a pass .


getTargetNodeName - This method returns the name of a target specific


<s> unsigned NyuziRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; return TFI -> hasFP ( MF ) ? Nyuzi :: FP_REG : Nyuzi :: SP_REG ; } </s>


<s> unsigned AllocateStack ( unsigned Size , unsigned Align ) { assert ( Align && ( ( Align - 1 ) & Align ) == 0 ) ; StackOffset = ( ( StackOffset + Align - 1 ) & ~ ( Align - 1 ) ) ; unsigned Result = StackOffset ; StackOffset += Size ; return Result ; } </s>

Version of AllocateStack with list of extra registers to be shadowed .


<s> bool X86PassConfig :: addPreEmitPass ( ) { bool ShouldPrint = false ; if ( getOptLevel ( ) != CodeGenOpt :: None && getX86Subtarget ( ) . hasSSE2 ( ) ) { PM -> add ( createExecutionDependencyFixPass ( & X86 :: VR128RegClass ) ) ; ShouldPrint = true ; } if ( getX86Subtarget ( ) . hasAVX ( ) && UseVZeroUpper ) { PM -> add ( createX86IssueVZeroUpperPass ( ) ) ; ShouldPrint = true ; } return ShouldPrint ; } </s>

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


"variables in %<__regio_symbol%> address space "

"pointers to %<__regio_symbol%> address space are prohibited"

Implement ` TARGET_INSERT_ATTRIBUTES ' . For PRU it 's used as a hook to provide better diagnostics for some invalid usages of the __regio_symbol address space . Any escapes of the following checks are supposed to be caught during the `` mov < mode > '' pattern expansion .


<s> static int rs6000_cpu_name_lookup ( const char * name ) { size_t i ; if ( name != NULL ) { for ( i = 0 ; i < ARRAY_SIZE ( processor_target_table ) ; i ++ ) if ( ! strcmp ( name , processor_target_table [ i ] . name ) ) return ( int ) i ; } return - 1 ; } </s>

Look up a processor name for -mcpu=xxx and -mtune=xxx . Return -1 if the name is invalid .


<s> bool AMDGPUInstructionSelector :: select ( MachineInstr & I ) { if ( I . isPHI ( ) ) return selectPHI ( I ) ; if ( ! I . isPreISelOpcode ( ) ) { if ( I . isCopy ( ) ) return selectCOPY ( I ) ; return true ; } switch ( I . getOpcode ( ) ) { case TargetOpcode :: G_AND : case TargetOpcode :: G_OR : case TargetOpcode :: G_XOR : if ( selectG_AND_OR_XOR ( I ) ) return true ; return selectImpl ( I , * CoverageInfo ) ; case TargetOpcode :: G_ADD : case TargetOpcode :: G_SUB : if ( selectImpl ( I , * CoverageInfo ) ) return true ; return selectG_ADD_SUB ( I ) ; case TargetOpcode :: G_UADDO : case TargetOpcode :: G_USUBO : return selectG_UADDO_USUBO ( I ) ; case TargetOpcode :: G_INTTOPTR : case TargetOpcode :: G_BITCAST : case TargetOpcode :: G_PTRTOINT : return selectCOPY ( I ) ; case TargetOpcode :: G_CONSTANT : case TargetOpcode :: G_FCONSTANT : return selectG_CONSTANT ( I ) ; case TargetOpcode :: G_EXTRACT : return selectG_EXTRACT ( I ) ; case TargetOpcode :: G_MERGE_VALUES : case TargetOpcode :: G_BUILD_VECTOR : case TargetOpcode :: G_CONCAT_VECTORS : return selectG_MERGE_VALUES ( I ) ; case TargetOpcode :: G_UNMERGE_VALUES : return selectG_UNMERGE_VALUES ( I ) ; case TargetOpcode :: G_PTR_ADD : return selectG_PTR_ADD ( I ) ; case TargetOpcode :: G_IMPLICIT_DEF : return selectG_IMPLICIT_DEF ( I ) ; case TargetOpcode :: G_INSERT : return selectG_INSERT ( I ) ; case TargetOpcode :: G_INTRINSIC : return selectG_INTRINSIC ( I ) ; case TargetOpcode :: G_INTRINSIC_W_SIDE_EFFECTS : return selectG_INTRINSIC_W_SIDE_EFFECTS ( I ) ; case TargetOpcode :: G_ICMP : if ( selectG_ICMP ( I ) ) return true ; return selectImpl ( I , * CoverageInfo ) ; case TargetOpcode :: G_LOAD : case TargetOpcode :: G_ATOMIC_CMPXCHG : case TargetOpcode :: G_ATOMICRMW_XCHG : case TargetOpcode :: G_ATOMICRMW_ADD : case TargetOpcode :: G_ATOMICRMW_SUB : case TargetOpcode :: G_ATOMICRMW_AND : case TargetOpcode :: G_ATOMICRMW_OR : case TargetOpcode :: G_ATOMICRMW_XOR : case TargetOpcode :: G_ATOMICRMW_MIN : case TargetOpcode :: G_ATOMICRMW_MAX : case TargetOpcode :: G_ATOMICRMW_UMIN : case TargetOpcode :: G_ATOMICRMW_UMAX : case TargetOpcode :: G_ATOMICRMW_FADD : return selectG_LOAD_ATOMICRMW ( I ) ; case TargetOpcode :: G_SELECT : return selectG_SELECT ( I ) ; case TargetOpcode :: G_STORE : return selectG_STORE ( I ) ; case TargetOpcode :: G_TRUNC : return selectG_TRUNC ( I ) ; case TargetOpcode :: G_SEXT : case TargetOpcode :: G_ZEXT : case TargetOpcode :: G_ANYEXT : return selectG_SZA_EXT ( I ) ; case TargetOpcode :: G_BRCOND : return selectG_BRCOND ( I ) ; case TargetOpcode :: G_FRAME_INDEX : return selectG_FRAME_INDEX ( I ) ; case TargetOpcode :: G_FENCE : I . setDesc ( TII . get ( AMDGPU :: ATOMIC_FENCE ) ) ; return true ; case TargetOpcode :: G_PTR_MASK : return selectG_PTR_MASK ( I ) ; default : return selectImpl ( I , * CoverageInfo ) ; } return false ; } </s>

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

AMDGPU AMDGPU SI SI SI SI AMDGPU::ATOMIC_FENCE


<s> SDNode * PatmosDAGToDAGISel :: Select ( SDNode * Node ) { if ( Node -> isMachineOpcode ( ) ) return NULL ; switch ( Node -> getOpcode ( ) ) { default : break ; } return SelectCode ( Node ) ; } </s>

Main hook for targets to transform nodes into machine nodes .


<s> static void function_arg_record_value_3 ( HOST_WIDE_INT bitpos , struct function_arg_record_value_parms * parms ) { enum machine_mode mode ; unsigned int regno ; unsigned int startbit , endbit ; int this_slotno , intslots , intoffset ; rtx reg ; if ( parms -> intoffset == - 1 ) return ; intoffset = parms -> intoffset ; parms -> intoffset = - 1 ; startbit = intoffset & - BITS_PER_WORD ; endbit = ( bitpos + BITS_PER_WORD - 1 ) & - BITS_PER_WORD ; intslots = ( endbit - startbit ) / BITS_PER_WORD ; this_slotno = parms -> slotno + intoffset / BITS_PER_WORD ; intslots = MIN ( intslots , SPARC_INT_ARG_MAX - this_slotno ) ; if ( intslots <= 0 ) return ; if ( intoffset % BITS_PER_WORD != 0 ) mode = smallest_mode_for_size ( BITS_PER_WORD - intoffset % BITS_PER_WORD , MODE_INT ) ; else mode = word_mode ; intoffset /= BITS_PER_UNIT ; do { regno = parms -> regbase + this_slotno ; reg = gen_rtx_REG ( mode , regno ) ; XVECEXP ( parms -> ret , 0 , parms -> stack + parms -> nregs ) = gen_rtx_EXPR_LIST ( VOIDmode , reg , GEN_INT ( intoffset ) ) ; this_slotno += 1 ; intoffset = ( intoffset | ( UNITS_PER_WORD - 1 ) ) + 1 ; mode = word_mode ; parms -> nregs += 1 ; intslots -= 1 ; } while ( intslots > 0 ) ; } </s>

A subroutine of function_arg_record_value . Assign the bits of the structure between parms- > intoffset and bitpos to integer registers .


<s> bool aarch64_float_const_rtx_p ( rtx x ) { machine_mode mode = GET_MODE ( x ) ; if ( mode == VOIDmode ) return false ; unsigned HOST_WIDE_INT ival ; if ( GET_CODE ( x ) == CONST_DOUBLE && SCALAR_FLOAT_MODE_P ( mode ) && aarch64_reinterpret_float_as_int ( x , & ival ) ) { scalar_int_mode imode = ( mode == HFmode ? SImode : int_mode_for_mode ( mode ) . require ( ) ) ; int num_instr = aarch64_internal_mov_immediate ( NULL_RTX , gen_int_mode ( ival , imode ) , false , imode ) ; return num_instr < 3 ; } return false ; } </s>

Return TRUE if rtx X is an immediate constant that can be moved using a single MOV ( +MOVK ) followed by an FMOV .


<s> PPCSubtarget :: PPCSubtarget ( const std :: string & TT , const std :: string & CPU , const std :: string & FS , bool is64Bit , CodeGenOpt :: Level OptLevel ) : PPCGenSubtargetInfo ( TT , CPU , FS ) , IsPPC64 ( is64Bit ) , TargetTriple ( TT ) , OptLevel ( OptLevel ) { initializeEnvironment ( ) ; resetSubtargetFeatures ( CPU , FS ) ; } </s>

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


<s> static bool ia64_skip_rtx_p ( const_rtx x ) { return get_spec_unspec_code ( x ) != - 1 ; } </s>


<s> void reset ( ) { loc = RC -> begin ( ) ; } </s>

Reset an existing scalar value for Def and a given Instance .


<s> const char * AArch64TargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { case AArch64ISD :: BR_CC : return "AArch64ISD::BR_CC" ; case AArch64ISD :: Call : return "AArch64ISD::Call" ; case AArch64ISD :: FPMOV : return "AArch64ISD::FPMOV" ; case AArch64ISD :: GOTLoad : return "AArch64ISD::GOTLoad" ; case AArch64ISD :: BFI : return "AArch64ISD::BFI" ; case AArch64ISD :: EXTR : return "AArch64ISD::EXTR" ; case AArch64ISD :: Ret : return "AArch64ISD::Ret" ; case AArch64ISD :: SBFX : return "AArch64ISD::SBFX" ; case AArch64ISD :: SELECT_CC : return "AArch64ISD::SELECT_CC" ; case AArch64ISD :: SETCC : return "AArch64ISD::SETCC" ; case AArch64ISD :: TC_RETURN : return "AArch64ISD::TC_RETURN" ; case AArch64ISD :: THREAD_POINTER : return "AArch64ISD::THREAD_POINTER" ; case AArch64ISD :: TLSDESCCALL : return "AArch64ISD::TLSDESCCALL" ; case AArch64ISD :: WrapperLarge : return "AArch64ISD::WrapperLarge" ; case AArch64ISD :: WrapperSmall : return "AArch64ISD::WrapperSmall" ; default : return NULL ; } } </s>


<s> const TargetRegisterClass * ARMBaseRegisterInfo :: getCrossCopyRegClass ( const TargetRegisterClass * RC ) const { if ( RC == & ARM :: CCRRegClass ) return & ARM :: rGPRRegClass ; return RC ; } </s>

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

ARM ARM ARM::CCRRegClass ARM::rGPRRegClass


<s> void ix86_d_target_versions ( void ) { if ( TARGET_64BIT ) { d_add_builtin_version ( "X86_64" ) ; if ( TARGET_X32 ) d_add_builtin_version ( "D_X32" ) ; } else d_add_builtin_version ( "X86" ) ; if ( TARGET_80387 ) d_add_builtin_version ( "D_HardFloat" ) ; else d_add_builtin_version ( "D_SoftFloat" ) ; } </s>

Implement TARGET_D_CPU_VERSIONS for x86 targets .


<s> int X86TTIImpl :: getIntImmCost ( unsigned Opcode , unsigned Idx , const APInt & Imm , Type * Ty ) { assert ( Ty -> isIntegerTy ( ) ) ; unsigned BitSize = Ty -> getPrimitiveSizeInBits ( ) ; if ( BitSize == 0 ) return TTI :: TCC_Free ; unsigned ImmIdx = ~ 0U ; switch ( Opcode ) { default : return TTI :: TCC_Free ; case Instruction :: GetElementPtr : if ( Idx == 0 ) return 2 * TTI :: TCC_Basic ; return TTI :: TCC_Free ; case Instruction :: Store : ImmIdx = 0 ; break ; case Instruction :: Add : case Instruction :: Sub : case Instruction :: Mul : case Instruction :: UDiv : case Instruction :: SDiv : case Instruction :: URem : case Instruction :: SRem : case Instruction :: And : case Instruction :: Or : case Instruction :: Xor : case Instruction :: ICmp : ImmIdx = 1 ; break ; case Instruction :: Shl : case Instruction :: LShr : case Instruction :: AShr : if ( Idx == 1 ) return TTI :: TCC_Free ; break ; case Instruction :: Trunc : case Instruction :: ZExt : case Instruction :: SExt : case Instruction :: IntToPtr : case Instruction :: PtrToInt : case Instruction :: BitCast : case Instruction :: PHI : case Instruction :: Call : case Instruction :: Select : case Instruction :: Ret : case Instruction :: Load : break ; } if ( Idx == ImmIdx ) { int NumConstants = ( BitSize + 63 ) / 64 ; int Cost = X86TTIImpl :: getIntImmCost ( Imm , Ty ) ; return ( Cost <= NumConstants * TTI :: TCC_Basic ) ? static_cast < int > ( TTI :: TCC_Free ) : Cost ; } return X86TTIImpl :: getIntImmCost ( Imm , Ty ) ; } </s>

Calculate the cost of materializing a 64-bit value .


<s> MCSection * getSectionForConstant ( const DataLayout & DL , SectionKind Kind , const Constant * C , Align & Alignment ) const override { return ReadOnlySection ; } </s>

Given a constant with the SectionKind , return a section that it should be placed in .


<s>
static
void
mips_output_function_prologue
(
FILE
*
file
,
HOST_WIDE_INT
size
ATTRIBUTE_UNUSED
)
{
const
char
*
fnname
;
if
(
TARGET_MIPS16
&&
TARGET_HARD_FLOAT_ABI
&&
crtl
->
args
.
info
.
fp_code
!=
0
)
mips16_build_function_stub
(
)
;
fnname
=
XSTR
(
XEXP
(
DECL_RTL
(
current_function_decl
)
,
0
)
,
0
)
;
mips_start_function_definition
(
fnname
,
TARGET_MIPS16
)
;
if
(
!
flag_inhibit_size_directive
)
{
const
struct
mips_frame_info
*
frame
;
frame
=
&
cfun
->
machine
->
frame
;
fprintf
(
file
,
"\t.frame\t%s,"
HOST_WIDE_INT_PRINT_DEC
",%s\t\t"
"# vars= "
HOST_WIDE_INT_PRINT_DEC
", regs= %d/%d"
", args= "
HOST_WIDE_INT_PRINT_DEC
", gp= "
HOST_WIDE_INT_PRINT_DEC
"\n"
,
reg_names
[
frame_pointer_needed
HARD_FRAME_POINTER_REGNUM
:
STACK_POINTER_REGNUM
]
,
(
frame_pointer_needed
frame
->
total_size
frame
->
hard_frame_pointer_offset
:
frame
->
total_size
)
,
reg_names
[
RETURN_ADDR_REGNUM
]
,
frame
->
var_size
,
frame
->
num_gp
,
frame
->
num_fp
,
frame
->
args_size
,
frame
->
cprestore_size
)
;
fprintf
(
file
,
"\t.mask\t0x%08x,"
HOST_WIDE_INT_PRINT_DEC
"\n"
,
frame
->
mask
,
frame
->
gp_save_offset
)
;
fprintf
(
file
,
"\t.fmask\t0x%08x,"
HOST_WIDE_INT_PRINT_DEC
"\n"
,
frame
->
fmask
,
frame
->
fp_save_offset
)
;
}
if
(
mips_must_initialize_gp_p
(
)
&&
mips_current_loadgp_style
(
)
==
LOADGP_OLDABI
)
{
if
(
TARGET_MIPS16
)
{
output_asm_insn
(
"li\t$2,%%hi(_gp_disp)"
,
0
)
;
output_asm_insn
(
"addiu\t$3,$pc,%%lo(_gp_disp)"
,
0
)
;
output_asm_insn
(
"sll\t$2,16"
,
0
)
;
output_asm_insn
(
"addu\t$2,$3"
,
0
)
;
}
else
{
mips_push_asm_switch
(
&
mips_noreorder
)
;
output_asm_insn
(
".cpload\t%^"
,
0
)
;
if
(
!
cfun
->
machine
->
all_noreorder_p
)
mips_pop_asm_switch
(
&
mips_noreorder
)
;
else
mips_push_asm_switch
(
&
mips_nomacro
)
;
}
}
else
if
(
cfun
->
machine
->
all_noreorder_p
)
{
mips_push_asm_switch
(
&
mips_noreorder
)
;
mips_push_asm_switch
(
&
mips_nomacro
)
;
}
mips_output_cplocal
(
)
;
}
</s>

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


<s> static void aarch64_update_cpp_builtins ( cpp_reader * pfile ) { aarch64_def_or_undef ( flag_unsafe_math_optimizations , "__ARM_FP_FAST" , pfile ) ; builtin_define_with_int_value ( "__ARM_ARCH" , aarch64_architecture_version ) ; builtin_define_with_int_value ( "__ARM_SIZEOF_MINIMAL_ENUM" , flag_short_enums ? 1 : 4 ) ; aarch64_def_or_undef ( TARGET_BIG_END , "__AARCH64EB__" , pfile ) ; aarch64_def_or_undef ( TARGET_BIG_END , "__ARM_BIG_ENDIAN" , pfile ) ; aarch64_def_or_undef ( ! TARGET_BIG_END , "__AARCH64EL__" , pfile ) ; aarch64_def_or_undef ( TARGET_FLOAT , "__ARM_FEATURE_FMA" , pfile ) ; if ( TARGET_FLOAT || TARGET_SIMD ) { builtin_define_with_int_value ( "__ARM_FP" , 0x0E ) ; builtin_define ( "__ARM_FP16_FORMAT_IEEE" ) ; builtin_define ( "__ARM_FP16_ARGS" ) ; } else cpp_undef ( pfile , "__ARM_FP" ) ; aarch64_def_or_undef ( TARGET_FP_F16INST , "__ARM_FEATURE_FP16_SCALAR_ARITHMETIC" , pfile ) ; aarch64_def_or_undef ( TARGET_SIMD_F16INST , "__ARM_FEATURE_FP16_VECTOR_ARITHMETIC" , pfile ) ; aarch64_def_or_undef ( TARGET_SIMD , "__ARM_FEATURE_NUMERIC_MAXMIN" , pfile ) ; aarch64_def_or_undef ( TARGET_SIMD , "__ARM_NEON" , pfile ) ; aarch64_def_or_undef ( TARGET_CRC32 , "__ARM_FEATURE_CRC32" , pfile ) ; cpp_undef ( pfile , "__AARCH64_CMODEL_TINY__" ) ; cpp_undef ( pfile , "__AARCH64_CMODEL_SMALL__" ) ; cpp_undef ( pfile , "__AARCH64_CMODEL_LARGE__" ) ; switch ( aarch64_cmodel ) { case AARCH64_CMODEL_TINY : case AARCH64_CMODEL_TINY_PIC : builtin_define ( "__AARCH64_CMODEL_TINY__" ) ; break ; case AARCH64_CMODEL_SMALL : case AARCH64_CMODEL_SMALL_PIC : builtin_define ( "__AARCH64_CMODEL_SMALL__" ) ; break ; case AARCH64_CMODEL_LARGE : builtin_define ( "__AARCH64_CMODEL_LARGE__" ) ; break ; default : break ; } aarch64_def_or_undef ( TARGET_ILP32 , "_ILP32" , pfile ) ; aarch64_def_or_undef ( TARGET_ILP32 , "__ILP32__" , pfile ) ; aarch64_def_or_undef ( TARGET_CRYPTO , "__ARM_FEATURE_CRYPTO" , pfile ) ; aarch64_def_or_undef ( TARGET_SIMD_RDMA , "__ARM_FEATURE_QRDMX" , pfile ) ; cpp_undef ( pfile , "__FLT_EVAL_METHOD__" ) ; builtin_define_with_int_value ( "__FLT_EVAL_METHOD__" , c_flt_eval_method ( true ) ) ; cpp_undef ( pfile , "__FLT_EVAL_METHOD_C99__" ) ; builtin_define_with_int_value ( "__FLT_EVAL_METHOD_C99__" , c_flt_eval_method ( false ) ) ; } </s>

Undefine/redefine macros that depend on the current backend state and may need to change when a target pragma modifies the backend state .


<s> static void sh_emit_storehi ( rtx addr , HOST_WIDE_INT offset , uint16_t w0 , uint16_t w1 ) { sh_emit_storesi ( addr , offset , gen_int_mode ( TARGET_LITTLE_ENDIAN ? ( w0 | ( w1 << 16 ) ) : ( w1 | ( w0 << 16 ) ) , SImode ) ) ; } </s>

Emit insns to store w0 at addr + offset and w1 at addr + offset + 2 .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> unsigned epiphany_adjust_field_align ( tree type , unsigned computed ) { if ( computed == 32 && TREE_CODE ( type ) == ARRAY_TYPE ) { tree elmsz = TYPE_SIZE ( TREE_TYPE ( type ) ) ; if ( ! tree_fits_uhwi_p ( elmsz ) || tree_to_uhwi ( elmsz ) >= 32 ) return 64 ; } return computed ; } </s>

Upping the alignment of arrays in structs is not only a performance enhancement , it also helps preserve assumptions about how arrays-at-the-end-of-structs work , like for struct gcov_fn_info in libgcov.c .


<s> static tree parse_type ( const function_instance & instance , const char * & format ) { int ch = * format ++ ; if ( ch == '_' ) return void_type_node ; if ( ch == 'a' ) { ch = * format ++ ; if ( ch == 'l' ) return build_const_pointer ( instance . memory_scalar_type ( ) ) ; if ( ch == 'p' ) return const_ptr_type_node ; if ( ch == 's' ) return build_pointer_type ( instance . memory_scalar_type ( ) ) ; gcc_unreachable ( ) ; } if ( ch == 'b' ) return instance . base_vector_type ( ) ; if ( ch == 'd' ) return instance . displacement_vector_type ( ) ; if ( ch == 'e' ) { if ( strncmp ( format , "pattern" , 7 ) == 0 ) { format += 7 ; return acle_svpattern ; } if ( strncmp ( format , "prfop" , 5 ) == 0 ) { format += 5 ; return acle_svprfop ; } gcc_unreachable ( ) ; } if ( ch == 's' ) { type_suffix_index suffix = parse_element_type ( instance , format ) ; return scalar_types [ type_suffixes [ suffix ] . vector_type ] ; } if ( ch == 't' ) { type_suffix_index suffix = parse_element_type ( instance , format ) ; vector_type_index vector_type = type_suffixes [ suffix ] . vector_type ; unsigned int num_vectors = instance . vectors_per_tuple ( ) ; return acle_vector_types [ num_vectors - 1 ] [ vector_type ] ; } if ( ch == 'v' ) { type_suffix_index suffix = parse_element_type ( instance , format ) ; return acle_vector_types [ 0 ] [ type_suffixes [ suffix ] . vector_type ] ; } gcc_unreachable ( ) ; } </s>

Read and return a type from FORMAT for function INSTANCE . Advance FORMAT beyond the type string . The format is : _ - void al - array pointer for loads ap - array pointer for prefetches as - array pointer for stores b - base vector type ( from a _ < m0 > base suffix ) d - displacement vector type ( from a _ < m1 > index or _ < m1 > offset suffix ) e < name > - an enum with the given name s < elt > - a scalar type with the given element suffix t < elt > - a vector or tuple type with given element suffix [ * 1 ] v < elt > - a vector with the given element suffix where < elt > has the format described above parse_element_type [ * 1 ] the vectors_per_tuple function indicates whether the type should be a tuple , and if so , how many vectors it should contain .


<s>
StringRef
getPassName
(
)
const
override
{
return
"AVR DAG->DAG Instruction Selection"
;
}
</s>

getPassName - Return a nice clean name for a pass .

AVR
"AVR DAG->DAG Instruction Selection"


<s> static rtx neon_vdup_constant ( rtx vals ) { machine_mode mode = GET_MODE ( vals ) ; machine_mode inner_mode = GET_MODE_INNER ( mode ) ; int n_elts = GET_MODE_NUNITS ( mode ) ; bool all_same = true ; rtx x ; int i ; if ( GET_CODE ( vals ) != CONST_VECTOR || GET_MODE_SIZE ( inner_mode ) > 4 ) return NULL_RTX ; for ( i = 0 ; i < n_elts ; ++ i ) { x = XVECEXP ( vals , 0 , i ) ; if ( i > 0 && ! rtx_equal_p ( x , XVECEXP ( vals , 0 , 0 ) ) ) all_same = false ; } if ( ! all_same ) return NULL_RTX ; x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , 0 , 0 ) ) ; return gen_rtx_VEC_DUPLICATE ( mode , x ) ; } </s>

Return a non-NULL RTX iff VALS is a vector constant that can be loaded into a register using VDUP . If this is the case , and GENERATE is set , we also generate instructions to do this and return an RTX to assign to the register .


<s> rtx mmix_eh_return_handler_rtx ( void ) { return gen_rtx_REG ( Pmode , MMIX_INCOMING_RETURN_ADDRESS_REGNUM ) ; } </s>


<s> unsigned char M680x0Subtarget :: classifyGlobalFunctionReference ( const GlobalValue * GV , const Module & M ) const { if ( TM . shouldAssumeDSOLocal ( M , GV ) ) return M680x0II :: MO_NO_FLAG ; auto * F = dyn_cast_or_null < Function > ( GV ) ; if ( F && F -> hasFnAttribute ( Attribute :: NonLazyBind ) ) { return M680x0II :: MO_GOTPCREL ; } return M680x0II :: MO_PLT ; } </s>

Classify a global function reference for the current subtarget .


<s> void Cpu0AsmBackend :: applyFixup ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target , MutableArrayRef < char > Data , uint64_t Value , bool IsResolved , const MCSubtargetInfo * STI ) const { MCFixupKind Kind = Fixup . getKind ( ) ; Value = adjustFixupValue ( Fixup , Value ) ; if ( ! Value ) return ; unsigned Offset = Fixup . getOffset ( ) ; unsigned NumBytes = ( getFixupKindInfo ( Kind ) . TargetSize + 7 ) / 8 ; unsigned FullSize ; switch ( ( unsigned ) Kind ) { default : FullSize = 4 ; break ; } uint64_t CurVal = 0 ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = Endian == support :: little ? i : ( FullSize - 1 - i ) ; CurVal |= ( uint64_t ) ( ( uint8_t ) Data [ Offset + Idx ] ) << ( i * 8 ) ; } uint64_t Mask = ( ( uint64_t ) ( - 1 ) >> ( 64 - getFixupKindInfo ( Kind ) . TargetSize ) ) ; CurVal |= Value & Mask ; for ( unsigned i = 0 ; i != NumBytes ; ++ i ) { unsigned Idx = Endian == support :: little ? i : ( FullSize - 1 - i ) ; Data [ Offset + Idx ] = ( uint8_t ) ( ( CurVal >> ( i * 8 ) ) & 0xff ) ; } } </s>

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


<s> static bool mips_pass_by_reference ( cumulative_args_t cum ATTRIBUTE_UNUSED , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { if ( mips_abi == ABI_EABI ) { int size ; if ( mode == DImode || mode == DFmode || mode == DQmode || mode == UDQmode || mode == DAmode || mode == UDAmode ) return 0 ; size = type ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; return size == - 1 || size > UNITS_PER_WORD ; } else { return targetm . calls . must_pass_in_stack ( mode , type ) ; } } </s>

Return nonzero when an argument must be passed by reference .


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

Does this instruction set its full destination register to zero ?


<s> bool mep_use_post_modify_p ( rtx_insn * insn , rtx reg , rtx offset ) { bool result = mep_use_post_modify_p_1 ( insn , reg , offset ) ; extract_insn ( insn ) ; return result ; } </s>

A wrapper around mep_use_post_modify_p_1 that preserves recog_data .


<s> void WebAssemblyPassConfig :: addPreEmitPass ( ) { addPass ( createWebAssemblyCFGStackify ( ) ) ; } </s>

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


<s> bool SIInsertSkips :: runOnMachineFunction ( MachineFunction & MF ) { const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; TII = ST . getInstrInfo ( ) ; TRI = & TII -> getRegisterInfo ( ) ; MDT = & getAnalysis < MachineDominatorTree > ( ) ; SkipThreshold = SkipThresholdFlag ; MachineBasicBlock * EmptyMBBAtEnd = nullptr ; SmallVector < MachineInstr * , 4 > KillInstrs ; bool MadeChange = false ; for ( MachineBasicBlock & MBB : MF ) { MachineBasicBlock :: iterator I , Next ; for ( I = MBB . begin ( ) ; I != MBB . end ( ) ; I = Next ) { Next = std :: next ( I ) ; MachineInstr & MI = * I ; switch ( MI . getOpcode ( ) ) { case AMDGPU :: SI_MASK_BRANCH : MadeChange |= skipMaskBranch ( MI , MBB ) ; break ; case AMDGPU :: S_BRANCH : if ( MBB . isLayoutSuccessor ( MI . getOperand ( 0 ) . getMBB ( ) ) ) { assert ( & MI == & MBB . back ( ) ) ; MI . eraseFromParent ( ) ; MadeChange = true ; } break ; case AMDGPU :: SI_KILL_F32_COND_IMM_TERMINATOR : case AMDGPU :: SI_KILL_I1_TERMINATOR : { MadeChange = true ; bool CanKill = kill ( MI ) ; if ( CanKill && MF . getFunction ( ) . getCallingConv ( ) == CallingConv :: AMDGPU_PS && dominatesAllReachable ( MBB ) ) { KillInstrs . push_back ( & MI ) ; } else { MI . eraseFromParent ( ) ; } break ; } case AMDGPU :: SI_RETURN_TO_EPILOG : assert ( ! MF . getInfo < SIMachineFunctionInfo > ( ) -> returnsVoid ( ) ) ; if ( & MBB != & MF . back ( ) || & MI != & MBB . back ( ) ) { if ( ! EmptyMBBAtEnd ) { EmptyMBBAtEnd = MF . CreateMachineBasicBlock ( ) ; MF . insert ( MF . end ( ) , EmptyMBBAtEnd ) ; } MBB . addSuccessor ( EmptyMBBAtEnd ) ; BuildMI ( MBB , & MI , MI . getDebugLoc ( ) , TII -> get ( AMDGPU :: S_BRANCH ) ) . addMBB ( EmptyMBBAtEnd ) ; MI . eraseFromParent ( ) ; MDT -> getBase ( ) . insertEdge ( & MBB , EmptyMBBAtEnd ) ; } break ; default : break ; } } } for ( MachineInstr * Kill : KillInstrs ) { skipIfDead ( * Kill -> getParent ( ) , std :: next ( Kill -> getIterator ( ) ) , Kill -> getDebugLoc ( ) ) ; Kill -> eraseFromParent ( ) ; } KillInstrs . clear ( ) ; return MadeChange ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool aarch64_simd_shift_imm_p ( rtx x , machine_mode mode , bool left ) { int bit_width = GET_MODE_UNIT_SIZE ( mode ) * BITS_PER_UNIT ; if ( left ) return aarch64_const_vec_all_same_in_range_p ( x , 0 , bit_width - 1 ) ; else return aarch64_const_vec_all_same_in_range_p ( x , 1 , bit_width ) ; } </s>

Check of immediate shift constants are within range .


"EBP/ESI restoration only required on win32"

"restoring EBP/ESI on non-32-bit target"

"end of registration object above normal EBP position!"

"32-bit frames with WinEH must use FramePtr or BasePtr"

Sets up EBP and optionally ESI based on the incoming EBP value .


<s> void GCNPassConfig :: addFastRegAlloc ( FunctionPass * RegAllocPass ) { insertPass ( & TwoAddressInstructionPassID , & SILowerControlFlowID , false ) ; TargetPassConfig :: addFastRegAlloc ( RegAllocPass ) ; } </s>

addFastRegAlloc - Add the minimum set of target-independent passes that are required for fast register allocation .


<s> SDValue MipsTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { SelectionDAG & DAG = DCI . DAG ; unsigned opc = N -> getOpcode ( ) ; switch ( opc ) { default : break ; case ISD :: ADDE : return PerformADDECombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SUBE : return PerformSUBECombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SDIVREM : case ISD :: UDIVREM : return PerformDivRemCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: SELECT : return PerformSELECTCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: AND : return PerformANDCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: OR : return PerformORCombine ( N , DAG , DCI , Subtarget ) ; } return SDValue ( ) ; } </s>

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

Mips Mips ISD::ADDE ISD::SUBE ISD::SDIVREM ISD::UDIVREM ISD::SELECT ISD::AND ISD::OR


<s> static rtx ix86_expand_sse_cmp ( rtx dest , enum rtx_code code , rtx cmp_op0 , rtx cmp_op1 , rtx op_true , rtx op_false ) { enum machine_mode mode = GET_MODE ( dest ) ; rtx x ; cmp_op0 = force_reg ( mode , cmp_op0 ) ; if ( ! nonimmediate_operand ( cmp_op1 , mode ) ) cmp_op1 = force_reg ( mode , cmp_op1 ) ; if ( optimize || reg_overlap_mentioned_p ( dest , op_true ) || reg_overlap_mentioned_p ( dest , op_false ) ) dest = gen_reg_rtx ( mode ) ; x = gen_rtx_fmt_ee ( code , mode , cmp_op0 , cmp_op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ; return dest ; } </s>

Expand an sse vector comparison . Return the register with the result .


"br_on_exn does not have a reversed condition"

Insert branch code into the end of the specified MachineBasicBlock .


<s> void write ( unsigned int i ) { std :: stringstream s ; s << MF -> getFunction ( ) . getName ( ) . str ( ) << "-" << i << ".dot" ; std :: error_code err ; raw_fd_ostream f ( s . str ( ) . c_str ( ) , err ) ; WriteGraph ( f , * this ) ; f . close ( ) ; } </s>

Write the profile to a string output stream OS .


<s> static int riscv_issue_rate ( void ) { return tune_param -> issue_rate ; } </s>

Return the number of instructions that can be issued per cycle .


<s> static void setup_incoming_varargs_64 ( CUMULATIVE_ARGS * cum ) { rtx save_area , mem ; alias_set_type set ; int i , max ; if ( cfun -> va_list_gpr_size ) ix86_varargs_gpr_size = X86_64_REGPARM_MAX * UNITS_PER_WORD ; else ix86_varargs_gpr_size = 0 ; if ( TARGET_SSE && cfun -> va_list_fpr_size ) ix86_varargs_fpr_size = X86_64_SSE_REGPARM_MAX * 16 ; else ix86_varargs_fpr_size = 0 ; if ( ! ix86_varargs_gpr_size && ! ix86_varargs_fpr_size ) return ; save_area = frame_pointer_rtx ; set = get_varargs_alias_set ( ) ; max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( max > X86_64_REGPARM_MAX ) max = X86_64_REGPARM_MAX ; for ( i = cum -> regno ; i < max ; i ++ ) { mem = gen_rtx_MEM ( word_mode , plus_constant ( Pmode , save_area , i * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( mem ) = 1 ; set_mem_alias_set ( mem , set ) ; emit_move_insn ( mem , gen_rtx_REG ( word_mode , x86_64_int_parameter_registers [ i ] ) ) ; } if ( ix86_varargs_fpr_size ) { machine_mode smode ; rtx_code_label * label ; rtx test ; label = gen_label_rtx ( ) ; test = gen_rtx_EQ ( VOIDmode , gen_rtx_REG ( QImode , AX_REG ) , const0_rtx ) ; emit_jump_insn ( gen_cbranchqi4 ( test , XEXP ( test , 0 ) , XEXP ( test , 1 ) , label ) ) ; smode = V4SFmode ; if ( crtl -> stack_alignment_needed < GET_MODE_ALIGNMENT ( smode ) ) crtl -> stack_alignment_needed = GET_MODE_ALIGNMENT ( smode ) ; max = cum -> sse_regno + cfun -> va_list_fpr_size / 16 ; if ( max > X86_64_SSE_REGPARM_MAX ) max = X86_64_SSE_REGPARM_MAX ; for ( i = cum -> sse_regno ; i < max ; ++ i ) { mem = plus_constant ( Pmode , save_area , i * 16 + ix86_varargs_gpr_size ) ; mem = gen_rtx_MEM ( smode , mem ) ; MEM_NOTRAP_P ( mem ) = 1 ; set_mem_alias_set ( mem , set ) ; set_mem_align ( mem , GET_MODE_ALIGNMENT ( smode ) ) ; emit_move_insn ( mem , gen_rtx_REG ( smode , SSE_REGNO ( i ) ) ) ; } emit_label ( label ) ; } } </s>

Worker function for TARGET_SETUP_INCOMING_VARARGS .


<s> static rtx arm_expand_acle_builtin ( int fcode , tree exp , rtx target ) { arm_builtin_datum * d = & acle_builtin_data [ fcode - ARM_BUILTIN_ACLE_PATTERN_START ] ; return arm_expand_builtin_1 ( fcode , exp , target , d ) ; } </s>

Expand an ACLE builtin , i.e . those registered only if their respective target constraints are met . This check happens within arm_expand_builtin_args .


<s> SDValue AArch64TargetLowering :: BuildSDIVPow2 ( SDNode * N , const APInt & Divisor , SelectionDAG & DAG , std :: vector < SDNode * > * Created ) const { AttributeList Attr = DAG . getMachineFunction ( ) . getFunction ( ) . getAttributes ( ) ; if ( isIntDivCheap ( N -> getValueType ( 0 ) , Attr ) ) return SDValue ( N , 0 ) ; EVT VT = N -> getValueType ( 0 ) ; if ( ( VT != MVT :: i32 && VT != MVT :: i64 ) || ! ( Divisor . isPowerOf2 ( ) || ( - Divisor ) . isPowerOf2 ( ) ) ) return SDValue ( ) ; SDLoc DL ( N ) ; SDValue N0 = N -> getOperand ( 0 ) ; unsigned Lg2 = Divisor . countTrailingZeros ( ) ; SDValue Zero = DAG . getConstant ( 0 , DL , VT ) ; SDValue Pow2MinusOne = DAG . getConstant ( ( 1ULL << Lg2 ) - 1 , DL , VT ) ; SDValue CCVal ; SDValue Cmp = getAArch64Cmp ( N0 , Zero , ISD :: SETLT , CCVal , DAG , DL ) ; SDValue Add = DAG . getNode ( ISD :: ADD , DL , VT , N0 , Pow2MinusOne ) ; SDValue CSel = DAG . getNode ( AArch64ISD :: CSEL , DL , VT , Add , N0 , CCVal , Cmp ) ; if ( Created ) { Created -> push_back ( Cmp . getNode ( ) ) ; Created -> push_back ( Add . getNode ( ) ) ; Created -> push_back ( CSel . getNode ( ) ) ; } SDValue SRA = DAG . getNode ( ISD :: SRA , DL , VT , CSel , DAG . getConstant ( Lg2 , DL , MVT :: i64 ) ) ; if ( Divisor . isNonNegative ( ) ) return SRA ; if ( Created ) Created -> push_back ( SRA . getNode ( ) ) ; return DAG . getNode ( ISD :: SUB , DL , VT , DAG . getConstant ( 0 , DL , VT ) , SRA ) ; } </s>

Targets may override this function to provide custom SDIV lowering for power-of-2 denominators .


<s> bool X86TargetLowering :: isVectorClearMaskLegal ( const SmallVectorImpl < int > & Mask , EVT VT ) const { unsigned NumElts = VT . getVectorNumElements ( ) ; if ( NumElts == 2 ) return true ; if ( NumElts == 4 && VT . is128BitVector ( ) ) { return ( isMOVLMask ( Mask , VT ) || isCommutedMOVLMask ( Mask , VT , true ) || isSHUFPMask ( Mask , VT , Subtarget -> hasAVX ( ) ) || isSHUFPMask ( Mask , VT , Subtarget -> hasAVX ( ) , true ) ) ; } return false ; } </s>


<s>
SDValue
BPFTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
case
ISD
::
BR_CC
:
return
LowerBR_CC
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
)
;
default
:
llvm_unreachable
(
"unimplemented operand"
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .

BPF
BPF
ISD::BR_CC
ISD::GlobalAddress
ISD::SELECT_CC
"unimplemented operand"


<s> unsigned SparcInstrInfo :: isLoadFromStackSlot ( const MachineInstr & MI , int & FrameIndex ) const { if ( MI . getOpcode ( ) == SP :: LDri || MI . getOpcode ( ) == SP :: LDXri || MI . getOpcode ( ) == SP :: LDFri || MI . getOpcode ( ) == SP :: LDDFri || MI . getOpcode ( ) == SP :: LDQFri ) { 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>

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 bool mips_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { return mips_const_insns ( x ) > 0 ; } </s>


<s> static int rs6000_issue_rate ( void ) { if ( ! reload_completed && ! flag_sched_pressure ) return 1 ; switch ( rs6000_cpu_attr ) { case CPU_RS64A : case CPU_PPC601 : case CPU_PPC7450 : return 3 ; case CPU_PPC440 : case CPU_PPC603 : case CPU_PPC750 : case CPU_PPC7400 : case CPU_PPC8540 : case CPU_PPC8548 : case CPU_CELL : case CPU_PPCE300C2 : case CPU_PPCE300C3 : case CPU_PPCE500MC : case CPU_PPCE500MC64 : case CPU_PPCE5500 : case CPU_PPCE6500 : case CPU_TITAN : return 2 ; case CPU_PPC476 : case CPU_PPC604 : case CPU_PPC604E : case CPU_PPC620 : case CPU_PPC630 : return 4 ; case CPU_POWER4 : case CPU_POWER5 : case CPU_POWER6 : case CPU_POWER7 : return 5 ; case CPU_POWER8 : return 7 ; default : return 1 ; } } </s>

Return how many instructions the machine can issue per cycle .


<s> static SDValue WidenVector ( SDValue V64Reg , SelectionDAG & DAG ) { EVT VT = V64Reg . getValueType ( ) ; unsigned NarrowSize = VT . getVectorNumElements ( ) ; MVT EltTy = VT . getVectorElementType ( ) . getSimpleVT ( ) ; MVT WideTy = MVT :: getVectorVT ( EltTy , 2 * NarrowSize ) ; SDLoc DL ( V64Reg ) ; return DAG . getNode ( ISD :: INSERT_SUBVECTOR , DL , WideTy , DAG . getUNDEF ( WideTy ) , V64Reg , DAG . getConstant ( 0 , MVT :: i32 ) ) ; } </s>

Widen the vector up to the next power of two using INSERT_SUBVECTOR .


<s> bool MipsAsmParser :: processInstruction ( MCInst & Inst , SMLoc IDLoc , SmallVectorImpl < MCInst > & Instructions ) { const MCInstrDesc & MCID = getInstDesc ( Inst . getOpcode ( ) ) ; Inst . setLoc ( IDLoc ) ; if ( MCID . hasDelaySlot ( ) && Options . isReorder ( ) ) { Instructions . push_back ( Inst ) ; MCInst NopInst ; NopInst . setOpcode ( Mips :: SLL ) ; NopInst . addOperand ( MCOperand :: CreateReg ( Mips :: ZERO ) ) ; NopInst . addOperand ( MCOperand :: CreateReg ( Mips :: ZERO ) ) ; NopInst . addOperand ( MCOperand :: CreateImm ( 0 ) ) ; Instructions . push_back ( NopInst ) ; return false ; } if ( MCID . mayLoad ( ) || MCID . mayStore ( ) ) { for ( unsigned i = 0 ; i < MCID . getNumOperands ( ) ; i ++ ) { const MCOperandInfo & OpInfo = MCID . OpInfo [ i ] ; if ( ( OpInfo . OperandType == MCOI :: OPERAND_MEMORY ) || ( OpInfo . OperandType == MCOI :: OPERAND_UNKNOWN ) ) { MCOperand & Op = Inst . getOperand ( i ) ; if ( Op . isImm ( ) ) { int MemOffset = Op . getImm ( ) ; if ( MemOffset < - 32768 || MemOffset > 32767 ) { expandMemInst ( Inst , IDLoc , Instructions , MCID . mayLoad ( ) , true ) ; return false ; } } else if ( Op . isExpr ( ) ) { const MCExpr * Expr = Op . getExpr ( ) ; if ( Expr -> getKind ( ) == MCExpr :: SymbolRef ) { const MCSymbolRefExpr * SR = static_cast < const MCSymbolRefExpr * > ( Expr ) ; if ( SR -> getKind ( ) == MCSymbolRefExpr :: VK_None ) { expandMemInst ( Inst , IDLoc , Instructions , MCID . mayLoad ( ) , false ) ; return false ; } } else if ( ! isEvaluated ( Expr ) ) { expandMemInst ( Inst , IDLoc , Instructions , MCID . mayLoad ( ) , false ) ; return false ; } } } } } if ( needsExpansion ( Inst ) ) expandInstruction ( Inst , IDLoc , Instructions ) ; else Instructions . push_back ( Inst ) ; return false ; } </s>

Process a single instruction and collect debug info anchors .


<s> bool ARMBaseRegisterInfo :: canSimplifyCallFramePseudos ( MachineFunction & MF ) const { return hasReservedCallFrame ( MF ) || MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ; } </s>

canSimplifyCallFramePseudos - If there is a reserved call frame , the call frame pseudos can be simplified .


"Can't break virtual register dependencies."

Insert a dependency-breaking instruction before MI to eliminate an unwanted dependency on OpNum .


<s>
SDValue
BlackfinTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
Op
.
getNode
(
)
->
dump
(
)
;
llvm_unreachable
(
"Should not custom lower this!"
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
llvm_unreachable
(
"TLS not implemented for Blackfin."
)
;
case
ISD
::
JumpTable
:
return
LowerJumpTable
(
Op
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
SDValue
(
)
;
case
ISD
::
RETURNADDR
:
return
SDValue
(
)
;
case
ISD
::
ADDE
:
case
ISD
::
SUBE
:
return
LowerADDE
(
Op
,
DAG
)
;
}
}
</s>

Blackfin
"Should not custom lower this!"
ISD::GlobalAddress
ISD::GlobalTLSAddress
"TLS not implemented for Blackfin."
ISD::JumpTable
ISD::FRAMEADDR
ISD::RETURNADDR
ISD::ADDE
ISD::SUBE


<s>
StackOffset
HexagonFrameLowering
::
getFrameIndexReference
(
const
MachineFunction
&
MF
,
int
FI
,
Register
&
FrameReg
)
const
{
auto
&
MFI
=
MF
.
getFrameInfo
(
)
;
auto
&
HRI
=
*
MF
.
getSubtarget
<
HexagonSubtarget
>
(
)
.
getRegisterInfo
(
)
;
int
Offset
=
MFI
.
getObjectOffset
(
FI
)
;
bool
HasAlloca
=
MFI
.
hasVarSizedObjects
(
)
;
bool
HasExtraAlign
=
HRI
.
needsStackRealignment
(
MF
)
;
bool
NoOpt
=
MF
.
getTarget
(
)
.
getOptLevel
(
)
==
CodeGenOpt
::
;
auto
&
HMFI
=
*
MF
.
getInfo
<
HexagonMachineFunctionInfo
>
(
)
;
unsigned
FrameSize
=
MFI
.
getStackSize
(
)
;
Register
SP
=
HRI
.
getStackRegister
(
)
;
Register
FP
=
HRI
.
getFrameRegister
(
)
;
Register
AP
=
HMFI
.
getStackAlignBasePhysReg
(
)
;
if
(
AP
==
0
)
AP
=
FP
;
bool
UseFP
=
false
,
UseAP
=
false
;
if
(
NoOpt
&&
!
HasExtraAlign
)
UseFP
=
true
;
if
(
MFI
.
isFixedObjectIndex
(
FI
)
||
MFI
.
isObjectPreAllocated
(
FI
)
)
{
UseFP
|=
(
HasAlloca
||
HasExtraAlign
)
;
}
else
{
if
(
HasAlloca
)
{
if
(
HasExtraAlign
)
UseAP
=
true
;
else
UseFP
=
true
;
}
}
bool
HasFP
=
hasFP
(
MF
)
;
assert
(
(
HasFP
||
!
UseFP
)
&&
"This function must have frame pointer"
)
;
if
(
Offset
>
0
&&
!
HasFP
)
Offset
-=
8
;
if
(
UseFP
)
FrameReg
=
FP
;
else
if
(
UseAP
)
FrameReg
=
AP
;
else
FrameReg
=
SP
;
int
RealOffset
=
Offset
;
if
(
!
UseFP
&&
!
UseAP
)
RealOffset
=
FrameSize
+
Offset
;
return
StackOffset
::
getFixed
(
RealOffset
)
;
}
</s>

getFrameIndexReference - This method should return the base register and offset used to reference a frame index location .