<s> void altivec_expand_lvx_be ( rtx op0 , rtx op1 , machine_mode mode , unsigned unspec ) { rtx tmp = gen_reg_rtx ( mode ) ; rtx load = gen_rtx_SET ( VOIDmode , tmp , op1 ) ; rtx lvx = gen_rtx_UNSPEC ( mode , gen_rtvec ( 1 , const0_rtx ) , unspec ) ; rtx par = gen_rtx_PARALLEL ( mode , gen_rtvec ( 2 , load , lvx ) ) ; rtx sel = swap_selector_for_mode ( mode ) ; rtx vperm = gen_rtx_UNSPEC ( mode , gen_rtvec ( 3 , tmp , tmp , sel ) , UNSPEC_VPERM ) ; gcc_assert ( REG_P ( op0 ) ) ; emit_insn ( par ) ; emit_insn ( gen_rtx_SET ( VOIDmode , op0 , vperm ) ) ; } </s>

Generate code for an `` lvx '' , `` lvxl '' , or `` lve * x '' built-in for a little endian target with -maltivec=be specified . Issue the load followed by an element-reversing permute .


"Instr doesn't have FrameIndex operand!"

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


<s> unsigned SITargetLowering :: getVectorTypeBreakdownForCallingConv ( LLVMContext & Context , CallingConv :: ID CC , EVT VT , EVT & IntermediateVT , unsigned & NumIntermediates , MVT & RegisterVT ) const { if ( CC != CallingConv :: AMDGPU_KERNEL && VT . isVector ( ) ) { unsigned NumElts = VT . getVectorNumElements ( ) ; EVT ScalarVT = VT . getScalarType ( ) ; unsigned Size = ScalarVT . getSizeInBits ( ) ; if ( Size == 32 ) { RegisterVT = ScalarVT . getSimpleVT ( ) ; IntermediateVT = RegisterVT ; NumIntermediates = NumElts ; return NumIntermediates ; } if ( Size > 32 ) { RegisterVT = MVT :: i32 ; IntermediateVT = RegisterVT ; NumIntermediates = NumElts * ( ( Size + 31 ) / 32 ) ; return NumIntermediates ; } if ( Size == 16 && Subtarget -> has16BitInsts ( ) ) { RegisterVT = VT . isInteger ( ) ? MVT :: v2i16 : MVT :: v2f16 ; IntermediateVT = RegisterVT ; NumIntermediates = ( NumElts + 1 ) / 2 ; return NumIntermediates ; } } return TargetLowering :: getVectorTypeBreakdownForCallingConv ( Context , CC , VT , IntermediateVT , NumIntermediates , RegisterVT ) ; } </s>

Certain targets such as MIPS require that some types such as vectors are always broken down into scalars in some contexts .


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

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


<s>
Register
ARMTargetLowering
::
getRegisterByName
(
const
char
*
RegName
,
EVT
VT
,
const
MachineFunction
&
MF
)
const
{
Register
Reg
=
StringSwitch
<
unsigned
>
(
RegName
)
.
Case
(
"r6"
,
ARM
::
R6
)
.
Case
(
"r7"
,
ARM
::
R7
)
.
Case
(
"r8"
,
ARM
::
R8
)
.
Case
(
"r9"
,
ARM
::
R9
)
.
Case
(
"r10"
,
ARM
::
R10
)
.
Case
(
"r11"
,
ARM
::
R11
)
.
Case
(
"sp"
,
ARM
::
SP
)
.
Default
(
ARM
::
NoRegister
)
;
if
(
Reg
!=
ARM
::
NoRegister
)
return
Reg
;
report_fatal_error
(
Twine
(
"Invalid register name \""
+
StringRef
(
RegName
)
+
"\"."
)
)
;
}
</s>

Return the register ID of the name passed in .


<s> void NVPTXFrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { MBB . erase ( I ) ; } </s>

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 ) .


"Unknown opcode to check as cheap as a move!"

Return true if the instruction is as cheap as a move instruction .


<s> static inline unsigned char * unw_decode ( unsigned char * dp , int inside_body , void * arg ) { unw_decoder decoder ; unsigned char code ; code = * dp ++ ; decoder = unw_decode_table [ inside_body ] [ code >> 5 ] ; dp = ( * decoder ) ( dp , code , arg ) ; return dp ; } </s>

Decode one descriptor and return address of next descriptor .


<s> static inline int arm_const_inline_cost ( enum rtx_code code , rtx val ) { return arm_gen_constant ( code , SImode , NULL_RTX , INTVAL ( val ) , NULL_RTX , NULL_RTX , 1 , 0 ) ; } </s>


<s> bool avr_has_nibble_0xf ( rtx ival ) { unsigned int map = UINTVAL ( ival ) & GET_MODE_MASK ( SImode ) ; return avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) != 0 ; } </s>

Return true if IVAL has a 0xf in its hexadecimal representation and false , otherwise . Only nibbles 0 .. 7 are taken into account . Used as constraint helper for C0f and Cxf .


<s> bool LoongArchAsmParser :: processInstruction ( MCInst & Inst , SMLoc IDLoc , OperandVector & Operands , MCStreamer & Out ) { Inst . setLoc ( IDLoc ) ; Out . emitInstruction ( Inst , getSTI ( ) ) ; return false ; } </s>

Process a single instruction and collect debug info anchors .


<s> bool ARMBaseInstrInfo :: isPredicable ( MachineInstr * MI ) const { if ( ! MI -> isPredicable ( ) ) return false ; if ( ( MI -> getDesc ( ) . TSFlags & ARMII :: DomainMask ) == ARMII :: DomainNEON ) { ARMFunctionInfo * AFI = MI -> getParent ( ) -> getParent ( ) -> getInfo < ARMFunctionInfo > ( ) ; return AFI -> isThumb2Function ( ) ; } return true ; } </s>

Return true if the specified instruction can be predicated .

ARM ARM ARMII::DomainMask ARMII::DomainNEON ARM ARM


