<s>
const
char
*
ashrhi3_out
(
rtx_insn
*
insn
,
rtx
operands
[
]
,
int
*
len
)
{
if
(
GET_CODE
(
operands
[
2
]
)
==
CONST_INT
)
{
int
scratch
=
(
GET_CODE
(
PATTERN
(
insn
)
)
==
PARALLEL
)
;
int
ldi_ok
=
test_hard_reg_class
(
LD_REGS
,
operands
[
0
]
)
;
int
k
;
int
*
t
=
len
;
if
(
!
len
)
len
=
&
k
;
switch
(
INTVAL
(
operands
[
2
]
)
)
{
case
4
:
case
5
:
break
;
case
6
:
if
(
optimize_size
)
break
;
*
len
=
8
;
return
(
"mov __tmp_reg__,%A0"
CR_TAB
"mov %A0,%B0"
CR_TAB
"lsl __tmp_reg__"
CR_TAB
"rol %A0"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"lsl __tmp_reg__"
CR_TAB
"rol %A0"
CR_TAB
"rol %B0"
)
;
case
7
:
*
len
=
4
;
return
(
"lsl %A0"
CR_TAB
"mov %A0,%B0"
CR_TAB
"rol %A0"
CR_TAB
"sbc %B0,%B0"
)
;
case
8
:
{
int
reg0
=
true_regnum
(
operands
[
0
]
)
;
int
reg1
=
true_regnum
(
operands
[
1
]
)
;
if
(
reg0
==
reg1
)
return
*
len
=
3
,
(
"mov %A0,%B0"
CR_TAB
"lsl %B0"
CR_TAB
"sbc %B0,%B0"
)
;
else
return
*
len
=
4
,
(
"mov %A0,%B1"
CR_TAB
"clr %B0"
CR_TAB
"sbrc %A0,7"
CR_TAB
"dec %B0"
)
;
}
case
9
:
*
len
=
4
;
return
(
"mov %A0,%B0"
CR_TAB
"lsl %B0"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"asr %A0"
)
;
case
10
:
*
len
=
5
;
return
(
"mov %A0,%B0"
CR_TAB
"lsl %B0"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
)
;
case
11
:
if
(
AVR_HAVE_MUL
&&
ldi_ok
)
{
*
len
=
5
;
return
(
"ldi %A0,0x20"
CR_TAB
"muls %B0,%A0"
CR_TAB
"mov %A0,r1"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"clr __zero_reg__"
)
;
}
if
(
optimize_size
&&
scratch
)
break
;
*
len
=
6
;
return
(
"mov %A0,%B0"
CR_TAB
"lsl %B0"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
)
;
case
12
:
if
(
AVR_HAVE_MUL
&&
ldi_ok
)
{
*
len
=
5
;
return
(
"ldi %A0,0x10"
CR_TAB
"muls %B0,%A0"
CR_TAB
"mov %A0,r1"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"clr __zero_reg__"
)
;
}
if
(
optimize_size
&&
scratch
)
break
;
*
len
=
7
;
return
(
"mov %A0,%B0"
CR_TAB
"lsl %B0"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
)
;
case
13
:
if
(
AVR_HAVE_MUL
&&
ldi_ok
)
{
*
len
=
5
;
return
(
"ldi %A0,0x08"
CR_TAB
"muls %B0,%A0"
CR_TAB
"mov %A0,r1"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"clr __zero_reg__"
)
;
}
if
(
optimize_size
)
break
;
*
len
=
8
;
return
(
"mov %A0,%B0"
CR_TAB
"lsl %B0"
CR_TAB
"sbc %B0,%B0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
CR_TAB
"asr %A0"
)
;
case
14
:
*
len
=
5
;
return
(
"lsl %B0"
CR_TAB
"sbc %A0,%A0"
CR_TAB
"lsl %B0"
CR_TAB
"mov %B0,%A0"
CR_TAB
"rol %A0"
)
;
default
:
if
(
INTVAL
(
operands
[
2
]
)
<
16
)
break
;
case
15
:
return
*
len
=
3
,
(
"lsl %B0"
CR_TAB
"sbc %A0,%A0"
CR_TAB
"mov %B0,%A0"
)
;
}
len
=
t
;
}
out_shift_with_cnt
(
"asr %B0"
CR_TAB
"ror %A0"
,
insn
,
operands
,
len
,
2
)
;
return
""
;
}
</s>

16bit arithmetic shift right ( ( signed short ) x > > i )


"Instr doesn't have FrameIndex operand!"

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


<s> enum tail_policy get_prefer_tail_policy ( ) { return TAIL_ANY ; } </s>


<s> bool PPCAIXAsmPrinter :: doFinalization ( Module & M ) { bool Ret = PPCAsmPrinter :: doFinalization ( M ) ; for ( MCSymbol * Sym : ExtSymSDNodeSymbols ) OutStreamer -> emitSymbolAttribute ( Sym , MCSA_Extern ) ; return Ret ; } </s>

doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes have run .


<s>
void
AArch64AsmBackend
::
applyFixup
(
const
MCAssembler
&
Asm
,
const
MCFixup
&
Fixup
,
const
MCValue
&
Target
,
MutableArrayRef
<
char
>
Data
,
uint64_t
Value
,
bool
IsResolved
,
const
MCSubtargetInfo
*
STI
)
const
{
unsigned
NumBytes
=
getFixupKindNumBytes
(
Fixup
.
getKind
(
)
)
;
if
(
!
Value
)
return
;
MCFixupKindInfo
Info
=
getFixupKindInfo
(
Fixup
.
getKind
(
)
)
;
MCContext
&
Ctx
=
Asm
.
getContext
(
)
;
int64_t
SignedValue
=
static_cast
<
int64_t
>
(
Value
)
;
Value
=
adjustFixupValue
(
Fixup
,
Target
,
Value
,
Ctx
,
TheTriple
,
IsResolved
)
;
Value
<<=
Info
.
TargetOffset
;
unsigned
Offset
=
Fixup
.
getOffset
(
)
;
assert
(
Offset
+
NumBytes
<=
Data
.
size
(
)
&&
"Invalid fixup offset!"
)
;
unsigned
FulleSizeInBytes
=
getFixupKindContainereSizeInBytes
(
Fixup
.
getKind
(
)
)
;
if
(
FulleSizeInBytes
==
0
)
{
for
(
unsigned
i
=
0
;
i
!=
NumBytes
;
++
i
)
{
Data
[
Offset
+
i
]
|=
uint8_t
(
(
Value
>>
(
i
*
8
)
)
&
0xff
)
;
}
}
else
{
assert
(
(
Offset
+
FulleSizeInBytes
)
<=
Data
.
size
(
)
&&
"Invalid fixup size!"
)
;
assert
(
NumBytes
<=
FulleSizeInBytes
&&
"Invalid fixup size!"
)
;
for
(
unsigned
i
=
0
;
i
!=
NumBytes
;
++
i
)
{
unsigned
Idx
=
FulleSizeInBytes
1
i
;
Data
[
Offset
+
Idx
]
|=
uint8_t
(
(
Value
>>
(
i
*
8
)
)
&
0xff
)
;
}
}
AArch64MCExpr
::
VariantKind
RefKind
=
static_cast
<
AArch64MCExpr
::
VariantKind
>
(
Target
.
getRefKind
(
)
)
;
if
(
RefKind
&
AArch64MCExpr
::
VK_SABS
)
{
if
(
SignedValue
<
0
)
Data
[
Offset
+
3
]
&=
~
(
1
<<
6
)
;
else
Data
[
Offset
+
3
]
|=
(
1
<<
6
)
;
}
}
</s>

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


<s> unsigned PHILinearize :: getNumSources ( unsigned DestReg ) { return phiInfoElementGetSources ( findPHIInfoElement ( DestReg ) ) . size ( ) ; } </s>

Returns the number of source registers .


Return the flags value to be used for string low-level builtins when expanded from overloaded builtin OB_FCODE .


<s>
void
SNESInstPrinter
::
printPCRelImm
(
const
MCInst
*
MI
,
unsigned
OpNo
,
raw_ostream
&
O
)
{
const
MCOperand
&
Op
=
MI
->
getOperand
(
OpNo
)
;
if
(
Op
.
isImm
(
)
)
{
int64_t
Imm
=
Op
.
getImm
(
)
;
O
<<
'.'
;
if
(
Imm
>=
0
)
O
<<
'+'
;
O
<<
Imm
;
}
else
{
assert
(
Op
.
isExpr
(
)
&&
"Unknown pcrel immediate operand"
)
;
O
<<
*
Op
.
getExpr
(
)
;
}
}
</s>

SNES
SNES
0
"Unknown pcrel immediate operand"


<s> void aarch64_split_atomic_op ( enum rtx_code code , rtx old_out , rtx new_out , rtx mem , rtx value , rtx model_rtx , rtx cond ) { machine_mode mode = GET_MODE ( mem ) ; machine_mode wmode = ( mode == DImode ? DImode : SImode ) ; rtx_code_label * label ; rtx x ; label = gen_label_rtx ( ) ; emit_label ( label ) ; if ( new_out ) new_out = gen_lowpart ( wmode , new_out ) ; if ( old_out ) old_out = gen_lowpart ( wmode , old_out ) ; else old_out = new_out ; value = simplify_gen_subreg ( wmode , value , mode , 0 ) ; aarch64_emit_load_exclusive ( mode , old_out , mem , model_rtx ) ; switch ( code ) { case SET : new_out = value ; break ; case NOT : x = gen_rtx_AND ( wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( VOIDmode , new_out , x ) ) ; x = gen_rtx_NOT ( wmode , new_out ) ; emit_insn ( gen_rtx_SET ( VOIDmode , new_out , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( value ) ) { value = GEN_INT ( - INTVAL ( value ) ) ; code = PLUS ; } default : x = gen_rtx_fmt_ee ( code , wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( VOIDmode , new_out , x ) ) ; break ; } aarch64_emit_store_exclusive ( mode , cond , mem , gen_lowpart ( mode , new_out ) , model_rtx ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label ) , pc_rtx ) ; aarch64_emit_unlikely_jump ( gen_rtx_SET ( VOIDmode , pc_rtx , x ) ) ; } </s>


<s> int reg_unused_after ( rtx insn , rtx reg ) { return ( dead_or_set_p ( insn , reg ) || ( REG_P ( reg ) && _reg_unused_after ( insn , reg ) ) ) ; } </s>

Return nonzero if REG is not used after INSN . We assume REG is a reload reg , and therefore does not live past labels or calls or jumps .


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

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


<s> SDValue ARMTargetLowering :: joinRegisterPartsIntoValue ( SelectionDAG & DAG , const SDLoc & DL , const SDValue * Parts , unsigned NumParts , MVT PartVT , EVT ValueVT , Optional < CallingConv :: ID > CC ) const { bool IsABIRegCopy = CC . hasValue ( ) ; if ( IsABIRegCopy && ( ValueVT == MVT :: f16 || ValueVT == MVT :: bf16 ) && PartVT == MVT :: f32 ) { unsigned ValueBits = ValueVT . getSizeInBits ( ) ; unsigned PartBits = PartVT . getSizeInBits ( ) ; SDValue Val = Parts [ 0 ] ; Val = DAG . getNode ( ISD :: BITCAST , DL , MVT :: getIntegerVT ( PartBits ) , Val ) ; Val = DAG . getNode ( ISD :: TRUNCATE , DL , MVT :: getIntegerVT ( ValueBits ) , Val ) ; Val = DAG . getNode ( ISD :: BITCAST , DL , ValueVT , Val ) ; return Val ; } return SDValue ( ) ; } </s>

Target-specific combining of register parts into its original value .


<s> bool TPCTargetLowering :: getPostIndexedAddressParts ( SDNode * N , SDNode * Op , SDValue & Base , SDValue & Offset , ISD :: MemIndexedMode & AM , SelectionDAG & DAG ) const { EVT VT ; SDValue Ptr ; unsigned AS ; if ( LoadSDNode * LD = dyn_cast < LoadSDNode > ( N ) ) { VT = LD -> getMemoryVT ( ) ; Ptr = LD -> getBasePtr ( ) ; AS = LD -> getAddressSpace ( ) ; } else if ( StoreSDNode * ST = dyn_cast < StoreSDNode > ( N ) ) { VT = ST -> getMemoryVT ( ) ; Ptr = ST -> getBasePtr ( ) ; AS = ST -> getAddressSpace ( ) ; } else return false ; if ( AS != 3 ) return false ; if ( ! getIndexedAddressParts ( Op , Base , Offset , DAG ) ) return false ; if ( Ptr != Base ) return false ; AM = ISD :: POST_INC ; return true ; } </s>

Returns true by value , base pointer and offset pointer and addressing mode by reference if this node can be combined with a load / store to form a post-indexed load / store .


<s> bool ARMBaseInstrInfo :: isProfitableToIfCvt ( MachineBasicBlock & TMBB , unsigned NumT , MachineBasicBlock & FMBB , unsigned NumF ) const { return NumT && NumF && NumT <= 2 && NumF <= 2 ; } </s>


<s> const MipsTargetLowering * MipsTargetLowering :: create ( const MipsTargetMachine & TM , const MipsSubtarget & STI ) { if ( STI . inMips16Mode ( ) ) return createMips16TargetLowering ( TM , STI ) ; return createMipsSETargetLowering ( TM , STI ) ; } </s>


<s> static rtx mips16_local_alias ( rtx func ) { if ( mips16_local_aliases == NULL ) mips16_local_aliases = hash_map < nofree_string_hash , rtx > :: create_ggc ( 37 ) ; bool existed ; const char * func_name = XSTR ( func , 0 ) ; rtx * slot = & mips16_local_aliases -> get_or_insert ( func_name , & existed ) ; gcc_assert ( slot != NULL ) ; if ( ! existed ) { rtx local ; func_name = targetm . strip_name_encoding ( XSTR ( func , 0 ) ) ; const char * local_name = ACONCAT ( ( "__fn_local_" , func_name , NULL ) ) ; local = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( local_name ) ) ; SYMBOL_REF_FLAGS ( local ) = SYMBOL_REF_FLAGS ( func ) | SYMBOL_FLAG_LOCAL ; * slot = local ; } return * slot ; } </s>

FUNC is the symbol for a locally-defined hard-float MIPS16 function . Return a local alias for it , creating a new one if necessary .


