<s> static bool address ( rtx op ) { if ( GET_CODE ( op ) == CONST ) op = XEXP ( op , 0 ) ; if ( TARGET_SMALL && GET_CODE ( op ) == CONST_INT ) return true ; if ( GET_MODE ( op ) != Pmode ) return false ; if ( GET_CODE ( op ) == PLUS && address ( XEXP ( op , 0 ) ) ) return true ; if ( GET_CODE ( op ) == SYMBOL_REF ) return true ; if ( GET_CODE ( op ) == LABEL_REF ) return true ; return false ; } </s>

return non zero if the rtx supplied can be used as an effective address calculation


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

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


<s> bool ARMTargetLowering :: isShuffleMaskLegal ( const SmallVectorImpl < int > & M , EVT VT ) const { if ( VT . getVectorNumElements ( ) == 4 && ( VT . is128BitVector ( ) || VT . is64BitVector ( ) ) ) { unsigned PFIndexes [ 4 ] ; for ( unsigned i = 0 ; i != 4 ; ++ i ) { if ( M [ i ] < 0 ) PFIndexes [ i ] = 8 ; else PFIndexes [ i ] = M [ i ] ; } unsigned PFTableIndex = PFIndexes [ 0 ] * 9 * 9 * 9 + PFIndexes [ 1 ] * 9 * 9 + PFIndexes [ 2 ] * 9 + PFIndexes [ 3 ] ; unsigned PFEntry = PerfectShuffleTable [ PFTableIndex ] ; unsigned Cost = ( PFEntry >> 30 ) ; if ( Cost <= 4 ) return true ; } bool ReverseVEXT ; unsigned Imm , WhichResult ; unsigned EltSize = VT . getVectorElementType ( ) . getSizeInBits ( ) ; return ( EltSize >= 32 || ShuffleVectorSDNode :: isSplatMask ( & M [ 0 ] , VT ) || isVREVMask ( M , VT , 64 ) || isVREVMask ( M , VT , 32 ) || isVREVMask ( M , VT , 16 ) || isVEXTMask ( M , VT , ReverseVEXT , Imm ) || isVTRNMask ( M , VT , WhichResult ) || isVUZPMask ( M , VT , WhichResult ) || isVZIPMask ( M , VT , WhichResult ) || isVTRN_v_undef_Mask ( M , VT , WhichResult ) || isVUZP_v_undef_Mask ( M , VT , WhichResult ) || isVZIP_v_undef_Mask ( M , VT , WhichResult ) ) ; } </s>

Targets can use this to indicate that they only support some VECTOR_SHUFFLE operations , those with specific masks .


<s> static bool ix86_legitimate_constant_p ( machine_mode mode , rtx x ) { switch ( GET_CODE ( x ) ) { case CONST : x = XEXP ( x , 0 ) ; if ( GET_CODE ( x ) == PLUS ) { if ( ! CONST_INT_P ( XEXP ( x , 1 ) ) ) return false ; x = XEXP ( x , 0 ) ; } if ( TARGET_MACHO && darwin_local_data_pic ( x ) ) return true ; if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , 1 ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : case UNSPEC_PLTOFF : return TARGET_64BIT ; case UNSPEC_TPOFF : case UNSPEC_NTPOFF : x = XVECEXP ( x , 0 , 0 ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_EXEC ) ; case UNSPEC_DTPOFF : x = XVECEXP ( x , 0 , 0 ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_DYNAMIC ) ; default : return false ; } if ( GET_CODE ( x ) == LABEL_REF ) return true ; if ( GET_CODE ( x ) != SYMBOL_REF ) return false ; case SYMBOL_REF : if ( SYMBOL_REF_TLS_MODEL ( x ) ) return false ; if ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P ( x ) ) return false ; if ( MACHO_DYNAMIC_NO_PIC_P ) return machopic_symbol_defined_p ( x ) ; if ( ix86_force_load_from_GOT_p ( x ) ) return false ; break ; CASE_CONST_SCALAR_INT : if ( ix86_endbr_immediate_operand ( x , VOIDmode ) ) return false ; switch ( mode ) { case E_TImode : if ( TARGET_64BIT ) return true ; case E_OImode : case E_XImode : if ( ! standard_sse_constant_p ( x , mode ) && GET_MODE_SIZE ( TARGET_AVX512F ? XImode : ( TARGET_AVX ? OImode : ( TARGET_SSE2 ? TImode : DImode ) ) ) < GET_MODE_SIZE ( mode ) ) return false ; default : break ; } break ; case CONST_VECTOR : if ( ! standard_sse_constant_p ( x , mode ) ) return false ; break ; case CONST_DOUBLE : if ( mode == E_BFmode ) return false ; default : break ; } return true ; } </s>

Determine if a given RTX is a valid constant . We already know this satisfies CONSTANT_P .


<s> virtual const DataLayout * getDataLayout ( ) const { return & DL ; } </s>

Return the DataLayout associated with the module this SCEV instance is operating on .


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

"failed to perform tail call elimination on a call "

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


<s> TargetRegisterClass * ARMTargetLowering :: getRegClassFor ( EVT VT ) const { if ( Subtarget -> hasNEON ( ) ) { if ( VT == MVT :: v4i64 ) return ARM :: QQPRRegisterClass ; else if ( VT == MVT :: v8i64 ) return ARM :: QQQQPRRegisterClass ; } return TargetLowering :: getRegClassFor ( VT ) ; } </s>

Return the register class that should be used for the specified value type .

ARM ARM MVT::v4i64 ARM::QQPRRegisterClass MVT::v8i64 ARM::QQQQPRRegisterClass


<s> bool MipsAsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { if ( Subtarget -> allowMixed16_32 ( ) ) const_cast < TargetLoweringObjectFile & > ( getObjFileLowering ( ) ) . Initialize ( OutContext , TM ) ; MipsFI = MF . getInfo < MipsFunctionInfo > ( ) ; if ( Subtarget -> inMips16Mode ( ) ) for ( std :: map < const char * , const llvm :: Mips16HardFloatInfo :: FuncSignature * > :: const_iterator it = MipsFI -> StubsNeeded . begin ( ) ; it != MipsFI -> StubsNeeded . end ( ) ; ++ it ) { const char * Symbol = it -> first ; const llvm :: Mips16HardFloatInfo :: FuncSignature * Signature = it -> second ; if ( StubsNeeded . find ( Symbol ) == StubsNeeded . end ( ) ) StubsNeeded [ Symbol ] = Signature ; } MCP = MF . getConstantPool ( ) ; if ( Subtarget -> isTargetNaCl ( ) ) NaClAlignIndirectJumpTargets ( MF ) ; AsmPrinter :: runOnMachineFunction ( MF ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .

Mips Mips Mips Mips Mips Mips16HardFloatInfo::FuncSignature Mips Mips Mips16HardFloatInfo::FuncSignature


<s> uint64_t PPCFrameLowering :: determineFrameLayoutAndUpdate ( MachineFunction & MF , bool UseEstimate ) const { unsigned NewMaxCallFrameSize = 0 ; uint64_t FrameSize = determineFrameLayout ( MF , UseEstimate , & NewMaxCallFrameSize ) ; MF . getFrameInfo ( ) . setStackSize ( FrameSize ) ; MF . getFrameInfo ( ) . setMaxCallFrameSize ( NewMaxCallFrameSize ) ; return FrameSize ; } </s>

Determine the frame layout and update the machine function .


<s> static void addarg ( const char * str ) { int i ; if ( ++ link_arg_index >= link_arg_max ) { const char * * new_link_args = ( const char * * ) xcalloc ( link_arg_max + 1000 , sizeof ( char * ) ) ; for ( i = 0 ; i <= link_arg_max ; i ++ ) new_link_args [ i ] = link_args [ i ] ; if ( link_args ) free ( link_args ) ; link_arg_max += 1000 ; link_args = new_link_args ; } link_args [ link_arg_index ] = str ; } </s>

Append STR to the command line to invoke the linker . Expand the line as necessary to accommodate .


<s> bool cris_output_addr_const_extra ( FILE * file , rtx xconst ) { switch ( GET_CODE ( xconst ) ) { rtx x ; case UNSPEC : x = XVECEXP ( xconst , 0 , 0 ) ; CRIS_ASSERT ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || GET_CODE ( x ) == CONST ) ; output_addr_const ( file , x ) ; switch ( XINT ( xconst , 1 ) ) { case CRIS_UNSPEC_PLT : fprintf ( file , ":PLTG" ) ; break ; case CRIS_UNSPEC_GOTREL : fprintf ( file , ":GOTOFF" ) ; break ; case CRIS_UNSPEC_GOTREAD : if ( flag_pic == 1 ) fprintf ( file , ":GOT16" ) ; else fprintf ( file , ":GOT" ) ; break ; case CRIS_UNSPEC_PLTGOTREAD : if ( flag_pic == 1 ) fprintf ( file , CRIS_GOTPLT_SUFFIX "16" ) ; else fprintf ( file , CRIS_GOTPLT_SUFFIX ) ; break ; default : gcc_unreachable ( ) ; } return true ; default : return false ; } } </s>

Worker function for OUTPUT_ADDR_CONST_EXTRA .


<s> Optional < MCFixupKind > ARMAsmBackend :: getFixupKind ( StringRef Name ) const { if ( ! STI . getTargetTriple ( ) . isOSBinFormatELF ( ) ) return None ; unsigned Type = llvm :: StringSwitch < unsigned > ( Name ) . Default ( - 1u ) ; if ( Type == - 1u ) return None ; return static_cast < MCFixupKind > ( FirstLiteralRelocationKind + Type ) ; } </s>

getFixupKind - Get the fixup kind of this expression .


<s> bool isVolatile ( ) const { return IsVolatile ; } </s>

Return true if this is a store to a volatile memory location .


<s> bool runOnModule ( Module & M ) override { for ( auto & GV : M . globals ( ) ) GV . setThreadLocalMode ( GlobalValue :: ThreadLocalMode :: NotThreadLocal ) ; return true ; } </s>

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


<s> unsigned getFirstUnallocated ( const unsigned * Regs , unsigned NumRegs ) const { for ( unsigned i = 0 ; i != NumRegs ; ++ i ) if ( ! isAllocated ( Regs [ i ] ) ) return i ; return NumRegs ; } </s>

getFirstUnallocated - Return the index of the first unallocated register in the set , or Regs.size ( ) if they are all allocated .


<s> bool OR1KDAGToDAGISel :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & static_cast < const OR1KSubtarget & > ( MF . getSubtarget ( ) ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ; } </s>


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

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

Mips
Mips
0
0
4
"unexpected inline asm memory operand"
"($"
Mips
")"


<s>
static
int
write_header_file
(
void
)
{
write_autogenerated_header
(
header_file
)
;
fprintf
(
header_file
,
"#ifndef _RS6000_BUILTINS_H\n"
)
;
fprintf
(
header_file
,
"#define _RS6000_BUILTINS_H 1\n\n"
)
;
write_decls
(
)
;
fprintf
(
header_file
,
"\n"
)
;
fprintf
(
header_file
,
"\n#endif\n"
)
;
return
1
;
}
</s>

Write everything to the header file ( rs6000-builtins.h ) . Return 1 if successful , 0 otherwise .

rs6000
"#ifndef _RS6000_BUILTINS_H\n"
"#define _RS6000_BUILTINS_H 1\n\n"
"\n"
"\n#endif\n"
1


<s> int ia64_st_address_bypass_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx dest , reg , mem ; gcc_assert ( producer && consumer ) ; dest = ia64_single_set ( producer ) ; gcc_assert ( dest ) ; reg = SET_DEST ( dest ) ; gcc_assert ( reg ) ; if ( GET_CODE ( reg ) == SUBREG ) reg = SUBREG_REG ( reg ) ; gcc_assert ( GET_CODE ( reg ) == REG ) ; dest = ia64_single_set ( consumer ) ; gcc_assert ( dest ) ; mem = SET_DEST ( dest ) ; gcc_assert ( mem && GET_CODE ( mem ) == MEM ) ; return reg_mentioned_p ( reg , mem ) ; } </s>

The following function returns TRUE if PRODUCER ( of type ilog or ld ) produces address for CONSUMER ( of type st or stf ) .


<s> void aarch64_split_sve_subreg_move ( rtx dest , rtx ptrue , rtx src ) { machine_mode mode_with_wider_elts = GET_MODE ( dest ) ; machine_mode mode_with_narrower_elts = GET_MODE ( src ) ; if ( GET_MODE_UNIT_SIZE ( mode_with_wider_elts ) < GET_MODE_UNIT_SIZE ( mode_with_narrower_elts ) ) std :: swap ( mode_with_wider_elts , mode_with_narrower_elts ) ; unsigned int wider_bytes = GET_MODE_UNIT_SIZE ( mode_with_wider_elts ) ; unsigned int unspec ; if ( wider_bytes == 8 ) unspec = UNSPEC_REV64 ; else if ( wider_bytes == 4 ) unspec = UNSPEC_REV32 ; else if ( wider_bytes == 2 ) unspec = UNSPEC_REV16 ; else gcc_unreachable ( ) ; machine_mode pred_mode = aarch64_sve_pred_mode ( wider_bytes ) . require ( ) ; ptrue = gen_lowpart ( pred_mode , ptrue ) ; dest = aarch64_replace_reg_mode ( dest , mode_with_narrower_elts ) ; src = aarch64_replace_reg_mode ( src , mode_with_narrower_elts ) ; src = gen_rtx_UNSPEC ( mode_with_narrower_elts , gen_rtvec ( 1 , src ) , unspec ) ; src = gen_rtx_UNSPEC ( mode_with_narrower_elts , gen_rtvec ( 2 , ptrue , src ) , UNSPEC_MERGE_PTRUE ) ; emit_insn ( gen_rtx_SET ( dest , src ) ) ; } </s>

Split a * aarch64_sve_mov < mode > _subreg_be pattern with the given operands .