<s> void function_arg_advance ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type ) { int words , max ; int * arg_words ; arg_words = & cum -> arg_words ; max = MAX_ARGS_IN_REGISTERS ; words = ( ( ( mode != BLKmode ) ? ( int ) GET_MODE_SIZE ( mode ) : int_size_in_bytes ( type ) ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; if ( * arg_words < max && ( targetm . calls . must_pass_in_stack ( mode , type ) || * arg_words + words > max ) ) * arg_words = max ; * arg_words += words ; } </s>

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


<s> unsigned postOffset ( unsigned LogAlign = 0 ) const { unsigned PO = Offset + Size ; unsigned Align = 1 << LogAlign ; return ( PO + Align - 1 ) / Align * Align ; } </s>

Compute the offset immediately following this block .


"Switch should handle all register classes"


<s>
char
*
aarch64_output_simd_mov_immediate
(
rtx
const_vector
,
unsigned
width
,
enum
simd_immediate_check
which
)
{
bool
is_valid
;
static
char
templ
[
40
]
;
const
char
*
mnemonic
;
const
char
*
shift_op
;
unsigned
int
lane_count
=
0
;
char
element_char
;
struct
simd_immediate_info
info
;
is_valid
=
aarch64_simd_valid_immediate
(
const_vector
,
&
info
,
which
)
;
gcc_assert
(
is_valid
)
;
element_char
=
sizetochar
(
GET_MODE_BITSIZE
(
info
.
elt_mode
)
)
;
lane_count
=
width
/
GET_MODE_BITSIZE
(
info
.
elt_mode
)
;
if
(
GET_MODE_CLASS
(
info
.
elt_mode
)
==
MODE_FLOAT
)
{
gcc_assert
(
info
.
insn
==
simd_immediate_info
::
MOV
&&
info
.
u
.
mov
.
shift
==
0
)
;
if
(
aarch64_float_const_zero_rtx_p
(
info
.
u
.
mov
.
value
)
)
info
.
u
.
mov
.
value
=
GEN_INT
(
0
)
;
else
{
const
unsigned
int
buf_size
=
20
;
char
float_buf
[
buf_size
]
=
{
'\0'
}
;
real_to_decimal_for_mode
(
float_buf
,
CONST_DOUBLE_REAL_VALUE
(
info
.
u
.
mov
.
value
)
,
buf_size
,
buf_size
,
1
,
info
.
elt_mode
)
;
if
(
lane_count
==
1
)
snprintf
(
templ
,
sizeof
(
templ
)
,
"fmov\t%%d0, %s"
,
float_buf
)
;
else
snprintf
(
templ
,
sizeof
(
templ
)
,
"fmov\t%%0.%d%c, %s"
,
lane_count
,
element_char
,
float_buf
)
;
return
templ
;
}
}
gcc_assert
(
CONST_INT_P
(
info
.
u
.
mov
.
value
)
)
;
if
(
which
==
AARCH64_CHECK_MOV
)
{
mnemonic
=
info
.
insn
==
simd_immediate_info
::
MVN
"mvni"
:
"movi"
;
shift_op
=
(
info
.
u
.
mov
.
modifier
==
simd_immediate_info
::
MSL
"msl"
:
"lsl"
)
;
if
(
lane_count
==
1
)
snprintf
(
templ
,
sizeof
(
templ
)
,
"%s\t%%d0, "
HOST_WIDE_INT_PRINT_HEX
,
mnemonic
,
UINTVAL
(
info
.
u
.
mov
.
value
)
)
;
else
if
(
info
.
u
.
mov
.
shift
)
snprintf
(
templ
,
sizeof
(
templ
)
,
"%s\t%%0.%d%c, "
HOST_WIDE_INT_PRINT_HEX
", %s %d"
,
mnemonic
,
lane_count
,
element_char
,
UINTVAL
(
info
.
u
.
mov
.
value
)
,
shift_op
,
info
.
u
.
mov
.
shift
)
;
else
snprintf
(
templ
,
sizeof
(
templ
)
,
"%s\t%%0.%d%c, "
HOST_WIDE_INT_PRINT_HEX
,
mnemonic
,
lane_count
,
element_char
,
UINTVAL
(
info
.
u
.
mov
.
value
)
)
;
}
else
{
mnemonic
=
info
.
insn
==
simd_immediate_info
::
MVN
"bic"
:
"orr"
;
if
(
info
.
u
.
mov
.
shift
)
snprintf
(
templ
,
sizeof
(
templ
)
,
"%s\t%%0.%d%c, #"
HOST_WIDE_INT_PRINT_DEC
", %s #%d"
,
mnemonic
,
lane_count
,
element_char
,
UINTVAL
(
info
.
u
.
mov
.
value
)
,
"lsl"
,
info
.
u
.
mov
.
shift
)
;
else
snprintf
(
templ
,
sizeof
(
templ
)
,
"%s\t%%0.%d%c, #"
HOST_WIDE_INT_PRINT_DEC
,
mnemonic
,
lane_count
,
element_char
,
UINTVAL
(
info
.
u
.
mov
.
value
)
)
;
}
return
templ
;
}
</s>

Returns the string with the instruction for AdvSIMD MOVI , MVNI , ORR or BIC immediate with a CONST_VECTOR of MODE and WIDTH . WHICH selects whether to output MOVI/MVNI , ORR or BIC immediate .


<s> const NyuziRegisterInfo * getRegisterInfo ( ) const override { return & InstrInfo . getRegisterInfo ( ) ; } </s>

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


"using vector_length (%d), ignoring runtime setting"

Validate compute dimensions of an OpenACC offload or routine , fill in non-unity defaults . FN_LEVEL indicates the level at which a routine might spawn a loop . It is negative for non-routines . If DECL is null , we are validating the default dimensions .


"static const void *__offload_target_data[] = {\n"

"  &__offload_image_intelmic_start, &__offload_image_intelmic_end\n"

"void GOMP_offload_register (void *, int, void *);\n"

"void GOMP_offload_unregister (void *, int, void *);\n\n"

"  GOMP_offload_register (&__OFFLOAD_TABLE__, %d, __offload_target_data);\n"

"  GOMP_offload_unregister (&__OFFLOAD_TABLE__, %d, __offload_target_data);\n"

Generates object file with the host side descriptor .


<s> void sh_va_start ( tree valist , rtx nextarg ) { tree f_next_o , f_next_o_limit , f_next_fp , f_next_fp_limit , f_next_stack ; tree next_o , next_o_limit , next_fp , next_fp_limit , next_stack ; tree t , u ; int nfp , nint ; if ( TARGET_SH5 ) { expand_builtin_saveregs ( ) ; std_expand_builtin_va_start ( valist , nextarg ) ; return ; } if ( ( ! TARGET_SH2E && ! TARGET_SH4 ) || TARGET_HITACHI || sh_cfun_attr_renesas_p ( ) ) { std_expand_builtin_va_start ( valist , nextarg ) ; return ; } f_next_o = TYPE_FIELDS ( va_list_type_node ) ; f_next_o_limit = TREE_CHAIN ( f_next_o ) ; f_next_fp = TREE_CHAIN ( f_next_o_limit ) ; f_next_fp_limit = TREE_CHAIN ( f_next_fp ) ; f_next_stack = TREE_CHAIN ( f_next_fp_limit ) ; next_o = build ( COMPONENT_REF , TREE_TYPE ( f_next_o ) , valist , f_next_o , NULL_TREE ) ; next_o_limit = build ( COMPONENT_REF , TREE_TYPE ( f_next_o_limit ) , valist , f_next_o_limit , NULL_TREE ) ; next_fp = build ( COMPONENT_REF , TREE_TYPE ( f_next_fp ) , valist , f_next_fp , NULL_TREE ) ; next_fp_limit = build ( COMPONENT_REF , TREE_TYPE ( f_next_fp_limit ) , valist , f_next_fp_limit , NULL_TREE ) ; next_stack = build ( COMPONENT_REF , TREE_TYPE ( f_next_stack ) , valist , f_next_stack , NULL_TREE ) ; u = make_tree ( ptr_type_node , expand_builtin_saveregs ( ) ) ; t = build ( MODIFY_EXPR , ptr_type_node , next_fp , u ) ; TREE_SIDE_EFFECTS ( t ) = 1 ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; nfp = current_function_args_info . arg_count [ SH_ARG_FLOAT ] ; if ( nfp < 8 ) nfp = 8 - nfp ; else nfp = 0 ; u = fold ( build ( PLUS_EXPR , ptr_type_node , u , build_int_cst ( NULL_TREE , UNITS_PER_WORD * nfp ) ) ) ; t = build ( MODIFY_EXPR , ptr_type_node , next_fp_limit , u ) ; TREE_SIDE_EFFECTS ( t ) = 1 ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build ( MODIFY_EXPR , ptr_type_node , next_o , u ) ; TREE_SIDE_EFFECTS ( t ) = 1 ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; nint = current_function_args_info . arg_count [ SH_ARG_INT ] ; if ( nint < 4 ) nint = 4 - nint ; else nint = 0 ; u = fold ( build ( PLUS_EXPR , ptr_type_node , u , build_int_cst ( NULL_TREE , UNITS_PER_WORD * nint ) ) ) ; t = build ( MODIFY_EXPR , ptr_type_node , next_o_limit , u ) ; TREE_SIDE_EFFECTS ( t ) = 1 ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; u = make_tree ( ptr_type_node , nextarg ) ; t = build ( MODIFY_EXPR , ptr_type_node , next_stack , u ) ; TREE_SIDE_EFFECTS ( t ) = 1 ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } </s>

Implement ` va_start ' for varargs and stdarg .


<s> static void ix86_init_pic_reg ( void ) { edge entry_edge ; rtx_insn * seq ; if ( ! ix86_use_pseudo_pic_reg ( ) ) return ; start_sequence ( ) ; if ( TARGET_64BIT ) { if ( ix86_cmodel == CM_LARGE_PIC ) ix86_init_large_pic_reg ( R11_REG ) ; else emit_insn ( gen_set_got_rex64 ( pic_offset_table_rtx ) ) ; } else { rtx reg = crtl -> profile ? gen_rtx_REG ( Pmode , REAL_PIC_OFFSET_TABLE_REGNUM ) : pic_offset_table_rtx ; rtx insn = emit_insn ( gen_set_got ( reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = 1 ; if ( crtl -> profile ) emit_move_insn ( pic_offset_table_rtx , reg ) ; add_reg_note ( insn , REG_CFA_FLUSH_QUEUE , NULL_RTX ) ; } seq = get_insns ( ) ; end_sequence ( ) ; entry_edge = single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ; insert_insn_on_edge ( seq , entry_edge ) ; commit_one_edge_insertion ( entry_edge ) ; } </s>

Create and initialize PIC register if required .


<s> void HexagonExpandCondsets :: shrinkToUses ( unsigned Reg , LiveInterval & LI ) { SmallVector < MachineInstr * , 4 > Deads ; LIS -> shrinkToUses ( & LI , & Deads ) ; for ( unsigned i = 0 , n = Deads . size ( ) ; i < n ; ++ i ) { MachineInstr * MI = Deads [ i ] ; for ( auto & Op : MI -> operands ( ) ) { if ( ! Op . isReg ( ) || ! Op . isDef ( ) || Op . getReg ( ) != Reg ) continue ; Op . setIsDead ( false ) ; } LiveInterval :: iterator End = LI . end ( ) ; SlotIndex S = LIS -> getInstructionIndex ( * MI ) . getRegSlot ( ) ; LiveInterval :: iterator T = LI . FindSegmentContaining ( S ) ; assert ( T != End ) ; LiveInterval :: iterator N = std :: next ( T ) ; if ( N != End ) T -> end = N -> start ; else T -> end = LIS -> getMBBEndIdx ( MI -> getParent ( ) ) ; } updateKillFlags ( Reg , LI ) ; } </s>

Specialized version of shrinkToUses ( LiveInterval li , SmallVectorImpl < MachineInstr > * dead ) that works on a subregister live range and only looks at uses matching the lane mask of the subregister range .


<s> bool addGCPasses ( ) override { return false ; } </s>

addGCPasses - Add late codegen passes that analyze code for garbage collection .


<s>
void
RISCVFrameLowering
::
emitPrologue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
assert
(
&
MF
.
front
(
)
==
&
MBB
&&
"Shrink-wrapping not yet supported"
)
;
MachineFrameInfo
&
MFI
=
MF
.
getFrameInfo
(
)
;
auto
*
RVFI
=
MF
.
getInfo
<
RISCVMachineFunctionInfo
>
(
)
;
MachineBasicBlock
::
iterator
MBBI
=
MBB
.
begin
(
)
;
const
RISCVInstrInfo
*
TII
=
STI
.
getInstrInfo
(
)
;
unsigned
FPReg
=
getFPReg
(
STI
)
;
unsigned
SPReg
=
getSPReg
(
STI
)
;
DebugLoc
DL
;
determineFrameLayout
(
MF
)
;
uint64_t
StackSize
=
MFI
.
getStackSize
(
)
;
if
(
StackSize
==
0
&&
!
MFI
.
adjustsStack
(
)
)
return
;
adjustReg
(
MBB
,
MBBI
,
DL
,
SPReg
,
SPReg
,
StackSize
,
MachineInstr
::
FrameSetup
)
;
const
std
::
vector
<
CalleeSavedInfo
>
&
CSI
=
MFI
.
getCalleeSavedInfo
(
)
;
std
::
advance
(
MBBI
,
CSI
.
size
(
)
)
;
if
(
hasFP
(
MF
)
)
adjustReg
(
MBB
,
MBBI
,
DL
,
FPReg
,
SPReg
,
StackSize
RVFI
->
getVarArgsSaveSize
(
)
,
MachineInstr
::
FrameSetup
)
;
const
MCRegisterInfo
*
MRI
=
MF
.
getMMI
(
)
.
getContext
(
)
.
getRegisterInfo
(
)
;
unsigned
CFIIndex
=
MF
.
addFrameInst
(
MCCFIInstruction
::
createDefCfaOffset
(
nullptr
,
StackSize
)
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
->
get
(
TargetOpcode
::
CFI_INSTRUCTION
)
)
.
addCFIIndex
(
CFIIndex
)
.
setMIFlags
(
MachineInstr
::
FrameSetup
)
;
for
(
const
auto
&
Entry
:
CSI
)
{
unsigned
Reg
=
Entry
.
getReg
(
)
;
int
FI
=
Entry
.
getFrameIdx
(
)
;
CFIIndex
=
MF
.
addFrameInst
(
MCCFIInstruction
::
createOffset
(
nullptr
,
MRI
->
getDwarfRegNum
(
Reg
,
true
)
,
MFI
.
getObjectOffset
(
FI
)
)
)
;
BuildMI
(
MBB
,
MBBI
,
DL
,
TII
->
get
(
TargetOpcode
::
CFI_INSTRUCTION
)
)
.
addCFIIndex
(
CFIIndex
)
.
setMIFlags
(
MachineInstr
::
FrameSetup
)
;
}
}
</s>

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

RISCV
RISCV
"Shrink-wrapping not yet supported"
RISCV
RISCV
0


"SPUTargetLowering::LowerOperation(): need to lower this!\n"

LowerOperation - Provide custom lowering hooks for some operations .


<s>
MachineBasicBlock
*
Z80oldTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
&
MI
,
MachineBasicBlock
*
BB
)
const
{
switch
(
MI
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Unexpected instr type to insert"
)
;
case
Z80old
::
Select8
:
case
Z80old
::
Select16
:
return
EmitLoweredSelect
(
MI
,
BB
)
;
case
Z80old
::
SExt8
:
case
Z80old
::
SExt16
:
return
EmitLoweredSExt
(
MI
,
BB
)
;
}
}
</s>

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


<s> bool SITargetLowering :: isFMAFasterThanFMulAndFAdd ( const MachineFunction & MF , EVT VT ) const { VT = VT . getScalarType ( ) ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { case MVT :: f32 : { if ( hasFP32Denormals ( MF ) ) return Subtarget -> hasFastFMAF32 ( ) || Subtarget -> hasDLInsts ( ) ; return Subtarget -> hasFastFMAF32 ( ) && Subtarget -> hasDLInsts ( ) ; } case MVT :: f64 : return true ; case MVT :: f16 : return Subtarget -> has16BitInsts ( ) && hasFP64FP16Denormals ( MF ) ; default : break ; } return false ; } </s>

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


<s> static ARMOperand * CreateMem ( unsigned BaseRegNum , bool OffsetIsReg , const MCExpr * Offset , unsigned OffsetRegNum , bool OffsetRegShifted , enum ShiftType ShiftType , const MCExpr * ShiftAmount , bool Preindexed , bool Postindexed , bool Negative , bool Writeback , SMLoc S , SMLoc E ) { ARMOperand * Op = new ARMOperand ( Memory ) ; Op -> Mem . BaseRegNum = BaseRegNum ; Op -> Mem . OffsetIsReg = OffsetIsReg ; Op -> Mem . Offset = Offset ; Op -> Mem . OffsetRegNum = OffsetRegNum ; Op -> Mem . OffsetRegShifted = OffsetRegShifted ; Op -> Mem . ShiftType = ShiftType ; Op -> Mem . ShiftAmount = ShiftAmount ; Op -> Mem . Preindexed = Preindexed ; Op -> Mem . Postindexed = Postindexed ; Op -> Mem . Negative = Negative ; Op -> Mem . Writeback = Writeback ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ; } </s>


<s> static void ix86_emit_probe_stack_range ( HOST_WIDE_INT first , HOST_WIDE_INT size , const bool int_registers_saved ) { if ( size <= 6 * get_probe_interval ( ) ) { HOST_WIDE_INT i ; for ( i = get_probe_interval ( ) ; i < size ; i += get_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 { gcc_assert ( int_registers_saved ) ; HOST_WIDE_INT rounded_size , last ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; rounded_size = ROUND_DOWN ( size , get_probe_interval ( ) ) ; emit_move_insn ( sr . reg , GEN_INT ( - first ) ) ; last = first + rounded_size ; emit_insn ( ix86_gen_probe_stack_range ( sr . reg , sr . reg , GEN_INT ( - last ) ) ) ; if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , sr . reg ) , rounded_size - size ) ) ; release_scratch_register_on_entry ( & sr , size , true ) ; } emit_insn ( gen_blockage ( ) ) ; } </s>

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


"rs6000_can_inline_p:, caller %s, callee %s, %s inline\n"

Hook to determine if one function can safely inline another .


<s> static enum machine_mode frv_matching_accg_mode ( enum machine_mode mode ) { switch ( mode ) { case V4SImode : return V4QImode ; case DImode : return HImode ; case SImode : return QImode ; default : gcc_unreachable ( ) ; } } </s>

If an ACC rtx has mode MODE , return the mode that the matching ACCG should have .


<s>
void
PPCTargetLowering
::
LowerAsmOperandForConstraint
(
SDValue
Op
,
char
Letter
,
bool
hasMemory
,
std
::
vector
<
SDValue
>
&
Ops
,
SelectionDAG
&
DAG
)
const
{
SDValue
Result
(
0
,
0
)
;
switch
(
Letter
)
{
default
:
break
;
case
'I'
:
case
'J'
:
case
'K'
:
case
'L'
:
case
'M'
:
case
'N'
:
case
'O'
:
case
'P'
:
{
ConstantSDNode
*
CST
=
dyn_cast
<
ConstantSDNode
>
(
Op
)
;
if
(
!
CST
)
return
;
unsigned
Value
=
CST
->
getZExtValue
(
)
;
switch
(
Letter
)
{
default
:
assert
(
0
&&
"Unknown constraint letter!"
)
;
case
'I'
:
if
(
(
short
)
Value
==
(
int
)
Value
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'J'
:
case
'L'
:
if
(
(
short
)
Value
==
0
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'K'
:
if
(
(
Value
>>
16
)
==
0
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'M'
:
if
(
Value
>
31
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'N'
:
if
(
(
int
)
Value
>
0
&&
isPowerOf2_32
(
Value
)
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'O'
:
if
(
Value
==
0
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
case
'P'
:
if
(
(
short
)
Value
==
(
int
)
Value
)
Result
=
DAG
.
getTargetConstant
(
Value
,
Op
.
getValueType
(
)
)
;
break
;
}
break
;
}
}
if
(
Result
.
getNode
(
)
)
{
Ops
.
push_back
(
Result
)
;
return
;
}
TargetLowering
::
LowerAsmOperandForConstraint
(
Op
,
Letter
,
hasMemory
,
Ops
,
DAG
)
;
}
</s>

Lower the specified operand into the Ops vector .


<s> static int ix86_return_pops_args ( tree fundecl , tree funtype , int size ) { unsigned int ccvt ; if ( TARGET_64BIT ) return 0 ; ccvt = ix86_get_callcvt ( funtype ) ; if ( ( ccvt & ( IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL ) ) != 0 && ! stdarg_p ( funtype ) ) return size ; if ( aggregate_value_p ( TREE_TYPE ( funtype ) , fundecl ) && ! ix86_keep_aggregate_return_pointer ( funtype ) ) { int nregs = ix86_function_regparm ( funtype , fundecl ) ; if ( nregs == 0 ) return GET_MODE_SIZE ( Pmode ) ; } return 0 ; } </s>

Value is the number of bytes of arguments automatically popped when returning from a subroutine call . FUNDECL is the declaration node of the function ( as a tree ) , FUNTYPE is the data type of the function ( as a tree ) , or for a library call it is an identifier node for the subroutine name . SIZE is the number of bytes of arguments passed on the stack . On the 80386 , the RTD insn may be used to pop them if the number of args is fixed , but if the number is variable then the caller must pop them all . RTD ca n't be used for library calls now because the library is compiled with the Unix compiler . Use of RTD is a selectable option , since it is incompatible with standard Unix calling sequences . If the option is not selected , the caller must always pop the args . The attribute stdcall is equivalent to RTD on a per module basis .


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


<s> bool X86TTIImpl :: isLegalMaskedStore ( Type * DataType , Align Alignment ) { return isLegalMaskedLoad ( DataType , Alignment ) ; } </s>

Return true if the target supports masked store .


<s> rtx sh_get_fdpic_reg_initial_val ( void ) { return get_hard_reg_initial_val ( Pmode , PIC_REG ) ; } </s>

Return an rtx holding the initial value of the FDPIC register ( the FDPIC pointer passed in from the caller ) .


"RegScavenger required for long branching"

"new block should be inserted for expanding unconditional branch"

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


<s> inline bool bundle_state_hasher :: equal ( const value_type * state1 , const compare_type * state2 ) { return ( state1 -> insn_num == state2 -> insn_num && memcmp ( state1 -> dfa_state , state2 -> dfa_state , dfa_state_size ) == 0 ) ; } </s>


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


<s> bool HexagonInstrInfo :: getIncrementValue ( const MachineInstr * MI , int & Value ) const { if ( isPostIncrement ( MI ) ) { unsigned AccessSize ; return getBaseAndOffset ( MI , Value , AccessSize ) ; } if ( MI -> getOpcode ( ) == Hexagon :: A2_addi ) { Value = MI -> getOperand ( 2 ) . getImm ( ) ; return true ; } return false ; } </s>

If the instruction is an increment of a constant value , return the amount .


<s> bool VEAsmParser :: parseExpression ( const MCExpr * & EVal ) { if ( getParser ( ) . parseExpression ( EVal ) ) return true ; EVal = fixupVariantKind ( EVal ) ; VEMCExpr :: VariantKind Variant ; const MCExpr * E = extractModifierFromExpr ( EVal , Variant ) ; if ( E ) EVal = VEMCExpr :: create ( Variant , E , getParser ( ) . getContext ( ) ) ; return false ; } </s>


Return a register that is zero iff CMP0 and CMP1 are equal . The register will have the same mode as CMP0 .


<s> bool X86DAGToDAGISel :: SelectInlineAsmMemoryOperand ( const SDValue & Op , unsigned ConstraintID , std :: vector < SDValue > & OutOps ) { SDValue Op0 , Op1 , Op2 , Op3 , Op4 ; switch ( ConstraintID ) { case InlineAsm :: Constraint_o : case InlineAsm :: Constraint_v : default : return true ; case InlineAsm :: Constraint_m : if ( ! SelectAddr ( nullptr , Op , Op0 , Op1 , Op2 , Op3 , Op4 ) ) return true ; break ; } OutOps . push_back ( Op0 ) ; OutOps . push_back ( Op1 ) ; OutOps . push_back ( Op2 ) ; OutOps . push_back ( Op3 ) ; OutOps . push_back ( Op4 ) ; return false ; } </s>

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


<s> static const char * aarch64_mangle_type ( const_tree type ) { if ( lang_hooks . types_compatible_p ( CONST_CAST_TREE ( type ) , va_list_type ) ) return "St9__va_list" ; if ( TREE_CODE ( type ) == REAL_TYPE && TYPE_PRECISION ( type ) == 16 ) return "Dh" ; if ( TYPE_NAME ( type ) != NULL ) return aarch64_mangle_builtin_type ( type ) ; return NULL ; } </s>


<s> rtx pru_expand_fp_compare ( rtx comparison , machine_mode mode ) { enum rtx_code code = GET_CODE ( comparison ) ; rtx op0 = XEXP ( comparison , 0 ) ; rtx op1 = XEXP ( comparison , 1 ) ; rtx cmp ; enum rtx_code jump_code = code ; machine_mode op_mode = GET_MODE ( op0 ) ; rtx_insn * insns ; rtx libfunc ; gcc_assert ( op_mode == DFmode || op_mode == SFmode ) ; if ( code == UNGE ) { code = LT ; jump_code = EQ ; } else if ( code == UNLE ) { code = GT ; jump_code = EQ ; } else jump_code = NE ; switch ( code ) { case EQ : libfunc = op_mode == DFmode ? eqdf_libfunc : eqsf_libfunc ; break ; case NE : libfunc = op_mode == DFmode ? nedf_libfunc : nesf_libfunc ; break ; case GT : libfunc = op_mode == DFmode ? gtdf_libfunc : gtsf_libfunc ; break ; case GE : libfunc = op_mode == DFmode ? gedf_libfunc : gesf_libfunc ; break ; case LT : libfunc = op_mode == DFmode ? ltdf_libfunc : ltsf_libfunc ; break ; case LE : libfunc = op_mode == DFmode ? ledf_libfunc : lesf_libfunc ; break ; default : gcc_unreachable ( ) ; } start_sequence ( ) ; cmp = emit_library_call_value ( libfunc , 0 , LCT_CONST , SImode , op0 , op_mode , op1 , op_mode ) ; insns = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insns , cmp , cmp , gen_rtx_fmt_ee ( code , SImode , op0 , op1 ) ) ; return gen_rtx_fmt_ee ( jump_code , mode , cmp , const0_rtx ) ; } </s>

Emit comparison instruction if necessary , returning the expression that holds the compare result in the proper mode . Return the comparison that should be used in the jump insn .


"Instr doesn't have FrameIndex operand!"

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


"Can only insert epilog into returning blocks"


<s> static rtx xtensa_function_arg_1 ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool incoming_p ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int regbase , words , max ; int * arg_words ; int regno ; arg_words = & cum -> arg_words ; regbase = ( incoming_p ? GP_ARG_FIRST : GP_OUTGOING_ARG_FIRST ) ; max = MAX_ARGS_IN_REGISTERS ; words = ( ( ( mode != BLKmode ) ? ( int ) GET_MODE_SIZE ( mode ) : int_size_in_bytes ( type ) ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; if ( type && ( TYPE_ALIGN ( type ) > BITS_PER_WORD ) ) { int align = MIN ( TYPE_ALIGN ( type ) , STACK_BOUNDARY ) / BITS_PER_WORD ; * arg_words = ( * arg_words + align - 1 ) & - align ; } if ( * arg_words + words > max ) return ( rtx ) 0 ; regno = regbase + * arg_words ; if ( cum -> incoming && regno <= A7_REG && regno + words > A7_REG ) cfun -> machine -> need_a7_copy = TARGET_WINDOWED_ABI ; return gen_rtx_REG ( mode , regno ) ; } </s>

Return an RTL expression containing the register for the given mode , or 0 if the argument is to be passed on the stack . INCOMING_P is nonzero if this is an incoming argument to the current function .


<s> ISD :: NodeType getExtendForAtomicOps ( ) const override { return ISD :: ZERO_EXTEND ; } </s>

Returns how the platform 's atomic operations are extended ( ZERO_EXTEND , SIGN_EXTEND , or ANY_EXTEND ) .


<s> static bool aarch64_shift_p ( enum rtx_code code ) { return code == ASHIFT || code == ASHIFTRT || code == LSHIFTRT ; } </s>

Return true iff CODE is a shift supported in combination with arithmetic instructions .


<s> static void init_float128_ibm ( machine_mode mode ) { if ( ! TARGET_XL_COMPAT ) { set_optab_libfunc ( add_optab , mode , "__gcc_qadd" ) ; set_optab_libfunc ( sub_optab , mode , "__gcc_qsub" ) ; set_optab_libfunc ( smul_optab , mode , "__gcc_qmul" ) ; set_optab_libfunc ( sdiv_optab , mode , "__gcc_qdiv" ) ; if ( ! ( TARGET_HARD_FLOAT && ( TARGET_FPRS || TARGET_E500_DOUBLE ) ) ) { set_optab_libfunc ( neg_optab , mode , "__gcc_qneg" ) ; set_optab_libfunc ( eq_optab , mode , "__gcc_qeq" ) ; set_optab_libfunc ( ne_optab , mode , "__gcc_qne" ) ; set_optab_libfunc ( gt_optab , mode , "__gcc_qgt" ) ; set_optab_libfunc ( ge_optab , mode , "__gcc_qge" ) ; set_optab_libfunc ( lt_optab , mode , "__gcc_qlt" ) ; set_optab_libfunc ( le_optab , mode , "__gcc_qle" ) ; set_conv_libfunc ( sext_optab , mode , SFmode , "__gcc_stoq" ) ; set_conv_libfunc ( sext_optab , mode , DFmode , "__gcc_dtoq" ) ; set_conv_libfunc ( trunc_optab , SFmode , mode , "__gcc_qtos" ) ; set_conv_libfunc ( trunc_optab , DFmode , mode , "__gcc_qtod" ) ; set_conv_libfunc ( sfix_optab , SImode , mode , "__gcc_qtoi" ) ; set_conv_libfunc ( ufix_optab , SImode , mode , "__gcc_qtou" ) ; set_conv_libfunc ( sfloat_optab , mode , SImode , "__gcc_itoq" ) ; set_conv_libfunc ( ufloat_optab , mode , SImode , "__gcc_utoq" ) ; } if ( ! ( TARGET_HARD_FLOAT && TARGET_FPRS ) ) set_optab_libfunc ( unord_optab , mode , "__gcc_qunord" ) ; } else { set_optab_libfunc ( add_optab , mode , "_xlqadd" ) ; set_optab_libfunc ( sub_optab , mode , "_xlqsub" ) ; set_optab_libfunc ( smul_optab , mode , "_xlqmul" ) ; set_optab_libfunc ( sdiv_optab , mode , "_xlqdiv" ) ; } if ( mode == IFmode ) { set_conv_libfunc ( sext_optab , mode , SDmode , "__dpd_extendsdtf2" ) ; set_conv_libfunc ( sext_optab , mode , DDmode , "__dpd_extendddtf2" ) ; set_conv_libfunc ( trunc_optab , mode , TDmode , "__dpd_trunctftd2" ) ; set_conv_libfunc ( trunc_optab , SDmode , mode , "__dpd_trunctfsd2" ) ; set_conv_libfunc ( trunc_optab , DDmode , mode , "__dpd_trunctfdd2" ) ; set_conv_libfunc ( sext_optab , TDmode , mode , "__dpd_extendtdtf2" ) ; if ( TARGET_POWERPC64 ) { set_conv_libfunc ( sfix_optab , TImode , mode , "__fixtfti" ) ; set_conv_libfunc ( ufix_optab , TImode , mode , "__fixunstfti" ) ; set_conv_libfunc ( sfloat_optab , mode , TImode , "__floattitf" ) ; set_conv_libfunc ( ufloat_optab , mode , TImode , "__floatuntitf" ) ; } } } </s>

Set up AIX/Darwin/64-bit Linux quad floating point routines .


<s> void SITargetLowering :: AdjustInstrPostInstrSelection ( MachineInstr * MI , SDNode * Node ) const { const SIInstrInfo * TII = static_cast < const SIInstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; MachineRegisterInfo & MRI = MI -> getParent ( ) -> getParent ( ) -> getRegInfo ( ) ; TII -> legalizeOperands ( MI ) ; if ( TII -> isMIMG ( MI -> getOpcode ( ) ) ) { unsigned VReg = MI -> getOperand ( 0 ) . getReg ( ) ; unsigned Writemask = MI -> getOperand ( 1 ) . getImm ( ) ; unsigned BitsSet = 0 ; for ( unsigned i = 0 ; i < 4 ; ++ i ) BitsSet += Writemask & ( 1 << i ) ? 1 : 0 ; const TargetRegisterClass * RC ; switch ( BitsSet ) { default : return ; case 1 : RC = & AMDGPU :: VGPR_32RegClass ; break ; case 2 : RC = & AMDGPU :: VReg_64RegClass ; break ; case 3 : RC = & AMDGPU :: VReg_96RegClass ; break ; } unsigned NewOpcode = TII -> getMaskedMIMGOp ( MI -> getOpcode ( ) , BitsSet ) ; MI -> setDesc ( TII -> get ( NewOpcode ) ) ; MRI . setRegClass ( VReg , RC ) ; return ; } int NoRetAtomicOp = AMDGPU :: getAtomicNoRetOp ( MI -> getOpcode ( ) ) ; if ( NoRetAtomicOp != - 1 ) { if ( ! Node -> hasAnyUseOfValue ( 0 ) ) { MI -> setDesc ( TII -> get ( NoRetAtomicOp ) ) ; MI -> RemoveOperand ( 0 ) ; } return ; } } </s>

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


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

Get a TargetTransformInfo implementation for the target .


<s> void ARMTargetLowering :: HandleByVal ( CCState * State , unsigned & Size , Align Alignment ) const { Alignment = std :: max ( Alignment , Align ( 4 ) ) ; unsigned Reg = State -> AllocateReg ( GPRArgRegs ) ; if ( ! Reg ) return ; unsigned AlignInRegs = Alignment . value ( ) / 4 ; unsigned Waste = ( ARM :: R4 - Reg ) % AlignInRegs ; for ( unsigned i = 0 ; i < Waste ; ++ i ) Reg = State -> AllocateReg ( GPRArgRegs ) ; if ( ! Reg ) return ; unsigned Excess = 4 * ( ARM :: R4 - Reg ) ; const unsigned NSAAOffset = State -> getNextStackOffset ( ) ; if ( NSAAOffset != 0 && Size > Excess ) { while ( State -> AllocateReg ( GPRArgRegs ) ) ; return ; } unsigned ByValRegBegin = Reg ; unsigned ByValRegEnd = std :: min < unsigned > ( Reg + Size / 4 , ARM :: R4 ) ; State -> addInRegsParamInfo ( ByValRegBegin , ByValRegEnd ) ; for ( unsigned i = Reg + 1 ; i != ByValRegEnd ; ++ i ) State -> AllocateReg ( GPRArgRegs ) ; Size = std :: max < int > ( Size - Excess , 0 ) ; } </s>

Target-specific cleanup for formal ByVal parameters .


<s> int riscv_address_insns ( rtx x , machine_mode mode , bool might_split_p ) { struct riscv_address_info addr ; int n = 1 ; if ( ! riscv_classify_address ( & addr , x , mode , false ) ) { return 3 ; } if ( mode != BLKmode && might_split_p ) n += ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; if ( addr . type == ADDRESS_LO_SUM ) n += riscv_symbol_insns ( addr . symbol_type ) - 1 ; return n ; } </s>

Return the number of instructions needed to load or store a value of mode MODE at address X . Return 0 if X is n't valid for MODE . Assume that multiword moves may need to be split into word moves if MIGHT_SPLIT_P , otherwise assume that a single load or store is enough .


<s>
void
TeeRISCAsmPrinter
::
emitFrameDirective
(
)
{
if
(
!
OutStreamer
.
hasRawTextSupport
(
)
)
return
;
const
TargetRegisterInfo
&
RI
=
*
TM
.
getRegisterInfo
(
)
;
unsigned
stkReg
=
RI
.
getFrameRegister
(
*
MF
)
;
unsigned
retReg
=
RI
.
getRARegister
(
)
;
unsigned
stkSze
=
MF
->
getFrameInfo
(
)
->
getStackSize
(
)
;
OutStreamer
.
EmitRawText
(
"\t.frame\t"
+
Twine
(
TeeRISCInstPrinter
::
getRegisterName
(
stkReg
)
)
+
", "
+
Twine
(
stkSze
)
+
", "
+
Twine
(
TeeRISCInstPrinter
::
getRegisterName
(
retReg
)
)
)
;
}
</s>

TeeRISC
TeeRISC
"\t.frame\t"
TeeRISC
", "
", "
TeeRISC


"Intrinsic instructions can't commute operand 1"

Returns an adjusted FMA opcode that must be used in FMA instruction that performs the same computations as the given MI but which has the operands SrcOpIdx1 and SrcOpIdx2 commuted .


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

Check whether the given instruction may need relaxation .


"\n;; Failed condition for casesi_<mode>_sequence\n\n"

Perform some extra checks on operands of casesi_ < mode > _sequence . Not all operand dependencies can be described by means of predicates . This function performs left over checks and should always return true . Returning false means that someone changed the casesi expander but did not adjust casesi_ < mode > _sequence .


<s> ScheduleHazardRecognizer * ARMBaseInstrInfo :: CreateTargetPostRAHazardRecognizer ( const InstrItineraryData * II , const ScheduleDAG * DAG ) const { if ( Subtarget . isThumb2 ( ) || Subtarget . hasVFP2 ( ) ) return ( ScheduleHazardRecognizer * ) new ARMHazardRecognizer ( II , DAG ) ; return TargetInstrInfo :: CreateTargetPostRAHazardRecognizer ( II , DAG ) ; } </s>

Allocate and return a hazard recognizer to use for by non-scheduling passes .


<s>
void
X86InstrInfo
::
insertSelect
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
,
DebugLoc
DL
,
unsigned
DstReg
,
ArrayRef
<
MachineOperand
>
Cond
,
unsigned
TrueReg
,
unsigned
FalseReg
)
const
{
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
assert
(
Cond
.
size
(
)
==
1
&&
"Invalid Cond array"
)
;
unsigned
Opc
=
getCMovFromCond
(
(
X86
::
CondCode
)
Cond
[
0
]
.
getImm
(
)
,
MRI
.
getRegClass
(
DstReg
)
->
getSize
(
)
,
false
)
;
BuildMI
(
MBB
,
I
,
DL
,
get
(
Opc
)
,
DstReg
)
.
addReg
(
FalseReg
)
.
addReg
(
TrueReg
)
;
}
</s>

Insert a select instruction into MBB before I that will copy TrueReg to DstReg when Cond is true , and FalseReg to DstReg when Cond is false .


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

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


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

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


<s> bool Z80oldExpandPseudo :: runOnMachineFunction ( MachineFunction & MF ) { getAnalysis < LiveIntervals > ( ) . addKillFlags ( & getAnalysis < VirtRegMap > ( ) ) ; TII = MF . getSubtarget ( ) . getInstrInfo ( ) ; bool Modified = false ; for ( auto & MBB : MF ) { Modified |= ExpandMBB ( MBB ) ; } return Modified ; } </s>

runOnMachineFunction - Emit the function body .


<s> bool M680x0RegisterInfo :: canRealignStack ( const MachineFunction & MF ) const { if ( ! TargetRegisterInfo :: canRealignStack ( MF ) ) return false ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const MachineRegisterInfo * MRI = & MF . getRegInfo ( ) ; if ( ! MRI -> canReserveReg ( FramePtr ) ) return false ; if ( CantUseSP ( MFI ) ) return MRI -> canReserveReg ( BasePtr ) ; return true ; } </s>

True if the stack can be realigned for the target .


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

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


<s> static int sched_get_attr_size_int ( rtx_insn * insn ) { int size ; switch ( get_attr_type ( insn ) ) { case TYPE_IGNORE : gcc_unreachable ( ) ; return 0 ; case TYPE_MUL_L : size = 2 ; break ; default : size = 1 ; break ; } switch ( get_attr_opx_type ( insn ) ) { case OPX_TYPE_NONE : case OPX_TYPE_RN : case OPX_TYPE_FPN : case OPX_TYPE_MEM1 : case OPX_TYPE_MEM234 : case OPY_TYPE_IMM_Q : break ; case OPX_TYPE_MEM5 : case OPX_TYPE_MEM6 : case OPX_TYPE_MEM7 : case OPY_TYPE_IMM_W : ++ size ; break ; case OPY_TYPE_IMM_L : size += 2 ; break ; default : gcc_unreachable ( ) ; } switch ( get_attr_opy_type ( insn ) ) { case OPY_TYPE_NONE : case OPY_TYPE_RN : case OPY_TYPE_FPN : case OPY_TYPE_MEM1 : case OPY_TYPE_MEM234 : case OPY_TYPE_IMM_Q : break ; case OPY_TYPE_MEM5 : case OPY_TYPE_MEM6 : case OPY_TYPE_MEM7 : case OPY_TYPE_IMM_W : ++ size ; break ; case OPY_TYPE_IMM_L : size += 2 ; break ; default : gcc_unreachable ( ) ; } if ( size > 3 ) { gcc_assert ( ! reload_completed ) ; size = 3 ; } return size ; } </s>


<s> unsigned AMDGPUTargetLowering :: ComputeNumSignBitsForTargetNode ( SDValue Op , const APInt & DemandedElts , const SelectionDAG & DAG , unsigned Depth ) const { switch ( Op . getOpcode ( ) ) { case AMDGPUISD :: BFE_I32 : { ConstantSDNode * Width = dyn_cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; if ( ! Width ) return 1 ; unsigned SignBits = 32 - Width -> getZExtValue ( ) + 1 ; if ( ! isNullConstant ( Op . getOperand ( 1 ) ) ) return SignBits ; unsigned Op0SignBits = DAG . ComputeNumSignBits ( Op . getOperand ( 0 ) , Depth + 1 ) ; return std :: max ( SignBits , Op0SignBits ) ; } case AMDGPUISD :: BFE_U32 : { ConstantSDNode * Width = dyn_cast < ConstantSDNode > ( Op . getOperand ( 2 ) ) ; return Width ? 32 - ( Width -> getZExtValue ( ) & 0x1f ) : 1 ; } case AMDGPUISD :: CARRY : case AMDGPUISD :: BORROW : return 31 ; case AMDGPUISD :: BUFFER_LOAD_BYTE : return 25 ; case AMDGPUISD :: BUFFER_LOAD_SHORT : return 17 ; case AMDGPUISD :: BUFFER_LOAD_UBYTE : return 24 ; case AMDGPUISD :: BUFFER_LOAD_USHORT : return 16 ; case AMDGPUISD :: FP_TO_FP16 : return 16 ; default : return 1 ; } } </s>

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


<s> static rtx arc_function_arg ( cumulative_args_t cum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int arg_num = * cum ; rtx ret ; const char * debstr ATTRIBUTE_UNUSED ; arg_num = ROUND_ADVANCE_CUM ( arg_num , arg . mode , arg . type ) ; if ( arg . end_marker_p ( ) ) { ret = const0_rtx ; debstr = "<0>" ; } else if ( GPR_REST_ARG_REGS ( arg_num ) > 0 ) { ret = gen_rtx_REG ( arg . mode , arg_num ) ; debstr = reg_names [ arg_num ] ; } else { ret = NULL_RTX ; debstr = "memory" ; } return ret ; } </s>

On the ARC the first MAX_ARC_PARM_REGS args are normally in registers and the rest are pushed .


<s>
static
rtx
nds32_expand_builtin_reg_ftype_imm
(
enum
insn_code
icode
,
tree
exp
,
rtx
target
)
{
struct
expand_operand
ops
[
2
]
;
tree
arg0
;
rtx
value0
;
arg0
=
CALL_EXPR_ARG
(
exp
,
0
)
;
value0
=
expand_normal
(
arg0
)
;
create_output_operand
(
&
ops
[
0
]
,
target
,
TYPE_MODE
(
TREE_TYPE
(
exp
)
)
)
;
create_input_operand
(
&
ops
[
1
]
,
value0
,
TYPE_MODE
(
TREE_TYPE
(
arg0
)
)
)
;
if
(
!
maybe_expand_insn
(
icode
,
2
,
ops
)
)
error
(
"invalid argument to built-in function"
)
;
return
target
;
}
</s>

Function to expand builtin function for ' [ ( set ( reg ) ( unspec_volatile [ ( imm ) ] ) ) ] ' .


<s> void RISCVELFTargetObjectFile :: getModuleMetadata ( Module & M ) { SmallVector < Module :: ModuleFlagEntry , 8 > ModuleFlags ; M . getModuleFlagsMetadata ( ModuleFlags ) ; for ( const auto & MFE : ModuleFlags ) { StringRef Key = MFE . Key -> getString ( ) ; if ( Key == "SmallDataLimit" ) { SSThreshold = mdconst :: extract < ConstantInt > ( MFE . Val ) -> getZExtValue ( ) ; break ; } } } </s>

Get the module-level metadata that the platform cares about .


<s> rtx s390_get_thread_pointer ( void ) { rtx tp = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_get_thread_pointer ( Pmode , tp ) ) ; mark_reg_pointer ( tp , BITS_PER_WORD ) ; return tp ; } </s>

Load the thread pointer into a register .


<s> void X86WinAllocaExpander :: lower ( MachineInstr * MI , Lowering L ) { DebugLoc DL = MI -> getDebugLoc ( ) ; MachineBasicBlock * MBB = MI -> getParent ( ) ; MachineBasicBlock :: iterator I = * MI ; int64_t Amount = getWinAllocaAmount ( MI , MRI ) ; if ( Amount == 0 ) { MI -> eraseFromParent ( ) ; return ; } bool Is64Bit = STI -> is64Bit ( ) ; bool Is64BitAlloca = MI -> getOpcode ( ) == X86 :: WIN_ALLOCA_64 ; assert ( SlotSize == 4 || SlotSize == 8 ) ; switch ( L ) { case TouchAndSub : { assert ( Amount >= SlotSize ) ; unsigned RegA = Is64Bit ? X86 :: RAX : X86 :: EAX ; BuildMI ( * MBB , I , DL , TII -> get ( Is64Bit ? X86 :: PUSH64r : X86 :: PUSH32r ) ) . addReg ( RegA , RegState :: Undef ) ; Amount -= SlotSize ; if ( ! Amount ) break ; LLVM_FALLTHROUGH ; } case Sub : assert ( Amount > 0 ) ; if ( Amount == SlotSize ) { unsigned RegA = Is64Bit ? X86 :: RAX : X86 :: EAX ; BuildMI ( * MBB , I , DL , TII -> get ( Is64Bit ? X86 :: PUSH64r : X86 :: PUSH32r ) ) . addReg ( RegA , RegState :: Undef ) ; } else { BuildMI ( * MBB , I , DL , TII -> get ( getSubOpcode ( Is64BitAlloca , Amount ) ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } break ; case Probe : if ( ! NoStackArgProbe ) { unsigned RegA = Is64BitAlloca ? X86 :: RAX : X86 :: EAX ; BuildMI ( * MBB , MI , DL , TII -> get ( TargetOpcode :: COPY ) , RegA ) . addReg ( MI -> getOperand ( 0 ) . getReg ( ) ) ; STI -> getFrameLowering ( ) -> emitStackProbe ( * MBB -> getParent ( ) , * MBB , MI , DL , false ) ; } else { BuildMI ( * MBB , I , DL , TII -> get ( Is64BitAlloca ? X86 :: SUB64rr : X86 :: SUB32rr ) , StackPtr ) . addReg ( StackPtr ) . addReg ( MI -> getOperand ( 0 ) . getReg ( ) ) ; } break ; } unsigned AmountReg = MI -> getOperand ( 0 ) . getReg ( ) ; MI -> eraseFromParent ( ) ; if ( MRI -> use_empty ( AmountReg ) ) if ( MachineInstr * AmountDef = MRI -> getUniqueVRegDef ( AmountReg ) ) AmountDef -> eraseFromParent ( ) ; } </s>


<s> static HOST_WIDE_INT spu_constant_alignment ( const_tree , HOST_WIDE_INT align ) { return MAX ( align , 128 ) ; } </s>

Implement TARGET_CONSTANT_ALIGNMENT . Make all static objects 16-byte aligned . This allows us to assume they are also padded to 16 bytes , which means we can use a single load or store instruction to access them .


<s> void Z80oldInstPrinterBase :: printInst ( const MCInst * MI , raw_ostream & OS , StringRef Annot , const MCSubtargetInfo & STI ) { printInstruction ( MI , OS ) ; printAnnotation ( OS , Annot ) ; } </s>

Print the specified MCInst to the specified raw_ostream .


Output assembler code to FILE to increment profiler label # LABELNO for profiling a function entry .


<s> BitVector MandarinRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; const TargetFrameLowering * TFI = MF . getTarget ( ) . getFrameLowering ( ) ; Reserved . set ( MD :: R30 ) ; if ( TFI -> hasFP ( MF ) ) Reserved . set ( MD :: R31 ) ; return Reserved ; } </s>

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


<s> bool HSAILAsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { SetupMachineFunction ( MF ) ; SmallString < 256 > Name ; getHSAILMangledName ( Name , MF . getFunction ( ) ) ; CurrentFnSym = OutContext . getOrCreateSymbol ( Name ) ; OutStreamer -> SwitchSection ( getObjFileLowering ( ) . getTextSection ( ) ) ; EmitFunctionBody ( ) ; return false ; } </s>


<s> bool X86FixupSetCCPass :: runOnMachineFunction ( MachineFunction & MF ) { bool Changed = false ; MRI = & MF . getRegInfo ( ) ; TII = MF . getSubtarget < X86Subtarget > ( ) . getInstrInfo ( ) ; SmallVector < MachineInstr * , 4 > ToErase ; for ( auto & MBB : MF ) { MachineInstr * FlagsDefMI = nullptr ; for ( auto & MI : MBB ) { if ( MI . definesRegister ( X86 :: EFLAGS ) ) FlagsDefMI = & MI ; if ( MI . getOpcode ( ) != X86 :: SETCCr ) continue ; MachineInstr * ZExt = nullptr ; for ( auto & Use : MRI -> use_instructions ( MI . getOperand ( 0 ) . getReg ( ) ) ) if ( Use . getOpcode ( ) == X86 :: MOVZX32rr8 ) ZExt = & Use ; if ( ! ZExt ) continue ; if ( ! FlagsDefMI ) continue ; if ( FlagsDefMI -> readsRegister ( X86 :: EFLAGS ) ) continue ; const TargetRegisterClass * RC = MF . getSubtarget < X86Subtarget > ( ) . is64Bit ( ) ? & X86 :: GR32RegClass : & X86 :: GR32_ABCDRegClass ; if ( ! MRI -> constrainRegClass ( ZExt -> getOperand ( 0 ) . getReg ( ) , RC ) ) { continue ; } ++ NumSubstZexts ; Changed = true ; Register ZeroReg = MRI -> createVirtualRegister ( RC ) ; BuildMI ( MBB , FlagsDefMI , MI . getDebugLoc ( ) , TII -> get ( X86 :: MOV32r0 ) , ZeroReg ) ; BuildMI ( * ZExt -> getParent ( ) , ZExt , ZExt -> getDebugLoc ( ) , TII -> get ( X86 :: INSERT_SUBREG ) , ZExt -> getOperand ( 0 ) . getReg ( ) ) . addReg ( ZeroReg ) . addReg ( MI . getOperand ( 0 ) . getReg ( ) ) . addImm ( X86 :: sub_8bit ) ; ToErase . push_back ( ZExt ) ; } } for ( auto & I : ToErase ) I -> eraseFromParent ( ) ; return Changed ; } </s>


<s> SDValue CreateLiveInRegister ( SelectionDAG & DAG , const TargetRegisterClass * RC , Register Reg , EVT VT ) const { return CreateLiveInRegister ( DAG , RC , Reg , VT , SDLoc ( DAG . getEntryNode ( ) ) ) ; } </s>

Helper function that adds Reg to the LiveIn list of the DAG 's MachineFunction .


<s>
ScheduleHazardRecognizer
*
SPUInstrInfo
::
CreateTargetHazardRecognizer
(
const
TargetMachine
*
TM
,
const
ScheduleDAG
*
DAG
)
const
{
const
TargetInstrInfo
*
TII
=
TM
->
getInstrInfo
(
)
;
assert
(
TII
&&
"No InstrInfo?"
)
;
return
new
SPUHazardRecognizer
(
*
TII
)
;
}
</s>

Allocate and return a hazard recognizer to use for this target when scheduling the machine instructions before register allocation .


<s> void VEFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; DebugLoc dl = MBBI -> getDebugLoc ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; uint64_t NumBytes = MFI . getStackSize ( ) ; emitEpilogueInsns ( MF , MBB , MBBI , NumBytes , true ) ; } </s>


<s> bool legitimate_pic_operand_p ( rtx x ) { rtx inner ; switch ( GET_CODE ( x ) ) { case CONST : inner = XEXP ( x , 0 ) ; if ( GET_CODE ( inner ) == PLUS && CONST_INT_P ( XEXP ( inner , 1 ) ) ) inner = XEXP ( inner , 0 ) ; if ( GET_CODE ( inner ) == UNSPEC ) switch ( XINT ( inner , 1 ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : case UNSPEC_PLTOFF : return TARGET_64BIT ; case UNSPEC_TPOFF : x = XVECEXP ( inner , 0 , 0 ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_EXEC ) ; case UNSPEC_MACHOPIC_OFFSET : return legitimate_pic_address_disp_p ( x ) ; default : return false ; } case SYMBOL_REF : case LABEL_REF : return legitimate_pic_address_disp_p ( x ) ; default : return true ; } } </s>

Return true if OP is a legitimate general operand when generating PIC code . It is given that flag_pic is on and that OP satisfies CONSTANT_P or is a CONST_DOUBLE .


<s> bool nios2_symbol_ref_in_small_data_p ( rtx sym ) { tree decl ; gcc_assert ( GET_CODE ( sym ) == SYMBOL_REF ) ; decl = SYMBOL_REF_DECL ( sym ) ; if ( SYMBOL_REF_TLS_MODEL ( sym ) != 0 ) return false ; switch ( nios2_gpopt_option ) { case gpopt_none : return false ; case gpopt_local : if ( decl && DECL_SECTION_NAME ( decl ) ) return nios2_small_section_name_p ( DECL_SECTION_NAME ( decl ) ) ; return ( SYMBOL_REF_SMALL_P ( sym ) && ! SYMBOL_REF_EXTERNAL_P ( sym ) && ! ( decl && DECL_WEAK ( decl ) ) ) ; case gpopt_global : return SYMBOL_REF_SMALL_P ( sym ) ; case gpopt_data : return ! SYMBOL_REF_FUNCTION_P ( sym ) ; case gpopt_all : return true ; default : return false ; } } </s>

Return true if symbol is in small data section .


<s>
StringRef
getPassName
(
)
const
override
{
return
"M680x0 MOVEM collapser pass"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> static rtx_code_label * ix86_expand_sse_compare_and_jump ( enum rtx_code code , rtx op0 , rtx op1 , bool swap_operands ) { machine_mode fpcmp_mode = ix86_fp_compare_mode ( code ) ; rtx_code_label * label ; rtx tmp ; if ( swap_operands ) std :: swap ( op0 , op1 ) ; label = gen_label_rtx ( ) ; tmp = gen_rtx_REG ( fpcmp_mode , FLAGS_REG ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_COMPARE ( fpcmp_mode , op0 , op1 ) ) ) ; tmp = gen_rtx_fmt_ee ( code , VOIDmode , tmp , const0_rtx ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; tmp = emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp ) ) ; JUMP_LABEL ( tmp ) = label ; return label ; } </s>

Expands a comparison of OP0 with OP1 using comparison code CODE , swapping the operands if SWAP_OPERANDS is true . The expanded code is a forward jump to a newly created label in case the comparison is true . The generated label rtx is returned .


<s> bool ARMTargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT , bool ForCodeSize ) const { if ( ! Subtarget -> hasVFP3Base ( ) ) return false ; if ( VT == MVT :: f16 && Subtarget -> hasFullFP16 ( ) ) return ARM_AM :: getFP16Imm ( Imm ) != - 1 ; if ( VT == MVT :: f32 && Subtarget -> hasFullFP16 ( ) && ARM_AM :: getFP32FP16Imm ( Imm ) != - 1 ) return true ; if ( VT == MVT :: f32 ) return ARM_AM :: getFP32Imm ( Imm ) != - 1 ; if ( VT == MVT :: f64 && Subtarget -> hasFP64 ( ) ) return ARM_AM :: getFP64Imm ( Imm ) != - 1 ; return false ; } </s>

Returns true if the target can instruction select the specified FP immediate natively .


<s> bool isLittleEndian ( ) const { return IsLittleEndian ; } </s>

Tests whether the target triple is little endian .


"Unhandled instruction encoding format!"

Targets should implement this to emit instructions .


<s> Register getStackAddress ( uint64_t Size , int64_t Offset , MachinePointerInfo & MPO ) override { MachineFunction & MF = MIRBuilder . getMF ( ) ; LLT p0 = LLT :: pointer ( 0 , 64 ) ; LLT s64 = LLT :: scalar ( 64 ) ; if ( IsTailCall ) { Offset += FPDiff ; int FI = MF . getFrameInfo ( ) . CreateFixedObject ( Size , Offset , true ) ; auto FIReg = MIRBuilder . buildFrameIndex ( p0 , FI ) ; MPO = MachinePointerInfo :: getFixedStack ( MF , FI ) ; return FIReg . getReg ( 0 ) ; } auto SPReg = MIRBuilder . buildCopy ( p0 , Register ( AArch64 :: SP ) ) ; auto OffsetReg = MIRBuilder . buildConstant ( s64 , Offset ) ; auto AddrReg = MIRBuilder . buildPtrAdd ( p0 , SPReg , OffsetReg ) ; MPO = MachinePointerInfo :: getStack ( MF , Offset ) ; return AddrReg . getReg ( 0 ) ; } </s>

Materialize a VReg containing the address of the specified stack-based object .


<s> static int pdp11_register_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t c1 , reg_class_t c2 ) { return move_costs [ ( int ) c1 ] [ ( int ) c2 ] ; } </s>

Register to register moves are cheap if both are general registers .


<s> static void mips_add_cfa_restore ( rtx reg ) { mips_epilogue . cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , reg , mips_epilogue . cfa_restores ) ; } </s>

Record that the epilogue has restored call-saved register REG .


<s> static bool mcore_legitimate_index_p ( machine_mode mode , const_rtx op ) { if ( CONST_INT_P ( op ) ) { if ( GET_MODE_SIZE ( mode ) >= 4 && ( ( ( unsigned HOST_WIDE_INT ) INTVAL ( op ) ) % 4 ) == 0 && ( ( unsigned HOST_WIDE_INT ) INTVAL ( op ) ) <= ( unsigned HOST_WIDE_INT ) 64 - GET_MODE_SIZE ( mode ) ) return true ; if ( GET_MODE_SIZE ( mode ) == 2 && ( ( ( unsigned HOST_WIDE_INT ) INTVAL ( op ) ) % 2 ) == 0 && ( ( unsigned HOST_WIDE_INT ) INTVAL ( op ) ) <= 30 ) return true ; if ( GET_MODE_SIZE ( mode ) == 1 && ( ( unsigned HOST_WIDE_INT ) INTVAL ( op ) ) <= 15 ) return true ; } return false ; } </s>

A legitimate index for a QI is 0 .. 15 , for HI is 0 .. 30 , for SI is 0 .. 60 , and for DI is 0 .. 56 because we use two SI loads , etc .


<s> bool X86TargetLowering :: isShuffleMaskLegal ( const SmallVectorImpl < int > & M , EVT VT ) const { if ( ! VT . isSimple ( ) ) return false ; if ( VT . getSimpleVT ( ) . getScalarType ( ) == MVT :: i1 ) return false ; if ( VT . getSimpleVT ( ) . getSizeInBits ( ) == 64 ) return false ; return isTypeLegal ( VT . getSimpleVT ( ) ) ; } </s>

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


<s> void TriCoreFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { } </s>


<s> void RISCVFrameLowering :: determineCalleeSaves ( MachineFunction & MF , BitVector & SavedRegs , RegScavenger * RS ) const { TargetFrameLowering :: determineCalleeSaves ( MF , SavedRegs , RS ) ; if ( hasFP ( MF ) ) { SavedRegs . set ( RISCV :: X1 ) ; SavedRegs . set ( RISCV :: X8 ) ; } } </s>

This method determines which of the registers reported by TargetRegisterInfo : :getCalleeSavedRegs ( ) should actually get saved .


<s> static tree riscv_build_function_type ( enum riscv_function_type type ) { static tree types [ ( int ) RISCV_MAX_FTYPE_MAX ] ; if ( types [ ( int ) type ] == NULL_TREE ) switch ( type ) { case RISCV_FTYPE_NAME ## NUM ARGS : \ types [ ( int ) type ] \ = build_function_type_list ( RISCV_FTYPE_ATYPES ## NUM ARGS , \ NULL_TREE ) ; \ break ; default : gcc_unreachable ( ) ; } return types [ ( int ) type ] ; } </s>

Return the function type associated with function prototype TYPE .


<s> bool TriCoreTargetLowering :: 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 ) ; if ( ! CCInfo . CheckReturn ( Outs , RetCC_TriCore ) ) { return false ; } if ( CCInfo . getNextStackOffset ( ) != 0 && isVarArg ) { return false ; } return true ; } </s>

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

TriCore TriCore ISD::OutputArg 16 TriCore 0


<s> std :: pair < unsigned , const TargetRegisterClass * > LM32TargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , MVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'r' : return std :: make_pair ( 0U , & LM32 :: GPRRegClass ) ; case 'd' : case 'y' : case 'f' : if ( VT == MVT :: f32 ) return std :: make_pair ( 0U , & LM32 :: GPRRegClass ) ; } } return TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> bool ARMInstrInfo :: isPredicated ( const MachineInstr * MI ) const { int PIdx = MI -> findFirstPredOperandIdx ( ) ; return PIdx != - 1 && MI -> getOperand ( PIdx ) . getImm ( ) != ARMCC :: AL ; } </s>

Returns true if the instruction is already predicated .


<s> bool SILowerControlFlowPass :: runOnMachineFunction ( MachineFunction & MF ) { TII = MF . getTarget ( ) . getInstrInfo ( ) ; TRI = MF . getTarget ( ) . getRegisterInfo ( ) ; bool HaveKill = false ; bool NeedWQM = false ; unsigned Depth = 0 ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { MachineBasicBlock & MBB = * BI ; for ( MachineBasicBlock :: iterator I = MBB . begin ( ) , Next = llvm :: next ( I ) ; I != MBB . end ( ) ; I = Next ) { Next = llvm :: next ( I ) ; MachineInstr & MI = * I ; switch ( MI . getOpcode ( ) ) { default : break ; case AMDGPU :: SI_IF : ++ Depth ; If ( MI ) ; break ; case AMDGPU :: SI_ELSE : Else ( MI ) ; break ; case AMDGPU :: SI_BREAK : Break ( MI ) ; break ; case AMDGPU :: SI_IF_BREAK : IfBreak ( MI ) ; break ; case AMDGPU :: SI_ELSE_BREAK : ElseBreak ( MI ) ; break ; case AMDGPU :: SI_LOOP : ++ Depth ; Loop ( MI ) ; break ; case AMDGPU :: SI_END_CF : if ( -- Depth == 0 && HaveKill ) { SkipIfDead ( MI ) ; HaveKill = false ; } EndCf ( MI ) ; break ; case AMDGPU :: SI_KILL : if ( Depth == 0 ) SkipIfDead ( MI ) ; else HaveKill = true ; Kill ( MI ) ; break ; case AMDGPU :: S_BRANCH : Branch ( MI ) ; break ; case AMDGPU :: SI_INDIRECT_SRC : IndirectSrc ( MI ) ; break ; case AMDGPU :: SI_INDIRECT_DST_V2 : case AMDGPU :: SI_INDIRECT_DST_V4 : case AMDGPU :: SI_INDIRECT_DST_V8 : case AMDGPU :: SI_INDIRECT_DST_V16 : IndirectDst ( MI ) ; break ; case AMDGPU :: V_INTERP_P1_F32 : case AMDGPU :: V_INTERP_P2_F32 : case AMDGPU :: V_INTERP_MOV_F32 : NeedWQM = true ; break ; } } } if ( NeedWQM ) { MachineBasicBlock & MBB = MF . front ( ) ; BuildMI ( MBB , MBB . getFirstNonPHI ( ) , DebugLoc ( ) , TII -> get ( AMDGPU :: S_WQM_B64 ) , AMDGPU :: EXEC ) . addReg ( AMDGPU :: EXEC ) ; } return true ; } </s>

runOnMachineFunction - Emit the function body .

R600 SI 0 SI SI SI SI SI SI SI 0 SI 0 SI SI SI SI SI


<s> bool SIFoldOperands :: runOnMachineFunction ( MachineFunction & MF ) { if ( skipFunction ( MF . getFunction ( ) ) ) return false ; MRI = & MF . getRegInfo ( ) ; ST = & MF . getSubtarget < GCNSubtarget > ( ) ; TII = ST -> getInstrInfo ( ) ; TRI = & TII -> getRegisterInfo ( ) ; const SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; bool IsIEEEMode = MFI -> getMode ( ) . IEEE ; bool HasNSZ = MFI -> hasNoSignedZerosFPMath ( ) ; for ( MachineBasicBlock * MBB : depth_first ( & MF ) ) { MachineBasicBlock :: iterator I , Next ; for ( I = MBB -> begin ( ) ; I != MBB -> end ( ) ; I = Next ) { Next = std :: next ( I ) ; MachineInstr & MI = * I ; tryFoldInst ( TII , & MI ) ; if ( ! TII -> isFoldableCopy ( MI ) ) { if ( IsIEEEMode || ( ! HasNSZ && ! MI . getFlag ( MachineInstr :: FmNsz ) ) || ! tryFoldOMod ( MI ) ) tryFoldClamp ( MI ) ; continue ; } MachineOperand & OpToFold = MI . getOperand ( 1 ) ; bool FoldingImm = OpToFold . isImm ( ) || OpToFold . isFI ( ) ; if ( ! FoldingImm && ! OpToFold . isReg ( ) ) continue ; if ( OpToFold . isReg ( ) && ! TargetRegisterInfo :: isVirtualRegister ( OpToFold . getReg ( ) ) ) continue ; MachineOperand & Dst = MI . getOperand ( 0 ) ; if ( Dst . isReg ( ) && ! TargetRegisterInfo :: isVirtualRegister ( Dst . getReg ( ) ) ) continue ; foldInstOperand ( MI , OpToFold ) ; } } return false ; } </s>


<s> int pdp11_shift_length ( rtx * operands , machine_mode m , int code , bool simple_operand_p ) { int shift_size ; shift_size = simple_operand_p ? 2 : 4 ; if ( m == E_SImode ) shift_size *= 2 ; if ( CONST_INT_P ( operands [ 2 ] ) && pdp11_small_shift ( INTVAL ( operands [ 2 ] ) ) ) shift_size *= INTVAL ( operands [ 2 ] ) ; else shift_size += 4 ; if ( code == LSHIFTRT ) shift_size += 2 ; return shift_size ; } </s>

Figure out the length of the instructions that will be produced for the given operands by pdp11_assemble_shift above .


<s>
void
WebAssemblyRegisterInfo
::
eliminateFrameIndex
(
MachineBasicBlock
::
iterator
II
,
int
SPAdj
,
unsigned
FIOperandNum
,
RegScavenger
*
)
const
{
assert
(
SPAdj
==
0
)
;
MachineInstr
&
MI
=
*
II
;
MachineBasicBlock
&
MBB
=
*
MI
.
getParent
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
int
FrameIndex
=
MI
.
getOperand
(
FIOperandNum
)
.
getIndex
(
)
;
const
MachineFrameInfo
&
MFI
=
*
MF
.
getFrameInfo
(
)
;
int64_t
FrameOffset
=
MFI
.
getStackSize
(
)
+
MFI
.
getObjectOffset
(
FrameIndex
)
;
if
(
MI
.
mayLoadOrStore
(
)
)
{
assert
(
FrameOffset
>=
0
&&
MI
.
getOperand
(
1
)
.
getImm
(
)
>=
0
)
;
int64_t
Offset
=
MI
.
getOperand
(
1
)
.
getImm
(
)
+
FrameOffset
;
if
(
static_cast
<
uint64_t
>
(
Offset
)
>
std
::
numeric_limits
<
uint32_t
>
::
max
(
)
)
{
report_fatal_error
(
"Memory offset field overflow"
)
;
}
MI
.
getOperand
(
1
)
.
setImm
(
Offset
)
;
MI
.
getOperand
(
2
)
.
ChangeToRegister
(
WebAssembly
::
SP32
,
false
)
;
}
else
{
auto
&
MRI
=
MF
.
getRegInfo
(
)
;
const
auto
*
TII
=
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
unsigned
OffsetReg
=
MRI
.
createVirtualRegister
(
&
WebAssembly
::
I32RegClass
)
;
BuildMI
(
MBB
,
MI
,
MI
.
getDebugLoc
(
)
,
TII
->
get
(
WebAssembly
::
CONST_I32
)
,
OffsetReg
)
.
addImm
(
FrameOffset
)
;
BuildMI
(
MBB
,
MI
,
MI
.
getDebugLoc
(
)
,
TII
->
get
(
WebAssembly
::
ADD_I32
)
,
OffsetReg
)
.
addReg
(
WebAssembly
::
SP32
)
.
addReg
(
OffsetReg
)
;
MI
.
getOperand
(
FIOperandNum
)
.
ChangeToRegister
(
OffsetReg
,
false
)
;
}
}
</s>

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


<s> static int fr30_num_arg_regs ( const function_arg_info & arg ) { if ( targetm . calls . must_pass_in_stack ( arg ) ) return 0 ; int size = arg . promoted_size_in_bytes ( ) ; return ( size + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD ; } </s>

Compute the number of word sized registers needed to hold a function argument of mode INT_MODE and tree type TYPE .


<s> bool ARM64PassConfig :: addILPOpts ( ) { if ( EnableCCMP ) addPass ( createARM64ConditionalCompares ( ) ) ; addPass ( & EarlyIfConverterID ) ; if ( EnableStPairSuppress ) addPass ( createARM64StorePairSuppressPass ( ) ) ; return true ; } </s>

Add passes that optimize instruction level parallelism for out-of-order targets .


<s> void PPCPostRASchedStrategy :: leaveMBB ( ) { PostGenericScheduler :: leaveMBB ( ) ; } </s>

Tell the strategy that current MBB is done .


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

Returns true if the target requires ( and can make use of ) the register scavenger .


<s> static bool m68k_reg_present_p ( const_rtx parallel , unsigned int regno ) { int i ; if ( REG_P ( parallel ) && REGNO ( parallel ) == regno ) return true ; if ( GET_CODE ( parallel ) != PARALLEL ) return false ; for ( i = 0 ; i < XVECLEN ( parallel , 0 ) ; ++ i ) { const_rtx x ; x = XEXP ( XVECEXP ( parallel , 0 , i ) , 0 ) ; if ( REG_P ( x ) && REGNO ( x ) == regno ) return true ; } return false ; } </s>

Return true if PARALLEL contains register REGNO .


<s> int ARMBaseInstrInfo :: getInstrLatency ( const InstrItineraryData * ItinData , const MachineInstr * MI , unsigned * PredCost ) const { if ( MI -> isCopyLike ( ) || MI -> isInsertSubreg ( ) || MI -> isRegSequence ( ) || MI -> isImplicitDef ( ) ) return 1 ; if ( ! ItinData || ItinData -> isEmpty ( ) ) return 1 ; if ( MI -> isBundle ( ) ) { int Latency = 0 ; MachineBasicBlock :: const_instr_iterator I = MI ; MachineBasicBlock :: const_instr_iterator E = MI -> getParent ( ) -> instr_end ( ) ; while ( ++ I != E && I -> isInsideBundle ( ) ) { if ( I -> getOpcode ( ) != ARM :: t2IT ) Latency += getInstrLatency ( ItinData , I , PredCost ) ; } return Latency ; } const MCInstrDesc & MCID = MI -> getDesc ( ) ; unsigned Class = MCID . getSchedClass ( ) ; unsigned UOps = ItinData -> Itineraries [ Class ] . NumMicroOps ; if ( PredCost && ( MCID . isCall ( ) || MCID . hasImplicitDefOfPhysReg ( ARM :: CPSR ) ) ) * PredCost = 1 ; if ( UOps ) return ItinData -> getStageLatency ( Class ) ; return getNumMicroOps ( ItinData , MI ) ; } </s>

Compute the instruction latency of a given instruction .


<s> ARMSubtarget :: ARMSubtarget ( const std :: string & TT , const std :: string & CPU , const std :: string & FS ) : ARMGenSubtargetInfo ( TT , CPU , FS ) , ARMProcFamily ( Others ) , HasV4TOps ( false ) , HasV5TOps ( false ) , HasV5TEOps ( false ) , HasV6Ops ( false ) , HasV6T2Ops ( false ) , HasV7Ops ( false ) , HasVFPv2 ( false ) , HasVFPv3 ( false ) , HasVFPv4 ( false ) , HasNEON ( false ) , UseNEONForSinglePrecisionFP ( false ) , UseMulOps ( UseFusedMulOps ) , SlowFPVMLx ( false ) , HasVMLxForwarding ( false ) , SlowFPBrcc ( false ) , InThumbMode ( false ) , HasThumb2 ( false ) , IsMClass ( false ) , NoARM ( false ) , PostRAScheduler ( false ) , IsR9Reserved ( ReserveR9 ) , UseMovt ( false ) , SupportsTailCall ( false ) , HasFP16 ( false ) , HasD16 ( false ) , HasHardwareDivide ( false ) , HasHardwareDivideInARM ( false ) , HasT2ExtractPack ( false ) , HasDataBarrier ( false ) , Pref32BitThumb ( false ) , AvoidCPSRPartialUpdate ( false ) , HasRAS ( false ) , HasMPExtension ( false ) , FPOnlySP ( false ) , AllowsUnalignedMem ( false ) , Thumb2DSP ( false ) , stackAlignment ( 4 ) , CPUString ( CPU ) , TargetTriple ( TT ) , TargetABI ( ARM_ABI_APCS ) { if ( CPUString . empty ( ) ) CPUString = "generic" ; std :: string ArchFS = ARM_MC :: ParseARMTriple ( TT , CPUString ) ; if ( ! FS . empty ( ) ) { if ( ! ArchFS . empty ( ) ) ArchFS = ArchFS + "," + FS ; else ArchFS = FS ; } ParseSubtargetFeatures ( CPUString , ArchFS ) ; if ( ! HasV6T2Ops && hasThumb2 ( ) ) HasV4TOps = HasV5TOps = HasV5TEOps = HasV6Ops = HasV6T2Ops = true ; SchedModel = getSchedModelForCPU ( CPUString ) ; InstrItins = getInstrItineraryForCPU ( CPUString ) ; if ( ( TT . find ( "eabi" ) != std :: string :: npos ) || ( isTargetIOS ( ) && isMClass ( ) ) ) TargetABI = ARM_ABI_AAPCS ; if ( isAAPCS_ABI ( ) ) stackAlignment = 8 ; if ( ! isTargetIOS ( ) ) UseMovt = hasV6T2Ops ( ) ; else { IsR9Reserved = ReserveR9 | ! HasV6Ops ; UseMovt = DarwinUseMOVT && hasV6T2Ops ( ) ; SupportsTailCall = ! getTargetTriple ( ) . isOSVersionLT ( 5 , 0 ) ; } if ( ! isThumb ( ) || hasThumb2 ( ) ) PostRAScheduler = true ; if ( ! StrictAlign && hasV6Ops ( ) && isTargetDarwin ( ) ) AllowsUnalignedMem = true ; } </s>

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

ARM ARM ARM ARM ARM ARM ARM 4 ARM "generic" ARM ARM "," "eabi" ARM 8 5 0


<s> bool Mips16TargetLowering :: allowsMisalignedMemoryAccesses ( EVT VT , unsigned , Align , MachineMemOperand :: Flags , bool * Fast ) const { return false ; } </s>

Returns true if the target allows unaligned memory accesses of the specified type .


<s> static bool scalar_to_vector_candidate_p ( rtx_insn * insn ) { if ( TARGET_64BIT ) return timode_scalar_to_vector_candidate_p ( insn ) ; else return dimode_scalar_to_vector_candidate_p ( insn ) ; } </s>

Return 1 if INSN may be converted into vector instruction .


<s> int effective_address_32bit_p ( rtx op , machine_mode mode ) { HOST_WIDE_INT offset ; mode = GET_MODE ( op ) ; op = XEXP ( op , 0 ) ; if ( GET_CODE ( op ) != PLUS ) { gcc_assert ( REG_P ( op ) || GET_CODE ( op ) == POST_INC || GET_CODE ( op ) == PRE_DEC || GET_CODE ( op ) == POST_DEC ) ; return 0 ; } if ( GET_CODE ( XEXP ( op , 1 ) ) == UNSPEC ) return 1 ; offset = INTVAL ( XEXP ( op , 1 ) ) ; if ( GET_MODE_SIZE ( mode ) == 1 ) return 1 ; if ( GET_MODE_SIZE ( mode ) == 4 ) { if ( XEXP ( op , 0 ) == frame_pointer_rtx ) return offset < - 128 || offset > 60 ; return offset < 0 || offset > 60 ; } return offset < 0 || offset > 30 ; } </s>

This predicate is used to compute the length of a load/store insn . OP is a MEM rtx , we return nonzero if its addressing mode requires a 32 bit instruction .


"Cannot spill SGPR to memory without RegScavenger"

"Exec is already saved, refuse to save again"

prepare - Reset state and prepare for a new spill placement computation .


"Unable to build a return instruction?!"

"The insertion did not happen where we expected"

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


<s> void AArch64BranchRelaxation :: verify ( ) { unsigned PrevNum = MF -> begin ( ) -> getNumber ( ) ; for ( MachineBasicBlock & MBB : * MF ) { unsigned Align = MBB . getAlignment ( ) ; unsigned Num = MBB . getNumber ( ) ; assert ( BlockInfo [ Num ] . Offset % ( 1u << Align ) == 0 ) ; assert ( ! Num || BlockInfo [ PrevNum ] . postOffset ( ) <= BlockInfo [ Num ] . Offset ) ; PrevNum = Num ; } } </s>


<s> static reg_class_t ix86_spill_class ( reg_class_t rclass , machine_mode mode ) { if ( 0 && TARGET_GENERAL_REGS_SSE_SPILL && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_TO_VEC && TARGET_INTER_UNIT_MOVES_FROM_VEC && ( mode == SImode || ( TARGET_64BIT && mode == DImode ) ) && INTEGER_CLASS_P ( rclass ) ) return ALL_SSE_REGS ; return NO_REGS ; } </s>

Return class of registers which could be used for pseudo of MODE and of class RCLASS for spilling instead of memory . Return NO_REGS if it is not possible or non-profitable .


<s> void WebAssemblyCFGStackify :: releaseMemory ( ) { ScopeTops . clear ( ) ; BeginToEnd . clear ( ) ; EndToBegin . clear ( ) ; TryToEHPad . clear ( ) ; EHPadToTry . clear ( ) ; AppendixBB = nullptr ; } </s>

releaseMemory ( ) - This member can be implemented by a pass if it wants to be able to release its memory when it is no longer needed .


<s> static rtx sparc_delegitimize_address ( rtx x ) { x = delegitimize_mem_from_attrs ( x ) ; if ( GET_CODE ( x ) == LO_SUM && GET_CODE ( XEXP ( x , 1 ) ) == UNSPEC ) switch ( XINT ( XEXP ( x , 1 ) , 1 ) ) { case UNSPEC_MOVE_PIC : case UNSPEC_TLSLE : x = XVECEXP ( XEXP ( x , 1 ) , 0 , 0 ) ; gcc_assert ( GET_CODE ( x ) == SYMBOL_REF ) ; break ; default : break ; } if ( GET_CODE ( x ) == MINUS && sparc_pic_register_p ( XEXP ( x , 0 ) ) && GET_CODE ( XEXP ( x , 1 ) ) == LO_SUM && GET_CODE ( XEXP ( XEXP ( x , 1 ) , 1 ) ) == UNSPEC && XINT ( XEXP ( XEXP ( x , 1 ) , 1 ) , 1 ) == UNSPEC_MOVE_PIC_LABEL ) { x = XVECEXP ( XEXP ( XEXP ( x , 1 ) , 1 ) , 0 , 0 ) ; gcc_assert ( GET_CODE ( x ) == LABEL_REF || ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , 0 ) , 0 ) ) == LABEL_REF && GET_CODE ( XEXP ( XEXP ( x , 0 ) , 1 ) ) == CONST_INT ) ) ; } return x ; } </s>

Delegitimize an address that was legitimized by the above function .


<s>
void
MipsCallEntry
::
printCustom
(
raw_ostream
&
O
)
const
{
O
<<
"MipsCallEntry: "
;
if
(
Val
)
O
<<
Val
->
getName
(
)
;
else
O
<<
Name
;
}
</s>

Implement printing for PseudoSourceValue .


<s> virtual bool runOnMachineFunction ( MachineFunction & MF ) { const X86TargetMachine * TM = static_cast < const X86TargetMachine * > ( & MF . getTarget ( ) ) ; const TargetFrameLowering * TFI = TM -> getFrameLowering ( ) ; MachineRegisterInfo & RI = MF . getRegInfo ( ) ; X86MachineFunctionInfo * FuncInfo = MF . getInfo < X86MachineFunctionInfo > ( ) ; unsigned StackAlignment = TFI -> getStackAlignment ( ) ; for ( unsigned i = 0 , e = RI . getNumVirtRegs ( ) ; i != e ; ++ i ) { unsigned Reg = TargetRegisterInfo :: index2VirtReg ( i ) ; if ( ( RI . getRegClass ( Reg ) -> getAlignment ( ) / 8 ) > StackAlignment ) { FuncInfo -> setForceFramePointer ( true ) ; return true ; } } return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> static machine_mode sparc_promote_function_mode ( const_tree type , machine_mode mode , int * punsignedp , const_tree fntype ATTRIBUTE_UNUSED , int for_return ATTRIBUTE_UNUSED ) { if ( type != NULL_TREE && POINTER_TYPE_P ( type ) ) { * punsignedp = POINTERS_EXTEND_UNSIGNED ; return Pmode ; } if ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) < UNITS_PER_WORD ) return word_mode ; return mode ; } </s>

Handle promotion of pointer and integer arguments .


<s> void pass_vsetvl :: transfer_after ( vector_insn_info & info , insn_info * insn ) const { if ( vector_config_insn_p ( insn -> rtl ( ) ) ) { info = m_vector_manager -> vector_insn_infos [ insn -> uid ( ) ] ; return ; } if ( fault_first_load_p ( insn -> rtl ( ) ) && info . update_fault_first_load_avl ( insn ) ) return ; if ( insn -> is_call ( ) || insn -> is_asm ( ) || find_access ( insn -> defs ( ) , VL_REGNUM ) || find_access ( insn -> defs ( ) , VTYPE_REGNUM ) ) info = vector_insn_info :: get_unknown ( ) ; } </s>

Given a state with which we evaluated insn ( see transfer_before above for why this might be different that the state insn requested ) , modify the state to reflect the changes insn might make .


<s> static rtx sh_struct_value_rtx ( tree fndecl , int incoming ATTRIBUTE_UNUSED ) { if ( TARGET_HITACHI || sh_attr_renesas_p ( fndecl ) ) return NULL_RTX ; return gen_rtx_REG ( Pmode , 2 ) ; } </s>

The Renesas calling convention does n't quite fit into this scheme since the address is passed like an invisible argument , but one that is always passed in memory .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> virtual MVT getShiftAmountTy ( EVT LHSTy ) const { return MVT :: i8 ; } </s>

Returns the type for the shift amount of a shift opcode .


<s> void LC3bFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { } </s>


<s> TargetLoweringBase :: AtomicExpansionKind X86TargetLowering :: shouldExpandAtomicStoreInIR ( StoreInst * SI ) const { Type * MemType = SI -> getValueOperand ( ) -> getType ( ) ; bool NoImplicitFloatOps = SI -> getFunction ( ) -> hasFnAttribute ( Attribute :: NoImplicitFloat ) ; if ( MemType -> getPrimitiveSizeInBits ( ) == 64 && ! Subtarget . is64Bit ( ) && ! Subtarget . useSoftFloat ( ) && ! NoImplicitFloatOps && ( Subtarget . hasSSE1 ( ) || Subtarget . hasX87 ( ) ) ) return AtomicExpansionKind :: None ; return needsCmpXchgNb ( MemType ) ? AtomicExpansionKind :: Expand : AtomicExpansionKind :: None ; } </s>

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


<s> uint64_t MipsFrameLowering :: estimateStackSize ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const TargetRegisterInfo & TRI = * MF . getTarget ( ) . getRegisterInfo ( ) ; int64_t Offset = 0 ; for ( int I = MFI -> getObjectIndexBegin ( ) ; I != 0 ; ++ I ) Offset = std :: max ( Offset , - MFI -> getObjectOffset ( I ) ) ; for ( const MCPhysReg * R = TRI . getCalleeSavedRegs ( & MF ) ; * R ; ++ R ) { unsigned Size = TRI . getMinimalPhysRegClass ( * R ) -> getSize ( ) ; Offset = RoundUpToAlignment ( Offset + Size , Size ) ; } unsigned MaxAlign = MFI -> getMaxAlignment ( ) ; assert ( ! MFI -> getObjectIndexEnd ( ) || MaxAlign ) ; for ( unsigned I = 0 , E = MFI -> getObjectIndexEnd ( ) ; I != E ; ++ I ) Offset = RoundUpToAlignment ( Offset + MFI -> getObjectSize ( I ) , MaxAlign ) ; if ( MFI -> adjustsStack ( ) && hasReservedCallFrame ( MF ) ) Offset = RoundUpToAlignment ( Offset + MFI -> getMaxCallFrameSize ( ) , std :: max ( MaxAlign , getStackAlignment ( ) ) ) ; return RoundUpToAlignment ( Offset , getStackAlignment ( ) ) ; } </s>

Estimate and return the size of the stack frame .


<s> void X86PassConfig :: addPreRegAlloc ( ) { if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( & LiveRangeShrinkID ) ; addPass ( createX86FixupSetCC ( ) ) ; addPass ( createX86OptimizeLEAs ( ) ) ; addPass ( createX86CallFrameOptimization ( ) ) ; addPass ( createX86AvoidStoreForwardingBlocks ( ) ) ; } addPass ( createX86SpeculativeLoadHardeningPass ( ) ) ; addPass ( createX86FlagsCopyLoweringPass ( ) ) ; addPass ( createX86DynAllocaExpander ( ) ) ; if ( getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createX86PreTileConfigPass ( ) ) ; } } </s>

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


<s> DecodeStatus MCS51Disassembler :: getInstruction ( MCInst & Instr , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & CStream ) const { uint32_t Insn ; DecodeStatus Result ; { Result = readInstruction16 ( Bytes , Address , Size , Insn ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; Result = decodeInstruction ( getDecoderTable ( Size ) , Instr , Insn , Address , this , STI ) ; if ( Result != MCDisassembler :: Fail ) return Result ; } { Result = readInstruction32 ( Bytes , Address , Size , Insn ) ; if ( Result == MCDisassembler :: Fail ) return MCDisassembler :: Fail ; Result = decodeInstruction ( getDecoderTable ( Size ) , Instr , Insn , Address , this , STI ) ; if ( Result != MCDisassembler :: Fail ) { return Result ; } return MCDisassembler :: Fail ; } } </s>

Returns the disassembly of a single instruction .


<s> static machine_mode zero_call_used_regno_mode ( const unsigned int regno ) { if ( GENERAL_REGNO_P ( regno ) ) return SImode ; else if ( SSE_REGNO_P ( regno ) ) return V4SFmode ; else if ( MASK_REGNO_P ( regno ) ) return HImode ; else if ( MMX_REGNO_P ( regno ) ) return V4HImode ; else gcc_unreachable ( ) ; } </s>

Return the machine_mode that is used to zero register REGNO .


<s> static bool expand_vec_perm_vpshufb2_vpermq ( struct expand_vec_perm_d * d ) { rtx rperm [ 2 ] [ 32 ] , vperm , l , h , hp , op , m128 ; unsigned int i , nelt , eltsz ; if ( ! TARGET_AVX2 || ! d -> one_operand_p || ( d -> vmode != V32QImode && d -> vmode != V16HImode ) ) return false ; if ( d -> testing_p ) return true ; nelt = d -> nelt ; eltsz = GET_MODE_UNIT_SIZE ( d -> vmode ) ; m128 = GEN_INT ( - 128 ) ; for ( i = 0 ; i < nelt ; ++ i ) { unsigned j , e = d -> perm [ i ] & ( nelt / 2 - 1 ) ; unsigned which = ( ( d -> perm [ i ] ^ i ) & ( nelt / 2 ) ) * eltsz ; for ( j = 0 ; j < eltsz ; ++ j ) { rperm [ ! ! which ] [ ( i * eltsz + j ) ^ which ] = GEN_INT ( e * eltsz + j ) ; rperm [ ! which ] [ ( i * eltsz + j ) ^ ( which ^ 16 ) ] = m128 ; } } vperm = gen_rtx_CONST_VECTOR ( V32QImode , gen_rtvec_v ( 32 , rperm [ 1 ] ) ) ; vperm = force_reg ( V32QImode , vperm ) ; h = gen_reg_rtx ( V32QImode ) ; op = gen_lowpart ( V32QImode , d -> op0 ) ; emit_insn ( gen_avx2_pshufbv32qi3 ( h , op , vperm ) ) ; hp = gen_reg_rtx ( V4DImode ) ; op = gen_lowpart ( V4DImode , h ) ; emit_insn ( gen_avx2_permv4di_1 ( hp , op , const2_rtx , GEN_INT ( 3 ) , const0_rtx , const1_rtx ) ) ; vperm = gen_rtx_CONST_VECTOR ( V32QImode , gen_rtvec_v ( 32 , rperm [ 0 ] ) ) ; vperm = force_reg ( V32QImode , vperm ) ; l = gen_reg_rtx ( V32QImode ) ; op = gen_lowpart ( V32QImode , d -> op0 ) ; emit_insn ( gen_avx2_pshufbv32qi3 ( l , op , vperm ) ) ; op = d -> target ; if ( d -> vmode != V32QImode ) op = gen_reg_rtx ( V32QImode ) ; emit_insn ( gen_iorv32qi3 ( op , l , gen_lowpart ( V32QImode , hp ) ) ) ; if ( op != d -> target ) emit_move_insn ( d -> target , gen_lowpart ( d -> vmode , op ) ) ; return true ; } </s>

Implement arbitrary permutation of one V32QImode and V16QImode operand with two vpshufb insns , vpermq and vpor . We should have already failed all two or three instruction sequences .


<s> static rtx nds32_expand_triop_builtin ( enum insn_code icode , tree exp , rtx target , bool return_p ) { rtx pat ; rtx op0 = nds32_read_argument ( exp , 0 ) ; rtx op1 = nds32_read_argument ( exp , 1 ) ; rtx op2 = nds32_read_argument ( exp , 2 ) ; int op0_num = return_p ? 1 : 0 ; int op1_num = return_p ? 2 : 1 ; int op2_num = return_p ? 3 : 2 ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; op0 = nds32_legitimize_argument ( icode , op0_num , op0 ) ; op1 = nds32_legitimize_argument ( icode , op1_num , op1 ) ; op2 = nds32_legitimize_argument ( icode , op2_num , op2 ) ; if ( return_p ) pat = GEN_FCN ( icode ) ( target , op0 , op1 , op2 ) ; else pat = GEN_FCN ( icode ) ( op0 , op1 , op2 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; return target ; } </s>

Expand builtins that take three operands .


<s> static bool bfin_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED , tree exp ATTRIBUTE_UNUSED ) { struct cgraph_local_info * this_func , * called_func ; e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; if ( fkind != SUBROUTINE ) return false ; if ( ! TARGET_ID_SHARED_LIBRARY || TARGET_SEP_DATA ) return true ; if ( ! decl ) return false ; this_func = cgraph_node :: local_info ( current_function_decl ) ; called_func = cgraph_node :: local_info ( decl ) ; if ( ! called_func ) return false ; return ! called_func -> local || this_func -> local ; } </s>

Decide whether we can make a sibling call to a function . DECL is the declaration of the function being targeted by the call and EXP is the CALL_EXPR representing the call .


<s> void SparcAsmPrinter :: emitInstruction ( const MachineInstr * MI ) { switch ( MI -> getOpcode ( ) ) { default : break ; case TargetOpcode :: DBG_VALUE : return ; case SP :: GETPCX : LowerGETPCXAndEmitMCInsts ( MI , getSubtargetInfo ( ) ) ; return ; } MachineBasicBlock :: const_instr_iterator I = MI -> getIterator ( ) ; MachineBasicBlock :: const_instr_iterator E = MI -> getParent ( ) -> instr_end ( ) ; do { MCInst TmpInst ; LowerSparcMachineInstrToMCInst ( & * I , TmpInst , * this ) ; EmitToStreamer ( * OutStreamer , TmpInst ) ; } while ( ( ++ I != E ) && I -> isInsideBundle ( ) ) ; } </s>

Targets should implement this to emit instructions .


"instruction use requires an option to be enabled"

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


<s> std :: pair < const TargetRegisterClass * , uint8_t > AArch64TargetLowering :: findRepresentativeClass ( MVT VT ) const { const TargetRegisterClass * RRC = 0 ; uint8_t Cost = 1 ; switch ( VT . SimpleTy ) { default : return TargetLowering :: findRepresentativeClass ( VT ) ; case MVT :: v4i64 : RRC = & AArch64 :: QPairRegClass ; Cost = 2 ; break ; case MVT :: v8i64 : RRC = & AArch64 :: QQuadRegClass ; Cost = 4 ; break ; } return std :: make_pair ( RRC , Cost ) ; } </s>

Return the largest legal super-reg register class of the register class for the specified type and its associated `` cost '' .


<s> static bool ix86_libgcc_floating_mode_supported_p ( machine_mode mode ) { switch ( mode ) { case SFmode : case DFmode : case XFmode : return true ; case TFmode : return false ; return TARGET_LONG_DOUBLE_128 ; return true ; default : return false ; } } </s>

Implement target hook libgcc_floating_mode_supported_p .


<s> inline const MatchEntry * begin ( const MatchEntry array [ ] ) { return array ; } </s>


<s> static void tilegx_output_mi_thunk ( FILE * file , tree thunk_fndecl ATTRIBUTE_UNUSED , HOST_WIDE_INT delta , HOST_WIDE_INT vcall_offset , tree function ) { rtx this_rtx , funexp , addend ; rtx_insn * insn ; reload_completed = 1 ; emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , 1 ) ; else this_rtx = gen_rtx_REG ( Pmode , 0 ) ; if ( ! ( delta >= - 32868 && delta <= 32767 ) ) { addend = gen_rtx_REG ( Pmode , 29 ) ; emit_move_insn ( addend , GEN_INT ( delta ) ) ; } else addend = GEN_INT ( delta ) ; if ( TARGET_32BIT ) emit_insn ( gen_addsi3 ( this_rtx , this_rtx , addend ) ) ; else emit_insn ( gen_adddi3 ( this_rtx , this_rtx , addend ) ) ; if ( vcall_offset ) { rtx tmp ; tmp = gen_rtx_REG ( Pmode , 29 ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , this_rtx ) ) ; if ( ! ( vcall_offset >= - 32868 && vcall_offset <= 32767 ) ) { addend = gen_rtx_REG ( Pmode , 28 ) ; emit_move_insn ( addend , GEN_INT ( vcall_offset ) ) ; } else addend = GEN_INT ( vcall_offset ) ; if ( TARGET_32BIT ) emit_insn ( gen_addsi3 ( tmp , tmp , addend ) ) ; else emit_insn ( gen_adddi3 ( tmp , tmp , addend ) ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp ) ) ; if ( TARGET_32BIT ) emit_insn ( gen_addsi3 ( this_rtx , this_rtx , tmp ) ) ; else emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = 1 ; } funexp = XEXP ( DECL_RTL ( function ) , 0 ) ; funexp = gen_rtx_MEM ( FUNCTION_MODE , funexp ) ; insn = emit_call_insn ( gen_sibcall ( funexp , const0_rtx ) ) ; SIBLING_CALL_P ( insn ) = 1 ; insn = get_insns ( ) ; shorten_branches ( insn ) ; final_start_function ( insn , file , 1 ) ; final ( insn , file , 1 ) ; final_end_function ( ) ; reload_completed = 0 ; } </s>


<s> static bool nds32_naked_function_p ( tree func ) { tree t ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) abort ( ) ; t = lookup_attribute ( "naked" , DECL_ATTRIBUTES ( func ) ) ; return ( t != NULL_TREE ) ; } </s>

Return true if FUNC is a naked function .


<s> StackOffset VEFrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const VERegisterInfo * RegInfo = STI . getRegisterInfo ( ) ; bool isFixed = MFI . isFixedObjectIndex ( FI ) ; int64_t FrameOffset = MF . getFrameInfo ( ) . getObjectOffset ( FI ) ; if ( ! hasFP ( MF ) ) { FrameReg = VE :: SX11 ; return StackOffset :: getFixed ( FrameOffset + MF . getFrameInfo ( ) . getStackSize ( ) ) ; } if ( RegInfo -> hasStackRealignment ( MF ) && ! isFixed ) { if ( hasBP ( MF ) ) FrameReg = VE :: SX17 ; else FrameReg = VE :: SX11 ; return StackOffset :: getFixed ( FrameOffset + MF . getFrameInfo ( ) . getStackSize ( ) ) ; } FrameReg = RegInfo -> getFrameRegister ( MF ) ; return StackOffset :: getFixed ( FrameOffset ) ; } </s>

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


<s> void SystemZFrameLowering :: processFunctionBeforeFrameFinalized ( MachineFunction & MF , RegScavenger * RS ) const { MachineFrameInfo & MFFrame = MF . getFrameInfo ( ) ; SystemZMachineFunctionInfo * ZFI = MF . getInfo < SystemZMachineFunctionInfo > ( ) ; MachineRegisterInfo * MRI = & MF . getRegInfo ( ) ; bool BackChain = MF . getFunction ( ) . hasFnAttribute ( "backchain" ) ; if ( ! usePackedStack ( MF ) || BackChain ) getOrCreateFramePointerSaveIndex ( MF ) ; uint64_t StackSize = ( MFFrame . estimateStackSize ( MF ) + SystemZMC :: ELFCallFrameSize ) ; int64_t MaxArgOffset = 0 ; for ( int I = MFFrame . getObjectIndexBegin ( ) ; I != 0 ; ++ I ) if ( MFFrame . getObjectOffset ( I ) >= 0 ) { int64_t ArgOffset = MFFrame . getObjectOffset ( I ) + MFFrame . getObjectSize ( I ) ; MaxArgOffset = std :: max ( MaxArgOffset , ArgOffset ) ; } uint64_t MaxReach = StackSize + MaxArgOffset ; if ( ! isUInt < 12 > ( MaxReach ) ) { RS -> addScavengingFrameIndex ( MFFrame . CreateStackObject ( 8 , Align ( 8 ) , false ) ) ; RS -> addScavengingFrameIndex ( MFFrame . CreateStackObject ( 8 , Align ( 8 ) , false ) ) ; } if ( MF . front ( ) . isLiveIn ( SystemZ :: R6D ) && ZFI -> getRestoreGPRRegs ( ) . LowGPR != SystemZ :: R6D ) for ( auto & MO : MRI -> use_nodbg_operands ( SystemZ :: R6D ) ) MO . setIsKill ( false ) ; } </s>

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


<s> bool sh_contains_memref_p ( rtx insn ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( MEM_P ( * iter ) ) return true ; return false ; } </s>

Return nonzero iff INSN contains a MEM .


<s> int m32c_push_rounding ( int n ) { if ( TARGET_R8C || TARGET_M16C ) return n ; return ( n + 1 ) & ~ 1 ; } </s>

Implements PUSH_ROUNDING . The R8C and M16C have byte stacks , the M32C has word stacks .


<s> static bool sparc_pic_register_p ( rtx x ) { if ( ! REG_P ( x ) || ! pic_offset_table_rtx ) return false ; if ( x == pic_offset_table_rtx ) return true ; if ( ! HARD_REGISTER_P ( pic_offset_table_rtx ) && ( HARD_REGISTER_P ( x ) || lra_in_progress ) && ORIGINAL_REGNO ( x ) == REGNO ( pic_offset_table_rtx ) ) return true ; return false ; } </s>

Return true if X is a representation of the PIC register .


<s> static void pa_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; rtx start_addr = gen_reg_rtx ( Pmode ) ; rtx end_addr = gen_reg_rtx ( Pmode ) ; rtx line_length = gen_reg_rtx ( Pmode ) ; rtx r_tramp , tmp ; emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ; r_tramp = force_reg ( Pmode , XEXP ( m_tramp , 0 ) ) ; if ( ! TARGET_64BIT ) { tmp = adjust_address ( m_tramp , Pmode , 48 ) ; emit_move_insn ( tmp , fnaddr ) ; tmp = adjust_address ( m_tramp , Pmode , 52 ) ; emit_move_insn ( tmp , chain_value ) ; tmp = adjust_address ( m_tramp , Pmode , 56 ) ; emit_move_insn ( tmp , r_tramp ) ; tmp = adjust_address ( m_tramp , Pmode , 60 ) ; emit_move_insn ( tmp , gen_rtx_REG ( Pmode , 19 ) ) ; emit_insn ( gen_andsi3 ( start_addr , r_tramp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; tmp = force_reg ( Pmode , plus_constant ( Pmode , r_tramp , TRAMPOLINE_CODE_SIZE - 1 ) ) ; emit_insn ( gen_andsi3 ( end_addr , tmp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; emit_move_insn ( line_length , GEN_INT ( MIN_CACHELINE_SIZE ) ) ; emit_insn ( gen_dcacheflushsi ( start_addr , end_addr , line_length ) ) ; emit_insn ( gen_icacheflushsi ( start_addr , end_addr , line_length , gen_reg_rtx ( Pmode ) , gen_reg_rtx ( Pmode ) ) ) ; } else { tmp = adjust_address ( m_tramp , Pmode , 56 ) ; emit_move_insn ( tmp , fnaddr ) ; tmp = adjust_address ( m_tramp , Pmode , 64 ) ; emit_move_insn ( tmp , chain_value ) ; tmp = adjust_address ( m_tramp , Pmode , 16 ) ; emit_move_insn ( tmp , force_reg ( Pmode , plus_constant ( Pmode , r_tramp , 32 ) ) ) ; tmp = adjust_address ( m_tramp , Pmode , 24 ) ; emit_move_insn ( tmp , gen_rtx_REG ( Pmode , 27 ) ) ; tmp = force_reg ( Pmode , plus_constant ( Pmode , r_tramp , 32 ) ) ; emit_insn ( gen_anddi3 ( start_addr , tmp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; tmp = force_reg ( Pmode , plus_constant ( Pmode , tmp , TRAMPOLINE_CODE_SIZE - 1 ) ) ; emit_insn ( gen_anddi3 ( end_addr , tmp , GEN_INT ( - MIN_CACHELINE_SIZE ) ) ) ; emit_move_insn ( line_length , GEN_INT ( MIN_CACHELINE_SIZE ) ) ; emit_insn ( gen_dcacheflushdi ( start_addr , end_addr , line_length ) ) ; emit_insn ( gen_icacheflushdi ( start_addr , end_addr , line_length , gen_reg_rtx ( Pmode ) , gen_reg_rtx ( Pmode ) ) ) ; } emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , "__enable_execute_stack" ) , LCT_NORMAL , VOIDmode , XEXP ( m_tramp , 0 ) , Pmode ) ; } </s>

Emit RTL insns to initialize the variable parts of a trampoline . FNADDR is an RTX for the address of the function 's pure code . CXT is an RTX for the static chain value for the function . Move the function address to the trampoline template at offset 36 . Move the static chain value to trampoline template at offset 40 . Move the trampoline address to trampoline template at offset 44 . Move r19 to trampoline template at offset 48 . The latter two words create a plabel for the indirect call to the trampoline . A similar sequence is used for the 64-bit port but the plabel is at the beginning of the trampoline . Finally , the cache entries for the trampoline code are flushed . This is necessary to ensure that the trampoline instruction sequence is written to memory prior to any attempts at prefetching the code sequence .


<s> static void mips_block_move_straight ( rtx dest , rtx src , HOST_WIDE_INT length ) { HOST_WIDE_INT offset , delta ; unsigned HOST_WIDE_INT bits ; int i ; machine_mode mode ; rtx * regs ; if ( ! ISA_HAS_LWL_LWR ) bits = MIN ( BITS_PER_WORD , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) ) ; else { if ( MEM_ALIGN ( src ) == BITS_PER_WORD / 2 && MEM_ALIGN ( dest ) == BITS_PER_WORD / 2 ) bits = BITS_PER_WORD / 2 ; else bits = BITS_PER_WORD ; } mode = int_mode_for_size ( bits , 0 ) . require ( ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( rtx , length / delta ) ; for ( offset = 0 , i = 0 ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; if ( MEM_ALIGN ( src ) >= bits ) mips_emit_move ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ext_as_unaligned_load ( regs [ i ] , part , bits , 0 , 0 ) ) gcc_unreachable ( ) ; } } for ( offset = 0 , i = 0 ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) mips_emit_move ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; else { rtx part = adjust_address ( dest , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ins_as_unaligned_store ( part , regs [ i ] , bits , 0 ) ) gcc_unreachable ( ) ; } if ( offset < length ) { src = adjust_address ( src , BLKmode , offset ) ; dest = adjust_address ( dest , BLKmode , offset ) ; move_by_pieces ( dest , src , length - offset , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) , 0 ) ; } } </s>

Emit straight-line code to move LENGTH bytes from SRC to DEST . Assume that the areas do not overlap .


<s>
unsigned
int
remove
(
void
)
{
unsigned
int
cnt
=
Removables
.
size
(
)
;
for
(
std
::
set
<
MachineInstr
*
>
::
iterator
I
=
Removables
.
begin
(
)
,
E
=
Removables
.
end
(
)
;
I
!=
E
;
++
I
)
{
DEBUG
(
dbgs
(
)
<<
"  "
<<
*
*
I
)
;
(
*
I
)
->
eraseFromParent
(
)
;
}
Removables
.
clear
(
)
;
return
cnt
;
}
</s>

remove - Remove the specified key/value pair from the map , but do not erase it .


<s> bool addRegAssignmentFast ( ) override { return false ; } </s>

Add core register alloator passes which do the actual register assignment and rewriting .


<s> static void microblaze_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; rtx mem ; emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( 6 * UNITS_PER_WORD ) , BLOCK_OP_NORMAL ) ; mem = adjust_address ( m_tramp , SImode , 16 ) ; emit_move_insn ( mem , chain_value ) ; mem = adjust_address ( m_tramp , SImode , 20 ) ; emit_move_insn ( mem , fnaddr ) ; } </s>


<s> void MipsSETargetLowering :: addMSAIntType ( MVT :: SimpleValueType Ty , const TargetRegisterClass * RC ) { addRegisterClass ( Ty , RC ) ; for ( unsigned Opc = 0 ; Opc < ISD :: BUILTIN_OP_END ; ++ Opc ) setOperationAction ( Opc , Ty , Expand ) ; setOperationAction ( ISD :: BITCAST , Ty , Legal ) ; setOperationAction ( ISD :: LOAD , Ty , Legal ) ; setOperationAction ( ISD :: STORE , Ty , Legal ) ; setOperationAction ( ISD :: ADD , Ty , Legal ) ; setOperationAction ( ISD :: CTLZ , Ty , Legal ) ; setOperationAction ( ISD :: MUL , Ty , Legal ) ; setOperationAction ( ISD :: SDIV , Ty , Legal ) ; setOperationAction ( ISD :: SHL , Ty , Legal ) ; setOperationAction ( ISD :: SRA , Ty , Legal ) ; setOperationAction ( ISD :: SRL , Ty , Legal ) ; setOperationAction ( ISD :: SUB , Ty , Legal ) ; setOperationAction ( ISD :: UDIV , Ty , Legal ) ; } </s>

Enable MSA support for the given integer type and Register class .

Mips Mips MVT::SimpleValueType 0 ISD::BUILTIN_OP_END ISD::BITCAST ISD::LOAD ISD::STORE ISD::ADD ISD::CTLZ ISD::MUL ISD::SDIV ISD::SHL ISD::SRA ISD::SRL ISD::SUB ISD::UDIV


"preferPredicateOverEpilogue: not a single block "

"preferPredicateOverEpilogue: hardware-loop is not "

Query the target whether it would be prefered to create a predicated vector loop , which can avoid the need to emit a scalar epilogue loop .


<s> static tree rs6000_fold_builtin ( tree fndecl , int n_args ATTRIBUTE_UNUSED , tree * args , bool ignore ATTRIBUTE_UNUSED ) { if ( DECL_BUILT_IN_CLASS ( fndecl ) == BUILT_IN_MD ) { enum rs6000_builtins fn_code = ( enum rs6000_builtins ) DECL_FUNCTION_CODE ( fndecl ) ; switch ( fn_code ) { case RS6000_BUILTIN_NANQ : case RS6000_BUILTIN_NANSQ : { tree type = TREE_TYPE ( TREE_TYPE ( fndecl ) ) ; const char * str = c_getstr ( * args ) ; int quiet = fn_code == RS6000_BUILTIN_NANQ ; REAL_VALUE_TYPE real ; if ( str && real_nan ( & real , str , quiet , TYPE_MODE ( type ) ) ) return build_real ( type , real ) ; return NULL_TREE ; } case RS6000_BUILTIN_INFQ : case RS6000_BUILTIN_HUGE_VALQ : { tree type = TREE_TYPE ( TREE_TYPE ( fndecl ) ) ; REAL_VALUE_TYPE inf ; real_inf ( & inf ) ; return build_real ( type , inf ) ; } default : break ; } } return SUBTARGET_FOLD_BUILTIN ( fndecl , n_args , args , ignore ) ; return NULL_TREE ; } </s>

Target hook for early folding of built-ins , shamelessly stolen from ia64.cc .