<s> unsigned int rs6000_debugger_regno ( unsigned int regno , unsigned int format ) { if ( ( format == 0 && dwarf_debuginfo_p ( ) ) || format == 1 ) { if ( regno <= 31 ) return regno ; if ( FP_REGNO_P ( regno ) ) return regno - FIRST_FPR_REGNO + 32 ; if ( ALTIVEC_REGNO_P ( regno ) ) return regno - FIRST_ALTIVEC_REGNO + 1124 ; if ( regno == LR_REGNO ) return 108 ; if ( regno == CTR_REGNO ) return 109 ; if ( regno == CA_REGNO ) return 101 ; if ( format == 1 && regno == CR2_REGNO ) return 64 ; if ( CR_REGNO_P ( regno ) ) return regno - CR0_REGNO + 86 ; if ( regno == VRSAVE_REGNO ) return 356 ; if ( regno == VSCR_REGNO ) return 67 ; if ( regno == FRAME_POINTER_REGNUM ) return 111 ; if ( regno == ARG_POINTER_REGNUM ) return 67 ; if ( regno == 64 ) return 100 ; gcc_unreachable ( ) ; } if ( regno <= 31 ) return regno ; if ( FP_REGNO_P ( regno ) ) return regno - FIRST_FPR_REGNO + 32 ; if ( ALTIVEC_REGNO_P ( regno ) ) return regno - FIRST_ALTIVEC_REGNO + 77 ; if ( regno == LR_REGNO ) return 65 ; if ( regno == CTR_REGNO ) return 66 ; if ( regno == CA_REGNO ) return 76 ; if ( CR_REGNO_P ( regno ) ) return regno - CR0_REGNO + 68 ; if ( regno == VRSAVE_REGNO ) return 109 ; if ( regno == VSCR_REGNO ) return 110 ; if ( regno == FRAME_POINTER_REGNUM ) return 111 ; if ( regno == ARG_POINTER_REGNUM ) return 67 ; if ( regno == 64 ) return 64 ; gcc_unreachable ( ) ; } </s>

Map internal gcc register numbers to debug format register numbers . FORMAT specifies the type of debug register number to use : 0 -- debug information , except for frame-related sections 1 -- DWARF .debug_frame section 2 -- DWARF .eh_frame section


"Instr doesn't have FrameIndex operand!"

Resolve a frame index operand of an instruction to reference the indicated base register plus offset instead .


<s>
void
ARMConstantIslands
::
verify
(
)
{
for
(
MachineFunction
::
iterator
MBBI
=
MF
->
begin
(
)
,
E
=
MF
->
end
(
)
;
MBBI
!=
E
;
++
MBBI
)
{
MachineBasicBlock
*
MBB
=
MBBI
;
unsigned
Align
=
MBB
->
getAlignment
(
)
;
unsigned
MBBId
=
MBB
->
getNumber
(
)
;
assert
(
BBInfo
[
MBBId
]
.
Offset
%
(
1u
<<
Align
)
==
0
)
;
assert
(
!
MBBId
||
BBInfo
[
MBBId
1
]
.
postOffset
(
)
<=
BBInfo
[
MBBId
]
.
Offset
)
;
}
for
(
unsigned
i
=
0
,
e
=
CPUsers
.
size
(
)
;
i
!=
e
;
++
i
)
{
CPUser
&
U
=
CPUsers
[
i
]
;
unsigned
UserOffset
=
GetUserOffset
(
U
)
;
assert
(
CPEIsInRange
(
U
.
MI
,
UserOffset
,
U
.
CPEMI
,
U
.
getMaxDisp
(
)
,
U
.
NegOk
)
&&
"Constant pool entry out of range!"
)
;
}
}
</s>


<s> void riscv_move_integer ( rtx temp , rtx dest , HOST_WIDE_INT value , machine_mode orig_mode , bool in_splitter ) { struct riscv_integer_op codes [ RISCV_MAX_INTEGER_OPS ] ; machine_mode mode ; int i , num_ops ; rtx x ; bool can_create_pseudo = can_create_pseudo_p ( ) && ! in_splitter ; mode = GET_MODE ( dest ) ; num_ops = riscv_build_integer ( codes , value , orig_mode ) ; if ( can_create_pseudo && num_ops > 2 && num_ops >= riscv_split_integer_cost ( value ) ) x = riscv_split_integer ( value , mode ) ; else { x = GEN_INT ( codes [ 0 ] . value ) ; for ( i = 1 ; i < num_ops ; i ++ ) { if ( ! can_create_pseudo ) x = riscv_emit_set ( temp , x ) ; else x = force_reg ( mode , x ) ; x = gen_rtx_fmt_ee ( codes [ i ] . code , mode , x , GEN_INT ( codes [ i ] . value ) ) ; } } riscv_emit_set ( dest , x ) ; } </s>

Load VALUE into DEST . TEMP is as for riscv_force_temporary .


<s> static int thumb_far_jump_used_p ( void ) { rtx insn ; if ( cfun -> machine -> far_jump_used ) return 1 ; if ( ! ( ARM_DOUBLEWORD_ALIGN || reload_completed ) ) { if ( regs_ever_live [ ARG_POINTER_REGNUM ] ) cfun -> machine -> arg_pointer_live = 1 ; else if ( ! cfun -> machine -> arg_pointer_live ) return 0 ; } for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) == JUMP_INSN && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && get_attr_far_jump ( insn ) == FAR_JUMP_YES ) { cfun -> machine -> far_jump_used = 1 ; return 1 ; } } return 0 ; } </s>

Returns non-zero if the current function contains , or might contain a far jump .


<s> long long rs6000_const_f32_to_i32 ( rtx operand ) { long long value ; const struct real_value * rv = CONST_DOUBLE_REAL_VALUE ( operand ) ; gcc_assert ( GET_MODE ( operand ) == SFmode ) ; REAL_VALUE_TO_TARGET_SINGLE ( * rv , value ) ; return value ; } </s>

Convert a SFmode constant to the integer bit pattern .


<s> bool SIInstrInfo :: isReallyTriviallyReMaterializable ( const MachineInstr & MI , AAResults * AA ) const { if ( isVOP1 ( MI ) || isVOP2 ( MI ) || isVOP3 ( MI ) || isSDWA ( MI ) || isSALU ( MI ) ) { return ! MI . hasImplicitDef ( ) && MI . getNumImplicitOperands ( ) == MI . getDesc ( ) . getNumImplicitUses ( ) && ! MI . mayRaiseFPException ( ) ; } return false ; } </s>

For instructions with opcodes for which the M_REMATERIALIZABLE flag is set , this hook lets the target specify whether the instruction is actually trivially rematerializable , taking into consideration its operands .


<s>
StringRef
RISCVMCExpr
::
getVariantKindName
(
VariantKind
Kind
)
{
switch
(
Kind
)
{
default
:
llvm_unreachable
(
"Invalid ELF symbol kind"
)
;
case
VK_RISCV_LO
:
return
"lo"
;
case
VK_RISCV_HI
:
return
"hi"
;
case
VK_RISCV_PCREL_HI
:
return
"pcrel_hi"
;
}
}
</s>