<s>
void
MachineConstPropagator
::
propagate
(
MachineFunction
&
MF
)
{
MachineBasicBlock
*
Entry
=
GraphTraits
<
MachineFunction
*
>
::
getEntryNode
(
&
MF
)
;
unsigned
EntryNum
=
Entry
->
getNumber
(
)
;
FlowQ
.
push
(
CFGEdge
(
EntryNum
,
EntryNum
)
)
;
while
(
!
FlowQ
.
empty
(
)
)
{
CFGEdge
Edge
=
FlowQ
.
front
(
)
;
FlowQ
.
pop
(
)
;
LLVM_DEBUG
(
dbgs
(
)
<<
"Picked edge "
<<
printMBBReference
(
*
MF
.
getBlockNumbered
(
Edge
.
first
)
)
<<
"->"
<<
printMBBReference
(
*
MF
.
getBlockNumbered
(
Edge
.
second
)
)
<<
'\n'
)
;
if
(
Edge
.
first
!=
EntryNum
)
if
(
EdgeExec
.
count
(
Edge
)
)
continue
;
EdgeExec
.
insert
(
Edge
)
;
MachineBasicBlock
*
SB
=
MF
.
getBlockNumbered
(
Edge
.
second
)
;
MachineBasicBlock
::
const_iterator
It
=
SB
->
begin
(
)
,
End
=
SB
->
end
(
)
;
while
(
It
!=
End
&&
It
->
isPHI
(
)
)
{
InstrExec
.
insert
(
&
*
It
)
;
visitPHI
(
*
It
)
;
++
It
;
}
while
(
It
!=
End
&&
It
->
isDebugInstr
(
)
)
++
It
;
assert
(
It
==
End
||
!
It
->
isPHI
(
)
)
;
if
(
It
!=
End
&&
InstrExec
.
count
(
&
*
It
)
)
continue
;
while
(
It
!=
End
&&
!
It
->
isBranch
(
)
)
{
if
(
!
It
->
isDebugInstr
(
)
)
{
InstrExec
.
insert
(
&
*
It
)
;
visitNonBranch
(
*
It
)
;
}
++
It
;
}
if
(
It
!=
End
)
{
visitBranchesFrom
(
*
It
)
;
}
else
{
unsigned
SBN
=
SB
->
getNumber
(
)
;
for
(
const
MachineBasicBlock
*
SSB
:
SB
->
successors
(
)
)
FlowQ
.
push
(
CFGEdge
(
SBN
,
SSB
->
getNumber
(
)
)
)
;
}
}
LLVM_DEBUG
(
{
dbgs
(
)
<<
"Cells after propagation:\n"
;
Cells
.
print
(
dbgs
(
)
,
MCE
.
TRI
)
;
dbgs
(
)
<<
"Dead CFG edges:\n"
;
for
(
const
MachineBasicBlock
&
B
:
MF
)
{
unsigned
BN
=
B
.
getNumber
(
)
;
for
(
const
MachineBasicBlock
*
SB
:
B
.
successors
(
)
)
{
unsigned
SN
=
SB
->
getNumber
(
)
;
if
(
!
EdgeExec
.
count
(
CFGEdge
(
BN
,
SN
)
)
)
dbgs
(
)
<<
"  "
<<
printMBBReference
(
B
)
<<
" -> "
<<
printMBBReference
(
*
SB
)
<<
'\n'
;
}
}
}
)
;
}
</s>

Propgate synthetic entry counts on a callgraph CG .

Hexagon
"Picked edge "
"->"
"Cells after propagation:\n"
"Dead CFG edges:\n"
"  "
" -> "


<s> static unsigned int aarch64_sve_in_loop_reduction_latency ( vec_info * vinfo , stmt_vec_info stmt_info , tree vectype , const sve_vec_cost * sve_costs ) { switch ( aarch64_reduc_type ( vinfo , stmt_info ) ) { case EXTRACT_LAST_REDUCTION : return sve_costs -> clast_cost ; case FOLD_LEFT_REDUCTION : switch ( GET_MODE_INNER ( TYPE_MODE ( vectype ) ) ) { case E_HFmode : case E_BFmode : return sve_costs -> fadda_f16_cost ; case E_SFmode : return sve_costs -> fadda_f32_cost ; case E_DFmode : return sve_costs -> fadda_f64_cost ; default : break ; } break ; } return 0 ; } </s>

We are considering implementing STMT_INFO using SVE vector type VECTYPE . If STMT_INFO is an in-loop reduction that SVE supports directly , return its latency in cycles , otherwise return zero . SVE_COSTS specifies the latencies of the relevant instructions .


<s> const char * M680x0TargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { case M680x0ISD :: CALL : return "M680x0ISD::CALL" ; case M680x0ISD :: TAIL_CALL : return "M680x0ISD::TAIL_CALL" ; case M680x0ISD :: RET : return "M680x0ISD::RET" ; case M680x0ISD :: TC_RETURN : return "M680x0ISD::TC_RETURN" ; case M680x0ISD :: ADD : return "M680x0ISD::ADD" ; case M680x0ISD :: SUB : return "M680x0ISD::SUB" ; case M680x0ISD :: ADDX : return "M680x0ISD::ADDX" ; case M680x0ISD :: SUBX : return "M680x0ISD::SUBX" ; case M680x0ISD :: SMUL : return "M680x0ISD::SMUL" ; case M680x0ISD :: UMUL : return "M680x0ISD::UMUL" ; case M680x0ISD :: OR : return "M680x0ISD::OR" ; case M680x0ISD :: XOR : return "M680x0ISD::XOR" ; case M680x0ISD :: AND : return "M680x0ISD::AND" ; case M680x0ISD :: CMP : return "M680x0ISD::CMP" ; case M680x0ISD :: BT : return "M680x0ISD::BT" ; case M680x0ISD :: SELECT : return "M680x0ISD::SELECT" ; case M680x0ISD :: CMOV : return "M680x0ISD::CMOV" ; case M680x0ISD :: BRCOND : return "M680x0ISD::BRCOND" ; case M680x0ISD :: SETCC : return "M680x0ISD::SETCC" ; case M680x0ISD :: SETCC_CARRY : return "M680x0ISD::SETCC_CARRY" ; case M680x0ISD :: GlobalBaseReg : return "M680x0ISD::GlobalBaseReg" ; case M680x0ISD :: Wrapper : return "M680x0ISD::Wrapper" ; case M680x0ISD :: WrapperPC : return "M680x0ISD::WrapperPC" ; case M680x0ISD :: SEG_ALLOCA : return "M680x0ISD::SEG_ALLOCA" ; default : return NULL ; } } </s>

getTargetNodeName - This method returns the name of a target specific


"Hexagon relaxInstruction only works on bundles"

"No room to insert extender for relaxation"

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


<s> void SIInstrInfo :: storeRegToStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , unsigned SrcReg , bool isKill , int FrameIndex , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; SIMachineFunctionInfo * MFI = MF -> getInfo < SIMachineFunctionInfo > ( ) ; MachineFrameInfo & FrameInfo = MF -> getFrameInfo ( ) ; const DebugLoc & DL = MBB . findDebugLoc ( MI ) ; unsigned Size = FrameInfo . getObjectSize ( FrameIndex ) ; unsigned Align = FrameInfo . getObjectAlignment ( FrameIndex ) ; MachinePointerInfo PtrInfo = MachinePointerInfo :: getFixedStack ( * MF , FrameIndex ) ; MachineMemOperand * MMO = MF -> getMachineMemOperand ( PtrInfo , MachineMemOperand :: MOStore , Size , Align ) ; unsigned SpillSize = TRI -> getSpillSize ( * RC ) ; if ( RI . isSGPRClass ( RC ) ) { MFI -> setHasSpilledSGPRs ( ) ; const MCInstrDesc & OpDesc = get ( getSGPRSpillSaveOpcode ( SpillSize ) ) ; if ( Register :: isVirtualRegister ( SrcReg ) && SpillSize == 4 ) { MachineRegisterInfo & MRI = MF -> getRegInfo ( ) ; MRI . constrainRegClass ( SrcReg , & AMDGPU :: SReg_32_XM0RegClass ) ; } BuildMI ( MBB , MI , DL , OpDesc ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addFrameIndex ( FrameIndex ) . addMemOperand ( MMO ) . addReg ( MFI -> getScratchRSrcReg ( ) , RegState :: Implicit ) . addReg ( MFI -> getStackPtrOffsetReg ( ) , RegState :: Implicit ) ; if ( RI . spillSGPRToVGPR ( ) ) FrameInfo . setStackID ( FrameIndex , TargetStackID :: SGPRSpill ) ; return ; } unsigned Opcode = RI . hasAGPRs ( RC ) ? getAGPRSpillSaveOpcode ( SpillSize ) : getVGPRSpillSaveOpcode ( SpillSize ) ; MFI -> setHasSpilledVGPRs ( ) ; auto MIB = BuildMI ( MBB , MI , DL , get ( Opcode ) ) ; if ( RI . hasAGPRs ( RC ) ) { MachineRegisterInfo & MRI = MF -> getRegInfo ( ) ; Register Tmp = MRI . createVirtualRegister ( & AMDGPU :: VGPR_32RegClass ) ; MIB . addReg ( Tmp , RegState :: Define ) ; } MIB . addReg ( SrcReg , getKillRegState ( isKill ) ) . addFrameIndex ( FrameIndex ) . addReg ( MFI -> getScratchRSrcReg ( ) ) . addReg ( MFI -> getStackPtrOffsetReg ( ) ) . addImm ( 0 ) . addMemOperand ( MMO ) ; } </s>

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


"Cannot adjust stack mid-function without a frame pointer"

This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy pseudo instructions ( but only if the Target is using them ) .


<s> static void swap_const_vector_halves ( rtx op ) { int i ; enum rtx_code code = GET_CODE ( op ) ; if ( GET_CODE ( op ) == CONST_VECTOR ) { int half_units = GET_MODE_NUNITS ( GET_MODE ( op ) ) / 2 ; for ( i = 0 ; i < half_units ; ++ i ) { rtx temp = CONST_VECTOR_ELT ( op , i ) ; CONST_VECTOR_ELT ( op , i ) = CONST_VECTOR_ELT ( op , i + half_units ) ; CONST_VECTOR_ELT ( op , i + half_units ) = temp ; } } else { int j ; const char * fmt = GET_RTX_FORMAT ( code ) ; for ( i = 0 ; i < GET_RTX_LENGTH ( code ) ; ++ i ) if ( fmt [ i ] == 'e' || fmt [ i ] == 'u' ) swap_const_vector_halves ( XEXP ( op , i ) ) ; else if ( fmt [ i ] == 'E' ) for ( j = 0 ; j < XVECLEN ( op , i ) ; ++ j ) swap_const_vector_halves ( XVECEXP ( op , i , j ) ) ; } } </s>

OP is either a CONST_VECTOR or an expression containing one . Swap the first half of the vector with the second in the first case . Recurse to find it in the second .


<s>
static
void
replace_swap_with_copy
(
swap_web_entry
*
insn_entry
,
unsigned
i
)
{
rtx_insn
*
insn
=
insn_entry
[
i
]
.
insn
;
rtx
body
=
PATTERN
(
insn
)
;
rtx
src_reg
=
XEXP
(
SET_SRC
(
body
)
,
0
)
;
rtx
copy
=
gen_rtx_SET
(
SET_DEST
(
body
)
,
src_reg
)
;
rtx_insn
*
new_insn
=
emit_insn_before
(
copy
,
insn
)
;
set_block_for_insn
(
new_insn
,
BLOCK_FOR_INSN
(
insn
)
)
;
df_insn_rescan
(
new_insn
)
;
if
(
dump_file
)
{
unsigned
int
new_uid
=
INSN_UID
(
new_insn
)
;
fprintf
(
dump_file
,
"Replacing swap %d with copy %d\n"
,
i
,
new_uid
)
;
}
df_insn_delete
(
insn
)
;
remove_insn
(
insn
)
;
insn
->
set_deleted
(
)
;
}
</s>

Find the insn from the Ith table entry , which is known to be a register swap Y = SWAP ( X ) . Replace it with a copy Y = X .


<s> static tree nios2_valid_target_attribute_tree ( tree args ) { if ( ! nios2_valid_target_attribute_rec ( args ) ) return NULL_TREE ; nios2_custom_check_insns ( ) ; return build_target_option_node ( & global_options , & global_options_set ) ; } </s>

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


<s> bool RISCVInstrInfo :: shouldOutlineFromFunctionByDefault ( MachineFunction & MF ) const { return MF . getFunction ( ) . hasMinSize ( ) ; } </s>

Return true if the function should be outlined from by default .


<s> void JVMPassConfig :: addPreEmitPass ( ) { TargetPassConfig :: addPreEmitPass ( ) ; if ( JvmLSOpt ) addPass ( createJVMLoadStoreEliminationOpt ( ) ) ; addPass ( createJVMOffsetAllocator ( ) ) ; addPass ( createJVMPostAllocationFixups ( ) ) ; } </s>

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


"pointer offset from symbol maybe incorrect"


"Skipping offset folding global address: "

"AArch64 doesn't support folding offsets into global "

Return true if folding a constant offset with the given GlobalAddress is legal .


<s> virtual EVT getSetCCResultType ( LLVMContext & , EVT ) const { return MVT :: i1 ; } </s>

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


<s> bool AMDGPUTTIImpl :: isSourceOfDivergence ( const Value * V ) const { if ( const Argument * A = dyn_cast < Argument > ( V ) ) return ! isArgPassedInSGPR ( A ) ; if ( const LoadInst * Load = dyn_cast < LoadInst > ( V ) ) return Load -> getPointerAddressSpace ( ) == ST -> getAMDGPUAS ( ) . PRIVATE_ADDRESS ; if ( isa < AtomicRMWInst > ( V ) || isa < AtomicCmpXchgInst > ( V ) ) return true ; if ( const IntrinsicInst * Intrinsic = dyn_cast < IntrinsicInst > ( V ) ) return isIntrinsicSourceOfDivergence ( Intrinsic ) ; if ( isa < CallInst > ( V ) || isa < InvokeInst > ( V ) ) return true ; return false ; } </s>

Returns whether V is a source of divergence .


<s> int X86InstrInfo :: getSPAdjust ( const MachineInstr & MI ) const { const MachineFunction * MF = MI . getParent ( ) -> getParent ( ) ; const TargetFrameLowering * TFI = MF -> getSubtarget ( ) . getFrameLowering ( ) ; if ( isFrameInstr ( MI ) ) { unsigned StackAlign = TFI -> getStackAlignment ( ) ; int SPAdj = alignTo ( getFrameSize ( MI ) , StackAlign ) ; SPAdj -= getFrameAdjustment ( MI ) ; if ( ! isFrameSetup ( MI ) ) SPAdj = - SPAdj ; return SPAdj ; } if ( MI . isCall ( ) ) { const MachineBasicBlock * MBB = MI . getParent ( ) ; auto I = ++ MachineBasicBlock :: const_iterator ( MI ) ; for ( auto E = MBB -> end ( ) ; I != E ; ++ I ) { if ( I -> getOpcode ( ) == getCallFrameDestroyOpcode ( ) || I -> isCall ( ) ) break ; } if ( I -> getOpcode ( ) != getCallFrameDestroyOpcode ( ) ) return 0 ; return - ( I -> getOperand ( 1 ) . getImm ( ) ) ; } switch ( MI . getOpcode ( ) ) { default : return 0 ; case X86 :: PUSH32i8 : case X86 :: PUSH32r : case X86 :: PUSH32rmm : case X86 :: PUSH32rmr : case X86 :: PUSHi32 : return 4 ; case X86 :: PUSH64i8 : case X86 :: PUSH64r : case X86 :: PUSH64rmm : case X86 :: PUSH64rmr : case X86 :: PUSH64i32 : return 8 ; } } </s>