<s> void RISCVELFTargetObjectFile :: Initialize ( MCContext & Ctx , const TargetMachine & TM ) { TargetLoweringObjectFileELF :: Initialize ( Ctx , TM ) ; InitializeELF ( TM . Options . UseInitArray ) ; SmallDataSection = getContext ( ) . getELFSection ( ".sdata" , ELF :: SHT_PROGBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ; SmallBSSSection = getContext ( ) . getELFSection ( ".sbss" , ELF :: SHT_NOBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ; } </s>

This method must be called before any actual lowering is done .


"  Skipping pass: no machine model present.\n"

runOnMachineFunction - Emit the function body .


<s> rtx bfin_gen_compare ( rtx cmp , machine_mode mode ATTRIBUTE_UNUSED ) { enum rtx_code code1 , code2 ; rtx op0 = XEXP ( cmp , 0 ) , op1 = XEXP ( cmp , 1 ) ; rtx tem = bfin_cc_rtx ; enum rtx_code code = GET_CODE ( cmp ) ; if ( GET_MODE ( op0 ) == BImode ) { gcc_assert ( ( code == NE || code == EQ ) && op1 == const0_rtx ) ; tem = op0 , code2 = code ; } else { switch ( code ) { case EQ : case LT : case LE : case LEU : case LTU : code1 = code ; code2 = NE ; break ; default : code1 = reverse_condition ( code ) ; code2 = EQ ; break ; } emit_insn ( gen_rtx_SET ( VOIDmode , tem , gen_rtx_fmt_ee ( code1 , BImode , op0 , op1 ) ) ) ; } return gen_rtx_fmt_ee ( code2 , BImode , tem , CONST0_RTX ( BImode ) ) ; } </s>

Emit rtl for a comparison operation CMP in mode MODE . Operands have been stored in bfin_compare_op0 and bfin_compare_op1 already .


<s>
void
NVPTXFrameLowering
::
emitPrologue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
if
(
MF
.
getFrameInfo
(
)
->
hasStackObjects
(
)
)
{
assert
(
&
MF
.
front
(
)
==
&
MBB
&&
"Shrink-wrapping not yet supported"
)
;
MachineBasicBlock
::
iterator
MBBI
=
MBB
.
begin
(
)
;
DebugLoc
dl
=
DebugLoc
(
)
;
MachineRegisterInfo
&
MRI
=
MF
.
getRegInfo
(
)
;
if
(
static_cast
<
const
NVPTXTargetMachine
&
>
(
MF
.
getTarget
(
)
)
.
is64Bit
(
)
)
{
unsigned
LocalReg
=
MRI
.
createVirtualRegister
(
&
NVPTX
::
Int64RegsRegClass
)
;
MachineInstr
*
MI
=
BuildMI
(
MBB
,
MBBI
,
dl
,
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
->
get
(
NVPTX
::
cvta_local_yes_64
)
,
NVPTX
::
VRFrame
)
.
addReg
(
LocalReg
)
;
BuildMI
(
MBB
,
MI
,
dl
,
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
->
get
(
NVPTX
::
MOV_DEPOT_ADDR_64
)
,
LocalReg
)
.
addImm
(
MF
.
getFunctionNumber
(
)
)
;
}
else
{
unsigned
LocalReg
=
MRI
.
createVirtualRegister
(
&
NVPTX
::
Int32RegsRegClass
)
;
MachineInstr
*
MI
=
BuildMI
(
MBB
,
MBBI
,
dl
,
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
->
get
(
NVPTX
::
cvta_local_yes
)
,
NVPTX
::
VRFrame
)
.
addReg
(
LocalReg
)
;
BuildMI
(
MBB
,
MI
,
dl
,
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
->
get
(
NVPTX
::
MOV_DEPOT_ADDR
)
,
LocalReg
)
.
addImm
(
MF
.
getFunctionNumber
(
)
)
;
}
}
}
</s>

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


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

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


"instruction requires a CPU feature not currently enabled"

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


<s> static void nios2_alternate_compare_const ( enum rtx_code code , rtx op , enum rtx_code * alt_code , rtx * alt_op , machine_mode mode ) { gcc_assert ( CONST_INT_P ( op ) ) ; HOST_WIDE_INT opval = INTVAL ( op ) ; enum rtx_code scode = signed_condition ( code ) ; bool dec_p = ( scode == LT || scode == GE ) ; if ( code == EQ || code == NE ) { * alt_code = code ; * alt_op = op ; return ; } * alt_op = ( dec_p ? gen_int_mode ( opval - 1 , mode ) : gen_int_mode ( opval + 1 , mode ) ) ; * alt_code = reverse_condition ( swap_condition ( code ) ) ; { unsigned HOST_WIDE_INT alt_opval = INTVAL ( * alt_op ) ; if ( code == scode ) alt_opval ^= ( 1 << ( GET_MODE_BITSIZE ( mode ) - 1 ) ) ; alt_opval &= GET_MODE_MASK ( mode ) ; gcc_assert ( dec_p ? alt_opval != GET_MODE_MASK ( mode ) : alt_opval != 0 ) ; } } </s>

Return in * ALT_CODE and * ALT_OP , an alternate equivalent constant comparison , e.g . > = 1 into > 0 .


<s> static void c6x_mark_reg_read ( rtx reg , bool cross ) { unsigned regno = REGNO ( reg ) ; unsigned nregs = REG_NREGS ( reg ) ; while ( nregs -- > 0 ) c6x_mark_regno_read ( regno + nregs , cross ) ; } </s>

Note that REG is read in the insn being examined . If CROSS , it means the access is through a cross path . Update the temporary reg access arrays , and set REG_ACCESS_STALL if the insn ca n't be issued in the current cycle .


<s>
void
AArch64TargetLowering
::
computeKnownBitsForTargetNode
(
const
SDValue
Op
,
APInt
&
KnownZero
,
APInt
&
KnownOne
,
const
SelectionDAG
&
DAG
,
unsigned
Depth
)
const
{
switch
(
Op
.
getOpcode
(
)
)
{
default
:
break
;
case
AArch64ISD
::
CSEL
:
{
APInt
KnownZero2
,
KnownOne2
;
DAG
.
computeKnownBits
(
Op
->
getOperand
(
0
)
,
KnownZero
,
KnownOne
,
Depth
+
1
)
;
DAG
.
computeKnownBits
(
Op
->
getOperand
(
1
)
,
KnownZero2
,
KnownOne2
,
Depth
+
1
)
;
KnownZero
&=
KnownZero2
;
KnownOne
&=
KnownOne2
;
break
;
}
case
ISD
::
INTRINSIC_W_CHAIN
:
{
ConstantSDNode
*
CN
=
cast
<
ConstantSDNode
>
(
Op
->
getOperand
(
1
)
)
;
Intrinsic
::
ID
IntID
=
static_cast
<
Intrinsic
::
ID
>
(
CN
->
getZExtValue
(
)
)
;
switch
(
IntID
)
{
default
:
return
;
case
Intrinsic
::
aarch64_ldaxr
:
case
Intrinsic
::
aarch64_ldxr
:
{
unsigned
BitWidth
=
KnownOne
.
getBitWidth
(
)
;
EVT
VT
=
cast
<
MemIntrinsicSDNode
>
(
Op
)
->
getMemoryVT
(
)
;
unsigned
MemBits
=
VT
.
getScalarSizeInBits
(
)
;
KnownZero
|=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
MemBits
)
;
return
;
}
}
break
;
}
case
ISD
::
INTRINSIC_WO_CHAIN
:
case
ISD
::
INTRINSIC_VOID
:
{
unsigned
IntNo
=
cast
<
ConstantSDNode
>
(
Op
.
getOperand
(
0
)
)
->
getZExtValue
(
)
;
switch
(
IntNo
)
{
default
:
break
;
case
Intrinsic
::
aarch64_neon_umaxv
:
case
Intrinsic
::
aarch64_neon_uminv
:
{
MVT
VT
=
Op
.
getOperand
(
1
)
.
getValueType
(
)
.
getSimpleVT
(
)
;
unsigned
BitWidth
=
KnownZero
.
getBitWidth
(
)
;
if
(
VT
==
MVT
::
v8i8
||
VT
==
MVT
::
v16i8
)
{
assert
(
BitWidth
>=
8
&&
"Unexpected width!"
)
;
APInt
Mask
=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
8
)
;
KnownZero
|=
Mask
;
}
else
if
(
VT
==
MVT
::
v4i16
||
VT
==
MVT
::
v8i16
)
{
assert
(
BitWidth
>=
16
&&
"Unexpected width!"
)
;
APInt
Mask
=
APInt
::
getHighBitsSet
(
BitWidth
,
BitWidth
16
)
;
KnownZero
|=
Mask
;
}
break
;
}
break
;
}
}
}
}
</s>

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


"********* Hexagon Hardware Loops *********\n"


<s> bool HexagonFrameLowering :: spillCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) const { MachineFunction * MF = MBB . getParent ( ) ; const TargetInstrInfo & TII = * MF -> getTarget ( ) . getInstrInfo ( ) ; if ( CSI . empty ( ) ) { return false ; } bool ContiguousRegs = true ; for ( unsigned i = 0 ; i < CSI . size ( ) ; ++ i ) { unsigned Reg = CSI [ i ] . getReg ( ) ; unsigned SuperReg = uniqueSuperReg ( Reg , TRI ) ; bool CanUseDblStore = false ; const TargetRegisterClass * SuperRegClass = 0 ; if ( ContiguousRegs && ( i < CSI . size ( ) - 1 ) ) { unsigned SuperRegNext = uniqueSuperReg ( CSI [ i + 1 ] . getReg ( ) , TRI ) ; SuperRegClass = TRI -> getMinimalPhysRegClass ( SuperReg ) ; CanUseDblStore = ( SuperRegNext == SuperReg ) ; } if ( CanUseDblStore ) { TII . storeRegToStackSlot ( MBB , MI , SuperReg , true , CSI [ i + 1 ] . getFrameIdx ( ) , SuperRegClass , TRI ) ; MBB . addLiveIn ( SuperReg ) ; ++ i ; } else { ContiguousRegs = false ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; TII . storeRegToStackSlot ( MBB , MI , Reg , true , CSI [ i ] . getFrameIdx ( ) , RC , TRI ) ; MBB . addLiveIn ( Reg ) ; } } return true ; } </s>

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


<s> void relaxInstruction ( const MCInst & Inst , MCInst & Res ) const override { } </s>

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


"Disqualifying LR because GPR0 is live "


<s> unsigned MipsFastISel :: fastEmitInst_rr ( unsigned MachineInstOpcode , const TargetRegisterClass * RC , unsigned Op0 , unsigned Op1 ) { if ( MachineInstOpcode == Mips :: MUL ) { Register ResultReg = createResultReg ( RC ) ; const MCInstrDesc & II = TII . get ( MachineInstOpcode ) ; Op0 = constrainOperandRegClass ( II , Op0 , II . getNumDefs ( ) ) ; Op1 = constrainOperandRegClass ( II , Op1 , II . getNumDefs ( ) + 1 ) ; BuildMI ( * FuncInfo . MBB , FuncInfo . InsertPt , DbgLoc , II , ResultReg ) . addReg ( Op0 ) . addReg ( Op1 ) . addReg ( Mips :: HI0 , RegState :: ImplicitDefine | RegState :: Dead ) . addReg ( Mips :: LO0 , RegState :: ImplicitDefine | RegState :: Dead ) ; return ResultReg ; } return FastISel :: fastEmitInst_rr ( MachineInstOpcode , RC , Op0 , Op1 ) ; } </s>

Emit a MachineInstr with two register operands and a result register in the given register class .


<s>
void
ELFMBlazeAsmBackend
::
applyFixup
(
const
MCFixup
&
Fixup
,
char
*
Data
,
unsigned
DataSize
,
uint64_t
Value
)
const
{
unsigned
Size
=
getFixupKindSize
(
Fixup
.
getKind
(
)
)
;
assert
(
Fixup
.
getOffset
(
)
+
Size
<=
DataSize
&&
"Invalid fixup offset!"
)
;
char
*
data
=
Data
+
Fixup
.
getOffset
(
)
;
switch
(
Size
)
{
default
:
llvm_unreachable
(
"Cannot fixup unknown value."
)
;
case
1
:
llvm_unreachable
(
"Cannot fixup 1 byte value."
)
;
case
8
:
llvm_unreachable
(
"Cannot fixup 8 byte value."
)
;
case
4
:
*
(
data
+
7
)
=
uint8_t
(
Value
)
;
*
(
data
+
6
)
=
uint8_t
(
Value
>>
8
)
;
*
(
data
+
3
)
=
uint8_t
(
Value
>>
16
)
;
*
(
data
+
2
)
=
uint8_t
(
Value
>>
24
)
;
break
;
case
2
:
*
(
data
+
3
)
=
uint8_t
(
Value
>>
0
)
;
*
(
data
+
2
)
=
uint8_t
(
Value
>>
8
)
;
}
}
</s>

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


<s> unsigned MipsAsmParser :: checkTargetMatchPredicate ( MCInst & Inst ) { switch ( Inst . getOpcode ( ) ) { case Mips :: JALR_HB : case Mips :: JALRC_HB_MMR6 : case Mips :: JALRC_MMR6 : if ( Inst . getOperand ( 0 ) . getReg ( ) == Inst . getOperand ( 1 ) . getReg ( ) ) return Match_RequiresDifferentSrcAndDst ; return Match_Success ; case Mips :: LWP_MM : case Mips :: LWP_MMR6 : if ( Inst . getOperand ( 0 ) . getReg ( ) == Inst . getOperand ( 2 ) . getReg ( ) ) return Match_RequiresDifferentSrcAndDst ; return Match_Success ; case Mips :: BLEZC : case Mips :: BGEZC : case Mips :: BGTZC : case Mips :: BLTZC : case Mips :: BEQZC : case Mips :: BNEZC : case Mips :: BLEZC64 : case Mips :: BGEZC64 : case Mips :: BGTZC64 : case Mips :: BLTZC64 : case Mips :: BEQZC64 : case Mips :: BNEZC64 : if ( Inst . getOperand ( 0 ) . getReg ( ) == Mips :: ZERO || Inst . getOperand ( 0 ) . getReg ( ) == Mips :: ZERO_64 ) return Match_RequiresNoZeroRegister ; return Match_Success ; case Mips :: BGEC : case Mips :: BLTC : case Mips :: BGEUC : case Mips :: BLTUC : case Mips :: BEQC : case Mips :: BNEC : case Mips :: BGEC64 : case Mips :: BLTC64 : case Mips :: BGEUC64 : case Mips :: BLTUC64 : case Mips :: BEQC64 : case Mips :: BNEC64 : if ( Inst . getOperand ( 0 ) . getReg ( ) == Mips :: ZERO || Inst . getOperand ( 0 ) . getReg ( ) == Mips :: ZERO_64 ) return Match_RequiresNoZeroRegister ; if ( Inst . getOperand ( 1 ) . getReg ( ) == Mips :: ZERO || Inst . getOperand ( 1 ) . getReg ( ) == Mips :: ZERO_64 ) return Match_RequiresNoZeroRegister ; if ( Inst . getOperand ( 0 ) . getReg ( ) == Inst . getOperand ( 1 ) . getReg ( ) ) return Match_RequiresDifferentOperands ; return Match_Success ; default : return Match_Success ; } } </s>

checkTargetMatchPredicate - Validate the instruction match against any complex target predicates not expressible via match classes .


<s> unsigned AArch64RegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { const AArch64FrameLowering * TFI = getFrameLowering ( MF ) ; return TFI -> hasFP ( MF ) ? AArch64 :: FP : AArch64 :: SP ; } </s>


<s> MCFragment * findAssociatedFragment ( ) const override { return getSubExpr ( ) -> findAssociatedFragment ( ) ; } </s>

Find the `` associated section '' for this expression , which is currently defined as the absolute section for constants , or otherwise the section associated with the first defined symbol in the expression .


<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> static rtx m68k_move_to_reg ( rtx x , rtx orig , rtx reg ) { rtx_insn * insn ; if ( reg == NULL_RTX ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } insn = emit_move_insn ( reg , x ) ; set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ; } </s>