Convert the variant kind into an ELF-appropriate modifier ( e.g .

RISCV
RISCV
"Invalid ELF symbol kind"
RISCV
"lo"
RISCV
"hi"
RISCV
"pcrel_hi"


<s> rtx legitimize_pic_address ( rtx orig , enum machine_mode mode ATTRIBUTE_UNUSED , rtx reg ) { rtx pic_ref = orig ; if ( GET_CODE ( orig ) == SYMBOL_REF || GET_CODE ( orig ) == LABEL_REF ) { gcc_assert ( reg ) ; pic_ref = gen_rtx_MEM ( Pmode , gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , orig ) ) ; current_function_uses_pic_offset_table = 1 ; MEM_READONLY_P ( pic_ref ) = 1 ; emit_move_insn ( reg , pic_ref ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base ; if ( GET_CODE ( XEXP ( orig , 0 ) ) == PLUS && XEXP ( XEXP ( orig , 0 ) , 0 ) == pic_offset_table_rtx ) return orig ; gcc_assert ( reg ) ; gcc_assert ( GET_CODE ( XEXP ( orig , 0 ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , 0 ) , 0 ) , Pmode , reg ) ; orig = legitimize_pic_address ( XEXP ( XEXP ( orig , 0 ) , 1 ) , Pmode , base == reg ? 0 : reg ) ; if ( GET_CODE ( orig ) == CONST_INT ) return plus_constant ( base , INTVAL ( orig ) ) ; pic_ref = gen_rtx_PLUS ( Pmode , base , orig ) ; } return pic_ref ; } </s>

Legitimize PIC addresses . If the address is already position-independent , we return ORIG . Newly generated position-independent addresses go into a reg . This is REG if nonzero , otherwise we allocate register ( s ) as necessary .


<s> bool constant_address_p ( rtx x ) { switch ( GET_CODE ( x ) ) { case LABEL_REF : case CONST_INT : case HIGH : return true ; case CONST : if ( flag_pic && pic_address_needs_scratch ( x ) ) return false ; return legitimate_constant_p ( x ) ; case SYMBOL_REF : return ! flag_pic && legitimate_constant_p ( x ) ; default : return false ; } } </s>

Determine if a given RTX is a valid constant address .


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

getPassName - Return a nice clean name for a pass .


"%qE attribute only applies to functions"

Handle an `` interrupt_handler '' attribute ; arguments as in struct attribute_spec.handler .


<s> int no_side_effect_operand ( rtx op , machine_mode mode ATTRIBUTE_UNUSED ) { rtx addr ; if ( GET_CODE ( op ) != MEM ) return FALSE ; indirection : addr = XEXP ( op , 0 ) ; switch ( GET_CODE ( addr ) ) { case REG : return 1 ; case PRE_DEC : case POST_INC : case PRE_MODIFY : case POST_MODIFY : return 0 ; case MEM : if ( GET_CODE ( XEXP ( addr , 0 ) ) == REG ) return 0 ; op = addr ; goto indirection ; case CONST_INT : case LABEL_REF : case CONST : case SYMBOL_REF : return 0 ; case PLUS : return 0 ; default : break ; } return FALSE ; } </s>

Similar to simple_memory_operand but does n't match push/pop .


<s> void arm_init_expanders ( void ) { init_machine_status = arm_init_machine_status ; if ( cfun ) mark_reg_pointer ( arg_pointer_rtx , PARM_BOUNDARY ) ; } </s>

Do anything needed before RTL is emitted for each function .


<s> static int m32r_adjust_priority ( rtx_insn * insn , int priority ) { if ( m32r_is_insn ( insn ) && get_attr_insn_size ( insn ) != INSN_SIZE_SHORT ) priority <<= 3 ; return priority ; } </s>

Increase the priority of long instructions so that the short instructions are scheduled ahead of the long ones .


<s> unsigned TeakRegisterInfo :: getRegPressureLimit ( const TargetRegisterClass * RC , MachineFunction & MF ) const { switch ( RC -> getID ( ) ) { default : return 0 ; case Teak :: GRRegsRegClassID : return 7 ; case Teak :: SVRegRegClassID : return 0 ; case Teak :: ABRegsRegClassID : return 4 ; case Teak :: ALRegsRegClassID : return 2 ; case Teak :: ABLRegsRegClassID : return 4 ; case Teak :: RegNoBRegs16_nohRegClassID : return 12 ; case Teak :: RegNoBRegs16_noh_pageRegClassID : return 12 + 80 ; } } </s>

Return the register pressure `` high water mark '' for the specific register class .


<s> bool pbsada_insn_rt_dep_reg_p ( rtx pbsada_insn , rtx def_reg ) { rtx pbsada_rt = SET_DEST ( PATTERN ( pbsada_insn ) ) ; if ( rtx_equal_p ( def_reg , pbsada_rt ) ) return true ; return false ; } </s>

Determine if the latency is occured when the consumer PBSADA_INSN uses the value of DEF_REG in its Rt field .


<s> static void epiphany_print_operand_address ( FILE * file , rtx addr ) { register rtx base , index = 0 ; int offset = 0 ; switch ( GET_CODE ( addr ) ) { case REG : fputs ( reg_names [ REGNO ( addr ) ] , file ) ; break ; case SYMBOL_REF : if ( 0 && SYMBOL_REF_FUNCTION_P ( addr ) ) { output_addr_const ( file , addr ) ; } else { output_addr_const ( file , addr ) ; } break ; case PLUS : if ( GET_CODE ( XEXP ( addr , 0 ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , 0 ) ) , base = XEXP ( addr , 1 ) ; else if ( GET_CODE ( XEXP ( addr , 1 ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , 1 ) ) , base = XEXP ( addr , 0 ) ; else base = XEXP ( addr , 0 ) , index = XEXP ( addr , 1 ) ; gcc_assert ( GET_CODE ( base ) == REG ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ; if ( index == 0 ) { fprintf ( file , ",%s%d" , IMMEDIATE_PREFIX , offset / current_frame_info . stld_sz ) ; } else { switch ( GET_CODE ( index ) ) { case REG : fprintf ( file , ",%s" , reg_names [ REGNO ( index ) ] ) ; break ; case SYMBOL_REF : fputc ( ',' , file ) , output_addr_const ( file , index ) ; break ; default : gcc_unreachable ( ) ; } } break ; case PRE_INC : case PRE_DEC : case POST_INC : case POST_DEC : case POST_MODIFY : gcc_unreachable ( ) ; break ; default : output_addr_const ( file , addr ) ; break ; } } </s>

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


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

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


Return an array that contains the direct target flag values and their names .


<s> static void register_tuple_type ( unsigned int num_vectors , vector_type_index type ) { tree tuple_type = lang_hooks . types . make_type ( RECORD_TYPE ) ; char buffer [ sizeof ( "svbfloat16x4_t" ) ] ; const char * vector_type_name = vector_types [ type ] . acle_name ; snprintf ( buffer , sizeof ( buffer ) , "%.*sx%d_t" , ( int ) strlen ( vector_type_name ) - 2 , vector_type_name , num_vectors ) ; tree vector_type = acle_vector_types [ 0 ] [ type ] ; tree array_type = build_array_type_nelts ( vector_type , num_vectors ) ; gcc_assert ( VECTOR_MODE_P ( TYPE_MODE ( array_type ) ) && TYPE_MODE_RAW ( array_type ) == TYPE_MODE ( array_type ) && TYPE_ALIGN ( array_type ) == 128 ) ; tree field = build_decl ( input_location , FIELD_DECL , get_identifier ( "__val" ) , array_type ) ; DECL_FIELD_CONTEXT ( field ) = tuple_type ; TYPE_FIELDS ( tuple_type ) = field ; add_sve_type_attribute ( tuple_type , num_vectors , 0 , NULL , buffer ) ; make_type_sizeless ( tuple_type ) ; layout_type ( tuple_type ) ; gcc_assert ( VECTOR_MODE_P ( TYPE_MODE ( tuple_type ) ) && TYPE_MODE_RAW ( tuple_type ) == TYPE_MODE ( tuple_type ) && TYPE_ALIGN ( tuple_type ) == 128 ) ; tree decl = build_decl ( input_location , TYPE_DECL , get_identifier ( buffer ) , tuple_type ) ; TYPE_NAME ( tuple_type ) = decl ; TYPE_STUB_DECL ( tuple_type ) = decl ; lang_hooks . decls . pushdecl ( decl ) ; DECL_ORIGINAL_TYPE ( decl ) = NULL_TREE ; acle_vector_types [ num_vectors - 1 ] [ type ] = tuple_type ; } </s>

Register the tuple type that contains NUM_VECTORS vectors of type TYPE .


<s> static rtx add_constant ( struct mips16_constant_pool * pool , rtx value , enum machine_mode mode ) { struct mips16_constant * * p , * c ; bool first_of_size_p ; first_of_size_p = true ; for ( p = & pool -> first ; * p != 0 ; p = & ( * p ) -> next ) { if ( mode == ( * p ) -> mode && rtx_equal_p ( value , ( * p ) -> value ) ) return ( * p ) -> label ; if ( GET_MODE_SIZE ( mode ) < GET_MODE_SIZE ( ( * p ) -> mode ) ) break ; if ( GET_MODE_SIZE ( mode ) == GET_MODE_SIZE ( ( * p ) -> mode ) ) first_of_size_p = false ; } if ( pool -> first == 0 ) pool -> highest_address = pool -> insn_address - ( UNITS_PER_WORD - 2 ) + 0x8000 ; pool -> highest_address -= GET_MODE_SIZE ( mode ) ; if ( first_of_size_p ) pool -> highest_address -= GET_MODE_SIZE ( mode ) - 1 ; c = ( struct mips16_constant * ) xmalloc ( sizeof * c ) ; c -> value = value ; c -> mode = mode ; c -> label = gen_label_rtx ( ) ; c -> next = * p ; * p = c ; return c -> label ; } </s>

Add a constant to the pool and return its label .


<s> unsigned int arm_dbx_register_number ( unsigned int regno ) { if ( regno < 16 ) return regno ; if ( IS_VFP_REGNUM ( regno ) ) { if ( VFP_REGNO_OK_FOR_SINGLE ( regno ) ) return 64 + regno - FIRST_VFP_REGNUM ; else return 256 + ( regno - FIRST_VFP_REGNUM ) / 2 ; } if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return 104 + regno - FIRST_IWMMXT_GR_REGNUM ; if ( IS_IWMMXT_REGNUM ( regno ) ) return 112 + regno - FIRST_IWMMXT_REGNUM ; return DWARF_FRAME_REGISTERS ; } </s>

Map internal gcc register numbers to DWARF2 register numbers .


<s> int short_memory_operand ( rtx x , enum machine_mode mode ) { if ( ! memory_operand ( x , mode ) ) return 0 ; return ( GET_CODE ( XEXP ( x , 0 ) ) != PLUS ) ; } </s>

Return 1 if OP is a valid operand for a ` short ' memory reference insn .


<s> int addr24_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { rtx sym ; if ( flag_pic ) return 0 ; if ( GET_CODE ( op ) == LABEL_REF ) return TARGET_ADDR24 ; if ( GET_CODE ( op ) == SYMBOL_REF ) sym = op ; else if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , 0 ) , 0 ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , 0 ) , 1 ) ) == CONST_INT && UINT24_P ( INTVAL ( XEXP ( XEXP ( op , 0 ) , 1 ) ) ) ) sym = XEXP ( XEXP ( op , 0 ) , 0 ) ; else return 0 ; if ( SYMBOL_REF_MODEL ( sym ) == M32R_MODEL_SMALL ) return 1 ; if ( TARGET_ADDR24 && ( CONSTANT_POOL_ADDRESS_P ( sym ) || LIT_NAME_P ( XSTR ( sym , 0 ) ) ) ) return 1 ; return 0 ; } </s>

Return 1 if OP is a symbol that can use 24 bit addressing .


<s>
bool
SystemZInstrInfo
::
PredicateInstruction
(
MachineInstr
&
MI
,
ArrayRef
<
MachineOperand
>
Pred
)
const
{
assert
(
Pred
.
size
(
)
==
2
&&
"Invalid condition"
)
;
unsigned
CCValid
=
Pred
[
0
]
.
getImm
(
)
;
unsigned
CCMask
=
Pred
[
1
]
.
getImm
(
)
;
assert
(
CCMask
>
0
&&
CCMask
<
15
&&
"Invalid predicate"
)
;
unsigned
Opcode
=
MI
.
getOpcode
(
)
;
if
(
STI
.
hasLoadStoreOnCond
(
)
)
{
if
(
unsigned
CondOpcode
=
getConditionalMove
(
Opcode
)
)
{
MI
.
setDesc
(
get
(
CondOpcode
)
)
;
MachineInstrBuilder
(
*
MI
.
getParent
(
)
->
getParent
(
)
,
MI
)
.
addImm
(
CCValid
)
.
addImm
(
CCMask
)
.
addReg
(
SystemZ
::
CC
,
RegState
::
Implicit
)
;
return
true
;
}
}
if
(
Opcode
==
SystemZ
::
Return
)
{
MI
.
setDesc
(
get
(
SystemZ
::
CondReturn
)
)
;
MachineInstrBuilder
(
*
MI
.
getParent
(
)
->
getParent
(
)
,
MI
)
.
addImm
(
CCValid
)
.
addImm
(
CCMask
)
.
addReg
(
SystemZ
::
CC
,
RegState
::
Implicit
)
;
return
true
;
}
if
(
Opcode
==
SystemZ
::
CallJG
)
{
const
GlobalValue
*
Global
=
MI
.
getOperand
(
0
)
.
getGlobal
(
)
;
const
uint32_t
*
RegMask
=
MI
.
getOperand
(
1
)
.
getRegMask
(
)
;
MI
.
RemoveOperand
(
1
)
;
MI
.
RemoveOperand
(
0
)
;
MI
.
setDesc
(
get
(
SystemZ
::
CallBRCL
)
)
;
MachineInstrBuilder
(
*
MI
.
getParent
(
)
->
getParent
(
)
,
MI
)
.
addImm
(
CCValid
)
.
addImm
(
CCMask
)
.
addGlobalAddress
(
Global
)
.
addRegMask
(
RegMask
)
.
addReg
(
SystemZ
::
CC
,
RegState
::
Implicit
)
;
return
true
;
}
if
(
Opcode
==
SystemZ
::
CallBR
)
{
const
uint32_t
*
RegMask
=
MI
.
getOperand
(
0
)
.
getRegMask
(
)
;
MI
.
RemoveOperand
(
0
)
;
MI
.
setDesc
(
get
(
SystemZ
::
CallBCR
)
)
;
MachineInstrBuilder
(
*
MI
.
getParent
(
)
->
getParent
(
)
,
MI
)
.
addImm
(
CCValid
)
.
addImm
(
CCMask
)
.
addRegMask
(
RegMask
)
.
addReg
(
SystemZ
::
CC
,
RegState
::
Implicit
)
;
return
true
;
}
return
false
;
}
</s>

Convert the instruction into a predicated instruction .


<s>
void
AAPTargetLowering
::
ReplaceNodeResults
(
SDNode
*
N
,
SmallVectorImpl
<
SDValue
>
&
Results
,
SelectionDAG
&
DAG
)
const
{
switch
(
N
->
getOpcode
(
)
)
{
case
ISD
::
FLT_ROUNDS_
:
Results
.
push_back
(
DAG
.
getTargetConstant
(
1
,
SDLoc
(
N
)
,
MVT
::
i32
)
)
;
break
;
default
:
llvm_unreachable
(
"Unhandled node in ReplaceNodeResults"
)
;
}
}
</s>

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


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

Returns true if the target is expected to pass all machine verifier checks .


<s>
bool
MSP430InstrInfo
::
analyzeBranch
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
*
&
TBB
,
MachineBasicBlock
*
&
FBB
,
SmallVectorImpl
<
MachineOperand
>
&
Cond
,
bool
AllowModify
)
const
{
MachineBasicBlock
::
iterator
I
=
MBB
.
end
(
)
;
while
(
I
!=
MBB
.
begin
(
)
)
{
I
;
if
(
I
->
isDebugValue
(
)
)
continue
;
if
(
!
isUnpredicatedTerminator
(
*
I
)
)
break
;
if
(
!
I
->
isBranch
(
)
)
return
true
;
if
(
I
->
getOpcode
(
)
==
MSP430
::
Br
||
I
->
getOpcode
(
)
==
MSP430
::
Bm
)
return
true
;
if
(
I
->
getOpcode
(
)
==
MSP430
::
JMP
)
{
if
(
!
AllowModify
)
{
TBB
=
I
->
getOperand
(
0
)
.
getMBB
(
)
;
continue
;
}
while
(
std
::
next
(
I
)
!=
MBB
.
end
(
)
)
std
::
next
(
I
)
->
eraseFromParent
(
)
;
Cond
.
clear
(
)
;
FBB
=
nullptr
;
if
(
MBB
.
isLayoutSuccessor
(
I
->
getOperand
(
0
)
.
getMBB
(
)
)
)
{
TBB
=
nullptr
;
I
->
eraseFromParent
(
)
;
I
=
MBB
.
end
(
)
;
continue
;
}
TBB
=
I
->
getOperand
(
0
)
.
getMBB
(
)
;
continue
;
}
assert
(
I
->
getOpcode
(
)
==
MSP430
::
JCC
&&
"Invalid conditional branch"
)
;
MSP430CC
::
CondCodes
BranchCode
=
static_cast
<
MSP430CC
::
CondCodes
>
(
I
->
getOperand
(
1
)
.
getImm
(
)
)
;
if
(
BranchCode
==
MSP430CC
::
COND_INVALID
)
return
true
;
if
(
Cond
.
empty
(
)
)
{
FBB
=
TBB
;
TBB
=
I
->
getOperand
(
0
)
.
getMBB
(
)
;
Cond
.
push_back
(
MachineOperand
::
CreateImm
(
BranchCode
)
)
;
continue
;
}
assert
(
Cond
.
size
(
)
==
1
)
;
assert
(
TBB
)
;
if
(
TBB
!=
I
->
getOperand
(
0
)
.
getMBB
(
)
)
return
true
;
MSP430CC
::
CondCodes
OldBranchCode
=
(
MSP430CC
::
CondCodes
)
Cond
[
0
]
.
getImm
(
)
;
if
(
OldBranchCode
==
BranchCode
)
continue
;
return
true
;
}
return
false
;
}
</s>

analyzeBranch - Analyze the branching code at the end of MBB , returning true if it can not be understood ( e.g .


<s> BitVector SIRegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; reserveRegisterTuples ( Reserved , AMDGPU :: EXEC ) ; reserveRegisterTuples ( Reserved , AMDGPU :: FLAT_SCR ) ; reserveRegisterTuples ( Reserved , AMDGPU :: M0 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SRC_SHARED_BASE ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SRC_SHARED_LIMIT ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SRC_PRIVATE_BASE ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SRC_PRIVATE_LIMIT ) ; reserveRegisterTuples ( Reserved , AMDGPU :: SRC_POPS_EXITING_WAVE_ID ) ; reserveRegisterTuples ( Reserved , AMDGPU :: XNACK_MASK ) ; reserveRegisterTuples ( Reserved , AMDGPU :: LDS_DIRECT ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TBA ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TMA ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP0_TTMP1 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP2_TTMP3 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP4_TTMP5 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP6_TTMP7 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP8_TTMP9 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP10_TTMP11 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP12_TTMP13 ) ; reserveRegisterTuples ( Reserved , AMDGPU :: TTMP14_TTMP15 ) ; const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; unsigned MaxNumSGPRs = ST . getMaxNumSGPRs ( MF ) ; unsigned TotalNumSGPRs = AMDGPU :: SGPR_32RegClass . getNumRegs ( ) ; for ( unsigned i = MaxNumSGPRs ; i < TotalNumSGPRs ; ++ i ) { unsigned Reg = AMDGPU :: SGPR_32RegClass . getRegister ( i ) ; reserveRegisterTuples ( Reserved , Reg ) ; } unsigned MaxNumVGPRs = ST . getMaxNumVGPRs ( MF ) ; unsigned TotalNumVGPRs = AMDGPU :: VGPR_32RegClass . getNumRegs ( ) ; for ( unsigned i = MaxNumVGPRs ; i < TotalNumVGPRs ; ++ i ) { unsigned Reg = AMDGPU :: VGPR_32RegClass . getRegister ( i ) ; reserveRegisterTuples ( Reserved , Reg ) ; } const SIMachineFunctionInfo * MFI = MF . getInfo < SIMachineFunctionInfo > ( ) ; unsigned ScratchWaveOffsetReg = MFI -> getScratchWaveOffsetReg ( ) ; if ( ScratchWaveOffsetReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , ScratchWaveOffsetReg ) ; } unsigned ScratchRSrcReg = MFI -> getScratchRSrcReg ( ) ; if ( ScratchRSrcReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , ScratchRSrcReg ) ; assert ( ! isSubRegister ( ScratchRSrcReg , ScratchWaveOffsetReg ) ) ; } unsigned StackPtrReg = MFI -> getStackPtrOffsetReg ( ) ; if ( StackPtrReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , StackPtrReg ) ; assert ( ! isSubRegister ( ScratchRSrcReg , StackPtrReg ) ) ; } unsigned FrameReg = MFI -> getFrameOffsetReg ( ) ; if ( FrameReg != AMDGPU :: NoRegister ) { reserveRegisterTuples ( Reserved , FrameReg ) ; assert ( ! isSubRegister ( ScratchRSrcReg , FrameReg ) ) ; } 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>
MachineBasicBlock
*
RISCVTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
&
MI
,
MachineBasicBlock
*
BB
)
const
{
switch
(
MI
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Unexpected instr type to insert"
)
;
case
RISCV
::
Select_GPR_Using_CC_GPR
:
case
RISCV
::
Select_FPR32_Using_CC_GPR
:
case
RISCV
::
Select_FPR64_Using_CC_GPR
:
break
;
case
RISCV
::
BuildPairF64Pseudo
:
return
emitBuildPairF64Pseudo
(
MI
,
BB
)
;
case
RISCV
::
SplitF64Pseudo
:
return
emitSplitF64Pseudo
(
MI
,
BB
)
;
}
const
TargetInstrInfo
&
TII
=
*
BB
->
getParent
(
)
->
getSubtarget
(
)
.
getInstrInfo
(
)
;
const
BasicBlock
*
LLVM_BB
=
BB
->
getBasicBlock
(
)
;
DebugLoc
DL
=
MI
.
getDebugLoc
(
)
;
MachineFunction
::
iterator
I
=
++
BB
->
getIterator
(
)
;
MachineBasicBlock
*
HeadMBB
=
BB
;
MachineFunction
*
F
=
BB
->
getParent
(
)
;
MachineBasicBlock
*
TailMBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
MachineBasicBlock
*
IfFalseMBB
=
F
->
CreateMachineBasicBlock
(
LLVM_BB
)
;
F
->
insert
(
I
,
IfFalseMBB
)
;
F
->
insert
(
I
,
TailMBB
)
;
TailMBB
->
splice
(
TailMBB
->
begin
(
)
,
HeadMBB
,
std
::
next
(
MachineBasicBlock
::
iterator
(
MI
)
)
,
HeadMBB
->
end
(
)
)
;
TailMBB
->
transferSuccessorsAndUpdatePHIs
(
HeadMBB
)
;
HeadMBB
->
addSuccessor
(
IfFalseMBB
)
;
HeadMBB
->
addSuccessor
(
TailMBB
)
;
unsigned
LHS
=
MI
.
getOperand
(
1
)
.
getReg
(
)
;
unsigned
RHS
=
MI
.
getOperand
(
2
)
.
getReg
(
)
;
auto
CC
=
static_cast
<
ISD
::
CondCode
>
(
MI
.
getOperand
(
3
)
.
getImm
(
)
)
;
unsigned
Opcode
=
getBranchOpcodeForIntCondCode
(
CC
)
;
BuildMI
(
HeadMBB
,
DL
,
TII
.
get
(
Opcode
)
)
.
addReg
(
LHS
)
.
addReg
(
RHS
)
.
addMBB
(
TailMBB
)
;
IfFalseMBB
->
addSuccessor
(
TailMBB
)
;
BuildMI
(
*
TailMBB
,
TailMBB
->
begin
(
)
,
DL
,
TII
.
get
(
RISCV
::
PHI
)
,
MI
.
getOperand
(
0
)
.
getReg
(
)
)
.
addReg
(
MI
.
getOperand
(
4
)
.
getReg
(
)
)
.
addMBB
(
HeadMBB
)
.
addReg
(
MI
.
getOperand
(
5
)
.
getReg
(
)
)
.
addMBB
(
IfFalseMBB
)
;
MI
.
eraseFromParent
(
)
;
return
TailMBB
;
}
</s>

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


"The function works only with LEA instructions"


<s> const MCSection * PIC16TargetObjectFile :: getExplicitSectionGlobal ( const GlobalValue * GV , SectionKind Kind , Mangler * Mang , const TargetMachine & TM ) const { assert ( GV -> hasSection ( ) ) ; if ( const GlobalVariable * GVar = cast < GlobalVariable > ( GV ) ) { std :: string SectName = GVar -> getSection ( ) ; std :: string AddrStr = "Address=" ; if ( SectName . compare ( 0 , AddrStr . length ( ) , AddrStr ) == 0 ) { std :: string SectAddr = SectName . substr ( AddrStr . length ( ) ) ; return CreateSectionForGlobal ( GVar , Mang , SectAddr ) ; } return CreateSectionForGlobal ( GVar , Mang ) ; } return getPIC16Section ( GV -> getSection ( ) . c_str ( ) , Kind ) ; } </s>

Targets should implement this method to assign a section to globals with an explicit section specfied .


<s> mips_output_ascii ( STREAM , STRING , LEN ) { \ const char * p = STRING ; \ int size = strlen ( p ) + 1 ; \ rdata_section ( ) ; \ assemble_string ( p , size ) ; \ } </s>

Output an ASCII string , in a space-saving way . PREFIX is the string that should be written before the opening quote , such as `` \t.ascii\t '' for real string data or `` \t # `` for a comment .


<s> std :: pair < unsigned , const TargetRegisterClass * > PPCTargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , EVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'b' : case 'r' : if ( VT == MVT :: i64 && PPCSubTarget . isPPC64 ( ) ) return std :: make_pair ( 0U , PPC :: G8RCRegisterClass ) ; return std :: make_pair ( 0U , PPC :: GPRCRegisterClass ) ; case 'f' : if ( VT == MVT :: f32 ) return std :: make_pair ( 0U , PPC :: F4RCRegisterClass ) ; else if ( VT == MVT :: f64 ) return std :: make_pair ( 0U , PPC :: F8RCRegisterClass ) ; break ; case 'v' : return std :: make_pair ( 0U , PPC :: VRRCRegisterClass ) ; case 'y' : return std :: make_pair ( 0U , PPC :: CRRCRegisterClass ) ; } } return TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> static bool xtensa_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { return ! xtensa_tls_referenced_p ( x ) ; } </s>


<s> const TargetRegisterClass * SIRegisterInfo :: getRegClass ( unsigned RCID ) const { switch ( ( int ) RCID ) { case AMDGPU :: SReg_1RegClassID : return getBoolRC ( ) ; case AMDGPU :: SReg_1_XEXECRegClassID : return isWave32 ? & AMDGPU :: SReg_32_XM0_XEXECRegClass : & AMDGPU :: SReg_64_XEXECRegClass ; case - 1 : return nullptr ; default : return AMDGPURegisterInfo :: getRegClass ( RCID ) ; } } </s>

Given a machine instruction descriptor , returns the register class constraint for OpNum , or NULL .


<s> enum reg_class secondary_reload_class ( enum reg_class class , enum machine_mode mode , rtx x , int in ) { if ( ( mode == QImode || mode == HImode ) && ! TARGET_BWX ) { if ( GET_CODE ( x ) == MEM || ( GET_CODE ( x ) == REG && REGNO ( x ) >= FIRST_PSEUDO_REGISTER ) || ( GET_CODE ( x ) == SUBREG && ( GET_CODE ( SUBREG_REG ( x ) ) == MEM || ( GET_CODE ( SUBREG_REG ( x ) ) == REG && REGNO ( SUBREG_REG ( x ) ) >= FIRST_PSEUDO_REGISTER ) ) ) ) { if ( ! in || ! aligned_memory_operand ( x , mode ) ) return GENERAL_REGS ; } } if ( class == FLOAT_REGS ) { if ( GET_CODE ( x ) == MEM && GET_CODE ( XEXP ( x , 0 ) ) == AND ) return GENERAL_REGS ; if ( GET_CODE ( x ) == SUBREG && ( GET_MODE_SIZE ( GET_MODE ( x ) ) > GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) return GENERAL_REGS ; if ( in && INTEGRAL_MODE_P ( mode ) && ! ( memory_operand ( x , mode ) || x == const0_rtx ) ) return GENERAL_REGS ; } </s>

Return the class of any secondary reload register that is needed to move IN into a register in class CLASS using mode MODE . Profiling has showed this routine and its descendants account for a significant amount of compile time ( ~7 % ) . So it has been optimized to reduce redundant computations and eliminate useless function calls . It might be worthwhile to try and make this a leaf function too .


<s>
void
AArch64FrameLowering
::
eliminateCallFramePseudoInstr
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
I
)
const
{
const
AArch64InstrInfo
*
TII
=
static_cast
<
const
AArch64InstrInfo
*
>
(
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
)
;
DebugLoc
DL
=
I
->
getDebugLoc
(
)
;
int
Opc
=
I
->
getOpcode
(
)
;
bool
IsDestroy
=
Opc
==
TII
->
getCallFrameDestroyOpcode
(
)
;
uint64_t
CalleePopAmount
=
IsDestroy
I
->
getOperand
(
1
)
.
getImm
(
)
:
0
;
const
TargetFrameLowering
*
TFI
=
MF
.
getSubtarget
(
)
.
getFrameLowering
(
)
;
if
(
!
TFI
->
hasReservedCallFrame
(
MF
)
)
{
unsigned
Align
=
getStackAlignment
(
)
;
int64_t
Amount
=
I
->
getOperand
(
0
)
.
getImm
(
)
;
Amount
=
RoundUpToAlignment
(
Amount
,
Align
)
;
if
(
!
IsDestroy
)
Amount
=
Amount
;
if
(
CalleePopAmount
==
0
)
{
assert
(
Amount
>
0xffffff
&&
Amount
<
0xffffff
&&
"call frame too large"
)
;
emitFrameOffset
(
MBB
,
I
,
DL
,
AArch64
::
SP
,
AArch64
::
SP
,
Amount
,
TII
)
;
}
}
else
if
(
CalleePopAmount
!=
0
)
{
assert
(
CalleePopAmount
<
0xffffff
&&
"call frame too large"
)
;
emitFrameOffset
(
MBB
,
I
,
DL
,
AArch64
::
SP
,
AArch64
::
SP
,
CalleePopAmount
,
TII
)
;
}
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 ) .


<s>
void
WebAssemblyTargetWasmStreamer
::
emitIndIdx
(
const
MCExpr
*
Value
)
{
llvm_unreachable
(
".indidx encoding not yet implemented"
)
;
}
</s>

WebAssembly
WebAssembly
".indidx encoding not yet implemented"


<s> bool HexagonInstrInfo :: getMemOperandWithOffset ( const MachineInstr & LdSt , const MachineOperand * & BaseOp , int64_t & Offset , const TargetRegisterInfo * TRI ) const { unsigned AccessSize = 0 ; BaseOp = getBaseAndOffset ( LdSt , Offset , AccessSize ) ; return BaseOp != nullptr && BaseOp -> isReg ( ) ; } </s>

Get the base operand and byte offset of an instruction that reads/writes memory .


<s> bool isMicroMips ( ) const { return STI . getFeatureBits ( ) & Mips :: FeatureMicroMips ; } </s>

Check whether a given symbol has been flagged with MICROMIPS flag .


<s> static bool thumb_force_lr_save ( void ) { return ! cfun -> machine -> lr_save_eliminated && ( ! leaf_function_p ( ) || thumb_far_jump_used_p ( ) || df_regs_ever_live_p ( LR_REGNUM ) ) ; } </s>

Return true if the current function needs to save/restore LR .


<s> static rtx rx_function_arg ( cumulative_args_t cum , machine_mode mode , const_tree type , bool named ) { unsigned int next_reg ; unsigned int bytes_so_far = * get_cumulative_args ( cum ) ; unsigned int size ; unsigned int rounded_size ; size = ( mode == BLKmode ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; if ( size < 1 ) return NULL_RTX ; rounded_size = rx_round_up ( size , UNITS_PER_WORD ) ; if ( rounded_size + bytes_so_far > MAX_NUM_ARG_BYTES ) return NULL_RTX ; if ( ! named ) return NULL_RTX ; if ( ( type == NULL || AGGREGATE_TYPE_P ( type ) ) && ( size % UNITS_PER_WORD ) != 0 ) return NULL_RTX ; next_reg = ( bytes_so_far / UNITS_PER_WORD ) + 1 ; return gen_rtx_REG ( mode , next_reg ) ; } </s>

Return an RTL expression describing the register holding a function parameter of mode MODE and type TYPE or NULL_RTX if the parameter should be passed on the stack . CUM describes the previous parameters to the function and NAMED is false if the parameter is part of a variable parameter list , or the last named parameter before the start of a variable parameter list .


<s>
void
AGCDAGToDAGISel
::
Select
(
SDNode
*
Node
)
{
if
(
Node
->
isMachineOpcode
(
)
)
{
LLVM_DEBUG
(
dbgs
(
)
<<
"== "
<<
Node
<<
"\n"
)
;
Node
->
setNodeId
(
1
)
;
return
;
}
switch
(
Node
->
getOpcode
(
)
)
{
default
:
break
;
case
ISD
::
Constant
:
{
SelectAGCConstant
(
Node
)
;
return
;
}
}
for
(
auto
&
Op
:
Node
->
ops
(
)
)
{
switch
(
Op
.
getNode
(
)
->
getOpcode
(
)
)
{
default
:
break
;
case
ISD
::
Constant
:
{
SelectAGCConstant
(
Op
.
getNode
(
)
)
;
break
;
}
}
}
SelectCode
(
Node
)
;
}
</s>

Main hook for targets to transform nodes into machine nodes .

AGC
AGC
"== "
"\n"
1
ISD::Constant
AGC
ISD::Constant
AGC


<s>
static
void
ia64_output_function_prologue
(
FILE
*
file
)
{
int
mask
,
grsave
,
grsave_prev
;
if
(
current_frame_info
.
need_regstk
)
fprintf
(
file
,
"\t.regstk %d, %d, %d, %d\n"
,
current_frame_info
.
n_input_regs
,
current_frame_info
.
n_local_regs
,
current_frame_info
.
n_output_regs
,
current_frame_info
.
n_rotate_regs
)
;
if
(
ia64_except_unwind_info
(
&
global_options
)
!=
UI_TARGET
)
return
;
mask
=
0
;
grsave
=
grsave_prev
=
0
;
if
(
current_frame_info
.
r
[
reg_save_b0
]
!=
0
)
{
mask
|=
8
;
grsave
=
grsave_prev
=
current_frame_info
.
r
[
reg_save_b0
]
;
}
if
(
current_frame_info
.
r
[
reg_save_ar_pfs
]
!=
0
&&
(
grsave_prev
==
0
||
current_frame_info
.
r
[
reg_save_ar_pfs
]
==
grsave_prev
+
1
)
)
{
mask
|=
4
;
if
(
grsave_prev
==
0
)
grsave
=
current_frame_info
.
r
[
reg_save_ar_pfs
]
;
grsave_prev
=
current_frame_info
.
r
[
reg_save_ar_pfs
]
;
}
if
(
current_frame_info
.
r
[
reg_fp
]
!=
0
&&
(
grsave_prev
==
0
||
current_frame_info
.
r
[
reg_fp
]
==
grsave_prev
+
1
)
)
{
mask
|=
2
;
if
(
grsave_prev
==
0
)
grsave
=
HARD_FRAME_POINTER_REGNUM
;
grsave_prev
=
current_frame_info
.
r
[
reg_fp
]
;
}
if
(
current_frame_info
.
r
[
reg_save_pr
]
!=
0
&&
(
grsave_prev
==
0
||
current_frame_info
.
r
[
reg_save_pr
]
==
grsave_prev
+
1
)
)
{
mask
|=
1
;
if
(
grsave_prev
==
0
)
grsave
=
current_frame_info
.
r
[
reg_save_pr
]
;
}
if
(
mask
&&
TARGET_GNU_AS
)
fprintf
(
file
,
"\t.prologue %d, %d\n"
,
mask
,
ia64_debugger_regno
(
grsave
)
)
;
else
fputs
(
"\t.prologue\n"
,
file
)
;
if
(
current_frame_info
.
spill_cfa_off
!=
16
)
fprintf
(
file
,
"\t.spill %ld\n"
,
(
long
)
(
current_frame_info
.
spill_cfa_off
+
current_frame_info
.
spill_size
)
)
;
}
</s>


<s> SMLoc getStartLoc ( ) const override { return StartLoc ; } </s>

getStartLoc - Get the location of the first token of this operand .


<s> bool X86FastISel :: fastSelectInstruction ( const Instruction * I ) { switch ( I -> getOpcode ( ) ) { default : break ; case Instruction :: Load : return X86SelectLoad ( I ) ; case Instruction :: Store : return X86SelectStore ( I ) ; case Instruction :: Ret : return X86SelectRet ( I ) ; case Instruction :: ICmp : case Instruction :: FCmp : return X86SelectCmp ( I ) ; case Instruction :: ZExt : return X86SelectZExt ( I ) ; case Instruction :: Br : return X86SelectBranch ( I ) ; case Instruction :: LShr : case Instruction :: AShr : case Instruction :: Shl : return X86SelectShift ( I ) ; case Instruction :: SDiv : case Instruction :: UDiv : case Instruction :: SRem : case Instruction :: URem : return X86SelectDivRem ( I ) ; case Instruction :: Select : return X86SelectSelect ( I ) ; case Instruction :: Trunc : return X86SelectTrunc ( I ) ; case Instruction :: FPExt : return X86SelectFPExt ( I ) ; case Instruction :: FPTrunc : return X86SelectFPTrunc ( I ) ; case Instruction :: SIToFP : return X86SelectSIToFP ( I ) ; case Instruction :: IntToPtr : case Instruction :: PtrToInt : { EVT SrcVT = TLI . getValueType ( DL , I -> getOperand ( 0 ) -> getType ( ) ) ; EVT DstVT = TLI . getValueType ( DL , I -> getType ( ) ) ; if ( DstVT . bitsGT ( SrcVT ) ) return X86SelectZExt ( I ) ; if ( DstVT . bitsLT ( SrcVT ) ) return X86SelectTrunc ( I ) ; unsigned Reg = getRegForValue ( I -> getOperand ( 0 ) ) ; if ( Reg == 0 ) return false ; updateValueMap ( I , Reg ) ; return true ; } case Instruction :: BitCast : { if ( ! Subtarget -> hasSSE2 ( ) ) return false ; EVT SrcVT = TLI . getValueType ( DL , I -> getOperand ( 0 ) -> getType ( ) ) ; EVT DstVT = TLI . getValueType ( DL , I -> getType ( ) ) ; if ( ! SrcVT . isSimple ( ) || ! DstVT . isSimple ( ) ) return false ; if ( ! SrcVT . is128BitVector ( ) && ! ( Subtarget -> hasAVX ( ) && SrcVT . is256BitVector ( ) ) ) return false ; unsigned Reg = getRegForValue ( I -> getOperand ( 0 ) ) ; if ( Reg == 0 ) return false ; updateValueMap ( I , Reg ) ; return true ; } } return false ; } </s>

This method is called by target-independent code when the normal FastISel process fails to select an instruction .


<s>
static
void
rs6000_parse_abi_options
(
)
{
if
(
rs6000_abi_string
==
0
)
return
;
else
if
(
!
strcmp
(
rs6000_abi_string
,
"altivec"
)
)
rs6000_altivec_abi
=
1
;
else
if
(
!
strcmp
(
rs6000_abi_string
,
"no-altivec"
)
)
rs6000_altivec_abi
=
0
;
else
error
(
"unknown ABI specified: '%s'"
,
rs6000_abi_string
)
;
}
</s>


"loadRegFromStackSlot didn't insert any code!"

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


<s> bool umips_movep_target_p ( rtx reg1 , rtx reg2 ) { int regno1 , regno2 , pair ; unsigned int i ; static const int match [ 8 ] = { 0x00000060 , 0x000000a0 , 0x000000c0 , 0x00200010 , 0x00400010 , 0x00000030 , 0x00000050 , 0x00000090 } ; if ( ! REG_P ( reg1 ) || ! REG_P ( reg2 ) ) return false ; regno1 = REGNO ( reg1 ) ; regno2 = REGNO ( reg2 ) ; if ( ! GP_REG_P ( regno1 ) || ! GP_REG_P ( regno2 ) ) return false ; pair = ( 1 << regno1 ) | ( 1 << regno2 ) ; for ( i = 0 ; i < ARRAY_SIZE ( match ) ; i ++ ) if ( pair == match [ i ] ) return true ; return false ; } </s>

Return true if REG1 and REG2 match the criteria for a movep insn .


<s> void WebAssemblyAsmPrinter :: emitJumpTableInfo ( ) { } </s>

Print assembly representations of the jump tables used by the current function to the current output stream .


Simple predicate for targets where ! Resolved implies requiring relaxation .


<s> const HexagonSubtarget * HexagonTargetMachine :: getSubtargetImpl ( const Function & F ) const { AttributeList FnAttrs = F . getAttributes ( ) ; Attribute CPUAttr = FnAttrs . getAttribute ( AttributeList :: FunctionIndex , "target-cpu" ) ; Attribute FSAttr = FnAttrs . getAttribute ( AttributeList :: FunctionIndex , "target-features" ) ; std :: string CPU = ! CPUAttr . hasAttribute ( Attribute :: None ) ? CPUAttr . getValueAsString ( ) . str ( ) : TargetCPU ; std :: string FS = ! FSAttr . hasAttribute ( Attribute :: None ) ? FSAttr . getValueAsString ( ) . str ( ) : TargetFS ; auto & I = SubtargetMap [ CPU + FS ] ; if ( ! I ) { resetTargetOptions ( F ) ; I = std :: make_unique < HexagonSubtarget > ( TargetTriple , CPU , FS , * this ) ; } return I . get ( ) ; } </s>

Virtual method implemented by subclasses that returns a reference to that target 's TargetSubtargetInfo-derived member variable .

Hexagon Hexagon Hexagon "target-cpu" "target-features" Hexagon


<s> bool arm_valid_symbolic_address_p ( rtx addr ) { rtx xop0 , xop1 = NULL_RTX ; rtx tmp = addr ; if ( target_word_relocations ) return false ; if ( SYMBOL_REF_P ( tmp ) || LABEL_REF_P ( tmp ) ) return true ; if ( GET_CODE ( addr ) == CONST ) tmp = XEXP ( addr , 0 ) ; if ( GET_CODE ( tmp ) == PLUS ) { xop0 = XEXP ( tmp , 0 ) ; xop1 = XEXP ( tmp , 1 ) ; if ( GET_CODE ( xop0 ) == SYMBOL_REF && CONST_INT_P ( xop1 ) ) { if ( TARGET_THUMB1 && ! TARGET_HAVE_MOVT ) return IN_RANGE ( INTVAL ( xop1 ) , 0 , 0xff ) ; else return IN_RANGE ( INTVAL ( xop1 ) , - 0x8000 , 0x7fff ) ; } } return false ; } </s>

Returns true if the pattern is a valid symbolic address , which is either a symbol_ref or ( symbol_ref + addend ) . According to the ARM ELF ABI , the initial addend of REL-type relocations processing MOVW and MOVT instructions is formed by interpreting the 16-bit literal field of the instruction as a 16-bit signed value in the range -32768 < = A < 32768 . In Thumb-1 mode , we use upper/lower relocations which have an 8-bit unsigned range of 0 < = A < 256 as described in the AAELF32 relocation handling documentation : REL-type relocations are encoded as unsigned in this case .


<s> bool ARMAsmPrinter :: runOnMachineFunction ( MachineFunction & MF ) { AFI = MF . getInfo < ARMFunctionInfo > ( ) ; MCP = MF . getConstantPool ( ) ; Subtarget = & MF . getSubtarget < ARMSubtarget > ( ) ; SetupMachineFunction ( MF ) ; const Function & F = MF . getFunction ( ) ; const TargetMachine & TM = MF . getTarget ( ) ; for ( auto * GV : AFI -> getGlobalsPromotedToConstantPool ( ) ) PromotedGlobals . insert ( GV ) ; unsigned OptimizationGoal ; if ( F . hasOptNone ( ) ) OptimizationGoal = 6 ; else if ( F . hasMinSize ( ) ) OptimizationGoal = 4 ; else if ( F . hasOptSize ( ) ) OptimizationGoal = 3 ; else if ( TM . getOptLevel ( ) == CodeGenOpt :: Aggressive ) OptimizationGoal = 2 ; else if ( TM . getOptLevel ( ) > CodeGenOpt :: None ) OptimizationGoal = 1 ; else OptimizationGoal = 5 ; if ( OptimizationGoals == - 1 ) OptimizationGoals = OptimizationGoal ; else if ( OptimizationGoals != ( int ) OptimizationGoal ) OptimizationGoals = 0 ; if ( Subtarget -> isTargetCOFF ( ) ) { bool Internal = F . hasInternalLinkage ( ) ; COFF :: SymbolStorageClass Scl = Internal ? COFF :: IMAGE_SYM_CLASS_STATIC : COFF :: IMAGE_SYM_CLASS_EXTERNAL ; int Type = COFF :: IMAGE_SYM_DTYPE_FUNCTION << COFF :: SCT_COMPLEX_TYPE_SHIFT ; OutStreamer -> BeginCOFFSymbolDef ( CurrentFnSym ) ; OutStreamer -> emitCOFFSymbolStorageClass ( Scl ) ; OutStreamer -> emitCOFFSymbolType ( Type ) ; OutStreamer -> EndCOFFSymbolDef ( ) ; } emitFunctionBody ( ) ; emitXRayTable ( ) ; if ( ! ThumbIndirectPads . empty ( ) ) { OutStreamer -> emitAssemblerFlag ( MCAF_Code16 ) ; emitAlignment ( Align ( 2 ) ) ; for ( std :: pair < unsigned , MCSymbol * > & TIP : ThumbIndirectPads ) { OutStreamer -> emitLabel ( TIP . second ) ; EmitToStreamer ( * OutStreamer , MCInstBuilder ( ARM :: tBX ) . addReg ( TIP . first ) . addImm ( ARMCC :: AL ) . addReg ( 0 ) ) ; } ThumbIndirectPads . clear ( ) ; } return false ; } </s>

runOnMachineFunction - Emit the function body .


<s> SDValue AMDGPUTargetLowering :: SplitVectorStore ( SDValue Op , SelectionDAG & DAG ) const { StoreSDNode * Store = cast < StoreSDNode > ( Op ) ; SDValue Val = Store -> getValue ( ) ; EVT VT = Val . getValueType ( ) ; if ( VT . getVectorNumElements ( ) == 2 ) return ScalarizeVectorStore ( Op , DAG ) ; EVT MemVT = Store -> getMemoryVT ( ) ; SDValue Chain = Store -> getChain ( ) ; SDValue BasePtr = Store -> getBasePtr ( ) ; SDLoc SL ( Op ) ; EVT LoVT , HiVT ; EVT LoMemVT , HiMemVT ; SDValue Lo , Hi ; std :: tie ( LoVT , HiVT ) = DAG . GetSplitDestVTs ( VT ) ; std :: tie ( LoMemVT , HiMemVT ) = DAG . GetSplitDestVTs ( MemVT ) ; std :: tie ( Lo , Hi ) = DAG . SplitVector ( Val , SL , LoVT , HiVT ) ; EVT PtrVT = BasePtr . getValueType ( ) ; SDValue HiPtr = DAG . getNode ( ISD :: ADD , SL , PtrVT , BasePtr , DAG . getConstant ( LoMemVT . getStoreSize ( ) , SL , PtrVT ) ) ; MachinePointerInfo SrcValue ( Store -> getMemOperand ( ) -> getValue ( ) ) ; SDValue LoStore = DAG . getTruncStore ( Chain , SL , Lo , BasePtr , SrcValue , LoMemVT , Store -> isNonTemporal ( ) , Store -> isVolatile ( ) , Store -> getAlignment ( ) ) ; SDValue HiStore = DAG . getTruncStore ( Chain , SL , Hi , HiPtr , SrcValue . getWithOffset ( LoMemVT . getStoreSize ( ) ) , HiMemVT , Store -> isNonTemporal ( ) , Store -> isVolatile ( ) , Store -> getAlignment ( ) ) ; return DAG . getNode ( ISD :: TokenFactor , SL , MVT :: Other , LoStore , HiStore ) ; } </s>

Split a vector store into 2 stores of half the vector .

AMDGPU AMDGPU 2 ISD::ADD ISD::TokenFactor MVT::Other


<s> static section * mips_function_rodata_section ( tree decl ) { if ( ! TARGET_ABICALLS || TARGET_ABSOLUTE_ABICALLS || TARGET_GPWORD ) return default_function_rodata_section ( decl ) ; if ( decl && DECL_SECTION_NAME ( decl ) ) { const char * name = DECL_SECTION_NAME ( decl ) ; if ( DECL_COMDAT_GROUP ( decl ) && strncmp ( name , ".gnu.linkonce.t." , 16 ) == 0 ) { char * rname = ASTRDUP ( name ) ; rname [ 14 ] = 'd' ; return get_section ( rname , SECTION_LINKONCE | SECTION_WRITE , decl ) ; } else if ( flag_function_sections && flag_data_sections && strncmp ( name , ".text." , 6 ) == 0 ) { char * rname = ASTRDUP ( name ) ; memcpy ( rname + 1 , "data" , 4 ) ; return get_section ( rname , SECTION_WRITE , decl ) ; } } return data_section ; } </s>

Implement TARGET_ASM_FUNCTION_RODATA_SECTION . The complication here is that , with the combination TARGET_ABICALLS & & ! TARGET_GPWORD , jump tables will use absolute addresses , and should therefore not be included in the read-only part of a DSO . Handle such cases by selecting a normal data section instead of a read-only one . The logic apes that in default_function_rodata_section .


<s> void M88kFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const M88kInstrInfo & LII = * static_cast < const M88kInstrInfo * > ( STI . getInstrInfo ( ) ) ; MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; DebugLoc DL = MBBI -> getDebugLoc ( ) ; unsigned StackSize = MFI . getStackSize ( ) ; if ( StackSize ) { BuildMI ( MBB , MBBI , DL , LII . get ( M88k :: ADDUri ) ) . addReg ( M88k :: R31 , RegState :: Define ) . addReg ( M88k :: R31 ) . addImm ( StackSize ) . setMIFlag ( MachineInstr :: FrameDestroy ) ; } } </s>


"-mno-mpy supported only for ARC700 or ARCv2"

"-mno-dpfp-lrsr supported only with -mdpfp"

"FPX fast and compact options cannot be specified together"

"-mspfp_fast not available on ARC600 or ARC601"

"PIC is not supported for %s. Generating non-PIC code only.."

Called by OVERRIDE_OPTIONS to initialize various things .


<s> static void ia64_asm_init_sections ( void ) { exception_section = get_unnamed_section ( 0 , output_section_asm_op , "\t.handlerdata" ) ; } </s>


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

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


<s> bool isVirtualSection ( const MCSection & Section ) const { const MCSectionMachO & SMO = static_cast < const MCSectionMachO & > ( Section ) ; return ( SMO . getType ( ) == MCSectionMachO :: S_ZEROFILL || SMO . getType ( ) == MCSectionMachO :: S_GB_ZEROFILL || SMO . getType ( ) == MCSectionMachO :: S_THREAD_LOCAL_ZEROFILL ) ; } </s>

Check whether this section is `` virtual '' , that is has no actual object file contents .


<s> bool AMDGPUTargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT ) const { if ( VT . getScalarType ( ) . getSimpleVT ( ) . SimpleTy == MVT :: f32 || VT . getScalarType ( ) . getSimpleVT ( ) . SimpleTy == MVT :: f64 ) { return true ; } else { return false ; } } </s>

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


<s> void mips_move_integer ( rtx temp , rtx dest , unsigned HOST_WIDE_INT value ) { struct mips_integer_op codes [ MIPS_MAX_INTEGER_OPS ] ; machine_mode mode ; unsigned int i , num_ops ; rtx x ; mode = GET_MODE ( dest ) ; num_ops = mips_build_integer ( codes , value ) ; x = GEN_INT ( codes [ 0 ] . value ) ; for ( i = 1 ; i < num_ops ; i ++ ) { if ( ! can_create_pseudo_p ( ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , temp , x ) ) ; x = temp ; } else x = force_reg ( mode , x ) ; x = gen_rtx_fmt_ee ( codes [ i ] . code , mode , x , GEN_INT ( codes [ i ] . value ) ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ; } </s>


<s> bool Thumb1FrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { if ( CSI . empty ( ) ) return false ; MachineFunction & MF = * MBB . getParent ( ) ; ARMFunctionInfo * AFI = MF . getInfo < ARMFunctionInfo > ( ) ; const TargetInstrInfo & TII = * STI . getInstrInfo ( ) ; bool isVarArg = AFI -> getArgRegsSaveSize ( ) > 0 ; DebugLoc DL = MI != MBB . end ( ) ? MI -> getDebugLoc ( ) : DebugLoc ( ) ; MachineInstrBuilder MIB = BuildMI ( MF , DL , TII . get ( ARM :: tPOP ) ) ; AddDefaultPred ( MIB ) ; bool NumRegs = false ; for ( unsigned i = CSI . size ( ) ; i != 0 ; -- i ) { unsigned Reg = CSI [ i - 1 ] . getReg ( ) ; if ( Reg == ARM :: LR && MBB . succ_empty ( ) ) { if ( isVarArg ) continue ; if ( STI . hasV4TOps ( ) && ! STI . hasV5TOps ( ) ) continue ; Reg = ARM :: PC ; ( * MIB ) . setDesc ( TII . get ( ARM :: tPOP_RET ) ) ; if ( MI != MBB . end ( ) ) MIB . copyImplicitOps ( & * MI ) ; MI = MBB . erase ( MI ) ; } MIB . addReg ( Reg , getDefRegState ( true ) ) ; NumRegs = true ; } if ( NumRegs ) MBB . insert ( MI , & * MIB ) ; else MF . DeleteMachineInstr ( MIB ) ; return true ; } </s>


<s> int const_ok_for_op ( HOST_WIDE_INT i , enum rtx_code code ) { if ( const_ok_for_arm ( i ) ) return 1 ; switch ( code ) { case SET : if ( arm_arch_thumb2 && ( i & 0xffff0000 ) == 0 ) return 1 ; else return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; case PLUS : if ( TARGET_THUMB2 && ( ( i & 0xfffff000 ) == 0 || ( ( - i ) & 0xfffff000 ) == 0 ) ) return 1 ; case COMPARE : case EQ : case NE : case GT : case LE : case LT : case GE : case GEU : case LTU : case GTU : case LEU : case UNORDERED : case ORDERED : case UNEQ : case UNGE : case UNLT : case UNGT : case UNLE : return const_ok_for_arm ( ARM_SIGN_EXTEND ( - i ) ) ; case MINUS : case XOR : return 0 ; case IOR : if ( TARGET_THUMB2 ) return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; return 0 ; case AND : return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; default : gcc_unreachable ( ) ; } } </s>

Return true if I is a valid constant for the operation CODE .


<s> std :: pair < unsigned , const TargetRegisterClass * > SITargetLowering :: getRegForInlineAsmConstraint ( const TargetRegisterInfo * TRI , StringRef Constraint , MVT VT ) const { if ( ! isTypeLegal ( VT ) ) return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 's' : case 'r' : switch ( VT . getSizeInBits ( ) ) { default : return std :: make_pair ( 0U , nullptr ) ; case 32 : case 16 : return std :: make_pair ( 0U , & AMDGPU :: SReg_32_XM0RegClass ) ; case 64 : return std :: make_pair ( 0U , & AMDGPU :: SGPR_64RegClass ) ; case 128 : return std :: make_pair ( 0U , & AMDGPU :: SReg_128RegClass ) ; case 256 : return std :: make_pair ( 0U , & AMDGPU :: SReg_256RegClass ) ; } case 'v' : switch ( VT . getSizeInBits ( ) ) { default : return std :: make_pair ( 0U , nullptr ) ; case 32 : case 16 : return std :: make_pair ( 0U , & AMDGPU :: VGPR_32RegClass ) ; case 64 : return std :: make_pair ( 0U , & AMDGPU :: VReg_64RegClass ) ; case 96 : return std :: make_pair ( 0U , & AMDGPU :: VReg_96RegClass ) ; case 128 : return std :: make_pair ( 0U , & AMDGPU :: VReg_128RegClass ) ; case 256 : return std :: make_pair ( 0U , & AMDGPU :: VReg_256RegClass ) ; case 512 : return std :: make_pair ( 0U , & AMDGPU :: VReg_512RegClass ) ; } } } if ( Constraint . size ( ) > 1 ) { const TargetRegisterClass * RC = nullptr ; if ( Constraint [ 1 ] == 'v' ) { RC = & AMDGPU :: VGPR_32RegClass ; } else if ( Constraint [ 1 ] == 's' ) { RC = & AMDGPU :: SGPR_32RegClass ; } if ( RC ) { uint32_t Idx ; bool Failed = Constraint . substr ( 2 ) . getAsInteger ( 10 , Idx ) ; if ( ! Failed && Idx < RC -> getNumRegs ( ) ) return std :: make_pair ( RC -> getRegister ( Idx ) , RC ) ; } } return TargetLowering :: getRegForInlineAsmConstraint ( TRI , Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> SparcTargetMachine :: SparcTargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , Optional < CodeModel :: Model > CM , CodeGenOpt :: Level OL , bool JIT , bool is64bit ) : LLVMTargetMachine ( T , computeDataLayout ( TT , is64bit ) , TT , CPU , FS , Options , getEffectiveRelocModel ( RM ) , getEffectiveCodeModel ( CM , getEffectiveRelocModel ( RM ) , is64bit , JIT ) , OL ) , TLOF ( make_unique < SparcELFTargetObjectFile > ( ) ) , Subtarget ( TT , CPU , FS , * this , is64bit ) , is64Bit ( is64bit ) { initAsmInfo ( ) ; } </s>


<s> bool X86InstrInfo :: areLoadsFromSameBasePtr ( SDNode * Load1 , SDNode * Load2 , int64_t & Offset1 , int64_t & Offset2 ) const { if ( ! Load1 -> isMachineOpcode ( ) || ! Load2 -> isMachineOpcode ( ) ) return false ; unsigned Opc1 = Load1 -> getMachineOpcode ( ) ; unsigned Opc2 = Load2 -> getMachineOpcode ( ) ; switch ( Opc1 ) { default : return false ; case X86 :: MOV8rm : case X86 :: MOV16rm : case X86 :: MOV32rm : case X86 :: MOV64rm : case X86 :: LD_Fp32m : case X86 :: LD_Fp64m : case X86 :: LD_Fp80m : case X86 :: MOVSSrm : case X86 :: MOVSDrm : case X86 :: MMX_MOVD64rm : case X86 :: MMX_MOVQ64rm : case X86 :: FsMOVAPSrm : case X86 :: FsMOVAPDrm : case X86 :: MOVAPSrm : case X86 :: MOVUPSrm : case X86 :: MOVUPSrm_Int : case X86 :: MOVAPDrm : case X86 :: MOVDQArm : case X86 :: MOVDQUrm : case X86 :: MOVDQUrm_Int : break ; } switch ( Opc2 ) { default : return false ; case X86 :: MOV8rm : case X86 :: MOV16rm : case X86 :: MOV32rm : case X86 :: MOV64rm : case X86 :: LD_Fp32m : case X86 :: LD_Fp64m : case X86 :: LD_Fp80m : case X86 :: MOVSSrm : case X86 :: MOVSDrm : case X86 :: MMX_MOVD64rm : case X86 :: MMX_MOVQ64rm : case X86 :: FsMOVAPSrm : case X86 :: FsMOVAPDrm : case X86 :: MOVAPSrm : case X86 :: MOVUPSrm : case X86 :: MOVUPSrm_Int : case X86 :: MOVAPDrm : case X86 :: MOVDQArm : case X86 :: MOVDQUrm : case X86 :: MOVDQUrm_Int : break ; } if ( Load1 -> getOperand ( 0 ) != Load2 -> getOperand ( 0 ) || Load1 -> getOperand ( 5 ) != Load2 -> getOperand ( 5 ) ) return false ; if ( Load1 -> getOperand ( 4 ) != Load2 -> getOperand ( 4 ) ) return false ; if ( Load1 -> getOperand ( 1 ) == Load2 -> getOperand ( 1 ) && Load1 -> getOperand ( 2 ) == Load2 -> getOperand ( 2 ) ) { if ( cast < ConstantSDNode > ( Load1 -> getOperand ( 1 ) ) -> getZExtValue ( ) != 1 ) return false ; SDValue Op2 = Load1 -> getOperand ( 2 ) ; if ( ! isa < RegisterSDNode > ( Op2 ) || cast < RegisterSDNode > ( Op2 ) -> getReg ( ) != 0 ) return 0 ; if ( isa < ConstantSDNode > ( Load1 -> getOperand ( 3 ) ) && isa < ConstantSDNode > ( Load2 -> getOperand ( 3 ) ) ) { Offset1 = cast < ConstantSDNode > ( Load1 -> getOperand ( 3 ) ) -> getSExtValue ( ) ; Offset2 = cast < ConstantSDNode > ( Load2 -> getOperand ( 3 ) ) -> getSExtValue ( ) ; return true ; } } return false ; } </s>

areLoadsFromSameBasePtr - This is used by the pre-regalloc scheduler to determine if two loads are loading from the same base address .


<s> static bool mips_split_addresses_p ( void ) { return ( TARGET_SPLIT_ADDRESSES && optimize && ! TARGET_MIPS16 && ! flag_pic && ! ABI_HAS_64BIT_SYMBOLS ) ; } </s>

Return true if -msplit-addresses is selected and should be honored . -msplit-addresses is a half-way house between explicit relocations and the traditional assembler macros . It can split absolute 32-bit symbolic constants into a high/lo_sum pair but uses macros for other sorts of access . Like explicit relocation support for REL targets , it relies on GNU extensions in the assembler and the linker . Although this code should work for -O0 , it has traditionally been treated as an optimization .


<s> unsigned getCacheLineSize ( ) { return 256 ; } </s>

Return the target cache line size in bytes .


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


<s> void J2MCCodeEmitter :: EmitInstruction ( uint64_t Val , unsigned Size , const MCSubtargetInfo & STI , raw_ostream & OS ) const { for ( unsigned i = 0 ; i < Size ; ++ i ) { unsigned Shift = i * 8 ; EmitByte ( ( Val >> Shift ) & 0xff , OS ) ; } } </s>

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


<s> virtual const ARMSubtarget * getSubtargetImpl ( ) const { return & Subtarget ; } </s>


<s> AArch64TargetLowering :: ConstraintType AArch64TargetLowering :: getConstraintType ( StringRef Constraint ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { default : break ; case 'z' : return C_Other ; case 'x' : case 'w' : return C_RegisterClass ; case 'Q' : return C_Memory ; } } return TargetLowering :: getConstraintType ( Constraint ) ; } </s>

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


<s>
unsigned
SparcTargetLowering
::
getRegisterByName
(
const
char
*
RegName
,
EVT
VT
,
SelectionDAG
&
DAG
)
const
{
unsigned
Reg
=
StringSwitch
<
unsigned
>
(
RegName
)
.
Case
(
"i0"
,
SP
::
I0
)
.
Case
(
"i1"
,
SP
::
I1
)
.
Case
(
"i2"
,
SP
::
I2
)
.
Case
(
"i3"
,
SP
::
I3
)
.
Case
(
"i4"
,
SP
::
I4
)
.
Case
(
"i5"
,
SP
::
I5
)
.
Case
(
"i6"
,
SP
::
I6
)
.
Case
(
"i7"
,
SP
::
I7
)
.
Case
(
"o0"
,
SP
::
O0
)
.
Case
(
"o1"
,
SP
::
O1
)
.
Case
(
"o2"
,
SP
::
O2
)
.
Case
(
"o3"
,
SP
::
O3
)
.
Case
(
"o4"
,
SP
::
O4
)
.
Case
(
"o5"
,
SP
::
O5
)
.
Case
(
"o6"
,
SP
::
O6
)
.
Case
(
"o7"
,
SP
::
O7
)
.
Case
(
"l0"
,
SP
::
L0
)
.
Case
(
"l1"
,
SP
::
L1
)
.
Case
(
"l2"
,
SP
::
L2
)
.
Case
(
"l3"
,
SP
::
L3
)
.
Case
(
"l4"
,
SP
::
L4
)
.
Case
(
"l5"
,
SP
::
L5
)
.
Case
(
"l6"
,
SP
::
L6
)
.
Case
(
"l7"
,
SP
::
L7
)
.
Case
(
"g0"
,
SP
::
G0
)
.
Case
(
"g1"
,
SP
::
G1
)
.
Case
(
"g2"
,
SP
::
G2
)
.
Case
(
"g3"
,
SP
::
G3
)
.
Case
(
"g4"
,
SP
::
G4
)
.
Case
(
"g5"
,
SP
::
G5
)
.
Case
(
"g6"
,
SP
::
G6
)
.
Case
(
"g7"
,
SP
::
G7
)
.
Default
(
0
)
;
if
(
Reg
)
return
Reg
;
report_fatal_error
(
"Invalid register name global variable"
)
;
}
</s>

Return the register ID of the name passed in .


"***** Machine Function before Domain Reassignment *****\n"

"***** Machine Function after Domain Reassignment *****\n"


<s> int direct_return_p ( void ) { frv_stack_t * info ; if ( ! reload_completed ) return FALSE ; info = frv_stack_info ( ) ; return ( info -> total_size == 0 ) ; } </s>

Return true if the bare return instruction can be used outside of the epilog code . For frv , we only do it if there was no stack allocation .


<s> void WebAssemblyExceptionInfo :: recalculate ( MachineDominatorTree & MDT , const MachineDominanceFrontier & MDF ) { SmallVector < std :: unique_ptr < WebAssemblyException > , 8 > Exceptions ; for ( auto DomNode : post_order ( & MDT ) ) { MachineBasicBlock * EHPad = DomNode -> getBlock ( ) ; if ( ! EHPad -> isEHPad ( ) ) continue ; auto WE = std :: make_unique < WebAssemblyException > ( EHPad ) ; discoverAndMapException ( WE . get ( ) , MDT , MDF ) ; Exceptions . push_back ( std :: move ( WE ) ) ; } for ( auto DomNode : post_order ( & MDT ) ) { MachineBasicBlock * MBB = DomNode -> getBlock ( ) ; WebAssemblyException * WE = getExceptionFor ( MBB ) ; for ( ; WE ; WE = WE -> getParentException ( ) ) WE -> addBlock ( MBB ) ; } SmallVector < WebAssemblyException * , 8 > ExceptionPointers ; ExceptionPointers . reserve ( Exceptions . size ( ) ) ; for ( auto & WE : Exceptions ) { ExceptionPointers . push_back ( WE . get ( ) ) ; if ( WE -> getParentException ( ) ) WE -> getParentException ( ) -> getSubExceptions ( ) . push_back ( std :: move ( WE ) ) ; else addTopLevelException ( std :: move ( WE ) ) ; } for ( auto * WE : ExceptionPointers ) { WE -> reverseBlock ( ) ; std :: reverse ( WE -> getSubExceptions ( ) . begin ( ) , WE -> getSubExceptions ( ) . end ( ) ) ; } } </s>

Notify DTU that the entry block was replaced .

WebAssembly WebAssembly WebAssembly 8 WebAssembly WebAssembly WebAssembly 8


<s> static tree rs6000_init_stack_protect_guard ( void ) { if ( rs6000_stack_protector_guard == SSP_GLOBAL ) return default_stack_protect_guard ( ) ; return NULL_TREE ; } </s>

Only create the global variable for the stack protect guard if we are using the global flavor of that guard .


<s> static bool rs6000_const_not_ok_for_debug_p ( rtx x ) { if ( GET_CODE ( x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) ) { rtx c = get_pool_constant ( x ) ; machine_mode cmode = get_pool_mode ( x ) ; if ( ASM_OUTPUT_SPECIAL_POOL_ENTRY_P ( c , cmode ) ) return true ; } return false ; } </s>

Return true if X should n't be emitted into the debug info . The linker does n't like .toc section references from .debug_ * sections , so reject .toc section symbols .


<s> bool ARMFrameLowering :: enableShrinkWrapping ( const MachineFunction & MF ) const { if ( STI . hasV8_1MMainlineOps ( ) && MF . getInfo < ARMFunctionInfo > ( ) -> isCmseNSEntryFunction ( ) ) return false ; if ( MF . getInfo < ARMFunctionInfo > ( ) -> shouldSignReturnAddress ( true ) ) return false ; return true ; } </s>

Returns true if the target will correctly handle shrink wrapping .


<s> unsigned Emitter < CodeEmitter > :: getMachineOpValue ( const MachineInstr & MI , const MachineOperand & MO ) { if ( MO . isReg ( ) ) return ARMRegisterInfo :: getRegisterNumbering ( MO . getReg ( ) ) ; else if ( MO . isImm ( ) ) return static_cast < unsigned > ( MO . getImm ( ) ) ; else if ( MO . isGlobal ( ) ) emitGlobalAddress ( MO . getGlobal ( ) , ARM :: reloc_arm_branch , true , false ) ; else if ( MO . isSymbol ( ) ) emitExternalSymbolAddress ( MO . getSymbolName ( ) , ARM :: reloc_arm_branch ) ; else if ( MO . isCPI ( ) ) { const TargetInstrDesc & TID = MI . getDesc ( ) ; unsigned Reloc = ( ( TID . TSFlags & ARMII :: FormMask ) == ARMII :: VFPLdStFrm ) ? ARM :: reloc_arm_vfp_cp_entry : ARM :: reloc_arm_cp_entry ; emitConstPoolAddress ( MO . getIndex ( ) , Reloc ) ; } else if ( MO . isJTI ( ) ) emitJumpTableAddress ( MO . getIndex ( ) , ARM :: reloc_arm_relative ) ; else if ( MO . isMBB ( ) ) emitMachineBasicBlock ( MO . getMBB ( ) , ARM :: reloc_arm_branch ) ; else { cerr << MO ; llvm_unreachable ( 0 ) ; } return 0 ; } </s>

getMachineOpValue - Return binary encoding of operand .


<s> rtx aarch64_atomic_ool_func ( machine_mode mode , rtx model_rtx , const atomic_ool_names * names ) { memmodel model = memmodel_base ( INTVAL ( model_rtx ) ) ; int mode_idx , model_idx ; switch ( mode ) { case E_QImode : mode_idx = 0 ; break ; case E_HImode : mode_idx = 1 ; break ; case E_SImode : mode_idx = 2 ; break ; case E_DImode : mode_idx = 3 ; break ; case E_TImode : mode_idx = 4 ; break ; default : gcc_unreachable ( ) ; } switch ( model ) { case MEMMODEL_RELAXED : model_idx = 0 ; break ; case MEMMODEL_CONSUME : case MEMMODEL_ACQUIRE : model_idx = 1 ; break ; case MEMMODEL_RELEASE : model_idx = 2 ; break ; case MEMMODEL_ACQ_REL : case MEMMODEL_SEQ_CST : model_idx = 3 ; break ; default : gcc_unreachable ( ) ; } return init_one_libfunc_visibility ( names -> str [ mode_idx ] [ model_idx ] , VISIBILITY_HIDDEN ) ; } </s>

We store the names of the various atomic helpers in a 5x4 array . Return the libcall function given MODE , MODEL and NAMES .


<s>
bool
fixupNeedsRelaxation
(
const
MCFixup
&
Fixup
,
uint64_t
Value
,
const
MCRelaxableFragment
*
DF
,
const
MCAsmLayout
&
Layout
)
const
override
{
llvm_unreachable
(
"RelaxInstruction() unimplemented"
)
;
return
false
;
}
</s>

Simple predicate for targets where ! Resolved implies requiring relaxation .


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

Return true if the specified instruction can be predicated .

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


"Unexpected Kind in getPointerRegClass!"

getPointerRegClass - Returns a TargetRegisterClass used for pointer values .


<s>
void
BTFDebug
::
beginFunctionImpl
(
const
MachineFunction
*
MF
)
{
auto
*
SP
=
MF
->
getFunction
(
)
.
getSubprogram
(
)
;
auto
*
Unit
=
SP
->
getUnit
(
)
;
if
(
Unit
->
getEmissionKind
(
)
==
DICompileUnit
::
NoDebug
)
{
SkipInstruction
=
true
;
return
;
}
SkipInstruction
=
false
;
if
(
MapDefNotCollected
)
{
processGlobals
(
true
)
;
MapDefNotCollected
=
false
;
}
std
::
unordered_map
<
uint32_t
,
StringRef
>
FuncArgNames
;
for
(
const
DINode
*
DN
:
SP
->
getRetainedNodes
(
)
)
{
if
(
const
auto
*
DV
=
dyn_cast
<
DILocalVariable
>
(
DN
)
)
{
uint32_t
Arg
=
DV
->
getArg
(
)
;
if
(
Arg
)
{
visitTypeEntry
(
DV
->
getType
(
)
)
;
FuncArgNames
[
Arg
]
=
DV
->
getName
(
)
;
}
}
}
uint32_t
ProtoTypeId
;
visitSubroutineType
(
SP
->
getType
(
)
,
true
,
FuncArgNames
,
ProtoTypeId
)
;
auto
FuncTypeEntry
=
std
::
make_unique
<
BTFTypeFunc
>
(
SP
->
getName
(
)
,
ProtoTypeId
)
;
uint32_t
FuncTypeId
=
addType
(
std
::
move
(
FuncTypeEntry
)
)
;
for
(
const
auto
&
TypeEntry
:
TypeEntries
)
TypeEntry
->
completeType
(
*
this
)
;
MCSymbol
*
FuncLabel
=
Asm
->
getFunctionBegin
(
)
;
BTFFuncInfo
FuncInfo
;
FuncInfo
.
Label
=
FuncLabel
;
FuncInfo
.
TypeId
=
FuncTypeId
;
if
(
FuncLabel
->
isInSection
(
)
)
{
MCSection
&
Section
=
FuncLabel
->
getSection
(
)
;
const
MCSectionELF
*
SectionELF
=
dyn_cast
<
MCSectionELF
>
(
&
Section
)
;
assert
(
SectionELF
&&
"Null section for Function Label"
)
;
SecNameOff
=
addString
(
SectionELF
->
getSectionName
(
)
)
;
}
else
{
SecNameOff
=
addString
(
".text"
)
;
}
FuncInfoTable
[
SecNameOff
]
.
push_back
(
FuncInfo
)
;
}
</s>

BPF
"Null section for Function Label"
".text"


<s>
const
MCFixupKindInfo
&
getFixupKindInfo
(
MCFixupKind
Kind
)
const
override
{
const
static
MCFixupKindInfo
Infos
[
X86
::
NumTargetFixupKinds
]
=
{
{
"reloc_riprel_4byte"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_riprel_4byte_movq_load"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_riprel_4byte_relax"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_riprel_4byte_relax_rex"
,
0
,
32
,
MCFixupKindInfo
::
FKF_IsPCRel
}
,
{
"reloc_signed_4byte"
,
0
,
32
,
0
}
,
{
"reloc_global_offset_table"
,
0
,
32
,
0
}
,
{
"reloc_global_offset_table8"
,
0
,
64
,
0
}
,
}
;
if
(
Kind
<
FirstTargetFixupKind
)
return
MCAsmBackend
::
getFixupKindInfo
(
Kind
)
;
assert
(
unsigned
(
Kind
FirstTargetFixupKind
)
<
getNumFixupKinds
(
)
&&
"Invalid kind!"
)
;
return
Infos
[
Kind
FirstTargetFixupKind
]
;
}
</s>


<s> const ARMSubtarget * ARMBaseTargetMachine :: getSubtargetImpl ( const Function & F ) const { Attribute CPUAttr = F . getFnAttribute ( "target-cpu" ) ; Attribute FSAttr = F . getFnAttribute ( "target-features" ) ; std :: string CPU = ! CPUAttr . hasAttribute ( Attribute :: None ) ? CPUAttr . getValueAsString ( ) . str ( ) : TargetCPU ; std :: string FS = ! FSAttr . hasAttribute ( Attribute :: None ) ? FSAttr . getValueAsString ( ) . str ( ) : TargetFS ; bool SoftFloat = F . getFnAttribute ( "use-soft-float" ) . getValueAsString ( ) == "true" ; if ( SoftFloat ) FS += FS . empty ( ) ? "+soft-float" : ",+soft-float" ; auto & I = SubtargetMap [ CPU + FS ] ; if ( ! I ) { resetTargetOptions ( F ) ; I = llvm :: make_unique < ARMSubtarget > ( TargetTriple , CPU , FS , * this , isLittle ) ; GISelAccessor * GISel = new GISelAccessor ( ) ; ARMGISelActualAccessor * GISel = new ARMGISelActualAccessor ( ) ; GISel -> CallLoweringInfo . reset ( new ARMCallLowering ( * I -> getTargetLowering ( ) ) ) ; GISel -> Legalizer . reset ( new ARMLegalizerInfo ( * I ) ) ; auto * RBI = new ARMRegisterBankInfo ( * I -> getRegisterInfo ( ) ) ; GISel -> InstSelector . reset ( createARMInstructionSelector ( * this , * I , * RBI ) ) ; GISel -> RegBankInfo . reset ( RBI ) ; I -> setGISelAccessor ( * GISel ) ; } return I . get ( ) ; } </s>

Virtual method implemented by subclasses that returns a reference to that target 's TargetSubtargetInfo-derived member variable .

ARM ARM ARM "target-cpu" "target-features" "use-soft-float" "true" "+soft-float" ",+soft-float" ARM ARM ARM ARM ARM ARM ARM


";; %smode fixup for i%d; addr %lu, range (%ld,%ld): "

Record INSN , which will need fixing up to load a value from the minipool . ADDRESS is the offset of the insn since the start of the function ; LOC is a pointer to the part of the insn which requires fixing ; VALUE is the constant that must be loaded , which is of type MODE .


"Basic block should contain at least a RET but is empty"

runOnMachineFunction - Emit the function body .


<s> bool BPFPreserveDIType :: runOnFunction ( Function & F ) { return BPFPreserveDITypeImpl ( F ) ; } </s>

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


<s> bool SIFixWWMLiveness :: runOnMachineFunction ( MachineFunction & MF ) { bool Modified = false ; LIS = getAnalysisIfAvailable < LiveIntervals > ( ) ; const GCNSubtarget & ST = MF . getSubtarget < GCNSubtarget > ( ) ; const SIInstrInfo * TII = ST . getInstrInfo ( ) ; TRI = & TII -> getRegisterInfo ( ) ; MRI = & MF . getRegInfo ( ) ; for ( MachineBasicBlock & MBB : MF ) { for ( MachineInstr & MI : MBB ) { if ( MI . getOpcode ( ) == AMDGPU :: EXIT_WWM ) { Modified |= runOnWWMInstruction ( MI ) ; } } } return Modified ; } </s>


<s>
TargetIRAnalysis
MipsTargetMachine
::
getTargetIRAnalysis
(
)
{
return
TargetIRAnalysis
(
[
this
]
(
Function
&
F
)
{
if
(
Subtarget
->
allowMixed16_32
(
)
)
{
DEBUG
(
errs
(
)
<<
"No Target Transform Info Pass Added\n"
)
;
return
TargetTransformInfo
(
getDataLayout
(
)
)
;
}
DEBUG
(
errs
(
)
<<
"Target Transform Info Pass Added\n"
)
;
return
TargetTransformInfo
(
BasicTTIImpl
(
this
,
F
)
)
;
}
)
;
}
</s>

Get a TargetIRAnalysis appropriate for the target .

Mips
Mips
"No Target Transform Info Pass Added\n"
"Target Transform Info Pass Added\n"


<s> void RISCVAsmPrinter :: emitStartOfAsmFile ( Module & M ) { if ( TM . getTargetTriple ( ) . isOSBinFormatELF ( ) ) emitAttributes ( ) ; } </s>

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


<s> SDValue LanaiSelectionDAGInfo :: EmitTargetCodeForMemcpy ( SelectionDAG & DAG , const SDLoc & dl , SDValue Chain , SDValue Dst , SDValue Src , SDValue Size , unsigned Align , bool isVolatile , bool AlwaysInline , MachinePointerInfo DstPtrInfo , MachinePointerInfo SrcPtrInfo ) const { ConstantSDNode * ConstantSize = dyn_cast < ConstantSDNode > ( Size ) ; if ( ! ConstantSize ) return SDValue ( ) ; return SDValue ( ) ; } </s>

Emit target-specific code that performs a memcpy .


"RelaxInstruction() is not implemented yet"


<s> void X86FrameLowering :: emitStackProbe ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , const DebugLoc & DL , bool InProlog ) const { const X86Subtarget & STI = MF . getSubtarget < X86Subtarget > ( ) ; if ( STI . isTargetWindowsCoreCLR ( ) ) { if ( InProlog ) { BuildMI ( MBB , MBBI , DL , TII . get ( X86 :: STACKALLOC_W_PROBING ) ) . addImm ( 0 ) ; } else { emitStackProbeInline ( MF , MBB , MBBI , DL , false ) ; } } else { emitStackProbeCall ( MF , MBB , MBBI , DL , InProlog ) ; } } </s>


<s>
static
void
*
device_malloc
(
size_t
size
,
hsa_region_t
region
)
{
void
*
result
;
XHSA
(
hsa_fns
.
hsa_memory_allocate_fn
(
region
,
size
,
&
result
)
,
"Allocate device memory"
)
;
return
result
;
}
</s>

Allocate some device memory from the kernargs region . The returned address will be 32-bit ( with excess zeroed on 64-bit host ) , and accessible via the same address on both host and target ( via __flat_scalar GCN address space ) .


"Wasn't expecting to be able to lower this!"

LowerOperation - Provide custom lowering hooks for some operations .


<s> std :: unique_ptr < SICacheControl > SICacheControl :: create ( const SISubtarget & ST ) { AMDGPUSubtarget :: Generation Generation = ST . getGeneration ( ) ; if ( Generation <= AMDGPUSubtarget :: SOUTHERN_ISLANDS ) return make_unique < SIGfx6CacheControl > ( ST ) ; return make_unique < SIGfx7CacheControl > ( ST ) ; } </s>


<s> void arm_load_pic_register ( unsigned long saved_regs ATTRIBUTE_UNUSED , rtx pic_reg ) { rtx l1 , labelno , pic_tmp , pic_rtx ; if ( crtl -> uses_pic_offset_table == 0 || TARGET_SINGLE_PIC_BASE ) return ; gcc_assert ( flag_pic ) ; if ( pic_reg == NULL_RTX ) pic_reg = cfun -> machine -> pic_reg ; if ( TARGET_VXWORKS_RTP ) { pic_rtx = gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_BASE ) ; pic_rtx = gen_rtx_CONST ( Pmode , pic_rtx ) ; emit_insn ( gen_pic_load_addr_32bit ( pic_reg , pic_rtx ) ) ; emit_insn ( gen_rtx_SET ( pic_reg , gen_rtx_MEM ( Pmode , pic_reg ) ) ) ; pic_tmp = gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_INDEX ) ; emit_insn ( gen_pic_offset_arm ( pic_reg , pic_reg , pic_tmp ) ) ; } else { labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; pic_rtx = plus_constant ( Pmode , l1 , TARGET_ARM ? 8 : 4 ) ; pic_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( 1 , pic_rtx ) , UNSPEC_GOTSYM_OFF ) ; pic_rtx = gen_rtx_CONST ( Pmode , pic_rtx ) ; if ( TARGET_32BIT ) { emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; } else { if ( arm_pic_register != INVALID_REGNUM && REGNO ( pic_reg ) > LAST_LO_REGNUM ) { pic_tmp = gen_rtx_REG ( SImode , thumb_find_work_register ( saved_regs ) ) ; emit_insn ( gen_pic_load_addr_thumb1 ( pic_tmp , pic_rtx ) ) ; emit_insn ( gen_movsi ( pic_offset_table_rtx , pic_tmp ) ) ; emit_insn ( gen_pic_add_dot_plus_four ( pic_reg , pic_reg , labelno ) ) ; } else if ( arm_pic_register != INVALID_REGNUM && arm_pic_register > LAST_LO_REGNUM && REGNO ( pic_reg ) <= LAST_LO_REGNUM ) { emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; emit_move_insn ( gen_rtx_REG ( Pmode , arm_pic_register ) , pic_reg ) ; emit_use ( gen_rtx_REG ( Pmode , arm_pic_register ) ) ; } else emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; } } emit_use ( pic_reg ) ; } </s>

Generate code to load the PIC register . In thumb mode SCRATCH is a low register .


<s> std :: pair < unsigned , unsigned > MOSInstrInfo :: decomposeMachineOperandsTargetFlags ( unsigned TF ) const { return std :: make_pair ( TF , 0u ) ; } </s>

Decompose the machine operand 's target flags into two values - the direct target flag value and any of bit flags that are applied .


<s> bool M68kPassConfig :: addGlobalInstructionSelect ( ) { addPass ( new InstructionSelect ( ) ) ; return false ; } </s>

This method should install a ( global ) instruction selector pass , which converts possibly generic instructions to fully target-specific instructions , thereby constraining all generic virtual registers to register classes .


<s> static void load_reg ( int reg , HOST_WIDE_INT disp , int base ) { rtx dest = gen_rtx_REG ( word_mode , reg ) ; rtx basereg = gen_rtx_REG ( Pmode , base ) ; rtx src ; if ( VAL_14_BITS_P ( disp ) ) src = gen_rtx_MEM ( word_mode , plus_constant ( Pmode , basereg , disp ) ) ; else if ( TARGET_64BIT && ! VAL_32_BITS_P ( disp ) ) { rtx delta = GEN_INT ( disp ) ; rtx tmpreg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( tmpreg , delta ) ; if ( TARGET_DISABLE_INDEXING ) { emit_move_insn ( tmpreg , gen_rtx_PLUS ( Pmode , tmpreg , basereg ) ) ; src = gen_rtx_MEM ( word_mode , tmpreg ) ; } else src = gen_rtx_MEM ( word_mode , gen_rtx_PLUS ( Pmode , tmpreg , basereg ) ) ; } else { rtx delta = GEN_INT ( disp ) ; rtx high = gen_rtx_PLUS ( Pmode , basereg , gen_rtx_HIGH ( Pmode , delta ) ) ; rtx tmpreg = gen_rtx_REG ( Pmode , 1 ) ; emit_move_insn ( tmpreg , high ) ; src = gen_rtx_MEM ( word_mode , gen_rtx_LO_SUM ( Pmode , tmpreg , delta ) ) ; } emit_move_insn ( dest , src ) ; } </s>

Emit RTL to load REG from the memory location specified by BASE+DISP . Handle case where DISP > 8k by using the add_high_const patterns .


<s> static void frv_registers_update ( rtx x ) { regstate_t flags ; flags = REGSTATE_MODIFIED ; if ( GET_CODE ( x ) == COND_EXEC ) { flags |= frv_cond_flags ( XEXP ( x , 0 ) ) ; x = XEXP ( x , 1 ) ; } note_stores ( x , frv_registers_update_1 , & flags ) ; } </s>

Update the register state information for an instruction whose body is X .


<s> void i386_pe_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( first && TREE_CODE ( decl ) == FUNCTION_DECL ) { tree type_attributes = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; tree newid = NULL_TREE ; if ( lookup_attribute ( "stdcall" , type_attributes ) ) newid = gen_stdcall_or_fastcall_suffix ( decl , false ) ; else if ( lookup_attribute ( "fastcall" , type_attributes ) ) newid = gen_stdcall_or_fastcall_suffix ( decl , true ) ; if ( newid != NULL_TREE ) { rtx rtlname = XEXP ( rtl , 0 ) ; if ( GET_CODE ( rtlname ) == MEM ) rtlname = XEXP ( rtlname , 0 ) ; XSTR ( rtlname , 0 ) = IDENTIFIER_POINTER ( newid ) ; change_decl_assembler_name ( decl , newid ) ; } } if ( i386_pe_dllexport_p ( decl ) ) i386_pe_mark_dllexport ( decl ) ; else if ( i386_pe_dllimport_p ( decl ) ) i386_pe_mark_dllimport ( decl ) ; else gcc_assert ( ! ( ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CODE ( decl ) == VAR_DECL ) && rtl != NULL_RTX && GET_CODE ( rtl ) == MEM && GET_CODE ( XEXP ( rtl , 0 ) ) == MEM && GET_CODE ( XEXP ( XEXP ( rtl , 0 ) , 0 ) ) == SYMBOL_REF && i386_pe_dllimport_name_p ( XSTR ( XEXP ( XEXP ( rtl , 0 ) , 0 ) , 0 ) ) ) ) ; } </s>

Cover function to implement ENCODE_SECTION_INFO .


<s> bool AArch64TargetLowering :: preferIncOfAddToSubOfNot ( EVT VT ) const { return VT . isScalarInteger ( ) ; } </s>

These two forms are equivalent : sub y , ( xor x , -1 ) add ( add x , 1 ) , y The variant with two add 's is IR-canonical .


<s>
MachineBasicBlock
*
M68kTargetLowering
::
EmitInstrWithCustomInserter
(
MachineInstr
&
MI
,
MachineBasicBlock
*
BB
)
const
{
switch
(
MI
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Unexpected instr type to insert"
)
;
case
M68k
::
CMOV8d
:
case
M68k
::
CMOV16d
:
case
M68k
::
CMOV32r
:
return
EmitLoweredSelect
(
MI
,
BB
)
;
case
M68k
::
SALLOCA
:
return
EmitLoweredSegAlloca
(
MI
,
BB
)
;
}
}
</s>

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


<s>
const
char
*
getPassName
(
)
const
override
{
return
"SI Type Rewriter"
;
}
</s>

getPassName - Return a nice clean name for a pass .


<s> static int unspec_sqrdcmlah ( int rot ) { switch ( rot ) { case 0 : return UNSPEC_SQRDCMLAH ; case 90 : return UNSPEC_SQRDCMLAH90 ; case 180 : return UNSPEC_SQRDCMLAH180 ; case 270 : return UNSPEC_SQRDCMLAH270 ; default : gcc_unreachable ( ) ; } } </s>

Return the UNSPEC_SQRDCMLAH * unspec for rotation amount ROT .


<s> static bool conditions_opposite_p ( rtx cond1 , rtx cond2 ) { return ( rtx_equal_p ( XEXP ( cond1 , 0 ) , XEXP ( cond2 , 0 ) ) && rtx_equal_p ( XEXP ( cond1 , 1 ) , XEXP ( cond2 , 1 ) ) && GET_CODE ( cond1 ) == reverse_condition ( GET_CODE ( cond2 ) ) ) ; } </s>

Return true iff COND1 and COND2 are exactly opposite conditions one of them NE and the other EQ .


<s> StackOffset AArch64FrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { return resolveFrameIndexReference ( MF , FI , FrameReg , MF . getFunction ( ) . hasFnAttribute ( Attribute :: SanitizeHWAddress ) , false ) ; } </s>

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


<s> bool isReg ( ) const override { return Kind == Register && Reg . Modifiers == - 1 ; } </s>


<s> virtual bool runOnMachineFunction ( MachineFunction & MF ) { MachineFrameInfo * FFI = MF . getFrameInfo ( ) ; MachineRegisterInfo & RI = MF . getRegInfo ( ) ; unsigned MaxAlign = calculateMaxStackAlignment ( FFI ) ; for ( unsigned RegNum = TargetRegisterInfo :: FirstVirtualRegister ; RegNum < RI . getLastVirtReg ( ) ; ++ RegNum ) MaxAlign = std :: max ( MaxAlign , RI . getRegClass ( RegNum ) -> getAlignment ( ) ) ; if ( FFI -> getMaxAlignment ( ) == MaxAlign ) return false ; FFI -> setMaxAlignment ( MaxAlign ) ; return true ; } </s>

runOnMachineFunction - Emit the function body .


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

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


<s> FunctionPass * TVMPassConfig :: createTargetRegisterAllocator ( bool ) { return nullptr ; } </s>

createTargetRegisterAllocator - Create the register allocator pass for this target at the current optimization level .


<s>
void
NVPTXFrameLowering
::
emitPrologue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
if
(
MF
.
getFrameInfo
(
)
->
hasStackObjects
(
)
)
{
assert
(
&
MF
.
front
(
)
==
&
MBB
&&
"Shrink-wrapping not yet supported"
)
;
MachineInstr
*
MI
=
&
MBB
.
front
(
)
;
MachineRegisterInfo
&
MR
=
MF
.
getRegInfo
(
)
;
DebugLoc
dl
=
DebugLoc
(
)
;
bool
Is64Bit
=
static_cast
<
const
NVPTXTargetMachine
&
>
(
MF
.
getTarget
(
)
)
.
is64Bit
(
)
;
unsigned
CvtaLocalOpcode
=
(
Is64Bit
NVPTX
::
cvta_local_yes_64
:
NVPTX
::
cvta_local_yes
)
;
unsigned
MovDepotOpcode
=
(
Is64Bit
NVPTX
::
MOV_DEPOT_ADDR_64
:
NVPTX
::
MOV_DEPOT_ADDR
)
;
if
(
!
MR
.
use_empty
(
NVPTX
::
VRFrame
)
)
{
MI
=
BuildMI
(
MBB
,
MI
,
dl
,
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
->
get
(
CvtaLocalOpcode
)
,
NVPTX
::
VRFrame
)
.
addReg
(
NVPTX
::
VRFrameLocal
)
;
}
BuildMI
(
MBB
,
MI
,
dl
,
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
->
get
(
MovDepotOpcode
)
,
NVPTX
::
VRFrameLocal
)
.
addImm
(
MF
.
getFunctionNumber
(
)
)
;
}
}
</s>

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

NVPTX
NVPTX
"Shrink-wrapping not yet supported"
NVPTX
NVPTX::cvta_local_yes_64
NVPTX::cvta_local_yes
NVPTX::MOV_DEPOT_ADDR_64
NVPTX::MOV_DEPOT_ADDR
NVPTX::VRFrame
NVPTX::VRFrame
NVPTX::VRFrameLocal
NVPTX::VRFrameLocal


<s> machine_mode nvptx_underlying_object_mode ( rtx obj ) { if ( GET_CODE ( obj ) == SUBREG ) obj = SUBREG_REG ( obj ) ; machine_mode mode = GET_MODE ( obj ) ; if ( mode == TImode ) return DImode ; if ( COMPLEX_MODE_P ( mode ) ) return GET_MODE_INNER ( mode ) ; return mode ; } </s>

Return the mode to be used when declaring a ptx object for OBJ . For objects with subparts such as complex modes this is the mode of the subpart .


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

LowerOperation - Provide custom lowering hooks for some operations .


<s>
void
dump
(
)
{
errs
(
)
<<
"rriCoreISelAddressMode "
<<
this
<<
'\n'
;
if
(
BaseType
==
RegBase
&&
Base
.
Reg
.
getNode
(
)
!=
nullptr
)
{
errs
(
)
<<
"Base.Reg "
;
Base
.
Reg
.
getNode
(
)
->
dump
(
)
;
}
else
if
(
BaseType
==
FrameIndexBase
)
{
errs
(
)
<<
" Base.FrameIndex "
<<
Base
.
FrameIndex
<<
'\n'
;
}
errs
(
)
<<
" Disp "
<<
Disp
<<
'\n'
;
if
(
GV
)
{
errs
(
)
<<
"GV "
;
GV
->
dump
(
)
;
}
else
if
(
CP
)
{
errs
(
)
<<
" CP "
;
CP
->
dump
(
)
;
errs
(
)
<<
" Align"
<<
Align
<<
'\n'
;
}
else
if
(
ES
)
{
errs
(
)
<<
"ES "
;
errs
(
)
<<
ES
<<
'\n'
;
}
else
if
(
JT
!=
1
)
errs
(
)
<<
" JT"
<<
JT
<<
" Align"
<<
Align
<<
'\n'
;
}
</s>

Dump the plan to stderr ( for debugging ) .

TriCore
"rriCoreISelAddressMode "
"Base.Reg "
" Base.FrameIndex "
" Disp "
"GV "
" CP "
" Align"
"ES "
1
" JT"
" Align"


<s> void alpha_split_atomic_exchange ( rtx operands [ ] ) { rtx retval , mem , val , scratch ; enum memmodel model ; machine_mode mode ; rtx label , x , cond ; retval = operands [ 0 ] ; mem = operands [ 1 ] ; val = operands [ 2 ] ; model = ( enum memmodel ) INTVAL ( operands [ 3 ] ) ; scratch = operands [ 4 ] ; mode = GET_MODE ( mem ) ; cond = gen_lowpart ( DImode , scratch ) ; alpha_pre_atomic_barrier ( model ) ; label = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label , 0 ) ) ; emit_insn ( gen_load_locked ( mode , retval , mem ) ) ; emit_move_insn ( scratch , val ) ; emit_insn ( gen_store_conditional ( mode , cond , mem , scratch ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label ) ; alpha_post_atomic_barrier ( model ) ; } </s>


<s> bool m68k_legitimate_address_p ( machine_mode mode , rtx x , bool strict_p ) { struct m68k_address address ; return m68k_decompose_address ( mode , x , strict_p , & address ) ; } </s>

Return true if X is a legitimate address for values of mode MODE . STRICT_P says whether strict checking is needed .


<s> void GCNPassConfig :: addOptimizedRegAlloc ( FunctionPass * RegAllocPass ) { insertPass ( & MachineSchedulerID , & SIFixControlFlowLiveIntervalsID ) ; insertPass ( & RenameIndependentSubregsID , & SILowerControlFlowID ) ; TargetPassConfig :: addOptimizedRegAlloc ( RegAllocPass ) ; } </s>

addOptimizedRegAlloc - Add passes related to register allocation .


<s> static ia64_addr_area ia64_get_addr_area ( tree decl ) { tree model_attr ; model_attr = lookup_attribute ( "model" , DECL_ATTRIBUTES ( decl ) ) ; if ( model_attr ) { tree id ; init_idents ( ) ; id = TREE_VALUE ( TREE_VALUE ( model_attr ) ) ; if ( id == small_ident1 || id == small_ident2 ) return ADDR_AREA_SMALL ; } return ADDR_AREA_NORMAL ; } </s>

Retrieve the address area that has been chosen for the given decl .


<s>
bool
X86TargetLowering
::
isNoopAddrSpaceCast
(
unsigned
SrcAS
,
unsigned
DestAS
)
const
{
assert
(
SrcAS
!=
DestAS
&&
"Expected different address spaces!"
)
;
const
TargetMachine
&
TM
=
getTargetMachine
(
)
;
if
(
TM
.
getPointerSize
(
SrcAS
)
!=
TM
.
getPointerSize
(
DestAS
)
)
return
false
;
return
SrcAS
<
256
&&
DestAS
<
256
;
}
</s>

Returns true if a cast between SrcAS and DestAS is a noop .


"ERROR: Unknown type of MachineOperand: "

getMachineOpValue - Return binary encoding of operand .


<s>
void
ARMTargetLowering
::
HandleByVal
(
CCState
*
State
,
unsigned
&
Size
,
unsigned
Align
)
const
{
assert
(
(
State
->
getCallOrPrologue
(
)
==
Prologue
||
State
->
getCallOrPrologue
(
)
==
Call
)
&&
"unhandled ParmContext"
)
;
Align
=
std
::
max
(
Align
,
4U
)
;
unsigned
Reg
=
State
->
AllocateReg
(
GPRArgRegs
)
;
if
(
!
Reg
)
return
;
unsigned
AlignInRegs
=
Align
/
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> static bool mips_near_type_p ( const_tree type ) { return ( lookup_attribute ( "short_call" , TYPE_ATTRIBUTES ( type ) ) != NULL || lookup_attribute ( "near" , TYPE_ATTRIBUTES ( type ) ) != NULL ) ; } </s>

Predicates to test for presence of `` near '' and `` far '' / '' long_call '' attributes on the given TYPE .


<s> static void emit_final_str_compare_gpr ( rtx str1 , rtx str2 , rtx result ) { machine_mode m = GET_MODE ( str1 ) ; rtx rot_amt = gen_reg_rtx ( m ) ; rtx rot1_1 = gen_reg_rtx ( m ) ; rtx rot1_2 = gen_reg_rtx ( m ) ; rtx rot2_1 = gen_reg_rtx ( m ) ; rtx rot2_2 = gen_reg_rtx ( m ) ; if ( m == SImode ) { emit_insn ( gen_clzsi2 ( rot_amt , result ) ) ; emit_insn ( gen_addsi3 ( rot_amt , rot_amt , GEN_INT ( 8 ) ) ) ; emit_insn ( gen_rotlsi3 ( rot1_1 , str1 , gen_lowpart ( SImode , rot_amt ) ) ) ; emit_insn ( gen_andsi3_mask ( rot1_2 , rot1_1 , GEN_INT ( 0xff ) ) ) ; emit_insn ( gen_rotlsi3 ( rot2_1 , str2 , gen_lowpart ( SImode , rot_amt ) ) ) ; emit_insn ( gen_andsi3_mask ( rot2_2 , rot2_1 , GEN_INT ( 0xff ) ) ) ; emit_insn ( gen_subsi3 ( result , rot1_2 , rot2_2 ) ) ; } else if ( m == DImode ) { emit_insn ( gen_clzdi2 ( rot_amt , result ) ) ; emit_insn ( gen_adddi3 ( rot_amt , rot_amt , GEN_INT ( 8 ) ) ) ; emit_insn ( gen_rotldi3 ( rot1_1 , str1 , gen_lowpart ( SImode , rot_amt ) ) ) ; emit_insn ( gen_anddi3_mask ( rot1_2 , rot1_1 , GEN_INT ( 0xff ) ) ) ; emit_insn ( gen_rotldi3 ( rot2_1 , str2 , gen_lowpart ( SImode , rot_amt ) ) ) ; emit_insn ( gen_anddi3_mask ( rot2_2 , rot2_1 , GEN_INT ( 0xff ) ) ) ; emit_insn ( gen_subdi3 ( result , rot1_2 , rot2_2 ) ) ; } else gcc_unreachable ( ) ; return ; } </s>

Generate the final sequence that identifies the differing byte and generates the final result , taking into account zero bytes : cntlzd get bit of first zero/diff byte addi convert for rldcl use rldcl rldcl extract diff/zero byte subf subtract for final result STR1 is the reg rtx for data from string 1 . STR2 is the reg rtx for data from string 2 . RESULT is the reg rtx for the comparison result .


<s> void AArch64WinCOFFStreamer :: finishImpl ( ) { emitFrames ( nullptr ) ; emitWindowsUnwindTables ( ) ; MCWinCOFFStreamer :: finishImpl ( ) ; } </s>


<s> void R600TTIImpl :: getPeelingPreferences ( Loop * L , ScalarEvolution & SE , TTI :: PeelingPreferences & PP ) { CommonTTI . getPeelingPreferences ( L , SE , PP ) ; } </s>

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


<s> virtual void * getAdjustedAnalysisPointer ( const void * ID ) { if ( ID == & TargetTransformInfo :: ID ) return ( TargetTransformInfo * ) this ; return this ; } </s>

getAdjustedAnalysisPointer - This method is used when a pass implements an analysis interface through multiple inheritance .


<s> void X86AsmPrinter :: emitEndOfAsmFile ( Module & M ) { const Triple & TT = TM . getTargetTriple ( ) ; emitAsanMemaccessSymbols ( M ) ; if ( TT . isOSBinFormatMachO ( ) ) { emitNonLazyStubs ( MMI , * OutStreamer ) ; emitStackMaps ( SM ) ; FM . serializeToFaultMapSection ( ) ; OutStreamer -> emitAssemblerFlag ( MCAF_SubsectionsViaSymbols ) ; } else if ( TT . isOSBinFormatCOFF ( ) ) { if ( MMI -> usesMSVCFloatingPoint ( ) ) { StringRef SymbolName = ( TT . getArch ( ) == Triple :: x86 ) ? "__fltused" : "_fltused" ; MCSymbol * S = MMI -> getContext ( ) . getOrCreateSymbol ( SymbolName ) ; OutStreamer -> emitSymbolAttribute ( S , MCSA_Global ) ; return ; } emitStackMaps ( SM ) ; } else if ( TT . isOSBinFormatELF ( ) ) { emitStackMaps ( SM ) ; FM . serializeToFaultMapSection ( ) ; } } </s>

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


<s> static unsigned long get_csky_isr_type ( tree argument ) { const isr_attribute_entry * ptr ; const char * arg ; if ( argument == NULL_TREE ) return CSKY_FT_ISR ; if ( TREE_VALUE ( argument ) == NULL_TREE || TREE_CODE ( TREE_VALUE ( argument ) ) != STRING_CST ) return CSKY_FT_UNKNOWN ; arg = TREE_STRING_POINTER ( TREE_VALUE ( argument ) ) ; for ( ptr = isr_attribute_map ; ptr -> arg != NULL ; ptr ++ ) if ( strcmp ( arg , ptr -> arg ) == 0 ) return ptr -> return_value ; return CSKY_FT_UNKNOWN ; } </s>

Return the function type of the current function , if it has not been determined , return CSKY_FT_UNKNOWN .


<s> static unsigned int ATTRIBUTE_UNUSED x86_64_elf_section_type_flags ( tree decl , const char * name , int reloc ) { unsigned int flags = default_section_type_flags ( decl , name , reloc ) ; if ( decl == NULL_TREE && ( strcmp ( name , ".ldata.rel.ro" ) == 0 || strcmp ( name , ".ldata.rel.ro.local" ) == 0 ) ) flags |= SECTION_RELRO ; if ( strcmp ( name , ".lbss" ) == 0 || strncmp ( name , ".lbss." , 5 ) == 0 || strncmp ( name , ".gnu.linkonce.lb." , 16 ) == 0 ) flags |= SECTION_BSS ; return flags ; } </s>

Select a set of attributes for section NAME based on the properties of DECL and whether or not RELOC indicates that DECL 's initializer might contain runtime relocations .


<s> Register NVPTXRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { return NVPTX :: VRFrame ; } </s>


<s> opt_machine_mode aarch64_full_sve_mode ( scalar_mode mode ) { switch ( mode ) { case E_DFmode : return VNx2DFmode ; case E_SFmode : return VNx4SFmode ; case E_HFmode : return VNx8HFmode ; case E_BFmode : return VNx8BFmode ; case E_DImode : return VNx2DImode ; case E_SImode : return VNx4SImode ; case E_HImode : return VNx8HImode ; case E_QImode : return VNx16QImode ; default : return opt_machine_mode ( ) ; } } </s>

Return the full-width SVE vector mode for element mode MODE , if one exists .


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

runOnMachineFunction - Emit the function body .


<s> void assignValueToReg ( Register ValVReg , Register PhysReg , CCValAssign & VA ) override { MIB . addUse ( PhysReg , RegState :: Implicit ) ; Register ExtReg = extendRegisterMin32 ( ValVReg , VA ) ; MIRBuilder . buildCopy ( PhysReg , ExtReg ) ; } </s>

The specified value has been assigned to a physical register , handle the appropriate COPY ( either to or from ) and mark any relevant uses/defines as needed .


<s> unsigned ARMFastISel :: constrainOperandRegClass ( const MCInstrDesc & II , unsigned Op , unsigned OpNum ) { if ( TargetRegisterInfo :: isVirtualRegister ( Op ) ) { const TargetRegisterClass * RegClass = TII . getRegClass ( II , OpNum , & TRI , * FuncInfo . MF ) ; if ( ! MRI . constrainRegClass ( Op , RegClass ) ) { unsigned NewOp = createResultReg ( RegClass ) ; AddOptionalDefs ( BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DL , TII . get ( TargetOpcode :: COPY ) , NewOp ) . addReg ( Op ) ) ; return NewOp ; } } return Op ; } </s>

Try to constrain Op so that it is usable by argument OpNum of the provided MCInstrDesc .


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

Print the specified MCInst to the specified raw_ostream .


<s> void arm_lang_object_attributes_init ( void ) { arm_lang_output_object_attributes_hook = arm_output_c_attributes ; } </s>

Setup so that common code calls arm_output_c_attributes .


<s> unsigned getGlobalBaseReg ( ) const { return GlobalBaseReg ; } </s>

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


<s> const LegalizerInfo * getLegalizerInfo ( ) const override { return Legalizer . get ( ) ; } </s>

Expose LegalizerInfo so the clients can re-use .


<s> static tree ix86_stack_protect_guard ( void ) { if ( TARGET_SSP_TLS_GUARD ) return NULL_TREE ; return default_stack_protect_guard ( ) ; } </s>

If using TLS guards , do n't waste time creating and expanding __stack_chk_guard decl and MEM as we are going to ignore it .


<s> int v9_regcmp_p ( enum rtx_code code ) { return ( code == EQ || code == NE || code == GE || code == LT || code == LE || code == GT ) ; } </s>

Nonzero if CODE , a comparison , is suitable for use in v9 conditional move or branch on register contents instructions .


<s> bool nds32_n10_ex_to_ex_p ( rtx_insn * producer , rtx_insn * consumer ) { gcc_assert ( get_attr_type ( producer ) == TYPE_FLOAD || get_attr_type ( producer ) == TYPE_FSTORE ) ; gcc_assert ( get_attr_type ( consumer ) == TYPE_FLOAD || get_attr_type ( consumer ) == TYPE_FSTORE ) ; if ( ! post_update_insn_p ( producer ) ) return false ; return reg_overlap_p ( extract_base_reg ( producer ) , extract_mem_rtx ( consumer ) ) ; } </s>

Check dependencies from EX to EX ( ADDR_OUT - > ADDR_IN ) .


<s>
bool
ARMCodeGenPrepare
::
runOnFunction
(
Function
&
F
)
{
if
(
skipFunction
(
F
)
||
DisableCGP
)
return
false
;
auto
*
TPC
=
&
getAnalysis
<
TargetPassConfig
>
(
)
;
if
(
!
TPC
)
return
false
;
const
TargetMachine
&
TM
=
TPC
->
getTM
<
TargetMachine
>
(
)
;
ST
=
&
TM
.
getSubtarget
<
ARMSubtarget
>
(
F
)
;
bool
MadeChange
=
false
;
LLVM_DEBUG
(
dbgs
(
)
<<
"ARM CGP: Running on "
<<
F
.
getName
(
)
<<
"\n"
)
;
for
(
BasicBlock
&
BB
:
F
)
{
auto
&
Insts
=
BB
.
getInstList
(
)
;
for
(
auto
&
I
:
Insts
)
{
if
(
AllVisited
.
count
(
&
I
)
)
continue
;
if
(
isa
<
ICmpInst
>
(
I
)
)
{
auto
&
CI
=
cast
<
ICmpInst
>
(
I
)
;
if
(
CI
.
isSigned
(
)
||
!
isa
<
IntegerType
>
(
CI
.
getOperand
(
0
)
->
getType
(
)
)
)
continue
;
LLVM_DEBUG
(
dbgs
(
)
<<
"ARM CGP: Searching from: "
<<
CI
<<
"\n"
)
;
for
(
auto
&
Op
:
CI
.
operands
(
)
)
{
if
(
auto
*
I
=
dyn_cast
<
Instruction
>
(
Op
)
)
{
if
(
isa
<
ZExtInst
>
(
I
)
)
MadeChange
|=
TryToPromote
(
I
->
getOperand
(
0
)
)
;
else
MadeChange
|=
TryToPromote
(
I
)
;
}
}
}
}
Promoter
->
Cleanup
(
)
;
LLVM_DEBUG
(
if
(
verifyFunction
(
F
,
&
dbgs
(
)
)
)
{
dbgs
(
)
;
report_fatal_error
(
"Broken function after type promotion"
)
;
}
)
;
}
if
(
MadeChange
)
LLVM_DEBUG
(
dbgs
(
)
<<
"After ARMCodeGenPrepare: "
<<
F
<<
"\n"
)
;
return
MadeChange
;
}
</s>

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

ARM
ARM
ARM
"ARM CGP: Running on "
"\n"
0
"ARM CGP: Searching from: "
"\n"
0
"Broken function after type promotion"
"After ARMCodeGenPrepare: "
"\n"


"' function does not match module xnack setting"

"' function does not match module sramecc setting"

Targets can override this to emit stuff before the first basic block in the function .