getSPAdjust - This returns the stack pointer adjustment made by this instruction .


<s> static int pa_adjust_priority ( rtx insn , int priority ) { rtx set = single_set ( insn ) ; rtx src , dest ; if ( set ) { src = SET_SRC ( set ) ; dest = SET_DEST ( set ) ; if ( GET_CODE ( src ) == LO_SUM && symbolic_operand ( XEXP ( src , 1 ) , VOIDmode ) && ! read_only_operand ( XEXP ( src , 1 ) , VOIDmode ) ) priority >>= 3 ; else if ( GET_CODE ( src ) == MEM && GET_CODE ( XEXP ( src , 0 ) ) == LO_SUM && symbolic_operand ( XEXP ( XEXP ( src , 0 ) , 1 ) , VOIDmode ) && ! read_only_operand ( XEXP ( XEXP ( src , 0 ) , 1 ) , VOIDmode ) ) priority >>= 1 ; else if ( GET_CODE ( dest ) == MEM && GET_CODE ( XEXP ( dest , 0 ) ) == LO_SUM && symbolic_operand ( XEXP ( XEXP ( dest , 0 ) , 1 ) , VOIDmode ) && ! read_only_operand ( XEXP ( XEXP ( dest , 0 ) , 1 ) , VOIDmode ) ) priority >>= 3 ; } return priority ; } </s>

Adjust scheduling priorities . We use this to try and keep addil and the next use of % r1 close together .


<s> bool SITargetLowering :: supportSplitCSR ( MachineFunction * MF ) const { const SIMachineFunctionInfo * Info = MF -> getInfo < SIMachineFunctionInfo > ( ) ; return ! Info -> isEntryFunction ( ) ; } </s>

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


<s> void P2MCCodeEmitter :: emitInstruction ( uint64_t Val , unsigned Size , raw_ostream & OS ) const { for ( unsigned i = 0 ; i < Size ; ++ i ) { emitByte ( ( Val >> i * 8 ) & 0xff , OS ) ; } } </s>

Targets should implement this to emit instructions .


<s> void AVRPassConfig :: addPreEmitPass ( ) { } </s>


<s> bool HexagonVLIWResourceModel :: hasDependence ( const SUnit * SUd , const SUnit * SUu ) { const auto * QII = static_cast < const HexagonInstrInfo * > ( TII ) ; if ( QII -> mayBeCurLoad ( * SUd -> getInstr ( ) ) ) return false ; if ( QII -> canExecuteInBundle ( * SUd -> getInstr ( ) , * SUu -> getInstr ( ) ) ) return false ; return VLIWResourceModel :: hasDependence ( SUd , SUu ) ; } </s>

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


<s> bool mep_expand_binary_intrinsic ( int ATTRIBUTE_UNUSED immediate , int ATTRIBUTE_UNUSED immediate3 , int ATTRIBUTE_UNUSED reg , int ATTRIBUTE_UNUSED reg3 , rtx * operands ATTRIBUTE_UNUSED ) { return false ; } </s>

Likewise , but apply a binary operation to OPERANDS [ 1 ] and OPERANDS [ 2 ] . OPERANDS [ 1 ] is a register_operand , OPERANDS [ 2 ] can be a general_operand . IMMEDIATE and IMMEDIATE3 are intrinsics that take an immediate third operand . REG and REG3 take register operands only .


<s> bool AMDGPUInstructionSelector :: select ( MachineInstr & I , CodeGenCoverage & CoverageInfo ) const { if ( ! isPreISelGenericOpcode ( I . getOpcode ( ) ) ) return true ; switch ( I . getOpcode ( ) ) { default : break ; case TargetOpcode :: G_ADD : return selectG_ADD ( I ) ; case TargetOpcode :: G_CONSTANT : return selectG_CONSTANT ( I ) ; case TargetOpcode :: G_GEP : return selectG_GEP ( I ) ; case TargetOpcode :: G_LOAD : return selectG_LOAD ( I ) ; case TargetOpcode :: G_STORE : return selectG_STORE ( I ) ; } return false ; } </s>

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


<s> void BTFTypeTag :: completeType ( BTFDebug & BDebug ) { if ( IsCompleted ) return ; IsCompleted = true ; BTFType . NameOff = BDebug . addString ( Tag ) ; } </s>

Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id 's are available for cross referece .


<s>
static
tree
bpf_resolve_overloaded_builtin
(
location_t
loc
,
tree
fndecl
,
void
*
arglist
)
{
enum
bpf_builtins
which
=
(
enum
bpf_builtins
)
DECL_MD_FUNCTION_CODE
(
fndecl
)
;
if
(
which
<
BPF_BUILTIN_PRESERVE_ACCESS_INDEX
||
which
>=
BPF_BUILTIN_MAX
)
return
NULL_TREE
;
vec
<
tree
,
va_gc
>
*
params
=
static_cast
<
vec
<
tree
,
va_gc
>
*
>
(
arglist
)
;
unsigned
n_params
=
params
params
->
length
(
)
:
0
;
if
(
!
(
which
==
BPF_BUILTIN_PRESERVE_ACCESS_INDEX
&&
n_params
==
1
)
&&
n_params
!=
2
)
{
error_at
(
loc
,
"wrong number of arguments"
)
;
return
error_mark_node
;
}
tree
param
=
(
*
params
)
[
0
]
;
if
(
which
==
BPF_BUILTIN_PRESERVE_ACCESS_INDEX
&&
!
TARGET_BPF_CORE
)
return
param
;
else
if
(
which
==
BPF_BUILTIN_PRESERVE_FIELD_INFO
&&
!
bpf_is_valid_preserve_field_info_arg
(
param
)
)
{
error_at
(
EXPR_LOC_OR_LOC
(
param
,
loc
)
,
"argument is not a field access"
)
;
return
error_mark_node
;
}
if
(
TREE_CODE
(
param
)
==
C_MAYBE_CONST_EXPR
)
param
=
C_MAYBE_CONST_EXPR_EXPR
(
param
)
;
struct
core_walk_data
data
;
data
.
loc
=
loc
;
data
.
which
=
which
;
if
(
which
==
BPF_BUILTIN_PRESERVE_ACCESS_INDEX
)
data
.
arg
=
NULL_TREE
;
else
data
.
arg
=
(
*
params
)
[
1
]
;
walk_tree
(
&
param
,
bpf_core_walk
,
(
void
*
)
&
data
,
)
;
return
param
;
}
</s>

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


<s> static int mips_mode_rep_extended ( machine_mode mode , machine_mode mode_rep ) { if ( TARGET_64BIT && mode == SImode && mode_rep == DImode ) return SIGN_EXTEND ; return UNKNOWN ; } </s>


<s>
SDValue
HexagonTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Should not custom lower this!"
)
;
case
ISD
::
CONCAT_VECTORS
:
return
LowerCONCAT_VECTORS
(
Op
,
DAG
)
;
case
ISD
::
INSERT_SUBVECTOR
:
return
LowerINSERT_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
INSERT_VECTOR_ELT
:
return
LowerINSERT_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
EXTRACT_SUBVECTOR
:
return
LowerEXTRACT_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
EXTRACT_VECTOR_ELT
:
return
LowerEXTRACT_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
BUILD_VECTOR
:
return
LowerBUILD_VECTOR
(
Op
,
DAG
)
;
case
ISD
::
VECTOR_SHUFFLE
:
return
LowerVECTOR_SHUFFLE
(
Op
,
DAG
)
;
case
ISD
::
SRA
:
case
ISD
::
SHL
:
case
ISD
::
SRL
:
return
LowerVECTOR_SHIFT
(
Op
,
DAG
)
;
case
ISD
::
ConstantPool
:
return
LowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
EH_RETURN
:
return
LowerEH_RETURN
(
Op
,
DAG
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
llvm_unreachable
(
"TLS not implemented for Hexagon."
)
;
case
ISD
::
ATOMIC_FENCE
:
return
LowerATOMIC_FENCE
(
Op
,
DAG
)
;
case
ISD
::
GlobalAddress
:
return
LowerGLOBALADDRESS
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
LowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
)
;
case
ISD
::
BR_JT
:
return
LowerBR_JT
(
Op
,
DAG
)
;
case
ISD
::
LOAD
:
return
LowerLOAD
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
case
ISD
::
SELECT
:
return
Op
;
case
ISD
::
SETCC
:
return
LowerSETCC
(
Op
,
DAG
)
;
case
ISD
::
VSELECT
:
return
LowerVSELECT
(
Op
,
DAG
)
;
case
ISD
::
CTPOP
:
return
LowerCTPOP
(
Op
,
DAG
)
;
case
ISD
::
INTRINSIC_WO_CHAIN
:
return
LowerINTRINSIC_WO_CHAIN
(
Op
,
DAG
)
;
case
ISD
::
INLINEASM
:
return
LowerINLINEASM
(
Op
,
DAG
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> bool ARMBaseInstrInfo :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; for ( unsigned i = 0 , e = CSI . size ( ) ; i != e ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; bool isKill = true ; if ( Reg == ARM :: LR ) { MachineFunction & MF = * MBB . getParent ( ) ; if ( MF . getFrameInfo ( ) -> isReturnAddressTaken ( ) && MF . getRegInfo ( ) . isLiveIn ( Reg ) ) isKill = false ; } if ( isKill ) MBB . addLiveIn ( Reg ) ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; storeRegToStackSlot ( MBB , MI , Reg , isKill , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; } return true ; } </s>

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


<s>
static
void
ix86_avoid_jump_mispredicts
(
void
)
{
rtx_insn
*
insn
,
*
start
=
get_insns
(
)
;
int
nbytes
=
0
,
njumps
=
0
;
bool
isjump
=
false
;
for
(
insn
=
start
;
insn
;
insn
=
NEXT_INSN
(
insn
)
)
{
int
min_size
;
if
(
LABEL_P
(
insn
)
)
{
int
align
=
label_to_alignment
(
insn
)
;
int
max_skip
=
label_to_max_skip
(
insn
)
;
if
(
max_skip
>
15
)
max_skip
=
15
;
if
(
align
<=
0
||
(
align
<=
3
&&
max_skip
!=
(
1
<<
align
)
1
)
)
max_skip
=
0
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Label %i with max_skip %i\n"
,
INSN_UID
(
insn
)
,
max_skip
)
;
if
(
max_skip
)
{
while
(
nbytes
+
max_skip
>=
16
)
{
start
=
NEXT_INSN
(
start
)
;
if
(
(
JUMP_P
(
start
)
&&
asm_noperands
(
PATTERN
(
start
)
)
<
0
)
||
CALL_P
(
start
)
)
njumps
,
isjump
=
true
;
else
isjump
=
false
;
nbytes
-=
min_insn_size
(
start
)
;
}
}
continue
;
}
min_size
=
min_insn_size
(
insn
)
;
nbytes
+=
min_size
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Insn %i estimated to %i bytes\n"
,
INSN_UID
(
insn
)
,
min_size
)
;
if
(
(
JUMP_P
(
insn
)
&&
asm_noperands
(
PATTERN
(
insn
)
)
<
0
)
||
CALL_P
(
insn
)
)
njumps
++
;
else
continue
;
while
(
njumps
>
3
)
{
start
=
NEXT_INSN
(
start
)
;
if
(
(
JUMP_P
(
start
)
&&
asm_noperands
(
PATTERN
(
start
)
)
<
0
)
||
CALL_P
(
start
)
)
njumps
,
isjump
=
true
;
else
isjump
=
false
;
nbytes
-=
min_insn_size
(
start
)
;
}
gcc_assert
(
njumps
>=
0
)
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Interval %i to %i has %i bytes\n"
,
INSN_UID
(
start
)
,
INSN_UID
(
insn
)
,
nbytes
)
;
if
(
njumps
==
3
&&
isjump
&&
nbytes
<
16
)
{
int
padsize
=
15
nbytes
+
min_insn_size
(
insn
)
;
if
(
dump_file
)
fprintf
(
dump_file
,
"Padding insn %i by %i bytes!\n"
,
INSN_UID
(
insn
)
,
padsize
)
;
emit_insn_before
(
gen_pad
(
GEN_INT
(
padsize
)
)
,
insn
)
;
}
}
}
</s>

AMD K8 core mispredicts jumps when there are more than 3 jumps in 16 byte window .


<s> static int find_gr_spill ( int try_locals ) { int regno ; if ( current_function_is_leaf ) { for ( regno = GR_REG ( 1 ) ; regno <= GR_REG ( 31 ) ; regno ++ ) if ( ! regs_ever_live [ regno ] && call_used_regs [ regno ] && ! fixed_regs [ regno ] && ! global_regs [ regno ] && ( ( current_frame_info . gr_used_mask >> regno ) & 1 ) == 0 ) { current_frame_info . gr_used_mask |= 1 << regno ; return regno ; } } if ( try_locals ) { regno = current_frame_info . n_local_regs ; if ( regno < ( 80 - frame_pointer_needed ) ) { current_frame_info . n_local_regs = regno + 1 ; return LOC_REG ( 0 ) + regno ; } } return 0 ; } </s>

Helper function for ia64_compute_frame_size : find an appropriate general register to spill some special register to . SPECIAL_SPILL_MASK contains bits in GR0 to GR31 that have already been allocated by this routine . TRY_LOCALS is true if we should attempt to locate a local regnum .


<s> int arm_float_words_big_endian ( void ) { if ( TARGET_MAVERICK ) return 0 ; if ( TARGET_FPA ) { return 1 ; } if ( TARGET_VFP ) return ( TARGET_BIG_END ? 1 : 0 ) ; return 1 ; } </s>

Indicate whether or not words of a double are in big-endian order .