Move X to a register and add REG_EQUAL note pointing to ORIG . If REG is non-null , use it ; generate new pseudo otherwise .


<s> static bool aarch64_expand_sve_widened_duplicate ( rtx dest , scalar_int_mode src_mode , rtx src ) { if ( src_mode != TImode ) { poly_uint64 count = exact_div ( GET_MODE_SIZE ( GET_MODE ( dest ) ) , GET_MODE_SIZE ( src_mode ) ) ; machine_mode dup_mode = mode_for_vector ( src_mode , count ) . require ( ) ; emit_move_insn ( gen_lowpart ( dup_mode , dest ) , gen_const_vec_duplicate ( dup_mode , src ) ) ; return true ; } src = force_const_mem ( src_mode , src ) ; if ( ! src ) return false ; if ( ! aarch64_sve_ld1r_operand_p ( src ) ) { rtx addr = force_reg ( Pmode , XEXP ( src , 0 ) ) ; src = replace_equiv_address ( src , addr ) ; } machine_mode mode = GET_MODE ( dest ) ; unsigned int elem_bytes = GET_MODE_UNIT_SIZE ( mode ) ; machine_mode pred_mode = aarch64_sve_pred_mode ( elem_bytes ) . require ( ) ; rtx ptrue = force_reg ( pred_mode , CONSTM1_RTX ( pred_mode ) ) ; src = gen_rtx_UNSPEC ( mode , gen_rtvec ( 2 , ptrue , src ) , UNSPEC_LD1RQ ) ; emit_insn ( gen_rtx_SET ( dest , src ) ) ; return true ; } </s>

Try to duplicate SRC into SVE register DEST , given that SRC is an integer of mode INT_MODE . Return true on success .


<s> Optional < MCFixupKind > MipsAsmBackend :: getFixupKind ( StringRef Name ) const { return StringSwitch < Optional < MCFixupKind >> ( Name ) . Case ( "R_MIPS_NONE" , FK_NONE ) . Case ( "R_MIPS_32" , FK_Data_4 ) . Case ( "R_MIPS_GOT_PAGE" , ( MCFixupKind ) Mips :: fixup_Mips_GOT_PAGE ) . Case ( "R_MIPS_CALL_HI16" , ( MCFixupKind ) Mips :: fixup_Mips_CALL_HI16 ) . Case ( "R_MIPS_CALL_LO16" , ( MCFixupKind ) Mips :: fixup_Mips_CALL_LO16 ) . Case ( "R_MIPS_CALL16" , ( MCFixupKind ) Mips :: fixup_Mips_CALL16 ) . Case ( "R_MIPS_GOT16" , ( MCFixupKind ) Mips :: fixup_Mips_GOT ) . Case ( "R_MIPS_GOT_PAGE" , ( MCFixupKind ) Mips :: fixup_Mips_GOT_PAGE ) . Case ( "R_MIPS_GOT_OFST" , ( MCFixupKind ) Mips :: fixup_Mips_GOT_OFST ) . Case ( "R_MIPS_GOT_DISP" , ( MCFixupKind ) Mips :: fixup_Mips_GOT_DISP ) . Case ( "R_MIPS_GOT_HI16" , ( MCFixupKind ) Mips :: fixup_Mips_GOT_HI16 ) . Case ( "R_MIPS_GOT_LO16" , ( MCFixupKind ) Mips :: fixup_Mips_GOT_LO16 ) . Case ( "R_MIPS_TLS_GOTTPREL" , ( MCFixupKind ) Mips :: fixup_Mips_GOTTPREL ) . Case ( "R_MIPS_TLS_DTPREL_HI16" , ( MCFixupKind ) Mips :: fixup_Mips_DTPREL_HI ) . Case ( "R_MIPS_TLS_DTPREL_LO16" , ( MCFixupKind ) Mips :: fixup_Mips_DTPREL_LO ) . Case ( "R_MIPS_TLS_GD" , ( MCFixupKind ) Mips :: fixup_Mips_TLSGD ) . Case ( "R_MIPS_TLS_LDM" , ( MCFixupKind ) Mips :: fixup_Mips_TLSLDM ) . Case ( "R_MIPS_TLS_TPREL_HI16" , ( MCFixupKind ) Mips :: fixup_Mips_TPREL_HI ) . Case ( "R_MIPS_TLS_TPREL_LO16" , ( MCFixupKind ) Mips :: fixup_Mips_TPREL_LO ) . Case ( "R_MICROMIPS_CALL16" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_CALL16 ) . Case ( "R_MICROMIPS_GOT_DISP" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_GOT_DISP ) . Case ( "R_MICROMIPS_GOT_PAGE" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_GOT_PAGE ) . Case ( "R_MICROMIPS_GOT_OFST" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_GOT_OFST ) . Case ( "R_MICROMIPS_GOT16" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_GOT16 ) . Case ( "R_MICROMIPS_TLS_GOTTPREL" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_GOTTPREL ) . Case ( "R_MICROMIPS_TLS_DTPREL_HI16" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_TLS_DTPREL_HI16 ) . Case ( "R_MICROMIPS_TLS_DTPREL_LO16" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_TLS_DTPREL_LO16 ) . Case ( "R_MICROMIPS_TLS_GD" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_TLS_GD ) . Case ( "R_MICROMIPS_TLS_LDM" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_TLS_LDM ) . Case ( "R_MICROMIPS_TLS_TPREL_HI16" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_TLS_TPREL_HI16 ) . Case ( "R_MICROMIPS_TLS_TPREL_LO16" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_TLS_TPREL_LO16 ) . Case ( "R_MIPS_JALR" , ( MCFixupKind ) Mips :: fixup_Mips_JALR ) . Case ( "R_MICROMIPS_JALR" , ( MCFixupKind ) Mips :: fixup_MICROMIPS_JALR ) . Default ( MCAsmBackend :: getFixupKind ( Name ) ) ; } </s>

getFixupKind - Get the fixup kind of this expression .


<s> bool HexagonTargetLowering :: mayBeEmittedAsTailCall ( const CallInst * CI ) const { auto Attr = CI -> getParent ( ) -> getParent ( ) -> getFnAttribute ( "disable-tail-calls" ) ; if ( ! CI -> isTailCall ( ) || Attr . getValueAsString ( ) == "true" ) return false ; return true ; } </s>

Return true if the target may be able emit the call instruction as a tail call .

Hexagon Hexagon "disable-tail-calls" "true"


<s> static int bfin_arg_partial_bytes ( cumulative_args_t cum , const function_arg_info & arg ) { int bytes = arg . promoted_size_in_bytes ( ) ; int bytes_left = get_cumulative_args ( cum ) -> nregs * UNITS_PER_WORD ; if ( bytes == - 1 ) return 0 ; if ( bytes_left == 0 ) return 0 ; if ( bytes > bytes_left ) return bytes_left ; return 0 ; } </s>

For an arg passed partly in registers and partly in memory , this is the number of bytes passed in registers . For args passed entirely in registers or entirely in memory , zero . Refer VDSP C Compiler manual , our ABI . First 3 words are in registers . So , if a an argument is larger than the registers available , it will span the register and stack .


<s> static tree resolve_vec_cmpne ( resolution * res , tree * args , tree * types , location_t loc ) { if ( TREE_CODE ( types [ 0 ] ) != VECTOR_TYPE || ! lang_hooks . types_compatible_p ( types [ 0 ] , types [ 1 ] ) ) { * res = resolved_bad ; return error_mark_node ; } machine_mode arg0_elt_mode = TYPE_MODE ( TREE_TYPE ( types [ 0 ] ) ) ; if ( ! TARGET_P9_VECTOR || arg0_elt_mode == DImode || arg0_elt_mode == TImode || arg0_elt_mode == SFmode || arg0_elt_mode == DFmode ) { switch ( arg0_elt_mode ) { case E_QImode : case E_HImode : case E_SImode : case E_DImode : case E_TImode : case E_SFmode : case E_DFmode : { vec < tree , va_gc > * params = make_tree_vector ( ) ; vec_safe_push ( params , args [ 0 ] ) ; vec_safe_push ( params , args [ 1 ] ) ; tree decl = rs6000_builtin_decls [ RS6000_OVLD_VEC_CMPEQ ] ; tree call = altivec_resolve_overloaded_builtin ( loc , decl , params ) ; call = save_expr ( call ) ; params = make_tree_vector ( ) ; vec_safe_push ( params , call ) ; vec_safe_push ( params , call ) ; decl = rs6000_builtin_decls [ RS6000_OVLD_VEC_NOR ] ; * res = resolved ; return altivec_resolve_overloaded_builtin ( loc , decl , params ) ; } default : * res = resolved_bad ; return error_mark_node ; } } * res = unresolved ; return error_mark_node ; } </s>

Resolve an overloaded vec_cmpne call and return a tree expression for the resolved call if successful . ARGS contains the arguments to the call . TYPES contains their types . RES must be set to indicate the status of the resolution attempt . LOC contains statement location information .


<s> rtx alpha_legitimize_reload_address ( rtx x , enum machine_mode mode ATTRIBUTE_UNUSED , int opnum , int type , int ind_levels ATTRIBUTE_UNUSED ) { if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , 0 ) , 0 ) ) == REG && GET_CODE ( XEXP ( XEXP ( x , 0 ) , 1 ) ) == CONST_INT && GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT ) { push_reload ( XEXP ( x , 0 ) , NULL_RTX , & XEXP ( x , 0 ) , NULL , BASE_REG_CLASS , GET_MODE ( x ) , VOIDmode , 0 , 0 , opnum , type ) ; return x ; } if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , 0 ) ) == REG && REGNO ( XEXP ( x , 0 ) ) < FIRST_PSEUDO_REGISTER && REGNO_OK_FOR_BASE_P ( REGNO ( XEXP ( x , 0 ) ) ) && GET_CODE ( XEXP ( x , 1 ) ) == CONST_INT ) { HOST_WIDE_INT val = INTVAL ( XEXP ( x , 1 ) ) ; HOST_WIDE_INT low = ( ( val & 0xffff ) ^ 0x8000 ) - 0x8000 ; HOST_WIDE_INT high = ( ( ( val - low ) & 0xffffffff ) ^ 0x80000000 ) - 0x80000000 ; if ( high + low != val ) return NULL_RTX ; x = gen_rtx_PLUS ( GET_MODE ( x ) , gen_rtx_PLUS ( GET_MODE ( x ) , XEXP ( x , 0 ) , GEN_INT ( high ) ) , GEN_INT ( low ) ) ; push_reload ( XEXP ( x , 0 ) , NULL_RTX , & XEXP ( x , 0 ) , NULL , BASE_REG_CLASS , GET_MODE ( x ) , VOIDmode , 0 , 0 , opnum , type ) ; return x ; } return NULL_RTX ; } </s>

Try a machine-dependent way of reloading an illegitimate address operand . If we find one , push the reload and return the new rtx .


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . setPreservesCFG ( ) ; AU . addRequired < DominatorTreeWrapperPass > ( ) ; AU . addPreserved < DominatorTreeWrapperPass > ( ) ; FunctionPass :: getAnalysisUsage ( AU ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> bool MipsPassConfig :: addInstSelector ( ) { addPass ( createMipsModuleISelDag ( getMipsTargetMachine ( ) ) ) ; addPass ( createMipsSEISelDag ( getMipsTargetMachine ( ) ) ) ; return false ; } </s>

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


<s> AArch64TargetMachine :: AArch64TargetMachine ( 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 LittleEndian ) : LLVMTargetMachine ( T , computeDataLayout ( TT , Options . MCOptions , LittleEndian ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , RM ) , getEffectiveCodeModel ( TT , CM , JIT ) , OL ) , TLOF ( createTLOF ( getTargetTriple ( ) ) ) , isLittle ( LittleEndian ) { initAsmInfo ( ) ; if ( TT . isOSBinFormatMachO ( ) ) { this -> Options . TrapUnreachable = true ; this -> Options . NoTrapAfterNoreturn = true ; } if ( getOptLevel ( ) <= EnableGlobalISelAtO ) setGlobalISel ( true ) ; setMachineOutliner ( true ) ; } </s>


<s> StringRef getSymbol ( ) const { return S ; } </s>

Get the target address and flags for the named symbol .


<s>
void
NVPTXPassConfig
::
addOptimizedRegAlloc
(
FunctionPass
*
RegAllocPass
)
{
assert
(
!
RegAllocPass
&&
"NVPTX uses no regalloc!"
)
;
addPass
(
&
StrongPHIEliminationID
)
;
}
</s>

addOptimizedRegAlloc - Add passes related to register allocation .


"Can't return value from vararg function in memory"

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


<s>
unsigned
SITargetLowering
::
getRegisterByName
(
const
char
*
RegName
,
EVT
VT
,
SelectionDAG
&
DAG
)
const
{
unsigned
Reg
=
StringSwitch
<
unsigned
>
(
RegName
)
.
Case
(
"m0"
,
AMDGPU
::
M0
)
.
Case
(
"exec"
,
AMDGPU
::
EXEC
)
.
Case
(
"exec_lo"
,
AMDGPU
::
EXEC_LO
)
.
Case
(
"exec_hi"
,
AMDGPU
::
EXEC_HI
)
.
Case
(
"flat_scratch"
,
AMDGPU
::
FLAT_SCR
)
.
Case
(
"flat_scratch_lo"
,
AMDGPU
::
FLAT_SCR_LO
)
.
Case
(
"flat_scratch_hi"
,
AMDGPU
::
FLAT_SCR_HI
)
.
Default
(
AMDGPU
::
NoRegister
)
;
if
(
Reg
==
AMDGPU
::
NoRegister
)
{
report_fatal_error
(
Twine
(
"invalid register name \""
+
StringRef
(
RegName
)
+
"\"."
)
)
;
}
if
(
(
Subtarget
->
getGeneration
(
)
==
AMDGPUSubtarget
::
SOUTHERN_ISLANDS
||
Subtarget
->
getGeneration
(
)
>=
AMDGPUSubtarget
::
GFX10
)
&&
Subtarget
->
getRegisterInfo
(
)
->
regsOverlap
(
Reg
,
AMDGPU
::
FLAT_SCR
)
)
{
report_fatal_error
(
Twine
(
"invalid register \""
+
StringRef
(
RegName
)
+
"\" for subtarget."
)
)
;
}
switch
(
Reg
)
{
case
AMDGPU
::
M0
:
case
AMDGPU
::
EXEC_LO
:
case
AMDGPU
::
EXEC_HI
:
case
AMDGPU
::
FLAT_SCR_LO
:
case
AMDGPU
::
FLAT_SCR_HI
:
if
(
VT
.
getSizeInBits
(
)
==
32
)
return
Reg
;
break
;
case
AMDGPU
::
EXEC
:
case
AMDGPU
::
FLAT_SCR
:
if
(
VT
.
getSizeInBits
(
)
==
64
)
return
Reg
;
break
;
default
:
llvm_unreachable
(
"missing register type checking"
)
;
}
report_fatal_error
(
Twine
(
"invalid type for register \""
+
StringRef
(
RegName
)
+
"\"."
)
)
;
}
</s>

Return the register ID of the name passed in .


<s> bool ARMFrameLowering :: 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 > ( ) ; bool isVarArg = AFI -> getVarArgsRegSaveSize ( ) > 0 ; unsigned NumAlignedDPRCS2Regs = AFI -> getNumAlignedDPRCS2Regs ( ) ; if ( NumAlignedDPRCS2Regs ) emitAlignedDPRCS2Restores ( MBB , MI , NumAlignedDPRCS2Regs , CSI , TRI ) ; unsigned PopOpc = AFI -> isThumbFunction ( ) ? ARM :: t2LDMIA_UPD : ARM :: LDMIA_UPD ; unsigned LdrOpc = AFI -> isThumbFunction ( ) ? ARM :: t2LDR_POST : ARM :: LDR_POST_IMM ; unsigned FltOpc = ARM :: VLDMDIA_UPD ; emitPopInst ( MBB , MI , CSI , FltOpc , 0 , isVarArg , true , & isARMArea3Register , NumAlignedDPRCS2Regs ) ; emitPopInst ( MBB , MI , CSI , PopOpc , LdrOpc , isVarArg , false , & isARMArea2Register , 0 ) ; emitPopInst ( MBB , MI , CSI , PopOpc , LdrOpc , isVarArg , false , & isARMArea1Register , 0 ) ; return true ; } </s>

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 MipsTargetMachine :: addPostRegAlloc ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { PM . add ( createMipsExpandPseudoPass ( * this ) ) ; return true ; } </s>

This method may be implemented by targets that want to run passes after register allocation pass pipeline but before prolog-epilog insertion .


<s> static void unicosmk_unique_section ( tree decl , int reloc ATTRIBUTE_UNUSED ) { const char * name ; int len ; gcc_assert ( decl ) ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = default_strip_name_encoding ( name ) ; len = strlen ( name ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { char * string ; string = alloca ( len + 6 ) ; sprintf ( string , "code@%s" , name ) ; DECL_SECTION_NAME ( decl ) = build_string ( len + 5 , string ) ; } else if ( TREE_PUBLIC ( decl ) ) DECL_SECTION_NAME ( decl ) = build_string ( len , name ) ; else { char * string ; string = alloca ( len + 6 ) ; sprintf ( string , "data@%s" , name ) ; DECL_SECTION_NAME ( decl ) = build_string ( len + 5 , string ) ; } } </s>

Generate a section name for decl and associate it with the declaration .


<s> bool gen_ldm_seq ( rtx * operands , int nops , bool sort_regs ) { int regs [ MAX_LDM_STM_OPS ] , mem_order [ MAX_LDM_STM_OPS ] ; rtx mems [ MAX_LDM_STM_OPS ] ; int i , j , base_reg ; rtx base_reg_rtx ; HOST_WIDE_INT offset ; int write_back = FALSE ; int ldm_case ; rtx addr ; ldm_case = load_multiple_sequence ( operands , nops , regs , mem_order , & base_reg , & offset , ! sort_regs ) ; if ( ldm_case == 0 ) return false ; if ( sort_regs ) for ( i = 0 ; i < nops - 1 ; i ++ ) for ( j = i + 1 ; j < nops ; j ++ ) if ( regs [ i ] > regs [ j ] ) { int t = regs [ i ] ; regs [ i ] = regs [ j ] ; regs [ j ] = t ; } base_reg_rtx = gen_rtx_REG ( Pmode , base_reg ) ; if ( TARGET_THUMB1 ) { gcc_assert ( peep2_reg_dead_p ( nops , base_reg_rtx ) ) ; gcc_assert ( ldm_case == 1 || ldm_case == 5 ) ; write_back = TRUE ; } if ( ldm_case == 5 ) { rtx newbase = TARGET_THUMB1 ? base_reg_rtx : gen_rtx_REG ( SImode , regs [ 0 ] ) ; emit_insn ( gen_addsi3 ( newbase , base_reg_rtx , GEN_INT ( offset ) ) ) ; offset = 0 ; if ( ! TARGET_THUMB1 ) { base_reg = regs [ 0 ] ; base_reg_rtx = newbase ; } } for ( i = 0 ; i < nops ; i ++ ) { addr = plus_constant ( Pmode , base_reg_rtx , offset + i * 4 ) ; mems [ i ] = adjust_automodify_address_nv ( operands [ nops + mem_order [ i ] ] , SImode , addr , 0 ) ; } emit_insn ( arm_gen_load_multiple_1 ( nops , regs , mems , base_reg_rtx , write_back ? offset + i * 4 : 0 ) ) ; return true ; } </s>

Called from a peephole2 expander to turn a sequence of loads into an LDM instruction . OPERANDS are the operands found by the peephole matcher ; NOPS indicates how many separate loads we are trying to combine . SORT_REGS is true if we can reorder the registers because they are used commutatively subsequently . Returns true iff we could generate a new instruction .


<s> void ARMConstantPoolMBB :: print ( raw_ostream & O ) const { O << "BB#" << MBB -> getNumber ( ) ; ARMConstantPoolValue :: print ( O ) ; } </s>

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


<s> bool NVVMReflect :: runOnModule ( Module & M ) { if ( ! NVVMReflectEnabled ) return false ; setVarMap ( ) ; bool Res = false ; std :: string Name ; Type * Tys [ 1 ] ; Type * I8Ty = Type :: getInt8Ty ( M . getContext ( ) ) ; Function * ReflectFunction ; for ( unsigned i = 0 ; i != 5 ; ++ i ) { Tys [ 0 ] = PointerType :: get ( I8Ty , i ) ; Name = Intrinsic :: getName ( Intrinsic :: nvvm_reflect , Tys ) ; ReflectFunction = M . getFunction ( Name ) ; if ( ReflectFunction != 0 ) { Res |= handleFunction ( ReflectFunction ) ; } } ReflectFunction = M . getFunction ( NVVM_REFLECT_FUNCTION ) ; if ( ReflectFunction != 0 ) Res |= handleFunction ( ReflectFunction ) ; return Res ; } </s>

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


<s> static tree altivec_build_resolved_builtin ( tree * args , int n , const struct altivec_builtin_types * desc ) { tree impl_fndecl = rs6000_builtin_decls [ desc -> overloaded_code ] ; tree ret_type = rs6000_builtin_type ( desc -> ret_type ) ; tree argtypes = TYPE_ARG_TYPES ( TREE_TYPE ( impl_fndecl ) ) ; tree arg_type [ 3 ] ; tree call ; int i ; for ( i = 0 ; i < n ; i ++ ) arg_type [ i ] = TREE_VALUE ( argtypes ) , argtypes = TREE_CHAIN ( argtypes ) ; if ( desc -> code == ALTIVEC_BUILTIN_VEC_VCMPGE_P && desc -> overloaded_code != ALTIVEC_BUILTIN_VCMPGEFP_P && desc -> overloaded_code != VSX_BUILTIN_XVCMPGEDP_P ) { tree t ; t = args [ 2 ] , args [ 2 ] = args [ 1 ] , args [ 1 ] = t ; t = arg_type [ 2 ] , arg_type [ 2 ] = arg_type [ 1 ] , arg_type [ 1 ] = t ; args [ 0 ] = fold_build2 ( BIT_XOR_EXPR , TREE_TYPE ( args [ 0 ] ) , args [ 0 ] , build_int_cst ( NULL_TREE , 2 ) ) ; } switch ( n ) { case 0 : call = build_call_expr ( impl_fndecl , 0 ) ; break ; case 1 : call = build_call_expr ( impl_fndecl , 1 , fully_fold_convert ( arg_type [ 0 ] , args [ 0 ] ) ) ; break ; case 2 : call = build_call_expr ( impl_fndecl , 2 , fully_fold_convert ( arg_type [ 0 ] , args [ 0 ] ) , fully_fold_convert ( arg_type [ 1 ] , args [ 1 ] ) ) ; break ; case 3 : call = build_call_expr ( impl_fndecl , 3 , fully_fold_convert ( arg_type [ 0 ] , args [ 0 ] ) , fully_fold_convert ( arg_type [ 1 ] , args [ 1 ] ) , fully_fold_convert ( arg_type [ 2 ] , args [ 2 ] ) ) ; break ; default : gcc_unreachable ( ) ; } return fold_convert ( ret_type , call ) ; } </s>

Build a tree for a function call to an Altivec non-overloaded builtin . The overloaded builtin that matched the types and args is described by DESC . The N arguments are given in ARGS , respectively . Actually the only thing it does is calling fold_convert on ARGS , with a small exception for vec_ { all , any } _ { ge , le } predicates .


<s> static bool arc_vector_mode_supported_p ( machine_mode mode ) { switch ( mode ) { case V2HImode : return TARGET_PLUS_DMPY ; case V4HImode : case V2SImode : return TARGET_PLUS_QMACW ; case V4SImode : case V8HImode : return TARGET_SIMD_SET ; default : return false ; } } </s>

Implements target hook vector_mode_supported_p .


<s> static bool m68k_interrupt_function_p ( tree func ) { tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return false ; a = lookup_attribute ( "interrupt_handler" , DECL_ATTRIBUTES ( func ) ) ; return ( a != NULL_TREE ) ; } </s>

Return nonzero if FUNC is an interrupt function as specified by the `` interrupt_handler '' attribute .


<s>
bool
processBlock
(
MachineBasicBlock
&
MBB
)
{
bool
Changed
=
false
;
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
for
(
MachineInstr
&
MI
:
MBB
)
{
if
(
!
MI
.
isFullCopy
(
)
)
continue
;
MachineOperand
&
DstMO
=
MI
.
getOperand
(
0
)
;
MachineOperand
&
SrcMO
=
MI
.
getOperand
(
1
)
;
if
(
IsVSReg
(
DstMO
.
getReg
(
)
,
MRI
)
&&
!
IsVSReg
(
SrcMO
.
getReg
(
)
,
MRI
)
)
{
Changed
=
true
;
const
TargetRegisterClass
*
SrcRC
=
&
PPC
::
VSLRCRegClass
;
assert
(
(
IsF8Reg
(
SrcMO
.
getReg
(
)
,
MRI
)
||
IsVSSReg
(
SrcMO
.
getReg
(
)
,
MRI
)
||
IsVSFReg
(
SrcMO
.
getReg
(
)
,
MRI
)
)
&&
"Unknown source for a VSX copy"
)
;
unsigned
NewVReg
=
MRI
.
createVirtualRegister
(
SrcRC
)
;
BuildMI
(
MBB
,
MI
,
MI
.
getDebugLoc
(
)
,
TII
->
get
(
TargetOpcode
::
SUBREG_TO_REG
)
,
NewVReg
)
.
addImm
(
1
)
.
addOperand
(
SrcMO
)
.
addImm
(
PPC
::
sub_64
)
;
SrcMO
.
setReg
(
NewVReg
)
;
}
else
if
(
!
IsVSReg
(
DstMO
.
getReg
(
)
,
MRI
)
&&
IsVSReg
(
SrcMO
.
getReg
(
)
,
MRI
)
)
{
Changed
=
true
;
const
TargetRegisterClass
*
DstRC
=
&
PPC
::
VSLRCRegClass
;
assert
(
(
IsF8Reg
(
DstMO
.
getReg
(
)
,
MRI
)
||
IsVSFReg
(
DstMO
.
getReg
(
)
,
MRI
)
||
IsVSSReg
(
DstMO
.
getReg
(
)
,
MRI
)
)
&&
"Unknown destination for a VSX copy"
)
;
unsigned
NewVReg
=
MRI
.
createVirtualRegister
(
DstRC
)
;
BuildMI
(
MBB
,
MI
,
MI
.
getDebugLoc
(
)
,
TII
->
get
(
TargetOpcode
::
COPY
)
,
NewVReg
)
.
addOperand
(
SrcMO
)
;
SrcMO
.
setReg
(
NewVReg
)
;
SrcMO
.
setSubReg
(
PPC
::
sub_64
)
;
}
}
return
Changed
;
}
</s>

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


<s> MCObjectWriter * LanaiAsmBackend :: createObjectWriter ( raw_pwrite_stream & OS ) const { return createLanaiELFObjectWriter ( OS , MCELFObjectTargetWriter :: getOSABI ( OSType ) ) ; } </s>

Create a new MCObjectWriter instance for use by the assembler backend to emit the final object file .


<s>
void
X86AvoidSFBPass
::
buildCopy
(
MachineInstr
*
LoadInst
,
unsigned
NLoadOpcode
,
int64_t
LoadDisp
,
MachineInstr
*
StoreInst
,
unsigned
NStoreOpcode
,
int64_t
StoreDisp
,
unsigned
Size
,
int64_t
LMMOffset
,
int64_t
SMMOffset
)
{
MachineOperand
&
LoadBase
=
getBaseOperand
(
LoadInst
)
;
MachineOperand
&
StoreBase
=
getBaseOperand
(
StoreInst
)
;
MachineBasicBlock
*
MBB
=
LoadInst
->
getParent
(
)
;
MachineMemOperand
*
LMMO
=
*
LoadInst
->
memoperands_begin
(
)
;
MachineMemOperand
*
SMMO
=
*
StoreInst
->
memoperands_begin
(
)
;
Register
Reg1
=
MRI
->
createVirtualRegister
(
TII
->
getRegClass
(
TII
->
get
(
NLoadOpcode
)
,
0
,
TRI
,
*
(
MBB
->
getParent
(
)
)
)
)
;
MachineInstr
*
NewLoad
=
BuildMI
(
*
MBB
,
LoadInst
,
LoadInst
->
getDebugLoc
(
)
,
TII
->
get
(
NLoadOpcode
)
,
Reg1
)
.
add
(
LoadBase
)
.
addImm
(
1
)
.
addReg
(
X86
::
NoRegister
)
.
addImm
(
LoadDisp
)
.
addReg
(
X86
::
NoRegister
)
.
addMemOperand
(
MBB
->
getParent
(
)
->
getMachineMemOperand
(
LMMO
,
LMMOffset
,
Size
)
)
;
if
(
LoadBase
.
isReg
(
)
)
getBaseOperand
(
NewLoad
)
.
setIsKill
(
false
)
;
LLVM_DEBUG
(
NewLoad
->
dump
(
)
)
;
MachineInstr
*
StInst
=
StoreInst
;
auto
PrevInstrIt
=
skipDebugInstructionsBackward
(
std
::
prev
(
MachineBasicBlock
::
instr_iterator
(
StoreInst
)
)
,
MBB
->
instr_begin
(
)
)
;
if
(
PrevInstrIt
.
getNodePtr
(
)
==
LoadInst
)
StInst
=
LoadInst
;
MachineInstr
*
NewStore
=
BuildMI
(
*
MBB
,
StInst
,
StInst
->
getDebugLoc
(
)
,
TII
->
get
(
NStoreOpcode
)
)
.
add
(
StoreBase
)
.
addImm
(
1
)
.
addReg
(
X86
::
NoRegister
)
.
addImm
(
StoreDisp
)
.
addReg
(
X86
::
NoRegister
)
.
addReg
(
Reg1
)
.
addMemOperand
(
MBB
->
getParent
(
)
->
getMachineMemOperand
(
SMMO
,
SMMOffset
,
Size
)
)
;
if
(
StoreBase
.
isReg
(
)
)
getBaseOperand
(
NewStore
)
.
setIsKill
(
false
)
;
MachineOperand
&
StoreSrcVReg
=
StoreInst
->
getOperand
(
X86
::
AddrNumOperands
)
;
assert
(
StoreSrcVReg
.
isReg
(
)
&&
"Expected virtual register"
)
;
NewStore
->
getOperand
(
X86
::
AddrNumOperands
)
.
setIsKill
(
StoreSrcVReg
.
isKill
(
)
)
;
LLVM_DEBUG
(
NewStore
->
dump
(
)
)
;
}
</s>


<s> static bool tile_vector_mode_supported_p ( machine_mode mode ) { return mode == V4QImode || mode == V2HImode ; } </s>


<s> static void addUses ( const MachineInstr & MI , SmallVectorImpl < const MachineInstr * > & Worklist , MachineRegisterInfo & MRI ) { for ( auto & UserOp : MRI . reg_operands ( MI . getOperand ( 0 ) . getReg ( ) ) ) { const auto * User = UserOp . getParent ( ) ; if ( User == & MI ) continue ; Worklist . push_back ( User ) ; } } </s>


<s> void sh_set_return_address ( rtx ra , rtx tmp ) { HARD_REG_SET live_regs_mask ; int d ; int pr_reg = TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG ; int pr_offset ; d = calc_live_regs ( & live_regs_mask ) ; if ( ! TEST_HARD_REG_BIT ( live_regs_mask , pr_reg ) ) { rtx rr ; if ( TARGET_SHMEDIA ) { int rr_regno = sh_media_register_for_return ( ) ; if ( rr_regno < 0 ) rr_regno = pr_reg ; rr = gen_rtx_REG ( DImode , rr_regno ) ; } else rr = gen_rtx_REG ( SImode , pr_reg ) ; emit_insn ( GEN_MOV ( rr , ra ) ) ; emit_use ( rr ) ; return ; } if ( TARGET_SH5 ) { int offset ; save_schedule schedule ; save_entry * entry ; entry = sh5_schedule_saves ( & live_regs_mask , & schedule , 0 ) ; offset = entry [ 1 ] . offset ; for ( ; entry -> mode != VOIDmode ; entry -- ) if ( entry -> reg == pr_reg ) goto found ; gcc_unreachable ( ) ; found : offset = entry -> offset - offset ; pr_offset = ( rounded_frame_size ( d ) + offset + SHMEDIA_REGS_STACK_ADJUST ( ) ) ; } else pr_offset = rounded_frame_size ( d ) ; emit_insn ( GEN_MOV ( tmp , GEN_INT ( pr_offset ) ) ) ; if ( frame_pointer_needed ) emit_insn ( GEN_ADD3 ( tmp , tmp , hard_frame_pointer_rtx ) ) ; else emit_insn ( GEN_ADD3 ( tmp , tmp , stack_pointer_rtx ) ) ; tmp = gen_frame_mem ( Pmode , tmp ) ; emit_insn ( GEN_MOV ( tmp , ra ) ) ; emit_use ( tmp ) ; } </s>

Emit code to change the current function 's return address to RA . TEMP is available as a scratch register , if needed .


<s>
unsigned
WebAssemblyInstrInfo
::
removeBranch
(
MachineBasicBlock
&
MBB
,
int
*
BytesRemoved
)
const
{
assert
(
!
BytesRemoved
&&
"code size not handled"
)
;
MachineBasicBlock
::
instr_iterator
I
=
MBB
.
instr_end
(
)
;
unsigned
Count
=
0
;
while
(
I
!=
MBB
.
instr_begin
(
)
)
{
I
;
if
(
I
->
isDebugValue
(
)
)
continue
;
if
(
!
I
->
isTerminator
(
)
)
break
;
I
->
eraseFromParent
(
)
;
I
=
MBB
.
instr_end
(
)
;
++
Count
;
}
return
Count
;
}
</s>

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

WebAssembly
WebAssembly
"code size not handled"
0


<s> ScheduleHazardRecognizer * ARMBaseInstrInfo :: CreateTargetHazardRecognizer ( const TargetSubtargetInfo * STI , const ScheduleDAG * DAG ) const { if ( usePreRAHazardRecognizer ( ) ) { const InstrItineraryData * II = & static_cast < const ARMSubtarget * > ( STI ) -> getInstrItineraryData ( ) ; return new ScoreboardHazardRecognizer ( II , DAG , "pre-RA-sched" ) ; } return TargetInstrInfo :: CreateTargetHazardRecognizer ( STI , DAG ) ; } </s>

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


<s>
void
AVRInstrInfo
::
copyPhysReg
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
DebugLoc
&
DL
,
MCRegister
DestReg
,
MCRegister
SrcReg
,
bool
KillSrc
)
const
{
const
AVRSubtarget
&
STI
=
MBB
.
getParent
(
)
->
getSubtarget
<
AVRSubtarget
>
(
)
;
const
AVRRegisterInfo
&
TRI
=
*
STI
.
getRegisterInfo
(
)
;
unsigned
Opc
;
if
(
AVR
::
DREGSRegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
if
(
STI
.
hasMOVW
(
)
)
{
BuildMI
(
MBB
,
MI
,
DL
,
get
(
AVR
::
MOVWRdRr
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
else
{
unsigned
DestLo
,
DestHi
,
SrcLo
,
SrcHi
;
TRI
.
splitReg
(
DestReg
,
DestLo
,
DestHi
)
;
TRI
.
splitReg
(
SrcReg
,
SrcLo
,
SrcHi
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
AVR
::
MOVRdRr
)
,
DestLo
)
.
addReg
(
SrcLo
,
getKillRegState
(
KillSrc
)
)
;
BuildMI
(
MBB
,
MI
,
DL
,
get
(
AVR
::
MOVRdRr
)
,
DestHi
)
.
addReg
(
SrcHi
,
getKillRegState
(
KillSrc
)
)
;
}
}
else
{
if
(
AVR
::
GPR8RegClass
.
contains
(
DestReg
,
SrcReg
)
)
{
Opc
=
AVR
::
MOVRdRr
;
}
else
if
(
SrcReg
==
AVR
::
SP
&&
AVR
::
DREGSRegClass
.
contains
(
DestReg
)
)
{
Opc
=
AVR
::
SPREAD
;
}
else
if
(
DestReg
==
AVR
::
SP
&&
AVR
::
DREGSRegClass
.
contains
(
SrcReg
)
)
{
Opc
=
AVR
::
SPWRITE
;
}
else
{
llvm_unreachable
(
"Impossible reg-to-reg copy"
)
;
}
BuildMI
(
MBB
,
MI
,
DL
,
get
(
Opc
)
,
DestReg
)
.
addReg
(
SrcReg
,
getKillRegState
(
KillSrc
)
)
;
}
}
</s>

AVR
AVR
AVR
AVR
AVR
AVR::DREGSRegClass
AVR::MOVWRdRr
AVR::MOVRdRr
AVR::MOVRdRr
AVR::GPR8RegClass
AVR::MOVRdRr
AVR::SP
AVR::DREGSRegClass
AVR::SPREAD
AVR::SP
AVR::DREGSRegClass
AVR::SPWRITE
"Impossible reg-to-reg copy"


<s>
AMDGPUTTI
::
PopcntSupportKind
AMDGPUTTI
::
getPopcntSupport
(
unsigned
TyWidth
)
const
{
assert
(
isPowerOf2_32
(
TyWidth
)
&&
"Ty width must be power of 2"
)
;
return
ST
->
hasBCNT
(
TyWidth
)
PSK_FastHardware
:
PSK_Software
;
}
</s>

Return hardware support for population count .


<s>
bool
AMDGPULegalizerInfo
::
legalizeCustom
(
MachineInstr
&
MI
,
MachineRegisterInfo
&
MRI
,
MachineIRBuilder
&
B
,
GISelChangeObserver
&
Observer
)
const
{
switch
(
MI
.
getOpcode
(
)
)
{
case
TargetOpcode
::
G_ADDRSPACE_CAST
:
return
legalizeAddrSpaceCast
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_FRINT
:
return
legalizeFrint
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_FCEIL
:
return
legalizeFceil
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_INTRINSIC_TRUNC
:
return
legalizeIntrinsicTrunc
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_SITOFP
:
return
legalizeITOFP
(
MI
,
MRI
,
B
,
true
)
;
case
TargetOpcode
::
G_UITOFP
:
return
legalizeITOFP
(
MI
,
MRI
,
B
,
false
)
;
case
TargetOpcode
::
G_FMINNUM
:
case
TargetOpcode
::
G_FMAXNUM
:
case
TargetOpcode
::
G_FMINNUM_IEEE
:
case
TargetOpcode
::
G_FMAXNUM_IEEE
:
return
legalizeMinNumMaxNum
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_EXTRACT_VECTOR_ELT
:
return
legalizeExtractVectorElt
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_INSERT_VECTOR_ELT
:
return
legalizeInsertVectorElt
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_FSIN
:
case
TargetOpcode
::
G_FCOS
:
return
legalizeSinCos
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_GLOBAL_VALUE
:
return
legalizeGlobalValue
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_LOAD
:
return
legalizeLoad
(
MI
,
MRI
,
B
,
Observer
)
;
case
TargetOpcode
::
G_FMAD
:
return
legalizeFMad
(
MI
,
MRI
,
B
)
;
case
TargetOpcode
::
G_FDIV
:
return
legalizeFDIV
(
MI
,
MRI
,
B
)
;
default
:
return
false
;
}
llvm_unreachable
(
"expected switch to return"
)
;
}
</s>

Called for instructions with the Custom LegalizationAction .

AMDGPU
AMDGPU
SI
SI
SI
"expected switch to return"


<s> bool SITargetLowering :: shouldConvertConstantLoadToIntImm ( const APInt & Imm , Type * Ty ) const { const SIInstrInfo * TII = static_cast < const SIInstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; return TII -> isInlineConstant ( Imm ) ; } </s>

Returns true if it is beneficial to convert a load of a constant to just the constant itself .


<s> bool HexagonExpandCondsets :: runOnMachineFunction ( MachineFunction & MF ) { HII = static_cast < const HexagonInstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; TRI = MF . getSubtarget ( ) . getRegisterInfo ( ) ; LIS = & getAnalysis < LiveIntervals > ( ) ; MRI = & MF . getRegInfo ( ) ; bool Changed = false ; Changed |= coalesceSegments ( MF ) ; for ( MachineFunction :: iterator I = MF . begin ( ) , E = MF . end ( ) ; I != E ; ++ I ) { Changed |= splitInBlock ( * I ) ; Changed |= predicateInBlock ( * I ) ; } for ( MachineFunction :: iterator I = MF . begin ( ) , E = MF . end ( ) ; I != E ; ++ I ) postprocessUndefImplicitUses ( * I ) ; return Changed ; } </s>

runOnMachineFunction - Emit the function body .


<s> TargetLowering :: AtomicExpansionKind X86TargetLowering :: shouldExpandAtomicLoadInIR ( LoadInst * LI ) const { Type * MemType = LI -> getType ( ) ; bool NoImplicitFloatOps = LI -> getFunction ( ) -> hasFnAttribute ( Attribute :: NoImplicitFloat ) ; if ( MemType -> getPrimitiveSizeInBits ( ) == 64 && ! Subtarget . is64Bit ( ) && ! Subtarget . useSoftFloat ( ) && ! NoImplicitFloatOps && ( Subtarget . hasSSE1 ( ) || Subtarget . hasX87 ( ) ) ) return AtomicExpansionKind :: None ; return needsCmpXchgNb ( MemType ) ? AtomicExpansionKind :: CmpXChg : AtomicExpansionKind :: None ; } </s>

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


<s> MachineInstr * SIInstrInfo :: foldMemoryOperandImpl ( MachineFunction & MF , MachineInstr & MI , ArrayRef < unsigned > Ops , MachineBasicBlock :: iterator InsertPt , int FrameIndex , LiveIntervals * LIS , VirtRegMap * VRM ) const { if ( MI . isFullCopy ( ) ) { Register DstReg = MI . getOperand ( 0 ) . getReg ( ) ; Register SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; if ( ( DstReg . isVirtual ( ) || SrcReg . isVirtual ( ) ) && ( DstReg . isVirtual ( ) != SrcReg . isVirtual ( ) ) ) { MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; Register VirtReg = DstReg . isVirtual ( ) ? DstReg : SrcReg ; const TargetRegisterClass * RC = MRI . getRegClass ( VirtReg ) ; if ( RC -> hasSuperClassEq ( & AMDGPU :: SReg_32RegClass ) ) { MRI . constrainRegClass ( VirtReg , & AMDGPU :: SReg_32_XM0_XEXECRegClass ) ; return nullptr ; } else if ( RC -> hasSuperClassEq ( & AMDGPU :: SReg_64RegClass ) ) { MRI . constrainRegClass ( VirtReg , & AMDGPU :: SReg_64_XEXECRegClass ) ; return nullptr ; } } } return nullptr ; } </s>

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


<s> static void init_alignment_context ( struct alignment_context * ac , rtx mem , enum machine_mode mode ) { ac -> shift = GEN_INT ( GET_MODE_SIZE ( SImode ) - GET_MODE_SIZE ( mode ) ) ; ac -> aligned = ( MEM_ALIGN ( mem ) >= GET_MODE_BITSIZE ( SImode ) ) ; if ( ac -> aligned ) ac -> memsi = adjust_address ( mem , SImode , 0 ) ; else { rtx byteoffset , addr , align ; addr = force_reg ( Pmode , XEXP ( mem , 0 ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - GET_MODE_SIZE ( SImode ) ) , NULL_RTX , 1 , OPTAB_DIRECT ) ; ac -> memsi = gen_rtx_MEM ( SImode , align ) ; MEM_VOLATILE_P ( ac -> memsi ) = MEM_VOLATILE_P ( mem ) ; set_mem_alias_set ( ac -> memsi , ALIAS_SET_MEMORY_BARRIER ) ; set_mem_align ( ac -> memsi , GET_MODE_BITSIZE ( SImode ) ) ; byteoffset = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( GET_MODE_SIZE ( SImode ) - 1 ) , NULL_RTX , 1 , OPTAB_DIRECT ) ; ac -> shift = expand_simple_binop ( SImode , MINUS , ac -> shift , byteoffset , NULL_RTX , 1 , OPTAB_DIRECT ) ; } ac -> shift = expand_simple_binop ( SImode , MULT , ac -> shift , GEN_INT ( BITS_PER_UNIT ) , NULL_RTX , 1 , OPTAB_DIRECT ) ; ac -> modemask = expand_simple_binop ( SImode , ASHIFT , GEN_INT ( GET_MODE_MASK ( mode ) ) , ac -> shift , NULL_RTX , 1 , OPTAB_DIRECT ) ; ac -> modemaski = expand_simple_unop ( SImode , NOT , ac -> modemask , NULL_RTX , 1 ) ; } </s>

Initialize structure AC for word access to HI and QI mode memory .


<s> static bool ix86_function_ok_for_sibcall ( tree decl , tree exp ) { tree type , decl_or_type ; rtx a , b ; bool bind_global = decl && ! targetm . binds_local_p ( decl ) ; if ( ! TARGET_MACHO && ! TARGET_64BIT && flag_pic && flag_plt && bind_global ) return false ; if ( ix86_minimum_incoming_stack_boundary ( true ) < PREFERRED_STACK_BOUNDARY ) return false ; if ( decl ) { decl_or_type = decl ; type = TREE_TYPE ( decl ) ; } else { type = CALL_EXPR_FN ( exp ) ; type = TREE_TYPE ( type ) ; type = TREE_TYPE ( type ) ; decl_or_type = type ; } a = ix86_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = ix86_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( STACK_REG_P ( a ) || STACK_REG_P ( b ) ) { if ( ! rtx_equal_p ( a , b ) ) return false ; } else if ( VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) ; else if ( ! rtx_equal_p ( a , b ) ) return false ; if ( TARGET_64BIT ) { if ( cfun -> machine -> call_abi == MS_ABI && ix86_function_type_abi ( type ) == SYSV_ABI ) return false ; } else { if ( ! decl || ( bind_global && flag_pic && ! flag_plt ) || ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P ( decl ) ) ) { if ( ix86_function_regparm ( type , NULL ) >= 3 && ! cfun -> machine -> arg_reg_available ) return false ; } } return true ; } </s>

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