<s> BitVector PPCRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; const PPCSubtarget & Subtarget = MF . getSubtarget < PPCSubtarget > ( ) ; const PPCFrameLowering * TFI = getFrameLowering ( MF ) ; Reserved . set ( PPC :: ZERO ) ; Reserved . set ( PPC :: ZERO8 ) ; Reserved . set ( PPC :: FP ) ; Reserved . set ( PPC :: FP8 ) ; Reserved . set ( PPC :: BP ) ; Reserved . set ( PPC :: BP8 ) ; Reserved . set ( PPC :: CTR ) ; Reserved . set ( PPC :: CTR8 ) ; Reserved . set ( PPC :: R1 ) ; Reserved . set ( PPC :: LR ) ; Reserved . set ( PPC :: LR8 ) ; Reserved . set ( PPC :: RM ) ; if ( ! Subtarget . isDarwinABI ( ) || ! Subtarget . hasAltivec ( ) ) Reserved . set ( PPC :: VRSAVE ) ; if ( Subtarget . isSVR4ABI ( ) ) { Reserved . set ( PPC :: R2 ) ; Reserved . set ( PPC :: R13 ) ; } if ( TM . isPPC64 ( ) ) { Reserved . set ( PPC :: R13 ) ; Reserved . set ( PPC :: X1 ) ; Reserved . set ( PPC :: X13 ) ; if ( TFI -> needsFP ( MF ) ) Reserved . set ( PPC :: X31 ) ; if ( hasBasePointer ( MF ) ) Reserved . set ( PPC :: X30 ) ; if ( Subtarget . isSVR4ABI ( ) ) { const PPCFunctionInfo * FuncInfo = MF . getInfo < PPCFunctionInfo > ( ) ; if ( FuncInfo -> usesTOCBasePtr ( ) || MF . hasInlineAsm ( ) ) Reserved . set ( PPC :: X2 ) ; else Reserved . reset ( PPC :: R2 ) ; } } if ( TFI -> needsFP ( MF ) ) Reserved . set ( PPC :: R31 ) ; if ( hasBasePointer ( MF ) ) { if ( Subtarget . isSVR4ABI ( ) && ! TM . isPPC64 ( ) && TM . getRelocationModel ( ) == Reloc :: PIC_ ) Reserved . set ( PPC :: R29 ) ; else Reserved . set ( PPC :: R30 ) ; } if ( Subtarget . isSVR4ABI ( ) && ! TM . isPPC64 ( ) && TM . getRelocationModel ( ) == Reloc :: PIC_ ) Reserved . set ( PPC :: R30 ) ; if ( ! Subtarget . hasAltivec ( ) ) for ( TargetRegisterClass :: iterator I = PPC :: VRRCRegClass . begin ( ) , IE = PPC :: VRRCRegClass . end ( ) ; I != IE ; ++ I ) Reserved . set ( * I ) ; return Reserved ; } </s>

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


<s> unsigned RISCVRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const TargetFrameLowering * TFI = MF . getSubtarget ( ) . getFrameLowering ( ) ; return TFI -> hasFP ( MF ) ? ( Subtarget . isRV64 ( ) ? RISCV :: fp_64 : RISCV :: fp ) : ( Subtarget . isRV64 ( ) ? RISCV :: sp_64 : RISCV :: sp ) ; } </s>

RISCV RISCV RISCV::fp_64 RISCV::fp RISCV::sp_64 RISCV::sp


<s> SDValue ARMSelectionDAGInfo :: EmitTargetCodeForMemset ( SelectionDAG & DAG , const SDLoc & dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , Align Alignment , bool isVolatile , MachinePointerInfo DstPtrInfo ) const { return EmitSpecializedLibcall ( DAG , dl , Chain , Dst , Src , Size , Alignment . value ( ) , RTLIB :: MEMSET ) ; } </s>

Emit target-specific code that performs a memset .


<s> virtual const DataLayout * getDataLayout ( ) const { return & DL ; } </s>

Return the DataLayout associated with the module this SCEV instance is operating on .


<s> int GCNTTIImpl :: getArithmeticReductionCost ( unsigned Opcode , VectorType * Ty , bool IsPairwise , TTI :: TargetCostKind CostKind ) { EVT OrigTy = TLI -> getValueType ( DL , Ty ) ; if ( IsPairwise || ! ST -> hasVOP3PInsts ( ) || OrigTy . getScalarSizeInBits ( ) != 16 ) return BaseT :: getArithmeticReductionCost ( Opcode , Ty , IsPairwise , CostKind ) ; std :: pair < int , MVT > LT = TLI -> getTypeLegalizationCost ( DL , Ty ) ; return LT . first * getFullRateInstrCost ( ) ; } </s>

Calculate the cost of vector reduction intrinsics .


<s> bool MVEGatherScatterLowering :: runOnFunction ( Function & F ) { if ( ! EnableMaskedGatherScatters ) return false ; auto & TPC = getAnalysis < TargetPassConfig > ( ) ; auto & TM = TPC . getTM < TargetMachine > ( ) ; auto * ST = & TM . getSubtarget < ARMSubtarget > ( F ) ; if ( ! ST -> hasMVEIntegerOps ( ) ) return false ; LI = & getAnalysis < LoopInfoWrapperPass > ( ) . getLoopInfo ( ) ; SmallVector < IntrinsicInst * , 4 > Gathers ; SmallVector < IntrinsicInst * , 4 > Scatters ; for ( BasicBlock & BB : F ) { for ( Instruction & I : BB ) { IntrinsicInst * II = dyn_cast < IntrinsicInst > ( & I ) ; if ( II && II -> getIntrinsicID ( ) == Intrinsic :: masked_gather ) { Gathers . push_back ( II ) ; if ( isa < GetElementPtrInst > ( II -> getArgOperand ( 0 ) ) ) optimiseOffsets ( cast < Instruction > ( II -> getArgOperand ( 0 ) ) -> getOperand ( 1 ) , II -> getParent ( ) , LI ) ; } else if ( II && II -> getIntrinsicID ( ) == Intrinsic :: masked_scatter ) { Scatters . push_back ( II ) ; if ( isa < GetElementPtrInst > ( II -> getArgOperand ( 1 ) ) ) optimiseOffsets ( cast < Instruction > ( II -> getArgOperand ( 1 ) ) -> getOperand ( 1 ) , II -> getParent ( ) , LI ) ; } } } bool Changed = false ; for ( unsigned i = 0 ; i < Gathers . size ( ) ; i ++ ) { IntrinsicInst * I = Gathers [ i ] ; Value * L = lowerGather ( I ) ; if ( L == nullptr ) continue ; SimplifyInstructionsInBlock ( cast < Instruction > ( L ) -> getParent ( ) ) ; Changed = true ; } for ( unsigned i = 0 ; i < Scatters . size ( ) ; i ++ ) { IntrinsicInst * I = Scatters [ i ] ; Value * S = lowerScatter ( I ) ; if ( S == nullptr ) continue ; SimplifyInstructionsInBlock ( cast < Instruction > ( S ) -> getParent ( ) ) ; Changed = true ; } return Changed ; } </s>

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


<s> bool R600InstrInfo :: fitsReadPortLimitations ( const std :: vector < MachineInstr * > & IG , const DenseMap < unsigned , unsigned > & PV , std :: vector < BankSwizzle > & ValidSwizzle , bool isLastAluTrans ) const { std :: vector < std :: vector < std :: pair < int , unsigned >> > IGSrcs ; ValidSwizzle . clear ( ) ; unsigned ConstCount ; BankSwizzle TransBS = ALU_VEC_012_SCL_210 ; for ( unsigned i = 0 , e = IG . size ( ) ; i < e ; ++ i ) { IGSrcs . push_back ( ExtractSrcs ( * IG [ i ] , PV , ConstCount ) ) ; unsigned Op = getOperandIdx ( IG [ i ] -> getOpcode ( ) , AMDGPU :: OpName :: bank_swizzle ) ; ValidSwizzle . push_back ( ( R600InstrInfo :: BankSwizzle ) IG [ i ] -> getOperand ( Op ) . getImm ( ) ) ; } std :: vector < std :: pair < int , unsigned >> TransOps ; if ( ! isLastAluTrans ) return FindSwizzleForVectorSlot ( IGSrcs , ValidSwizzle , TransOps , TransBS ) ; TransOps = std :: move ( IGSrcs . back ( ) ) ; IGSrcs . pop_back ( ) ; ValidSwizzle . pop_back ( ) ; static const R600InstrInfo :: BankSwizzle TransSwz [ ] = { ALU_VEC_012_SCL_210 , ALU_VEC_021_SCL_122 , ALU_VEC_120_SCL_212 , ALU_VEC_102_SCL_221 } ; for ( unsigned i = 0 ; i < 4 ; i ++ ) { TransBS = TransSwz [ i ] ; if ( ! isConstCompatible ( TransBS , TransOps , ConstCount ) ) continue ; bool Result = FindSwizzleForVectorSlot ( IGSrcs , ValidSwizzle , TransOps , TransBS ) ; if ( Result ) { ValidSwizzle . push_back ( TransBS ) ; return true ; } } return false ; } </s>

Given the order VEC_012 < VEC_021 < VEC_120 < VEC_102 < VEC_201 < VEC_210 returns true and the first ( in lexical order ) BankSwizzle affectation starting from the one already provided in the Instruction Group MIs that fits Read Port limitations in BS if available .


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

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


<s> void ix86_split_convert_uns_si_sse ( rtx operands [ ] ) { machine_mode vecmode ; rtx value , large , zero_or_two31 , input , two31 , x ; large = operands [ 1 ] ; zero_or_two31 = operands [ 2 ] ; input = operands [ 3 ] ; two31 = operands [ 4 ] ; vecmode = GET_MODE ( large ) ; value = gen_rtx_REG ( vecmode , REGNO ( operands [ 0 ] ) ) ; if ( MEM_P ( input ) ) { if ( vecmode == V4SFmode ) emit_insn ( gen_vec_setv4sf_0 ( value , CONST0_RTX ( V4SFmode ) , input ) ) ; else emit_insn ( gen_sse2_loadlpd ( value , CONST0_RTX ( V2DFmode ) , input ) ) ; } else { input = gen_rtx_REG ( vecmode , REGNO ( input ) ) ; emit_move_insn ( value , CONST0_RTX ( vecmode ) ) ; if ( vecmode == V4SFmode ) emit_insn ( gen_sse_movss ( value , value , input ) ) ; else emit_insn ( gen_sse2_movsd ( value , value , input ) ) ; } emit_move_insn ( large , two31 ) ; emit_move_insn ( zero_or_two31 , MEM_P ( two31 ) ? large : two31 ) ; x = gen_rtx_fmt_ee ( LE , vecmode , large , value ) ; emit_insn ( gen_rtx_SET ( VOIDmode , large , x ) ) ; x = gen_rtx_AND ( vecmode , zero_or_two31 , large ) ; emit_insn ( gen_rtx_SET ( VOIDmode , zero_or_two31 , x ) ) ; x = gen_rtx_MINUS ( vecmode , value , zero_or_two31 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , value , x ) ) ; large = gen_rtx_REG ( V4SImode , REGNO ( large ) ) ; emit_insn ( gen_ashlv4si3 ( large , large , GEN_INT ( 31 ) ) ) ; x = gen_rtx_REG ( V4SImode , REGNO ( value ) ) ; if ( vecmode == V4SFmode ) emit_insn ( gen_fix_truncv4sfv4si2 ( x , value ) ) ; else emit_insn ( gen_sse2_cvttpd2dq ( x , value ) ) ; value = x ; emit_insn ( gen_xorv4si3 ( value , value , large ) ) ; } </s>

Post-reload splitter for converting an SF or DFmode value in an SSE register into an unsigned SImode .


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

getPassName - Return a nice clean name for a pass .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


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

Check whether the given instruction may need relaxation .


<s> static bool aarch64_print_vector_float_operand ( FILE * f , rtx x , bool negate ) { rtx elt ; if ( ! const_vec_duplicate_p ( x , & elt ) ) return false ; REAL_VALUE_TYPE r = * CONST_DOUBLE_REAL_VALUE ( elt ) ; if ( negate ) r = real_value_negate ( & r ) ; if ( real_equal ( & r , & dconst0 ) ) asm_fprintf ( f , "0.0" ) ; else if ( real_equal ( & r , & dconst2 ) ) asm_fprintf ( f , "2.0" ) ; else if ( real_equal ( & r , & dconst1 ) ) asm_fprintf ( f , "1.0" ) ; else if ( real_equal ( & r , & dconsthalf ) ) asm_fprintf ( f , "0.5" ) ; else { const int buf_size = 20 ; char float_buf [ buf_size ] = { '\0' } ; real_to_decimal_for_mode ( float_buf , & r , buf_size , buf_size , 1 , GET_MODE ( elt ) ) ; asm_fprintf ( f , "%s" , float_buf ) ; } return true ; } </s>

Print floating-point vector immediate operand X to F , negating it first if NEGATE is true . Return true on success , false if it is n't a constant we can handle .


<s> static void avr_output_data_section_asm_op ( const char * data ) { avr_need_copy_data_p = true ; output_section_asm_op ( data ) ; } </s>

Unnamed section callback for data_section to track need of __do_copy_data .


<s> void mips_expand_conditional_move ( rtx * operands ) { rtx cond ; enum rtx_code code = GET_CODE ( operands [ 1 ] ) ; rtx op0 = XEXP ( operands [ 1 ] , 0 ) ; rtx op1 = XEXP ( operands [ 1 ] , 1 ) ; mips_emit_compare ( & code , & op0 , & op1 , true ) ; cond = gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) ; if ( ISA_HAS_SEL && INTEGRAL_MODE_P ( GET_MODE ( operands [ 2 ] ) ) && register_operand ( operands [ 2 ] , VOIDmode ) && register_operand ( operands [ 3 ] , VOIDmode ) ) { machine_mode mode = GET_MODE ( operands [ 0 ] ) ; rtx temp = gen_reg_rtx ( mode ) ; rtx temp2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , temp , gen_rtx_IF_THEN_ELSE ( mode , cond , operands [ 2 ] , const0_rtx ) ) ) ; cond = gen_rtx_fmt_ee ( ( code == EQ ) ? NE : EQ , GET_MODE ( op0 ) , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , temp2 , gen_rtx_IF_THEN_ELSE ( mode , cond , operands [ 3 ] , const0_rtx ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ 0 ] , gen_rtx_IOR ( mode , temp , temp2 ) ) ) ; } else { if ( FLOAT_MODE_P ( GET_MODE ( operands [ 2 ] ) ) && ! ISA_HAS_SEL ) { operands [ 2 ] = force_reg ( GET_MODE ( operands [ 0 ] ) , operands [ 2 ] ) ; operands [ 3 ] = force_reg ( GET_MODE ( operands [ 0 ] ) , operands [ 3 ] ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , operands [ 0 ] , gen_rtx_IF_THEN_ELSE ( GET_MODE ( operands [ 0 ] ) , cond , operands [ 2 ] , operands [ 3 ] ) ) ) ; } } </s>

Perform the comparison in OPERANDS [ 1 ] . Move OPERANDS [ 2 ] into OPERANDS [ 0 ] if the condition holds , otherwise move OPERANDS [ 3 ] into OPERANDS [ 0 ] .


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