<s> void relaxInstruction ( const MCInst & Inst , MCInst & Res ) const { } </s>

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


<s> void HexagonPassConfig :: addPreEmitPass ( ) { bool NoOpt = ( getOptLevel ( ) == CodeGenOpt :: None ) ; if ( ! NoOpt ) addPass ( createHexagonNewValueJump ( ) ) ; addPass ( createHexagonBranchRelaxation ( ) ) ; if ( ! NoOpt ) { if ( ! DisableHardwareLoops ) addPass ( createHexagonFixupHwLoops ( ) ) ; if ( EnableGenMux ) addPass ( createHexagonGenMux ( ) ) ; } addPass ( createHexagonPacketizer ( NoOpt ) ) ; if ( EnableVectorPrint ) addPass ( createHexagonVectorPrint ( ) ) ; addPass ( createHexagonCallFrameInformation ( ) ) ; } </s>

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

Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon Hexagon


<s> unsigned find_first ( ) const { int First = Bits . find_first ( ) ; if ( First < 0 ) return 0 ; return x2v ( First ) ; } </s>

find_first - Returns the index of the first set bit .


<s> static void m68hc11_reorg ( void ) { int split_done = 0 ; rtx insn , first ; z_replacement_completed = 0 ; z_reg = gen_rtx_REG ( HImode , HARD_Z_REGNUM ) ; first = get_insns ( ) ; unshare_all_rtl_again ( first ) ; split_all_insns_noflow ( ) ; split_done = 1 ; z_replacement_completed = 1 ; m68hc11_reassign_regs ( first ) ; if ( optimize ) compute_bb_for_insn ( ) ; if ( optimize > 0 && split_done ) { reload_cse_regs ( first ) ; } if ( optimize ) { for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { if ( INSN_P ( insn ) ) { rtx * pnote ; pnote = & REG_NOTES ( insn ) ; while ( * pnote != 0 ) { if ( REG_NOTE_KIND ( * pnote ) == REG_DEAD ) * pnote = XEXP ( * pnote , 1 ) ; else pnote = & XEXP ( * pnote , 1 ) ; } } } life_analysis ( 0 , PROP_REG_INFO | PROP_DEATH_NOTES ) ; } z_replacement_completed = 2 ; if ( optimize > 0 ) split_all_insns_noflow ( ) ; { rtx insn ; for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { rtx body ; if ( INSN_DELETED_P ( insn ) ) continue ; if ( ! INSN_P ( insn ) ) continue ; body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == SET && rtx_equal_p ( SET_SRC ( body ) , SET_DEST ( body ) ) ) { PUT_CODE ( insn , NOTE ) ; NOTE_LINE_NUMBER ( insn ) = NOTE_INSN_DELETED ; NOTE_SOURCE_FILE ( insn ) = 0 ; continue ; } } } } </s>

Machine-dependent reorg pass . Specific optimizations are defined here : - this pass changes the Z register into either X or Y ( it preserves X/Y previous values in a memory slot in page0 ) . When this pass is finished , the global variable 'z_replacement_completed ' is set to 2 .


<s>
bool
PPCRegisterInfo
::
needsFrameBaseReg
(
MachineInstr
*
MI
,
int64_t
Offset
)
const
{
assert
(
Offset
<
0
&&
"Local offset must be negative"
)
;
unsigned
OpC
=
MI
->
getOpcode
(
)
;
if
(
!
ImmToIdxMap
.
count
(
OpC
)
)
return
false
;
if
(
(
OpC
==
PPC
::
ADDI
||
OpC
==
PPC
::
ADDI8
)
&&
MI
->
getOperand
(
2
)
.
getImm
(
)
==
0
)
return
false
;
MachineBasicBlock
&
MBB
=
*
MI
->
getParent
(
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
const
PPCFrameLowering
*
TFI
=
getFrameLowering
(
MF
)
;
unsigned
StackEst
=
TFI
->
determineFrameLayout
(
MF
,
true
)
;
if
(
!
StackEst
)
return
false
;
Offset
+=
StackEst
;
return
!
isFrameOffsetLegal
(
MI
,
getBaseRegister
(
MF
)
,
Offset
)
;
}
</s>

Returns true if the instruction 's frame index reference would be better served by a base register other than FP or SP .


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

Print the specified MCInst to the specified raw_ostream .


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

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


<s> static void tilepro_reorg ( void ) { compute_bb_for_insn ( ) ; if ( flag_reorder_blocks_and_partition ) { tilepro_fixup_pcrel_references ( ) ; } if ( flag_schedule_insns_after_reload ) { split_all_insns ( ) ; timevar_push ( TV_SCHED2 ) ; schedule_insns ( ) ; timevar_pop ( TV_SCHED2 ) ; tilepro_gen_bundles ( ) ; } df_analyze ( ) ; if ( flag_var_tracking ) { timevar_push ( TV_VAR_TRACKING ) ; variable_tracking_main ( ) ; reorder_var_tracking_notes ( ) ; timevar_pop ( TV_VAR_TRACKING ) ; } df_finish_pass ( false ) ; } </s>

Perform machine dependent operations on the rtl chain INSNS .


<s> void DLXRegisterInfo :: eliminateFrameIndex ( MachineBasicBlock :: iterator II , int SPAdj , unsigned FIOperandNum , RegScavenger * RS ) const { } </s>

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


<s> void HexagonFrameLowering :: determineCalleeSaves ( MachineFunction & MF , BitVector & SavedRegs , RegScavenger * RS ) const { auto & HST = MF . getSubtarget < HexagonSubtarget > ( ) ; auto & HRI = * HST . getRegisterInfo ( ) ; SavedRegs . resize ( HRI . getNumRegs ( ) ) ; if ( MF . getInfo < HexagonMachineFunctionInfo > ( ) -> hasEHReturn ( ) ) for ( const MCPhysReg * R = HRI . getCalleeSavedRegs ( & MF ) ; * R ; ++ R ) SavedRegs . set ( * R ) ; SmallVector < unsigned , 8 > NewRegs ; expandSpillMacros ( MF , NewRegs ) ; if ( OptimizeSpillSlots && ! isOptNone ( MF ) ) optimizeSpillSlots ( MF , NewRegs ) ; if ( ! NewRegs . empty ( ) || mayOverflowFrameOffset ( MF ) ) { MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; SetVector < const TargetRegisterClass * > SpillRCs ; SpillRCs . insert ( & Hexagon :: IntRegsRegClass ) ; for ( unsigned VR : NewRegs ) SpillRCs . insert ( MRI . getRegClass ( VR ) ) ; for ( auto * RC : SpillRCs ) { if ( ! needToReserveScavengingSpillSlots ( MF , HRI , RC ) ) continue ; unsigned Num = RC == & Hexagon :: IntRegsRegClass ? NumberScavengerSlots : 1 ; unsigned S = RC -> getSize ( ) , A = RC -> getAlignment ( ) ; for ( unsigned i = 0 ; i < Num ; i ++ ) { int NewFI = MFI . CreateSpillStackObject ( S , A ) ; RS -> addScavengingFrameIndex ( NewFI ) ; } } } TargetFrameLowering :: determineCalleeSaves ( MF , SavedRegs , RS ) ; } </s>

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

Hexagon Hexagon Hexagon Hexagon 8 Hexagon::IntRegsRegClass Hexagon::IntRegsRegClass 1 0


<s> unsigned ARMBaseInstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { switch ( MI -> getOpcode ( ) ) { default : break ; case ARM :: STRrs : case ARM :: t2STRs : if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isReg ( ) && MI -> getOperand ( 3 ) . isImm ( ) && MI -> getOperand ( 2 ) . getReg ( ) == 0 && MI -> getOperand ( 3 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: STRi12 : case ARM :: t2STRi12 : case ARM :: tSTRspi : case ARM :: VSTRD : case ARM :: VSTRS : if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 2 ) . isImm ( ) && MI -> getOperand ( 2 ) . getImm ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; case ARM :: VST1q64 : case ARM :: VST1d64TPseudo : case ARM :: VST1d64QPseudo : if ( MI -> getOperand ( 0 ) . isFI ( ) && MI -> getOperand ( 2 ) . getSubReg ( ) == 0 ) { FrameIndex = MI -> getOperand ( 0 ) . getIndex ( ) ; return MI -> getOperand ( 2 ) . getReg ( ) ; } break ; case ARM :: VSTMQIA : if ( MI -> getOperand ( 1 ) . isFI ( ) && MI -> getOperand ( 0 ) . getSubReg ( ) == 0 ) { FrameIndex = MI -> getOperand ( 1 ) . getIndex ( ) ; return MI -> getOperand ( 0 ) . getReg ( ) ; } break ; } return 0 ; } </s>

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


<s>
static
void
arm_setup_incoming_varargs
(
cumulative_args_t
pcum_v
,
machine_mode
mode
,
tree
type
,
int
*
pretend_size
,
int
second_time
ATTRIBUTE_UNUSED
)
{
CUMULATIVE_ARGS
*
pcum
=
get_cumulative_args
(
pcum_v
)
;
int
nregs
;
cfun
->
machine
->
uses_anonymous_args
=
1
;
if
(
pcum
->
pcs_variant
<=
ARM_PCS_AAPCS_LOCAL
)
{
nregs
=
pcum
->
aapcs_ncrn
;
if
(
nregs
&
1
)
{
int
res
=
arm_needs_doubleword_align
(
mode
,
type
)
;
if
(
res
<
0
&&
warn_psabi
)
inform
(
input_location
,
"parameter passing for argument of "
"type %qT changed in GCC 7.1"
,
type
)
;
else
if
(
res
>
0
)
nregs
++
;
}
}
else
nregs
=
pcum
->
nregs
;
if
(
nregs
<
NUM_ARG_REGS
)
*
pretend_size
=
(
NUM_ARG_REGS
nregs
)
*
UNITS_PER_WORD
;
}
</s>

Worker function for TARGET_SETUP_INCOMING_VARARGS . On the ARM , PRETEND_SIZE is set in order to have the prologue push the last named arg and all anonymous args onto the stack . XXX I know the prologue should n't be pushing registers , but it is faster that way .


<s> bool HexagonCopyToCombine :: runOnMachineFunction ( MachineFunction & MF ) { if ( skipFunction ( MF . getFunction ( ) ) ) return false ; if ( IsCombinesDisabled ) return false ; bool HasChanged = false ; ST = & MF . getSubtarget < HexagonSubtarget > ( ) ; TRI = ST -> getRegisterInfo ( ) ; TII = ST -> getInstrInfo ( ) ; const Function & F = MF . getFunction ( ) ; bool OptForSize = F . hasFnAttribute ( Attribute :: OptimizeForSize ) ; ShouldCombineAggressively = MF . getTarget ( ) . getOptLevel ( ) <= CodeGenOpt :: Default ; for ( MachineFunction :: iterator BI = MF . begin ( ) , BE = MF . end ( ) ; BI != BE ; ++ BI ) { PotentiallyNewifiableTFR . clear ( ) ; findPotentialNewifiableTFRs ( * BI ) ; for ( MachineBasicBlock :: iterator MI = BI -> begin ( ) , End = BI -> end ( ) ; MI != End ; ) { MachineInstr & I1 = * MI ++ ; if ( I1 . isDebugValue ( ) ) continue ; if ( ShouldCombineAggressively && PotentiallyNewifiableTFR . count ( & I1 ) ) continue ; if ( ! isCombinableInstType ( I1 , TII , ShouldCombineAggressively ) ) continue ; bool DoInsertAtI1 = false ; DbgMItoMove . clear ( ) ; MachineInstr * I2 = findPairable ( I1 , DoInsertAtI1 , OptForSize ) ; if ( I2 ) { HasChanged = true ; combine ( I1 , * I2 , MI , DoInsertAtI1 , OptForSize ) ; } } } return HasChanged ; } </s>

runOnMachineFunction - Emit the function body .


Wrapper around the output_probe_stack_range routines .


<s> static rtx_insn * nds32_md_asm_adjust ( vec < rtx > & outputs ATTRIBUTE_UNUSED , vec < rtx > & inputs ATTRIBUTE_UNUSED , vec < machine_mode > & input_modes ATTRIBUTE_UNUSED , vec < const char * > & constraints ATTRIBUTE_UNUSED , vec < rtx > & clobbers , HARD_REG_SET & clobbered_regs , location_t ) { if ( ! flag_inline_asm_r15 ) { clobbers . safe_push ( gen_rtx_REG ( SImode , TA_REGNUM ) ) ; SET_HARD_REG_BIT ( clobbered_regs , TA_REGNUM ) ; } return NULL ; } </s>


<s> int nds32_can_use_btgl_p ( int ival ) { int one_bit_count ; one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ival ) ) ; return ( TARGET_EXT_PERF && ( one_bit_count == 1 ) ) ; } </s>

Function to check if 'btgl ' instruction can be used with IVAL .


<s> const uint16_t * MBlazeRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const uint16_t CalleeSavedRegs [ ] = { MBlaze :: R20 , MBlaze :: R21 , MBlaze :: R22 , MBlaze :: R23 , MBlaze :: R24 , MBlaze :: R25 , MBlaze :: R26 , MBlaze :: R27 , MBlaze :: R28 , MBlaze :: R29 , MBlaze :: R30 , MBlaze :: R31 , 0 } ; return CalleeSavedRegs ; } </s>


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> const uint16_t * ARMBaseRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { bool ghcCall = false ; if ( MF ) { const Function * F = MF -> getFunction ( ) ; ghcCall = ( F ? F -> getCallingConv ( ) == CallingConv :: GHC : false ) ; } if ( ghcCall ) { return CSR_GHC_SaveList ; } else { return ( STI . isTargetIOS ( ) && ! STI . isAAPCS_ABI ( ) ) ? CSR_iOS_SaveList : CSR_AAPCS_SaveList ; } } </s>