<s> bool h8300_move_ok ( rtx dest , rtx src ) { rtx addr , other ; if ( MEM_P ( dest ) ) { if ( MEM_P ( src ) || CONSTANT_P ( src ) ) return false ; addr = XEXP ( dest , 0 ) ; other = src ; } else if ( MEM_P ( src ) ) { addr = XEXP ( src , 0 ) ; other = dest ; } else return true ; if ( GET_RTX_CLASS ( GET_CODE ( addr ) ) != RTX_AUTOINC ) return true ; addr = XEXP ( addr , 0 ) ; if ( addr == stack_pointer_rtx ) return register_no_sp_elim_operand ( other , VOIDmode ) ; else return ! reg_overlap_mentioned_p ( other , addr ) ; } </s>

Helper function for the move patterns . Make sure a move is legitimate .


runOnMachineFunction - Emit the function body .


<s> bool RISCVMCAsmBackend :: fixupNeedsRelaxation ( const MCFixup & Fixup , uint64_t Value , const MCRelaxableFragment * Fragment , const MCAsmLayout & Layout ) const { Value = extractBitsForFixup ( Fixup . getKind ( ) , Value ) ; return ( int16_t ) Value != ( int64_t ) Value ; } </s>

Simple predicate for targets where ! Resolved implies requiring relaxation .


<s> static void rs6000_emit_probe_stack_range ( HOST_WIDE_INT first , HOST_WIDE_INT size ) { if ( first + size <= 32768 ) { HOST_WIDE_INT i ; for ( i = PROBE_INTERVAL ; i < size ; i += PROBE_INTERVAL ) emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + i ) ) ) ; emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + size ) ) ) ; } else { HOST_WIDE_INT rounded_size ; rtx r12 = gen_rtx_REG ( Pmode , 12 ) ; rtx r0 = gen_rtx_REG ( Pmode , 0 ) ; gcc_assert ( first <= 32768 ) ; rounded_size = size & - PROBE_INTERVAL ; emit_insn ( gen_rtx_SET ( VOIDmode , r12 , plus_constant ( Pmode , stack_pointer_rtx , - first ) ) ) ; if ( rounded_size > 32768 ) { emit_move_insn ( r0 , GEN_INT ( - rounded_size ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , r0 , gen_rtx_PLUS ( Pmode , r12 , r0 ) ) ) ; } else emit_insn ( gen_rtx_SET ( VOIDmode , r0 , plus_constant ( Pmode , r12 , - rounded_size ) ) ) ; if ( TARGET_64BIT ) emit_insn ( gen_probe_stack_rangedi ( r12 , r12 , r0 ) ) ; else emit_insn ( gen_probe_stack_rangesi ( r12 , r12 , r0 ) ) ; if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , r12 , rounded_size - size ) ) ; } } </s>

Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE , inclusive . These are offsets from the current stack pointer .


<s> unsigned ARMBaseInstrInfo :: isLoadFromStackSlotPostFE ( const MachineInstr & MI , int & FrameIndex ) const { SmallVector < const MachineMemOperand * , 1 > Accesses ; if ( MI . mayLoad ( ) && hasLoadFromStackSlot ( MI , Accesses ) ) { FrameIndex = cast < FixedStackPseudoSourceValue > ( Accesses . front ( ) -> getPseudoValue ( ) ) -> getFrameIndex ( ) ; return true ; } return false ; } </s>

isLoadFromStackSlotPostFE - Check for post-frame ptr elimination stack locations as well .


<s> void aarch64_simd_emit_reg_reg_move ( rtx * operands , enum machine_mode mode , unsigned int count ) { unsigned int i ; int rdest = REGNO ( operands [ 0 ] ) ; int rsrc = REGNO ( operands [ 1 ] ) ; if ( ! reg_overlap_mentioned_p ( operands [ 0 ] , operands [ 1 ] ) || rdest < rsrc ) for ( i = 0 ; i < count ; i ++ ) emit_move_insn ( gen_rtx_REG ( mode , rdest + i ) , gen_rtx_REG ( mode , rsrc + i ) ) ; else for ( i = 0 ; i < count ; i ++ ) emit_move_insn ( gen_rtx_REG ( mode , rdest + count - i - 1 ) , gen_rtx_REG ( mode , rsrc + count - i - 1 ) ) ; } </s>

Emit a register copy from operand to operand , taking care not to early-clobber source registers in the process . COUNT is the number of components into which the copy needs to be decomposed .


<s> static machine_mode aarch64_preferred_simd_mode ( machine_mode mode ) { return aarch64_simd_container_mode ( mode , 128 ) ; } </s>

Return 128-bit container as the preferred SIMD mode for MODE .


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

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


<s>
void
JVMAsmPrinter
::
EmitInstruction
(
const
MachineInstr
*
MI
)
{
if
(
IsSkipInstruction
(
*
MI
)
)
return
;
LLVM_DEBUG
(
dbgs
(
)
<<
"EmitInstruction: "
<<
*
MI
<<
'\n'
)
;
JVMMCInstLower
InstLower
(
OutContext
,
*
this
)
;
MCInst
TmpInst
;
InstLower
.
Lower
(
MI
,
TmpInst
)
;
EmitToStreamer
(
*
OutStreamer
,
TmpInst
)
;
}
</s>

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


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

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


"Pseudo flag setting opcodes only exist in Selection DAG"

Perform target-specific instruction verification .


<s> static void fusion_split_address ( rtx addr , rtx * p_hi , rtx * p_lo ) { rtx hi , lo ; if ( GET_CODE ( addr ) == UNSPEC && XINT ( addr , 1 ) == UNSPEC_FUSION_ADDIS ) { lo = XVECEXP ( addr , 0 , 0 ) ; hi = gen_rtx_HIGH ( Pmode , lo ) ; } else if ( GET_CODE ( addr ) == PLUS || GET_CODE ( addr ) == LO_SUM ) { hi = XEXP ( addr , 0 ) ; lo = XEXP ( addr , 1 ) ; } else gcc_unreachable ( ) ; * p_hi = hi ; * p_lo = lo ; } </s>

Given an address , convert it into the addis and load offset parts . Addresses created during the peephole2 process look like : ( lo_sum ( high ( unspec [ ( sym ) ] UNSPEC_TOCREL ) ) ( unspec [ ( ... ) ] UNSPEC_TOCREL ) )


<s> bool PPCPassConfig :: addPreSched2 ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) addPass ( & IfConverterID ) ; return true ; } </s>

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


<s>
bool
doInitialization
(
Module
&
)
override
{
auto
*
TPC
=
getAnalysisIfAvailable
<
TargetPassConfig
>
(
)
;
if
(
!
TPC
)
report_fatal_error
(
"TargetMachine is required"
)
;
TM
=
&
TPC
->
getTM
<
TargetMachine
>
(
)
;
return
false
;
}
</s>

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


<s> BitVector HexagonRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( HEXAGON_RESERVED_REG_1 ) ; Reserved . set ( HEXAGON_RESERVED_REG_2 ) ; Reserved . set ( Hexagon :: R29 ) ; Reserved . set ( Hexagon :: R30 ) ; Reserved . set ( Hexagon :: R31 ) ; Reserved . set ( Hexagon :: D14 ) ; Reserved . set ( Hexagon :: D15 ) ; Reserved . set ( Hexagon :: LC0 ) ; Reserved . set ( Hexagon :: LC1 ) ; Reserved . set ( Hexagon :: SA0 ) ; Reserved . set ( Hexagon :: SA1 ) ; return Reserved ; } </s>

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


<s> MCDisassembler :: DecodeStatus XCoreDisassembler :: getInstruction ( MCInst & instr , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & vStream , raw_ostream & cStream ) const { uint16_t insn16 ; if ( ! readInstruction16 ( Bytes , Address , Size , insn16 ) ) { return Fail ; } DecodeStatus Result = decodeInstruction ( DecoderTable16 , instr , insn16 , Address , this , STI ) ; if ( Result != Fail ) { Size = 2 ; return Result ; } uint32_t insn32 ; if ( ! readInstruction32 ( Bytes , Address , Size , insn32 ) ) { return Fail ; } Result = decodeInstruction ( DecoderTable32 , instr , insn32 , Address , this , STI ) ; if ( Result != Fail ) { Size = 4 ; return Result ; } return Fail ; } </s>

Returns the disassembly of a single instruction .


<s> bool SPIRVModuleAnalysis :: runOnModule ( Module & M ) { SPIRVTargetMachine & TM = getAnalysis < TargetPassConfig > ( ) . getTM < SPIRVTargetMachine > ( ) ; ST = TM . getSubtargetImpl ( ) ; GR = ST -> getSPIRVGlobalRegistry ( ) ; TII = ST -> getInstrInfo ( ) ; MMI = & getAnalysis < MachineModuleInfoWrapperPass > ( ) . getMMI ( ) ; setBaseInfo ( M ) ; numberRegistersGlobally ( M ) ; processOtherInstrs ( M ) ; return false ; } </s>

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


<s> bool PPCTargetLowering :: getPreIndexedAddressParts ( SDNode * N , SDValue & Base , SDValue & Offset , ISD :: MemIndexedMode & AM , SelectionDAG & DAG ) const { if ( DisablePPCPreinc ) return false ; bool isLoad = true ; SDValue Ptr ; EVT VT ; unsigned Alignment ; if ( LoadSDNode * LD = dyn_cast < LoadSDNode > ( N ) ) { Ptr = LD -> getBasePtr ( ) ; VT = LD -> getMemoryVT ( ) ; Alignment = LD -> getAlignment ( ) ; } else if ( StoreSDNode * ST = dyn_cast < StoreSDNode > ( N ) ) { Ptr = ST -> getBasePtr ( ) ; VT = ST -> getMemoryVT ( ) ; Alignment = ST -> getAlignment ( ) ; isLoad = false ; } else return false ; if ( isLoad && usePartialVectorLoads ( N , Subtarget ) ) { return false ; } if ( VT . isVector ( ) ) { if ( ! Subtarget . hasQPX ( ) || ( VT != MVT :: v4f64 && VT != MVT :: v4f32 ) ) { return false ; } else if ( SelectAddressRegRegOnly ( Ptr , Offset , Base , DAG ) ) { AM = ISD :: PRE_INC ; return true ; } } if ( SelectAddressRegReg ( Ptr , Base , Offset , DAG ) ) { bool Swap = false ; if ( isa < FrameIndexSDNode > ( Base ) || isa < RegisterSDNode > ( Base ) ) Swap = true ; else if ( ! isLoad ) { SDValue Val = cast < StoreSDNode > ( N ) -> getValue ( ) ; if ( Val == Base || Base . getNode ( ) -> isPredecessorOf ( Val . getNode ( ) ) ) Swap = true ; } if ( Swap ) std :: swap ( Base , Offset ) ; AM = ISD :: PRE_INC ; return true ; } if ( VT != MVT :: i64 ) { if ( ! SelectAddressRegImm ( Ptr , Offset , Base , DAG , 0 ) ) return false ; } else { if ( Alignment < 4 ) return false ; if ( ! SelectAddressRegImm ( Ptr , Offset , Base , DAG , 4 ) ) return false ; } if ( LoadSDNode * LD = dyn_cast < LoadSDNode > ( N ) ) { if ( LD -> getValueType ( 0 ) == MVT :: i64 && LD -> getMemoryVT ( ) == MVT :: i32 && LD -> getExtensionType ( ) == ISD :: SEXTLOAD && isa < ConstantSDNode > ( Offset ) ) return false ; } AM = ISD :: PRE_INC ; return true ; } </s>

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


<s>
static
void
process_cfa_adjust_cfa
(
FILE
*
out_file
,
rtx
pat
,
rtx
insn
,
bool
unwind
,
bool
frame
)
{
rtx
dest
=
SET_DEST
(
pat
)
;
rtx
src
=
SET_SRC
(
pat
)
;
if
(
dest
==
stack_pointer_rtx
)
{
if
(
GET_CODE
(
src
)
==
PLUS
)
{
rtx
op0
=
XEXP
(
src
,
0
)
;
rtx
op1
=
XEXP
(
src
,
1
)
;
gcc_assert
(
op0
==
dest
&&
GET_CODE
(
op1
)
==
CONST_INT
)
;
if
(
INTVAL
(
op1
)
<
0
)
{
gcc_assert
(
!
frame_pointer_needed
)
;
if
(
unwind
)
fprintf
(
out_file
,
"\t.fframe "
HOST_WIDE_INT_PRINT_DEC
"\n"
,
INTVAL
(
op1
)
)
;
}
else
process_epilogue
(
out_file
,
insn
,
unwind
,
frame
)
;
}
else
{
gcc_assert
(
src
==
hard_frame_pointer_rtx
)
;
process_epilogue
(
out_file
,
insn
,
unwind
,
frame
)
;
}
}
else
if
(
dest
==
hard_frame_pointer_rtx
)
{
gcc_assert
(
src
==
stack_pointer_rtx
)
;
gcc_assert
(
frame_pointer_needed
)
;
if
(
unwind
)
fprintf
(
out_file
,
"\t.vframe r%d\n"
,
ia64_dbx_register_number
(
REGNO
(
dest
)
)
)
;
}
else
gcc_unreachable
(
)
;
}
</s>

This function processes a SET pattern for REG_CFA_ADJUST_CFA .


<s>
void
MSP430FrameLowering
::
emitPrologue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
assert
(
&
MF
.
front
(
)
==
&
MBB
&&
"Shrink-wrapping not yet supported"
)
;
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
MSP430MachineFunctionInfo
*
MSP430FI
=
MF
.
getInfo
<
MSP430MachineFunctionInfo
>
(
)
;
const
MSP430InstrInfo
&
TII
=
*
static_cast
<
const
MSP430InstrInfo
*
>
(
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
)
;
MachineBasicBlock
::
iterator
MBBI
=
MBB
.
begin
(
)
;
DebugLoc
DL
=
MBBI
!=
MBB
.
end
(
)
MBBI
->
getDebugLoc
(
)
:
DebugLoc
(
)
;
uint64_t
StackSize
=
MFI
.
getStackSize
(
)
;
uint64_t
NumBytes
=
0
;
if
(
hasFP
(
MF
)
)
{
uint64_t
FrameSize
=
StackSize
2
;
NumBytes
=
FrameSize
MSP430FI
->
getCalleeSavedFrameSize
(
)
;
MFI
.
setOffsetAdjustment
(
NumBytes
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
.
get
(
MSP430
::
PUSH16r
)
)
.
addReg
(
MSP430
::
R4
,
RegState
::
Kill
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
.
get
(
MSP430
::
MOV16rr
)
,
MSP430
::
R4
)
.
addReg
(
MSP430
::
SP
)
;
for
(
MachineBasicBlock
&
MBBJ
:
llvm
::
drop_begin
(
MF
)
)
MBBJ
.
addLiveIn
(
MSP430
::
R4
)
;
}
else
NumBytes
=
StackSize
MSP430FI
->
getCalleeSavedFrameSize
(
)
;
while
(
MBBI
!=
MBB
.
end
(
)
&&
(
MBBI
->
getOpcode
(
)
==
MSP430
::
PUSH16r
)
)
++
MBBI
;
if
(
MBBI
!=
MBB
.
end
(
)
)
DL
=
MBBI
->
getDebugLoc
(
)
;
if
(
NumBytes
)
{
if
(
NumBytes
)
{
MachineInstr
*
MI
=
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
.
get
(
MSP430
::
SUB16ri
)
,
MSP430
::
SP
)
.
addReg
(
MSP430
::
SP
)
.
addImm
(
NumBytes
)
;
MI
->
getOperand
(
3
)
.
setIsDead
(
)
;
}
}
}
</s>

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


<s> static bool originalTypeIsF128 ( const Type * Ty , const SDNode * CallNode ) { if ( Ty -> isFP128Ty ( ) ) return true ; const ExternalSymbolSDNode * ES = dyn_cast_or_null < const ExternalSymbolSDNode > ( CallNode ) ; return ( ES && Ty -> isIntegerTy ( 128 ) && isF128SoftLibCall ( ES -> getSymbol ( ) ) ) ; } </s>

This function returns true if Ty is fp128 , { f128 } or i128 which was originally a fp128 .


<s> std :: pair < unsigned , const TargetRegisterClass * > ARM64TargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'r' : if ( VT . getSizeInBits ( ) == 64 ) return std :: make_pair ( 0U , & ARM64 :: GPR64commonRegClass ) ; return std :: make_pair ( 0U , & ARM64 :: GPR32commonRegClass ) ; case 'w' : if ( VT == MVT :: f32 ) return std :: make_pair ( 0U , & ARM64 :: FPR32RegClass ) ; if ( VT . getSizeInBits ( ) == 64 ) return std :: make_pair ( 0U , & ARM64 :: FPR64RegClass ) ; if ( VT . getSizeInBits ( ) == 128 ) return std :: make_pair ( 0U , & ARM64 :: FPR128RegClass ) ; break ; case 'x' : if ( VT . getSizeInBits ( ) == 128 ) return std :: make_pair ( 0U , & ARM64 :: FPR128_loRegClass ) ; break ; } } if ( StringRef ( "{cc}" ) . equals_lower ( Constraint ) ) return std :: make_pair ( unsigned ( ARM64 :: CPSR ) , & ARM64 :: CCRRegClass ) ; std :: pair < unsigned , const TargetRegisterClass * > Res ; Res = TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; if ( ! Res . second ) { unsigned Size = Constraint . size ( ) ; if ( ( Size == 4 || Size == 5 ) && Constraint [ 0 ] == '{' && tolower ( Constraint [ 1 ] ) == 'v' && Constraint [ Size - 1 ] == '}' ) { const std :: string Reg = std :: string ( & Constraint [ 2 ] , & Constraint [ Size - 1 ] ) ; int RegNo = atoi ( Reg . c_str ( ) ) ; if ( RegNo >= 0 && RegNo <= 31 ) { Res . first = ARM64 :: FPR128RegClass . getRegister ( RegNo ) ; Res . second = & ARM64 :: FPR128RegClass ; } } } return Res ; } </s>

Given a physical register constraint ( e.g .


<s> std :: pair < uint16_t , uint16_t > ARMBaseInstrInfo :: getExecutionDomain ( const MachineInstr * MI ) const { if ( Subtarget . hasNEON ( ) ) { if ( MI -> getOpcode ( ) == ARM :: VMOVD && ! isPredicated ( * MI ) ) return std :: make_pair ( ExeVFP , ( 1 << ExeVFP ) | ( 1 << ExeNEON ) ) ; if ( Subtarget . isCortexA9 ( ) && ! isPredicated ( * MI ) && ( MI -> getOpcode ( ) == ARM :: VMOVRS || MI -> getOpcode ( ) == ARM :: VMOVSR || MI -> getOpcode ( ) == ARM :: VMOVS ) ) return std :: make_pair ( ExeVFP , ( 1 << ExeVFP ) | ( 1 << ExeNEON ) ) ; } unsigned Domain = MI -> getDesc ( ) . TSFlags & ARMII :: DomainMask ; if ( Domain & ARMII :: DomainNEON ) return std :: make_pair ( ExeNEON , 0 ) ; if ( ( Domain & ARMII :: DomainNEONA8 ) && Subtarget . isCortexA8 ( ) ) return std :: make_pair ( ExeNEON , 0 ) ; if ( Domain & ARMII :: DomainVFP ) return std :: make_pair ( ExeVFP , 0 ) ; return std :: make_pair ( ExeGeneric , 0 ) ; } </s>

Return the current execution domain and bit mask of possible domains for instruction .


<s> int HexagonMCInst :: getMaxValue ( void ) const { const uint64_t F = MCID . TSFlags ; unsigned isSigned = ( F >> HexagonII :: ExtentSignedPos ) & HexagonII :: ExtentSignedMask ; unsigned bits = ( F >> HexagonII :: ExtentBitsPos ) & HexagonII :: ExtentBitsMask ; if ( isSigned ) return ~ ( - 1U << ( bits - 1 ) ) ; else return ~ ( - 1U << bits ) ; } </s>

Return the maximal unsigned value possible given these KnownBits .

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


<s> void split_di ( rtx operands [ ] , int num , rtx lo_half [ ] , rtx hi_half [ ] ) { while ( num -- ) { rtx op = operands [ num ] ; if ( GET_CODE ( op ) == MEM ) { lo_half [ num ] = adjust_address ( op , SImode , 0 ) ; hi_half [ num ] = adjust_address ( op , SImode , 4 ) ; } else { lo_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , 0 ) ; hi_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , 4 ) ; } } } </s>

Split one or more DImode RTL references into pairs of SImode references . The RTL can be REG , offsettable MEM , integer constant , or CONST_DOUBLE . `` operands '' is a pointer to an array of DImode RTL to split and `` num '' is its length . lo_half and hi_half are output arrays that parallel `` operands '' .


<s> bool LanaiInstrInfo :: analyzeCompare ( const MachineInstr & MI , unsigned & SrcReg , unsigned & SrcReg2 , int & CmpMask , int & CmpValue ) const { switch ( MI . getOpcode ( ) ) { default : break ; case Lanai :: SFSUB_F_RI_LO : case Lanai :: SFSUB_F_RI_HI : SrcReg = MI . getOperand ( 0 ) . getReg ( ) ; SrcReg2 = 0 ; CmpMask = ~ 0 ; CmpValue = MI . getOperand ( 1 ) . getImm ( ) ; return true ; case Lanai :: SFSUB_F_RR : SrcReg = MI . getOperand ( 0 ) . getReg ( ) ; SrcReg2 = MI . getOperand ( 1 ) . getReg ( ) ; CmpMask = ~ 0 ; CmpValue = 0 ; return true ; } return false ; } </s>

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


<s> static bool isSigned ( Value * V ) { if ( ! isa < Instruction > ( V ) ) return false ; unsigned Opc = cast < Instruction > ( V ) -> getOpcode ( ) ; return Opc == Instruction :: AShr || Opc == Instruction :: SDiv || Opc == Instruction :: SRem ; } </s>

Returns true if all source operands of the recurrence are SExtInsts .


"non-standard ABI extension with no compatibility "

Return a nonzero value to say to return the function value in memory , just as large structures are always returned . TYPE will be the data type of the value , and FNTYPE will be the type of the function doing the returning , or @ code { NULL } for libcalls . The AIX ABI for the RS/6000 specifies that all structures are returned in memory . The Darwin ABI does the same . The SVR4 ABI specifies that structures < = 8 bytes are returned in r3/r4 , but a draft put them in memory , and GCC used to implement the draft instead of the final standard . Therefore , aix_struct_return controls this instead of DEFAULT_ABI ; V.4 targets needing backward compatibility can change DRAFT_V4_STRUCT_RET to override the default , and -m switches get the final word . See rs6000_override_options for more details . The PPC32 SVR4 ABI uses IEEE double extended for long double , if 128-bit long double support is enabled . These values are returned in memory . int_size_in_bytes returns -1 for variable size objects , which go in memory always . The cast to unsigned makes -1 > 8 .


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

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s> int pa_mem_shadd_constant_p ( int val ) { if ( val == 2 || val == 4 || val == 8 ) return 1 ; else return 0 ; } </s>

Return 1 if the given constant is 2 , 4 , or 8 . These are the valid constants for a MULT embedded inside a memory address .


"Load should return a value and a chain"

LowerOperation - Provide custom lowering hooks for some operations .


<s> static bool nios2_in_small_data_p ( const_tree exp ) { if ( TREE_CODE ( exp ) == STRING_CST ) return false ; if ( TREE_CODE ( exp ) == VAR_DECL ) { if ( DECL_SECTION_NAME ( exp ) ) { const char * section = DECL_SECTION_NAME ( exp ) ; if ( nios2_small_section_name_p ( section ) ) return true ; } else { HOST_WIDE_INT size = int_size_in_bytes ( TREE_TYPE ( exp ) ) ; if ( size > 0 && ( unsigned HOST_WIDE_INT ) size <= nios2_section_threshold ) return true ; } } return false ; } </s>

Return true if EXP should be placed in the small data section .


<s> static opt_scalar_float_mode rs6000_floatn_mode ( int n , bool extended ) { if ( extended ) { switch ( n ) { case 32 : return DFmode ; case 64 : if ( TARGET_FLOAT128_KEYWORD ) return ( FLOAT128_IEEE_P ( TFmode ) ) ? TFmode : KFmode ; else return opt_scalar_float_mode ( ) ; case 128 : return opt_scalar_float_mode ( ) ; default : gcc_unreachable ( ) ; } } else { switch ( n ) { case 32 : return SFmode ; case 64 : return DFmode ; case 128 : if ( TARGET_FLOAT128_KEYWORD ) return ( FLOAT128_IEEE_P ( TFmode ) ) ? TFmode : KFmode ; else return opt_scalar_float_mode ( ) ; default : return opt_scalar_float_mode ( ) ; } } } </s>


<s> unsigned get132Opcode ( ) const { return Opcodes [ Form132 ] ; } </s>


<s> bool MSP430FrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , ArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MSP430MachineFunctionInfo * MFI = MF . getInfo < MSP430MachineFunctionInfo > ( ) ; MFI -> setCalleeSavedFrameSize ( CSI . size ( ) * 2 ) ; bool MSP430X = MF . getSubtarget < MSP430Subtarget > ( ) . hasMSP430X ( ) ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; MBB . addLiveIn ( Reg ) ; if ( ! MSP430X ) BuildMI ( MBB , MI , DL , TII . get ( MSP430 :: PUSH16r ) ) . addReg ( Reg , RegState :: Kill ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } if ( MSP430X ) BuildMI ( MBB , MI , DL , TII . get ( MSP430 :: PUSHM16r ) ) . addImm ( CSI . size ( ) ) . addReg ( CSI [ CSI . size ( ) - 1 ] . getReg ( ) ) . setMIFlag ( MachineInstr :: FrameSetup ) ; return true ; } </s>

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


<s> bool GeneralShuffle :: add ( SDValue Op , unsigned Elem ) { unsigned BytesPerElement = VT . getVectorElementType ( ) . getStoreSize ( ) ; EVT FromVT = Op . getNode ( ) ? Op . getValueType ( ) : VT ; unsigned FromBytesPerElement = FromVT . getVectorElementType ( ) . getStoreSize ( ) ; if ( FromBytesPerElement < BytesPerElement ) return false ; unsigned Byte = ( ( Elem * FromBytesPerElement ) % SystemZ :: VectorBytes + ( FromBytesPerElement - BytesPerElement ) ) ; while ( Op . getNode ( ) ) { if ( Op . getOpcode ( ) == ISD :: BITCAST ) Op = Op . getOperand ( 0 ) ; else if ( Op . getOpcode ( ) == ISD :: VECTOR_SHUFFLE && Op . hasOneUse ( ) ) { SmallVector < int , SystemZ :: VectorBytes > OpBytes ; if ( ! getVPermMask ( Op , OpBytes ) ) break ; int NewByte ; if ( ! getShuffleInput ( OpBytes , Byte , BytesPerElement , NewByte ) ) break ; if ( NewByte < 0 ) { addUndef ( ) ; return true ; } Op = Op . getOperand ( unsigned ( NewByte ) / SystemZ :: VectorBytes ) ; Byte = unsigned ( NewByte ) % SystemZ :: VectorBytes ; } else if ( Op . isUndef ( ) ) { addUndef ( ) ; return true ; } else break ; } unsigned OpNo = 0 ; for ( ; OpNo < Ops . size ( ) ; ++ OpNo ) if ( Ops [ OpNo ] == Op ) break ; if ( OpNo == Ops . size ( ) ) Ops . push_back ( Op ) ; unsigned Base = OpNo * SystemZ :: VectorBytes + Byte ; for ( unsigned I = 0 ; I < BytesPerElement ; ++ I ) Bytes . push_back ( Base + I ) ; return true ; } </s>


Return whether we need to emit an ELFv2 global entry point prologue .


"Function has local memory argument. Promoting to "

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


"Can't eliminate FI yet if offset is already set"

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


<s>
static
unsigned
getOppositeBranchOpc
(
unsigned
Opcode
)
{
switch
(
Opcode
)
{
default
:
llvm_unreachable
(
"Unknown conditional branch!"
)
;
case
CSKY
::
BT32
:
return
CSKY
::
BF32
;
case
CSKY
::
BT16
:
return
CSKY
::
BF16
;
case
CSKY
::
BF32
:
return
CSKY
::
BT32
;
case
CSKY
::
BF16
:
return
CSKY
::
BT16
;
case
CSKY
::
BHZ32
:
return
CSKY
::
BLSZ32
;
case
CSKY
::
BHSZ32
:
return
CSKY
::
BLZ32
;
case
CSKY
::
BLZ32
:
return
CSKY
::
BHSZ32
;
case
CSKY
::
BLSZ32
:
return
CSKY
::
BHZ32
;
case
CSKY
::
BNEZ32
:
return
CSKY
::
BEZ32
;
case
CSKY
::
BEZ32
:
return
CSKY
::
BNEZ32
;
}
}
</s>

getOppositeBranchOpc - Return the inverse of the specified opcode , e.g .