<s> static unsigned int arc_compute_frame_size ( void ) { int regno ; unsigned int total_size , var_size , args_size , pretend_size , extra_size ; unsigned int reg_size ; uint64_t gmask ; struct arc_frame_info * frame_info ; int size ; unsigned int extra_plus_reg_size ; unsigned int extra_plus_reg_size_aligned ; unsigned int fn_type = arc_compute_function_type ( cfun ) ; if ( cfun -> machine -> frame_info . initialized ) return cfun -> machine -> frame_info . total_size ; frame_info = & cfun -> machine -> frame_info ; size = ARC_STACK_ALIGN ( get_frame_size ( ) ) ; var_size = size ; args_size = crtl -> outgoing_args_size ; reg_size = 0 ; gmask = 0 ; for ( regno = 0 ; regno <= ( GMASK_LEN - 4 ) ; regno ++ ) { if ( arc_must_save_register ( regno , cfun , false ) ) { reg_size += UNITS_PER_WORD ; gmask |= 1ULL << regno ; } } if ( crtl -> calls_eh_return ) for ( regno = 0 ; EH_RETURN_DATA_REGNO ( regno ) != INVALID_REGNUM ; regno ++ ) { reg_size += UNITS_PER_WORD ; gmask |= 1ULL << regno ; } frame_info -> save_return_addr = ( ! crtl -> is_leaf || df_regs_ever_live_p ( RETURN_ADDR_REGNUM ) || crtl -> calls_eh_return ) ; if ( TARGET_MILLICODE_THUNK_SET && ! ARC_INTERRUPT_P ( fn_type ) && ! crtl -> calls_eh_return ) { if ( arc_compute_millicode_save_restore_regs ( gmask , frame_info ) ) frame_info -> save_return_addr = true ; } if ( arc_lpcwidth != 0 && arc_must_save_register ( LP_COUNT , cfun , true ) ) reg_size += UNITS_PER_WORD * 3 ; if ( arc_must_save_register ( TARGET_BIG_ENDIAN ? R41_REG : R40_REG , cfun , TARGET_DPFP ) ) reg_size += UNITS_PER_WORD * 2 ; if ( arc_must_save_register ( TARGET_BIG_ENDIAN ? R43_REG : R42_REG , cfun , TARGET_DPFP ) ) reg_size += UNITS_PER_WORD * 2 ; if ( arc_must_save_register ( R58_REG , cfun , true ) ) reg_size += UNITS_PER_WORD * 2 ; extra_size = 0 ; if ( arc_must_save_return_addr ( cfun ) ) extra_size = 4 ; if ( arc_frame_pointer_needed ( ) && ! ARC_AUTOFP_IRQ_P ( fn_type ) ) extra_size += 4 ; pretend_size = crtl -> args . pretend_args_size ; extra_plus_reg_size = extra_size + reg_size ; extra_plus_reg_size_aligned = ARC_STACK_ALIGN ( extra_plus_reg_size ) ; reg_size = extra_plus_reg_size_aligned - extra_size ; total_size = var_size + args_size + extra_size + pretend_size + reg_size ; gcc_assert ( total_size == ARC_STACK_ALIGN ( total_size ) ) ; frame_info -> total_size = total_size ; frame_info -> extra_size = extra_size ; frame_info -> pretend_size = pretend_size ; frame_info -> var_size = var_size ; frame_info -> args_size = args_size ; frame_info -> reg_size = reg_size ; frame_info -> gmask = gmask ; frame_info -> initialized = reload_completed ; return total_size ; } </s>

Return the bytes needed to compute the frame pointer from the current stack pointer . SIZE is the size needed for local variables .


<s> static bool loongarch_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { return loongarch_hard_regno_mode_ok_p [ mode ] [ regno ] ; } </s>


<s> static bool mips_lo_sum_offset_lookup ( mips_offset_table * htab , rtx x , enum insert_option option ) { rtx base , offset ; mips_lo_sum_offset * * slot ; struct mips_lo_sum_offset * entry ; split_const ( x , & base , & offset ) ; if ( UNSPEC_ADDRESS_P ( base ) ) base = UNSPEC_ADDRESS ( base ) ; slot = htab -> find_slot_with_hash ( base , mips_hash_base ( base ) , option ) ; if ( slot == NULL ) return false ; entry = ( struct mips_lo_sum_offset * ) * slot ; if ( option == INSERT ) { if ( entry == NULL ) { entry = XNEW ( struct mips_lo_sum_offset ) ; entry -> base = base ; entry -> offset = INTVAL ( offset ) ; * slot = entry ; } else { if ( INTVAL ( offset ) > entry -> offset ) entry -> offset = INTVAL ( offset ) ; } } return INTVAL ( offset ) <= entry -> offset ; } </s>

Look up symbolic constant X in HTAB , which is a hash table of mips_lo_sum_offsets . If OPTION is NO_INSERT , return true if X can be paired with a recorded LO_SUM , otherwise record X in the table .


<s>
void
addExpr
(
MCInst
&
Inst
,
const
MCExpr
*
Expr
)
const
{
assert
(
Expr
&&
"Expr shouldn't be null!"
)
;
if
(
auto
*
CE
=
dyn_cast
<
MCConstantExpr
>
(
Expr
)
)
Inst
.
addOperand
(
MCOperand
::
createImm
(
CE
->
getValue
(
)
)
)
;
else
Inst
.
addOperand
(
MCOperand
::
createExpr
(
Expr
)
)
;
}
</s>


<s> inline machine_mode function_instance :: memory_vector_mode ( ) const { return base -> memory_vector_mode ( * this ) ; } </s>

If the function addresses memory , return a vector mode whose GET_MODE_NUNITS is the number of elements addressed and whose GET_MODE_INNER is the mode of a single scalar memory element .


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

Get a TargetTransformInfo implementation for the target .


<s> SDValue X86TargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { SelectionDAG & DAG = DCI . DAG ; switch ( N -> getOpcode ( ) ) { default : break ; case ISD :: EXTRACT_VECTOR_ELT : return PerformEXTRACT_VECTOR_ELTCombine ( N , DAG , * this ) ; case ISD :: SELECT : return PerformSELECTCombine ( N , DAG , Subtarget ) ; case X86ISD :: CMOV : return PerformCMOVCombine ( N , DAG , DCI ) ; case ISD :: ADD : case ISD :: SUB : return OptimizeConditonalInDecrement ( N , DAG ) ; case X86ISD :: ADC : return PerformADCCombine ( N , DAG , DCI ) ; case ISD :: MUL : return PerformMulCombine ( N , DAG , DCI ) ; case ISD :: SHL : case ISD :: SRA : case ISD :: SRL : return PerformShiftCombine ( N , DAG , Subtarget ) ; case ISD :: AND : return PerformAndCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: OR : return PerformOrCombine ( N , DAG , DCI , Subtarget ) ; case ISD :: STORE : return PerformSTORECombine ( N , DAG , Subtarget ) ; case X86ISD :: FXOR : case X86ISD :: FOR : return PerformFORCombine ( N , DAG ) ; case X86ISD :: FAND : return PerformFANDCombine ( N , DAG ) ; case X86ISD :: BT : return PerformBTCombine ( N , DAG , DCI ) ; case X86ISD :: VZEXT_MOVL : return PerformVZEXT_MOVLCombine ( N , DAG ) ; case ISD :: ZERO_EXTEND : return PerformZExtCombine ( N , DAG ) ; case X86ISD :: SETCC : return PerformSETCCCombine ( N , DAG ) ; case X86ISD :: SHUFPS : case X86ISD :: SHUFPD : case X86ISD :: PALIGN : case X86ISD :: PUNPCKHBW : case X86ISD :: PUNPCKHWD : case X86ISD :: PUNPCKHDQ : case X86ISD :: PUNPCKHQDQ : case X86ISD :: UNPCKHPS : case X86ISD :: UNPCKHPD : case X86ISD :: PUNPCKLBW : case X86ISD :: PUNPCKLWD : case X86ISD :: PUNPCKLDQ : case X86ISD :: PUNPCKLQDQ : case X86ISD :: UNPCKLPS : case X86ISD :: UNPCKLPD : case X86ISD :: VUNPCKLPS : case X86ISD :: VUNPCKLPD : case X86ISD :: VUNPCKLPSY : case X86ISD :: VUNPCKLPDY : case X86ISD :: MOVHLPS : case X86ISD :: MOVLHPS : case X86ISD :: PSHUFD : case X86ISD :: PSHUFHW : case X86ISD :: PSHUFLW : case X86ISD :: MOVSS : case X86ISD :: MOVSD : case ISD :: VECTOR_SHUFFLE : return PerformShuffleCombine ( N , DAG , DCI ) ; } return SDValue ( ) ; } </s>

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


<s> static bool use_rsqrt_p ( ) { return ( TARGET_SSE_MATH && flag_finite_math_only && ! flag_trapping_math && flag_unsafe_math_optimizations ) ; } </s>

Return true if it is safe to use the rsqrt optabs to optimize 1.0/sqrt .


<s> static void nvptx_reorg ( void ) { compute_bb_for_insn ( ) ; thread_prologue_and_epilogue_insns ( ) ; bb_insn_map_t bb_insn_map ; nvptx_split_blocks ( & bb_insn_map ) ; df_clear_flags ( DF_LR_RUN_DCE ) ; df_set_flags ( DF_NO_INSN_RESCAN | DF_NO_HARD_REGS ) ; df_live_add_problem ( ) ; df_live_set_all_dirty ( ) ; df_analyze ( ) ; regstat_init_n_sets_and_refs ( ) ; if ( dump_file ) df_dump ( dump_file ) ; int max_regs = max_reg_num ( ) ; for ( int i = LAST_VIRTUAL_REGISTER + 1 ; i < max_regs ; i ++ ) if ( REG_N_SETS ( i ) == 0 && REG_N_REFS ( i ) == 0 ) regno_reg_rtx [ i ] = const0_rtx ; tree attr = get_oacc_fn_attrib ( current_function_decl ) ; if ( attr ) { unsigned mask = 0 ; tree dims = TREE_VALUE ( attr ) ; unsigned ix ; for ( ix = 0 ; ix != GOMP_DIM_MAX ; ix ++ , dims = TREE_CHAIN ( dims ) ) { int size = TREE_INT_CST_LOW ( TREE_VALUE ( dims ) ) ; tree allowed = TREE_PURPOSE ( dims ) ; if ( size != 1 && ! ( allowed && integer_zerop ( allowed ) ) ) mask |= GOMP_DIM_MASK ( ix ) ; } gcc_assert ( ! ( mask & GOMP_DIM_MASK ( GOMP_DIM_WORKER ) ) || ( mask & GOMP_DIM_MASK ( GOMP_DIM_VECTOR ) ) ) ; parallel * pars = nvptx_discover_pars ( & bb_insn_map ) ; nvptx_process_pars ( pars ) ; nvptx_neuter_pars ( pars , mask , 0 ) ; delete pars ; } nvptx_reorg_subreg ( ) ; regstat_free_n_sets_and_refs ( ) ; df_finish_pass ( true ) ; } </s>

Clean up subreg operands . In ptx assembly , everything is typed , and the presence of subregs would break the rules for most instructions . Replace them with a suitable new register of the right size , plus conversion copyin/copyout instructions .


<s> SDValue R600TargetLowering :: LowerFormalArguments ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < ISD :: InputArg > & Ins , const SDLoc & DL , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { SmallVector < CCValAssign , 16 > ArgLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , ArgLocs , * DAG . getContext ( ) ) ; MachineFunction & MF = DAG . getMachineFunction ( ) ; R600MachineFunctionInfo * MFI = MF . getInfo < R600MachineFunctionInfo > ( ) ; SmallVector < ISD :: InputArg , 8 > LocalIns ; getOriginalFunctionArgs ( DAG , MF . getFunction ( ) , Ins , LocalIns ) ; AnalyzeFormalArguments ( CCInfo , LocalIns ) ; for ( unsigned i = 0 , e = Ins . size ( ) ; i < e ; ++ i ) { CCValAssign & VA = ArgLocs [ i ] ; const ISD :: InputArg & In = Ins [ i ] ; EVT VT = In . VT ; EVT MemVT = VA . getLocVT ( ) ; if ( ! VT . isVector ( ) && MemVT . isVector ( ) ) { MemVT = MemVT . getVectorElementType ( ) ; } if ( AMDGPU :: isShader ( CallConv ) ) { unsigned Reg = MF . addLiveIn ( VA . getLocReg ( ) , & AMDGPU :: R600_Reg128RegClass ) ; SDValue Register = DAG . getCopyFromReg ( Chain , DL , Reg , VT ) ; InVals . push_back ( Register ) ; continue ; } PointerType * PtrTy = PointerType :: get ( VT . getTypeForEVT ( * DAG . getContext ( ) ) , AMDGPUAS :: CONSTANT_BUFFER_0 ) ; ISD :: LoadExtType Ext = ISD :: NON_EXTLOAD ; if ( MemVT . getScalarSizeInBits ( ) != VT . getScalarSizeInBits ( ) ) { Ext = ISD :: SEXTLOAD ; } unsigned ValBase = ArgLocs [ In . getOrigArgIndex ( ) ] . getLocMemOffset ( ) ; unsigned PartOffset = VA . getLocMemOffset ( ) ; unsigned Offset = 36 + VA . getLocMemOffset ( ) ; MachinePointerInfo PtrInfo ( UndefValue :: get ( PtrTy ) , PartOffset - ValBase ) ; SDValue Arg = DAG . getLoad ( ISD :: UNINDEXED , Ext , VT , DL , Chain , DAG . getConstant ( Offset , DL , MVT :: i32 ) , DAG . getUNDEF ( MVT :: i32 ) , PtrInfo , MemVT , false , true , true , 4 ) ; InVals . push_back ( Arg ) ; MFI -> ABIArgOffset = Offset + MemVT . getStoreSize ( ) ; } return Chain ; } </s>

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


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

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


<s> static enum rtx_code ix86_prepare_fp_compare_args ( enum rtx_code code , rtx * pop0 , rtx * pop1 ) { bool unordered_compare = ix86_unordered_fp_compare ( code ) ; rtx op0 = * pop0 , op1 = * pop1 ; machine_mode op_mode = GET_MODE ( op0 ) ; bool is_sse = SSE_FLOAT_MODE_SSEMATH_OR_HF_P ( op_mode ) ; if ( ! is_sse && ( unordered_compare || ( op_mode == XFmode && ! ( standard_80387_constant_p ( op0 ) == 1 || standard_80387_constant_p ( op1 ) == 1 ) && GET_CODE ( op1 ) != FLOAT ) || ix86_fp_comparison_strategy ( code ) == IX86_FPCMP_COMI ) ) { op0 = force_reg ( op_mode , op0 ) ; op1 = force_reg ( op_mode , op1 ) ; } else { if ( standard_80387_constant_p ( op0 ) == 0 || ( MEM_P ( op0 ) && ! ( standard_80387_constant_p ( op1 ) == 0 || MEM_P ( op1 ) ) ) ) { enum rtx_code new_code = ix86_fp_swap_condition ( code ) ; if ( new_code != UNKNOWN ) { std :: swap ( op0 , op1 ) ; code = new_code ; } } if ( ! REG_P ( op0 ) ) op0 = force_reg ( op_mode , op0 ) ; if ( CONSTANT_P ( op1 ) ) { int tmp = standard_80387_constant_p ( op1 ) ; if ( tmp == 0 ) op1 = validize_mem ( force_const_mem ( op_mode , op1 ) ) ; else if ( tmp == 1 ) { if ( TARGET_CMOVE ) op1 = force_reg ( op_mode , op1 ) ; } else op1 = force_reg ( op_mode , op1 ) ; } } if ( ix86_fp_comparison_cost ( code ) > ix86_fp_comparison_cost ( swap_condition ( code ) ) && ( REG_P ( op1 ) || can_create_pseudo_p ( ) ) ) { std :: swap ( op0 , op1 ) ; code = swap_condition ( code ) ; if ( ! REG_P ( op0 ) ) op0 = force_reg ( op_mode , op0 ) ; } * pop0 = op0 ; * pop1 = op1 ; return code ; } </s>