<s>
void
RISCVDAGToDAGISel
::
PreprocessISelDAG
(
)
{
for
(
SelectionDAG
::
allnodes_iterator
I
=
CurDAG
->
allnodes_begin
(
)
,
E
=
CurDAG
->
allnodes_end
(
)
;
I
!=
E
;
)
{
SDNode
*
N
=
&
*
I
++
;
if
(
N
->
getOpcode
(
)
!=
RISCVISD
::
SPLAT_VECTOR_SPLIT_I64_VL
)
continue
;
assert
(
N
->
getNumOperands
(
)
==
3
&&
"Unexpected number of operands"
)
;
MVT
VT
=
N
->
getSimpleValueType
(
0
)
;
SDValue
Lo
=
N
->
getOperand
(
0
)
;
SDValue
Hi
=
N
->
getOperand
(
1
)
;
SDValue
VL
=
N
->
getOperand
(
2
)
;
assert
(
VT
.
getVectorElementType
(
)
==
MVT
::
i64
&&
VT
.
isScalableVector
(
)
&&
Lo
.
getValueType
(
)
==
MVT
::
i32
&&
Hi
.
getValueType
(
)
==
MVT
::
i32
&&
"Unexpected VTs!"
)
;
MachineFunction
&
MF
=
CurDAG
->
getMachineFunction
(
)
;
RISCVMachineFunctionInfo
*
FuncInfo
=
MF
.
getInfo
<
RISCVMachineFunctionInfo
>
(
)
;
SDLoc
DL
(
N
)
;
int
FI
=
FuncInfo
->
getMoveF64FrameIndex
(
MF
)
;
MachinePointerInfo
MPI
=
MachinePointerInfo
::
getFixedStack
(
MF
,
FI
)
;
const
TargetLowering
&
TLI
=
CurDAG
->
getTargetLoweringInfo
(
)
;
SDValue
StackSlot
=
CurDAG
->
getFrameIndex
(
FI
,
TLI
.
getPointerTy
(
CurDAG
->
getDataLayout
(
)
)
)
;
SDValue
Chain
=
CurDAG
->
getEntryNode
(
)
;
Lo
=
CurDAG
->
getStore
(
Chain
,
DL
,
Lo
,
StackSlot
,
MPI
,
Align
(
8
)
)
;
SDValue
OffsetSlot
=
CurDAG
->
getMemBasePlusOffset
(
StackSlot
,
TypeSize
::
Fixed
(
4
)
,
DL
)
;
Hi
=
CurDAG
->
getStore
(
Chain
,
DL
,
Hi
,
OffsetSlot
,
MPI
.
getWithOffset
(
4
)
,
Align
(
8
)
)
;
Chain
=
CurDAG
->
getNode
(
ISD
::
TokenFactor
,
DL
,
MVT
::
Other
,
Lo
,
Hi
)
;
SDVTList
VTs
=
CurDAG
->
getVTList
(
{
VT
,
MVT
::
Other
}
)
;
SDValue
IntID
=
CurDAG
->
getTargetConstant
(
Intrinsic
::
riscv_vlse
,
DL
,
MVT
::
i64
)
;
SDValue
Ops
[
]
=
{
Chain
,
IntID
,
CurDAG
->
getUNDEF
(
VT
)
,
StackSlot
,
CurDAG
->
getRegister
(
RISCV
::
X0
,
MVT
::
i64
)
,
VL
}
;
SDValue
Result
=
CurDAG
->
getMemIntrinsicNode
(
ISD
::
INTRINSIC_W_CHAIN
,
DL
,
VTs
,
Ops
,
MVT
::
i64
,
MPI
,
Align
(
8
)
,
MachineMemOperand
::
MOLoad
)
;
I
;
CurDAG
->
ReplaceAllUsesOfValueWith
(
SDValue
(
N
,
0
)
,
Result
)
;
++
I
;
CurDAG
->
DeleteNode
(
N
)
;
}
}
</s>

PreprocessISelDAG - This hook allows targets to hack on the graph before instruction selection starts .


<s> int spu_saved_regs_size ( void ) { int reg_save_size = 0 ; int regno ; for ( regno = FIRST_PSEUDO_REGISTER - 1 ; regno >= 0 ; -- regno ) if ( need_to_save_reg ( regno , 0 ) ) reg_save_size += 0x10 ; return reg_save_size ; } </s>

This function is only correct starting with local register allocation


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


<s> static Cpu0ABIInfo Unknown ( ) { return Cpu0ABIInfo ( ABI :: Unknown ) ; } </s>

The kind of location description being produced . More ...


<s> static bool frv_local_funcdesc_p ( rtx fnx ) { tree fn ; enum symbol_visibility vis ; bool ret ; if ( ! SYMBOL_REF_LOCAL_P ( fnx ) ) return FALSE ; fn = SYMBOL_REF_DECL ( fnx ) ; if ( ! fn ) return FALSE ; vis = DECL_VISIBILITY ( fn ) ; if ( vis == VISIBILITY_PROTECTED ) vis = VISIBILITY_DEFAULT ; else if ( flag_shlib ) return TRUE ; ret = default_binds_local_p_1 ( fn , flag_pic ) ; DECL_VISIBILITY ( fn ) = vis ; return ret ; } </s>

Test whether a local function descriptor is canonical , i.e. , whether we can use FUNCDESC_GOTOFF to compute the address of the function .


<s> bool X86TargetLowering :: isBinOp ( unsigned Opcode ) const { switch ( Opcode ) { case X86ISD :: ANDNP : case X86ISD :: PCMPGT : case X86ISD :: FMAX : case X86ISD :: FMIN : case X86ISD :: FANDN : case X86ISD :: VPSHA : case X86ISD :: VPSHL : case X86ISD :: VSHLV : case X86ISD :: VSRLV : case X86ISD :: VSRAV : return true ; } return TargetLoweringBase :: isBinOp ( Opcode ) ; } </s>

Add x86-specific opcodes to the default list .


<s>
const
char
*
getPassName
(
)
const
override
{
return
"X86 WinAlloca Expander"
;
}
</s>

getPassName - Return a nice clean name for a pass .


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

Returns the register associated with this edge .


<s> AArch64Subtarget :: AArch64Subtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const TargetMachine & TM , bool LittleEndian ) : AArch64GenSubtargetInfo ( TT , CPU , FS ) , ReserveX18 ( TT . isOSDarwin ( ) || TT . isOSWindows ( ) ) , IsLittle ( LittleEndian ) , TargetTriple ( TT ) , FrameLowering ( ) , InstrInfo ( initializeSubtargetDependencies ( FS , CPU ) ) , TSInfo ( ) , TLInfo ( TM , * this ) { CallLoweringInfo . reset ( new AArch64CallLowering ( * getTargetLowering ( ) ) ) ; Legalizer . reset ( new AArch64LegalizerInfo ( ) ) ; auto * RBI = new AArch64RegisterBankInfo ( * getRegisterInfo ( ) ) ; InstSelector . reset ( createAArch64InstructionSelector ( * static_cast < const AArch64TargetMachine * > ( & TM ) , * this , * RBI ) ) ; RegBankInfo . reset ( RBI ) ; } </s>

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


<s> void SystemZInstPrinter :: printInst ( const MCInst * MI , raw_ostream & O , StringRef Annot ) { printInstruction ( MI , O ) ; printAnnotation ( O , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


<s> void aarch64_split_128bit_move ( rtx dst , rtx src ) { rtx dst_lo , dst_hi ; rtx src_lo , src_hi ; machine_mode mode = GET_MODE ( dst ) ; gcc_assert ( mode == TImode || mode == TFmode ) ; gcc_assert ( ! ( side_effects_p ( src ) || side_effects_p ( dst ) ) ) ; gcc_assert ( mode == GET_MODE ( src ) || GET_MODE ( src ) == VOIDmode ) ; if ( REG_P ( dst ) && REG_P ( src ) ) { int src_regno = REGNO ( src ) ; int dst_regno = REGNO ( dst ) ; if ( FP_REGNUM_P ( dst_regno ) && GP_REGNUM_P ( src_regno ) ) { src_lo = gen_lowpart ( word_mode , src ) ; src_hi = gen_highpart ( word_mode , src ) ; if ( mode == TImode ) { emit_insn ( gen_aarch64_movtilow_di ( dst , src_lo ) ) ; emit_insn ( gen_aarch64_movtihigh_di ( dst , src_hi ) ) ; } else { emit_insn ( gen_aarch64_movtflow_di ( dst , src_lo ) ) ; emit_insn ( gen_aarch64_movtfhigh_di ( dst , src_hi ) ) ; } return ; } else if ( GP_REGNUM_P ( dst_regno ) && FP_REGNUM_P ( src_regno ) ) { dst_lo = gen_lowpart ( word_mode , dst ) ; dst_hi = gen_highpart ( word_mode , dst ) ; if ( mode == TImode ) { emit_insn ( gen_aarch64_movdi_tilow ( dst_lo , src ) ) ; emit_insn ( gen_aarch64_movdi_tihigh ( dst_hi , src ) ) ; } else { emit_insn ( gen_aarch64_movdi_tflow ( dst_lo , src ) ) ; emit_insn ( gen_aarch64_movdi_tfhigh ( dst_hi , src ) ) ; } return ; } } dst_lo = gen_lowpart ( word_mode , dst ) ; dst_hi = gen_highpart ( word_mode , dst ) ; src_lo = gen_lowpart ( word_mode , src ) ; src_hi = gen_highpart_mode ( word_mode , mode , src ) ; if ( reg_overlap_mentioned_p ( dst_lo , src_hi ) ) { aarch64_emit_move ( dst_hi , src_hi ) ; aarch64_emit_move ( dst_lo , src_lo ) ; } else { aarch64_emit_move ( dst_lo , src_lo ) ; aarch64_emit_move ( dst_hi , src_hi ) ; } } </s>

Split a 128-bit move operation into two 64-bit move operations , taking care to handle partial overlap of register to register copies . Special cases are needed when moving between GP regs and FP regs . SRC can be a register , constant or memory ; DST a register or memory . If either operand is memory it must not have any side effects .


"passing %qT to argument %d of %qE, which"

" when using a vector of base addresses"

"passing %qT to argument %d of %qE, but %qT is not"

" expects a pointer to 32-bit or 64-bit elements"

Require argument ARGNO to be a pointer to a scalar type that has a corresponding type suffix . Return that type suffix on success , otherwise report an error and return NUM_TYPE_SUFFIXES . GATHER_SCATTER_P is true if the function is a gather/scatter operation , and so requires a pointer to 32-bit or 64-bit data .


<s>
void
ix86_function_specific_print
(
FILE
*
file
,
int
indent
,
struct
cl_target_option
*
ptr
)
{
char
*
target_string
=
ix86_target_string
(
ptr
->
x_ix86_isa_flags
,
ptr
->
x_ix86_isa_flags2
,
ptr
->
x_target_flags
,
ptr
->
x_ix86_target_flags
,
,
,
ptr
->
x_ix86_fpmath
,
ptr
->
x_prefer_vector_width_type
,
ptr
->
x_ix86_move_max
,
ptr
->
x_ix86_store_max
,
false
,
true
)
;
gcc_assert
(
ptr
->
arch
<
PROCESSOR_max
)
;
fprintf
(
file
,
"%*sarch = %d (%s)\n"
,
indent
,
""
,
ptr
->
arch
,
processor_names
[
ptr
->
arch
]
)
;
gcc_assert
(
ptr
->
tune
<
PROCESSOR_max
)
;
fprintf
(
file
,
"%*stune = %d (%s)\n"
,
indent
,
""
,
ptr
->
tune
,
processor_names
[
ptr
->
tune
]
)
;
fprintf
(
file
,
"%*sbranch_cost = %d\n"
,
indent
,
""
,
ptr
->
branch_cost
)
;
if
(
target_string
)
{
fprintf
(
file
,
"%*s%s\n"
,
indent
,
""
,
target_string
)
;
free
(
target_string
)
;
}
}
</s>


<s>
SUnit
*
TPCSchedStrategy
::
pickNode
(
bool
&
IsTopNode
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"\n*** pickNode\n"
)
;
SUnit
*
SU
=
nullptr
;
if
(
DAG
->
top
(
)
==
DAG
->
bottom
(
)
)
{
assert
(
Top
.
Available
.
empty
(
)
&&
"ReadyQ garbage"
)
;
return
nullptr
;
}
if
(
llvm
::
ForceTopDown
)
{
SU
=
Top
.
pickOnlyChoice
(
)
;
if
(
!
SU
)
{
SchedCandidate
TopCand
;
CandResult
TopResult
=
pickNodeFromQueue
(
Top
.
Available
,
DAG
->
getTopRPTracker
(
)
,
TopCand
)
;
assert
(
TopResult
!=
NoCand
&&
"failed to find the first candidate"
)
;
(
void
)
TopResult
;
SU
=
TopCand
.
SU
;
}
IsTopNode
=
true
;
}
else
if
(
llvm
::
ForceBottomUp
)
{
SU
=
Bot
.
pickOnlyChoice
(
)
;
if
(
!
SU
)
{
SchedCandidate
BotCand
;
CandResult
BotResult
=
pickNodeFromQueue
(
Bot
.
Available
,
DAG
->
getBotRPTracker
(
)
,
BotCand
)
;
assert
(
BotResult
!=
NoCand
&&
"failed to find the first candidate"
)
;
(
void
)
BotResult
;
SU
=
BotCand
.
SU
;
}
IsTopNode
=
false
;
}
else
{
SU
=
pickNodeBidrectional
(
IsTopNode
)
;
}
if
(
SU
->
isTopReady
(
)
)
Top
.
removeReady
(
SU
)
;
if
(
SU
->
isBottomReady
(
)
)
Bot
.
removeReady
(
SU
)
;
LLVM_DEBUG
(
if
(
SU
)
{
dbgs
(
)
<<
"*** Pick node "
<<
(
IsTopNode
"Top"
:
"Bottom"
)
<<
" at cycle "
<<
(
IsTopNode
Top
.
CurrCycle
:
Bot
.
CurrCycle
)
<<
'\n'
;
dbgs
(
)
<<
"   "
;
DAG
->
dumpNode
(
*
SU
)
;
}
else
{
dbgs
(
)
<<
"  ** NO NODE \n"
;
for
(
unsigned
i
=
0
;
i
<
DAG
->
SUnits
.
size
(
)
;
i
++
)
{
const
SUnit
&
S
=
DAG
->
SUnits
[
i
]
;
if
(
!
S
.
isScheduled
)
DAG
->
dumpNode
(
S
)
;
}
}
</s>

Pick the next node to schedule , or return NULL .

TPC
TPC
"\n*** pickNode\n"
"ReadyQ garbage"
"failed to find the first candidate"
"failed to find the first candidate"
"*** Pick node "
"Top"
"Bottom"
" at cycle "
"   "
"  ** NO NODE \n"
0


<s> static void s390_reorg ( void ) { bool pool_overflow = false ; int hw_before , hw_after ; split_all_insns_noflow ( ) ; for ( ; ; ) { struct constant_pool * pool = NULL ; if ( ! pool_overflow ) { pool = s390_mainpool_start ( ) ; if ( ! pool ) pool_overflow = true ; } if ( pool_overflow ) pool = s390_chunkify_start ( ) ; if ( ! TARGET_CPU_ZARCH && s390_split_branches ( ) ) { if ( pool_overflow ) s390_chunkify_cancel ( pool ) ; else s390_mainpool_cancel ( pool ) ; continue ; } if ( pool_overflow ) s390_chunkify_finish ( pool ) ; else s390_mainpool_finish ( pool ) ; cfun -> machine -> split_branches_pending_p = false ; break ; } if ( TARGET_CPU_ZARCH ) { rtx_insn * insn , * target ; rtx label ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { label = s390_execute_label ( insn ) ; if ( ! label ) continue ; gcc_assert ( label != const0_rtx ) ; target = emit_label ( XEXP ( label , 0 ) ) ; INSN_ADDRESSES_NEW ( target , - 1 ) ; target = emit_insn ( s390_execute_target ( insn ) ) ; INSN_ADDRESSES_NEW ( target , - 1 ) ; } } s390_optimize_prologue ( ) ; if ( s390_tune >= PROCESSOR_2097_Z10 ) { rtx_insn * insn ; bool insn_added_p = false ; shorten_branches ( get_insns ( ) ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( ! INSN_P ( insn ) || INSN_CODE ( insn ) <= 0 ) continue ; if ( JUMP_P ( insn ) ) insn_added_p |= s390_fix_long_loop_prediction ( insn ) ; if ( ( GET_CODE ( PATTERN ( insn ) ) == PARALLEL || GET_CODE ( PATTERN ( insn ) ) == SET ) && s390_tune == PROCESSOR_2097_Z10 ) insn_added_p |= s390_z10_optimize_cmp ( insn ) ; } if ( insn_added_p ) shorten_branches ( get_insns ( ) ) ; } s390_function_num_hotpatch_hw ( current_function_decl , & hw_before , & hw_after ) ; if ( hw_after > 0 ) { rtx_insn * insn ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( active_insn_p ( insn ) || BARRIER_P ( insn ) || LABEL_P ( insn ) ) break ; while ( insn && hw_after > 0 ) { if ( hw_after >= 3 && TARGET_CPU_ZARCH ) { emit_insn_before ( gen_nop_6_byte ( ) , insn ) ; hw_after -= 3 ; } else if ( hw_after >= 2 ) { emit_insn_before ( gen_nop_4_byte ( ) , insn ) ; hw_after -= 2 ; } else { emit_insn_before ( gen_nop_2_byte ( ) , insn ) ; hw_after -= 1 ; } } } } </s>


<s> unsigned int LC2200AsmParser :: validateTargetOperandClass ( MCParsedAsmOperand & Op , unsigned Kind ) { return MCTargetAsmParser :: validateTargetOperandClass ( Op , Kind ) ; } </s>

Allow a target to add special case operand matching for things that tblgen doesn't/ca n't handle effectively .


<s>
static
unsigned
int
aarch64_parse_boolean_options
(
const
char
*
option
,
const
struct
aarch64_flag_desc
*
flags
,
unsigned
int
initial_state
,
const
char
*
option_name
)
{
const
char
separator
=
'.'
;
const
char
*
specs
=
option
;
const
char
*
ntoken
=
option
;
unsigned
int
found_flags
=
initial_state
;
while
(
(
ntoken
=
strchr
(
specs
,
separator
)
)
)
{
size_t
token_length
=
ntoken
specs
;
unsigned
token_ops
=
aarch64_parse_one_option_token
(
specs
,
token_length
,
flags
,
option_name
)
;
if
(
!
token_ops
)
found_flags
=
0
;
found_flags
|=
token_ops
;
specs
=
++
ntoken
;
}
if
(
!
(
*
specs
)
)
{
error
(
"%s string ill-formed\n"
,
option_name
)
;
return
0
;
}
size_t
token_length
=
strlen
(
specs
)
;
unsigned
token_ops
=
aarch64_parse_one_option_token
(
specs
,
token_length
,
flags
,
option_name
)
;
if
(
!
token_ops
)
found_flags
=
0
;
found_flags
|=
token_ops
;
return
found_flags
;
}
</s>

Parse OPTION which is a comma-separated list of flags to enable . FLAGS gives the list of flags we understand , INITIAL_STATE gives any default state we inherit from the CPU tuning structures . OPTION_NAME gives the top-level option we are parsing in the -moverride string , for use in error messages .


<s> void c4x_global_label ( const char * name ) { struct name_list * p , * last ; p = global_head ; while ( p ) { if ( strcmp ( p -> name , name ) == 0 ) return ; p = p -> next ; } p = ( struct name_list * ) xmalloc ( sizeof * p ) ; p -> next = global_head ; p -> name = name ; global_head = p ; last = NULL ; p = extern_head ; while ( p ) { if ( strcmp ( p -> name , name ) == 0 ) { if ( last ) last -> next = p -> next ; else extern_head = p -> next ; break ; } last = p ; p = p -> next ; } } </s>

Add NAME to list of global symbols and remove from external list if present on external list .


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

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


<s> void setReg ( unsigned Val ) { Contents . RegNum = Val ; } </s>

Assigns the associated register for this edge .


We are choosing insn from the ready queue . Return nonzero if INSN can be chosen .


<s> bool SIFixSGPRCopies :: runOnMachineFunction ( MachineFunction & MF ) { MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; const TargetRegisterInfo * TRI = MF . getTarget ( ) . getRegisterInfo ( ) ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { MachineBasicBlock & MBB = * BI ; for ( MachineBasicBlock :: iterator I = MBB . begin ( ) , E = MBB . end ( ) ; I != E ; ++ I ) { MachineInstr & MI = * I ; if ( MI . getOpcode ( ) != AMDGPU :: PHI ) { continue ; } unsigned Reg = MI . getOperand ( 0 ) . getReg ( ) ; const TargetRegisterClass * RC = inferRegClass ( TRI , MRI , Reg ) ; if ( RC == & AMDGPU :: VSrc_32RegClass ) { MRI . constrainRegClass ( Reg , & AMDGPU :: VReg_32RegClass ) ; } } } return false ; } </s>

runOnMachineFunction - Emit the function body .


"stack limit expression is not supported"

Emit the correct code for allocating stack space , as insns . If COPY_R12 , make sure a copy of the old frame is left in r12 . The generated code may use hard register 0 as a temporary .


"Instr doesn't have FrameIndex operand!"

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


<s> bool isScheduled ( const SUnit * SU ) const { assert ( ! SU -> isBoundaryNode ( ) ) ; return NumPreds [ SU -> NodeNum ] == std :: numeric_limits < unsigned > :: max ( ) ; } </s>


<s> static int msp430_memory_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ) { int cost ; const struct double_op_cost * cost_p ; bool speed = ( ! optimize_size && optimize >= 2 ) ; cost_p = ( speed ? & cycle_cost_double_op_mov : & size_cost_double_op ) ; if ( in ) cost = cost_p -> ind2r ; else cost = cost_p -> r2m ; return 2 * cost ; } </s>

Return the cost of moving data between registers and memory . The returned cost must be relative to the default TARGET_REGISTER_MOVE_COST of 2 . IN is false if the value is to be written to memory .


<s> bool ARMAsmBackend :: writeNopData ( raw_ostream & OS , uint64_t Count ) const { const uint16_t Thumb1_16bitNopEncoding = 0x46c0 ; const uint16_t Thumb2_16bitNopEncoding = 0xbf00 ; const uint32_t ARMv4_NopEncoding = 0xe1a00000 ; const uint32_t ARMv6T2_NopEncoding = 0xe320f000 ; if ( isThumb ( ) ) { const uint16_t nopEncoding = hasNOP ( ) ? Thumb2_16bitNopEncoding : Thumb1_16bitNopEncoding ; uint64_t NumNops = Count / 2 ; for ( uint64_t i = 0 ; i != NumNops ; ++ i ) support :: endian :: write ( OS , nopEncoding , Endian ) ; if ( Count & 1 ) OS << '\0' ; return true ; } const uint32_t nopEncoding = hasNOP ( ) ? ARMv6T2_NopEncoding : ARMv4_NopEncoding ; uint64_t NumNops = Count / 4 ; for ( uint64_t i = 0 ; i != NumNops ; ++ i ) support :: endian :: write ( OS , nopEncoding , Endian ) ; switch ( Count % 4 ) { default : break ; case 1 : OS << '\0' ; break ; case 2 : OS . write ( "\0\0" , 2 ) ; break ; case 3 : OS . write ( "\0\0\xa0" , 3 ) ; break ; } return true ; } </s>

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


<s> static rtx_insn * nvptx_discover_pre ( basic_block block , int expected ) { gcc_assert ( block -> preds -> length ( ) == 1 ) ; basic_block pre_block = ( * block -> preds ) [ 0 ] -> src ; rtx_insn * pre_insn ; for ( pre_insn = BB_END ( pre_block ) ; ! INSN_P ( pre_insn ) ; pre_insn = PREV_INSN ( pre_insn ) ) gcc_assert ( pre_insn != BB_HEAD ( pre_block ) ) ; gcc_assert ( recog_memoized ( pre_insn ) == expected ) ; return pre_insn ; } </s>

BLOCK is a basic block containing a head or tail instruction . Locate the associated prehead or pretail instruction , which must be in the single predecessor block .


<s> const uint32_t * Z80RegisterInfo :: getNoPreservedMask ( ) const { return CSR_NoRegs_RegMask ; } </s>

Return a register mask that clobbers everything .


<s> void SIInstrInfo :: moveToVALU ( MachineInstr & TopInst ) const { SmallVector < MachineInstr * , 128 > Worklist ; Worklist . push_back ( & TopInst ) ; while ( ! Worklist . empty ( ) ) { MachineInstr * Inst = Worklist . pop_back_val ( ) ; unsigned NewOpcode = getVALUOp ( * Inst ) ; if ( NewOpcode == AMDGPU :: INSTRUCTION_LIST_END ) continue ; MachineRegisterInfo & MRI = Inst -> getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; const MCInstrDesc & NewDesc = get ( NewOpcode ) ; Inst -> setDesc ( NewDesc ) ; for ( unsigned i = Inst -> getNumOperands ( ) - 1 ; i > 0 ; -- i ) { MachineOperand & Op = Inst -> getOperand ( i ) ; if ( Op . isReg ( ) && Op . getReg ( ) == AMDGPU :: SCC ) Inst -> RemoveOperand ( i ) ; } if ( NewDesc . ImplicitUses ) { for ( unsigned i = 0 ; NewDesc . ImplicitUses [ i ] ; ++ i ) { unsigned Reg = NewDesc . ImplicitUses [ i ] ; Inst -> addOperand ( MachineOperand :: CreateReg ( Reg , false , true ) ) ; } } if ( NewDesc . ImplicitDefs ) { for ( unsigned i = 0 ; NewDesc . ImplicitDefs [ i ] ; ++ i ) { unsigned Reg = NewDesc . ImplicitDefs [ i ] ; Inst -> addOperand ( MachineOperand :: CreateReg ( Reg , true , true ) ) ; } } legalizeOperands ( Inst ) ; const TargetRegisterClass * NewDstRC = getOpRegClass ( * Inst , 0 ) ; switch ( Inst -> getOpcode ( ) ) { case AMDGPU :: COPY : case AMDGPU :: PHI : case AMDGPU :: REG_SEQUENCE : if ( RI . hasVGPRs ( NewDstRC ) ) continue ; NewDstRC = RI . getEquivalentVGPRClass ( NewDstRC ) ; if ( ! NewDstRC ) continue ; break ; default : break ; } unsigned DstReg = Inst -> getOperand ( 0 ) . getReg ( ) ; unsigned NewDstReg = MRI . createVirtualRegister ( NewDstRC ) ; MRI . replaceRegWith ( DstReg , NewDstReg ) ; for ( MachineRegisterInfo :: use_iterator I = MRI . use_begin ( NewDstReg ) , E = MRI . use_end ( ) ; I != E ; ++ I ) { MachineInstr & UseMI = * I -> getParent ( ) ; if ( ! canReadVGPR ( UseMI , I . getOperandNo ( ) ) ) { Worklist . push_back ( & UseMI ) ; } } } } </s>

Replace the instructions opcode with the equivalent VALU opcode .


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

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


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

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


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

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


<s>
bool
VLIWResourceModel
::
reserveResources
(
SUnit
*
SU
)
{
bool
startNewCycle
=
false
;
if
(
!
SU
)
{
ResourcesModel
->
clearResources
(
)
;
Packet
.
clear
(
)
;
TotalPackets
++
;
return
false
;
}
if
(
!
isResourceAvailable
(
SU
)
)
{
ResourcesModel
->
clearResources
(
)
;
Packet
.
clear
(
)
;
TotalPackets
++
;
startNewCycle
=
true
;
}
switch
(
SU
->
getInstr
(
)
->
getOpcode
(
)
)
{
default
:
ResourcesModel
->
reserveResources
(
SU
->
getInstr
(
)
)
;
break
;
case
TargetOpcode
::
EXTRACT_SUBREG
:
case
TargetOpcode
::
INSERT_SUBREG
:
case
TargetOpcode
::
SUBREG_TO_REG
:
case
TargetOpcode
::
REG_SEQUENCE
:
case
TargetOpcode
::
IMPLICIT_DEF
:
case
TargetOpcode
::
KILL
:
case
TargetOpcode
::
CFI_INSTRUCTION
:
case
TargetOpcode
::
EH_LABEL
:
case
TargetOpcode
::
COPY
:
case
TargetOpcode
::
INLINEASM
:
break
;
}
Packet
.
push_back
(
SU
)
;
DEBUG
(
dbgs
(
)
<<
"Packet["
<<
TotalPackets
<<
"]:\n"
)
;
for
(
unsigned
i
=
0
,
e
=
Packet
.
size
(
)
;
i
!=
e
;
++
i
)
{
DEBUG
(
dbgs
(
)
<<
"\t["
<<
i
<<
"] SU("
)
;
DEBUG
(
dbgs
(
)
<<
Packet
[
i
]
->
NodeNum
<<
")\t"
)
;
DEBUG
(
Packet
[
i
]
->
getInstr
(
)
->
dump
(
)
)
;
}
if
(
Packet
.
size
(
)
>=
SchedModel
->
getIssueWidth
(
)
)
{
ResourcesModel
->
clearResources
(
)
;
Packet
.
clear
(
)
;
TotalPackets
++
;
startNewCycle
=
true
;
}
return
startNewCycle
;
}
</s>