Swap , force into registers , or otherwise massage the two operands to a fp comparison . The operands are updated in place ; the new comparsion code is returned .


<s> void ia64_split_return_addr_rtx ( rtx dest ) { rtx src ; if ( TEST_HARD_REG_BIT ( current_frame_info . mask , BR_REG ( 0 ) ) ) { if ( current_frame_info . r [ reg_save_b0 ] != 0 ) { src = gen_rtx_REG ( DImode , current_frame_info . r [ reg_save_b0 ] ) ; reg_emitted ( reg_save_b0 ) ; } else { HOST_WIDE_INT off ; unsigned int regno ; rtx off_r ; off = ( current_frame_info . spill_cfa_off + current_frame_info . spill_size ) ; for ( regno = GR_REG ( 1 ) ; regno <= GR_REG ( 31 ) ; ++ regno ) if ( TEST_HARD_REG_BIT ( current_frame_info . mask , regno ) ) off -= 8 ; if ( frame_pointer_needed ) src = hard_frame_pointer_rtx ; else { src = stack_pointer_rtx ; off += current_frame_info . total_size ; } off_r = GEN_INT ( off ) ; if ( satisfies_constraint_I ( off_r ) ) emit_insn ( gen_adddi3 ( dest , src , off_r ) ) ; else { emit_move_insn ( dest , off_r ) ; emit_insn ( gen_adddi3 ( dest , src , dest ) ) ; } src = gen_rtx_MEM ( Pmode , dest ) ; } } else src = gen_rtx_REG ( DImode , BR_REG ( 0 ) ) ; emit_move_insn ( dest , src ) ; } </s>

Split this value after reload , now that we know where the return address is saved .


<s> static void alpha_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr , mem , word1 , word2 ; fnaddr = XEXP ( DECL_RTL ( fndecl ) , 0 ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; chain_value = convert_memory_address ( Pmode , chain_value ) ; if ( TARGET_ABI_OPEN_VMS ) { const char * fnname ; char * trname ; fnname = XSTR ( fnaddr , 0 ) ; trname = ( char * ) alloca ( strlen ( fnname ) + 5 ) ; strcpy ( trname , fnname ) ; strcat ( trname , "..tr" ) ; fnname = ggc_alloc_string ( trname , strlen ( trname ) + 1 ) ; word2 = gen_rtx_SYMBOL_REF ( Pmode , fnname ) ; word1 = force_reg ( DImode , gen_const_mem ( DImode , fnaddr ) ) ; word1 = expand_and ( DImode , word1 , GEN_INT ( HOST_WIDE_INT_C ( 0xffff0fff0000fff0 ) ) , NULL ) ; } else { word1 = GEN_INT ( HOST_WIDE_INT_C ( 0xa77b0010a43b0018 ) ) ; word2 = GEN_INT ( HOST_WIDE_INT_C ( 0x47ff041f6bfb0000 ) ) ; } mem = adjust_address ( m_tramp , DImode , 0 ) ; emit_move_insn ( mem , word1 ) ; mem = adjust_address ( m_tramp , DImode , 8 ) ; emit_move_insn ( mem , word2 ) ; mem = adjust_address ( m_tramp , Pmode , 16 ) ; emit_move_insn ( mem , fnaddr ) ; mem = adjust_address ( m_tramp , Pmode , 24 ) ; emit_move_insn ( mem , chain_value ) ; if ( TARGET_ABI_OSF ) { emit_insn ( gen_imb ( ) ) ; emit_library_call ( init_one_libfunc ( "__enable_execute_stack" ) , LCT_NORMAL , VOIDmode , 1 , XEXP ( m_tramp , 0 ) , Pmode ) ; } } </s>

Emit RTL insns to initialize the variable parts of a trampoline at M_TRAMP . FNDECL is target function 's decl . CHAIN_VALUE is an rtx for the static chain value for the function .


<s> bool shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) override { switch ( ( Sparc :: Fixups ) Fixup . getKind ( ) ) { default : return false ; case Sparc :: fixup_sparc_wplt30 : if ( Target . getSymA ( ) -> getSymbol ( ) . isTemporary ( ) ) return false ; LLVM_FALLTHROUGH ; case Sparc :: fixup_sparc_tls_gd_hi22 : case Sparc :: fixup_sparc_tls_gd_lo10 : case Sparc :: fixup_sparc_tls_gd_add : case Sparc :: fixup_sparc_tls_gd_call : case Sparc :: fixup_sparc_tls_ldm_hi22 : case Sparc :: fixup_sparc_tls_ldm_lo10 : case Sparc :: fixup_sparc_tls_ldm_add : case Sparc :: fixup_sparc_tls_ldm_call : case Sparc :: fixup_sparc_tls_ldo_hix22 : case Sparc :: fixup_sparc_tls_ldo_lox10 : case Sparc :: fixup_sparc_tls_ldo_add : case Sparc :: fixup_sparc_tls_ie_hi22 : case Sparc :: fixup_sparc_tls_ie_lo10 : case Sparc :: fixup_sparc_tls_ie_ld : case Sparc :: fixup_sparc_tls_ie_ldx : case Sparc :: fixup_sparc_tls_ie_add : case Sparc :: fixup_sparc_tls_le_hix22 : case Sparc :: fixup_sparc_tls_le_lox10 : return true ; } } </s>

Hook to check if a relocation is needed for some target specific reason .


"%qE attribute only applies to functions"

"requested %qE attribute is not a comma separated pair of"

" non-negative integer constants or too large (max. %d)"

Check whether the hotpatch attribute is applied to a function and , if it has an argument , the argument is valid .


"InsertBranch must not be told to insert a fallthrough"

"RISCV branch conditions have two components!"

Insert branch code into the end of the specified MachineBasicBlock .


<s> unsigned Mips16InstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { return 0 ; } </s>

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


<s> static rtx nvptx_libcall_value ( machine_mode mode , const_rtx ) { if ( cfun -> machine -> start_call == NULL_RTX ) return gen_rtx_REG ( mode , NVPTX_RETURN_REGNUM ) ; return gen_reg_rtx ( mode ) ; } </s>


<s> void avr_register_target_pragmas ( void ) { gcc_assert ( ADDR_SPACE_GENERIC == ADDR_SPACE_RAM ) ; for ( int i = 0 ; i < ADDR_SPACE_COUNT ; i ++ ) { gcc_assert ( i == avr_addrspace [ i ] . id ) ; if ( ! ADDR_SPACE_GENERIC_P ( i ) ) c_register_addr_space ( avr_addrspace [ i ] . name , avr_addrspace [ i ] . id ) ; } targetm . resolve_overloaded_builtin = avr_resolve_overloaded_builtin ; } </s>


<s>
void
GCNUpwardRPTracker
::
recede
(
const
MachineInstr
&
MI
)
{
assert
(
MRI
&&
"call reset first"
)
;
LastTrackedMI
=
&
MI
;
if
(
MI
.
isDebugValue
(
)
)
return
;
for
(
const
auto
&
MO
:
MI
.
operands
(
)
)
{
if
(
!
MO
.
isReg
(
)
||
!
MO
.
isDef
(
)
||
!
TargetRegisterInfo
::
isVirtualRegister
(
MO
.
getReg
(
)
)
)
continue
;
auto
Reg
=
MO
.
getReg
(
)
;
auto
&
LiveMask
=
LiveRegs
[
Reg
]
;
auto
PrevMask
=
LiveMask
;
LiveMask
&=
~
getDefRegMask
(
MO
)
;
CurPressure
.
inc
(
Reg
,
PrevMask
,
LiveMask
,
*
MRI
)
;
}
for
(
const
auto
&
MO
:
MI
.
uses
(
)
)
{
if
(
!
MO
.
isReg
(
)
||
!
MO
.
readsReg
(
)
||
!
TargetRegisterInfo
::
isVirtualRegister
(
MO
.
getReg
(
)
)
)
continue
;
auto
Reg
=
MO
.
getReg
(
)
;
auto
&
LiveMask
=
LiveRegs
[
Reg
]
;
auto
PrevMask
=
LiveMask
;
LiveMask
|=
getUsedRegMask
(
MO
)
;
CurPressure
.
inc
(
Reg
,
PrevMask
,
LiveMask
,
*
MRI
)
;
}
MaxPressure
=
max
(
MaxPressure
,
CurPressure
)
;
}
</s>

Recede across the previous instruction .


<s> void applyFixup ( const MCFixup & Fixup , char * Data , unsigned DataSize , uint64_t Value ) const { } </s>

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


<s> void PatmosLatencyQueue :: clear ( ) { PendingQueue . clear ( ) ; AvailableQueue . clear ( ) ; } </s>


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

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


<s>
SDValue
SparcTargetLowering
::
LowerOperation
(
SDValue
Op
,
SelectionDAG
&
DAG
)
const
{
bool
hasHardQuad
=
Subtarget
->
hasHardQuad
(
)
;
bool
is64Bit
=
Subtarget
->
is64Bit
(
)
;
bool
isV9
=
Subtarget
->
isV9
(
)
;
switch
(
Op
.
getOpcode
(
)
)
{
default
:
llvm_unreachable
(
"Should not custom lower this!"
)
;
case
ISD
::
RETURNADDR
:
return
LowerRETURNADDR
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
FRAMEADDR
:
return
LowerFRAMEADDR
(
Op
,
DAG
)
;
case
ISD
::
GlobalTLSAddress
:
llvm_unreachable
(
"TLS not implemented for Sparc."
)
;
case
ISD
::
GlobalAddress
:
return
LowerGlobalAddress
(
Op
,
DAG
)
;
case
ISD
::
BlockAddress
:
return
LowerBlockAddress
(
Op
,
DAG
)
;
case
ISD
::
ConstantPool
:
return
LowerConstantPool
(
Op
,
DAG
)
;
case
ISD
::
FP_TO_SINT
:
return
LowerFP_TO_SINT
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
SINT_TO_FP
:
return
LowerSINT_TO_FP
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
BR_CC
:
return
LowerBR_CC
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
SELECT_CC
:
return
LowerSELECT_CC
(
Op
,
DAG
,
*
this
,
hasHardQuad
)
;
case
ISD
::
VASTART
:
return
LowerVASTART
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
VAARG
:
return
LowerVAARG
(
Op
,
DAG
)
;
case
ISD
::
DYNAMIC_STACKALLOC
:
return
LowerDYNAMIC_STACKALLOC
(
Op
,
DAG
)
;
case
ISD
::
LOAD
:
return
LowerF128Load
(
Op
,
DAG
)
;
case
ISD
::
STORE
:
return
LowerF128Store
(
Op
,
DAG
)
;
case
ISD
::
FADD
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
ADD_F128
)
,
2
)
;
case
ISD
::
FSUB
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
SUB_F128
)
,
2
)
;
case
ISD
::
FMUL
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
MUL_F128
)
,
2
)
;
case
ISD
::
FDIV
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
DIV_F128
)
,
2
)
;
case
ISD
::
FSQRT
:
return
LowerF128Op
(
Op
,
DAG
,
getLibcallName
(
RTLIB
::
SQRT_F128
)
,
1
)
;
case
ISD
::
FNEG
:
return
LowerFNEG
(
Op
,
DAG
,
*
this
,
is64Bit
)
;
case
ISD
::
FABS
:
return
LowerFABS
(
Op
,
DAG
,
isV9
)
;
case
ISD
::
FP_EXTEND
:
return
LowerF128_FPEXTEND
(
Op
,
DAG
,
*
this
)
;
case
ISD
::
FP_ROUND
:
return
LowerF128_FPROUND
(
Op
,
DAG
,
*
this
)
;
}
}
</s>

LowerOperation - Provide custom lowering hooks for some operations .


<s> static int ix86_set_reg_reg_cost ( machine_mode mode ) { unsigned int units = UNITS_PER_WORD ; switch ( GET_MODE_CLASS ( mode ) ) { default : break ; case MODE_CC : units = GET_MODE_SIZE ( CCmode ) ; break ; case MODE_FLOAT : if ( ( TARGET_SSE && mode == TFmode ) || ( TARGET_80387 && mode == XFmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DFmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SFmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_COMPLEX_FLOAT : if ( ( TARGET_SSE && mode == TCmode ) || ( TARGET_80387 && mode == XCmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DCmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SCmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_VECTOR_INT : case MODE_VECTOR_FLOAT : if ( ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) || ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) || ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) || ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) || ( TARGET_MMX && VALID_MMX_REG_MODE ( mode ) ) ) units = GET_MODE_SIZE ( mode ) ; } return COSTS_N_INSNS ( CEIL ( GET_MODE_SIZE ( mode ) , units ) ) ; } </s>

Return the cost of moving between two registers of mode MODE .


<s> int X86FrameLowering :: mergeSPUpdates ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator & MBBI , bool doMergeWithPrevious ) const { if ( ( doMergeWithPrevious && MBBI == MBB . begin ( ) ) || ( ! doMergeWithPrevious && MBBI == MBB . end ( ) ) ) return 0 ; MachineBasicBlock :: iterator PI = doMergeWithPrevious ? std :: prev ( MBBI ) : MBBI ; MachineBasicBlock :: iterator NI = doMergeWithPrevious ? nullptr : std :: next ( MBBI ) ; unsigned Opc = PI -> getOpcode ( ) ; int Offset = 0 ; if ( ( Opc == X86 :: ADD64ri32 || Opc == X86 :: ADD64ri8 || Opc == X86 :: ADD32ri || Opc == X86 :: ADD32ri8 ) && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { Offset += PI -> getOperand ( 2 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } else if ( ( Opc == X86 :: LEA32r || Opc == X86 :: LEA64_32r ) && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { Offset += PI -> getOperand ( 4 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } else if ( ( Opc == X86 :: SUB64ri32 || Opc == X86 :: SUB64ri8 || Opc == X86 :: SUB32ri || Opc == X86 :: SUB32ri8 ) && PI -> getOperand ( 0 ) . getReg ( ) == StackPtr ) { Offset -= PI -> getOperand ( 2 ) . getImm ( ) ; MBB . erase ( PI ) ; if ( ! doMergeWithPrevious ) MBBI = NI ; } return Offset ; } </s>

Check the instruction before/after the passed instruction .


<s> bool X86MCInstrAnalysis :: evaluateBranch ( const MCInst & Inst , uint64_t Addr , uint64_t Size , uint64_t & Target ) const { if ( Inst . getNumOperands ( ) == 0 || Info -> get ( Inst . getOpcode ( ) ) . OpInfo [ 0 ] . OperandType != MCOI :: OPERAND_PCREL ) return false ; Target = Addr + Size + Inst . getOperand ( 0 ) . getImm ( ) ; return true ; } </s>

Given a branch instruction try to get the address the branch targets .