<s> bool BPFAdjustOptImpl :: run ( ) { for ( Function & F : * M ) for ( auto & BB : F ) { adjustBasicBlock ( BB ) ; for ( auto & I : BB ) adjustInst ( I ) ; } return insertPassThrough ( ) ; } </s>

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


<s> static rtx mips_expand_builtin_bposge ( enum mips_builtin_type builtin_type , rtx target ) { rtx condition , cmp_result ; int cmp_value ; if ( target == 0 || GET_MODE ( target ) != SImode ) target = gen_reg_rtx ( SImode ) ; cmp_result = gen_rtx_REG ( CCDSPmode , CCDSP_PO_REGNUM ) ; if ( builtin_type == MIPS_BUILTIN_BPOSGE32 ) cmp_value = 32 ; else gcc_assert ( 0 ) ; condition = gen_rtx_GE ( VOIDmode , cmp_result , GEN_INT ( cmp_value ) ) ; return mips_builtin_branch_and_move ( condition , target , const1_rtx , const0_rtx ) ; } </s>

Expand a bposge builtin of type BUILTIN_TYPE . TARGET , if nonnull , suggests a good place to put the boolean result . The sequence we want is li target , 0 bposge * label1 j label2 label1 : li target , 1 label2 :


<s> Register getStackAddress ( uint64_t Size , int64_t Offset , MachinePointerInfo & MPO , ISD :: ArgFlagsTy Flags ) override { auto & MFI = MIRBuilder . getMF ( ) . getFrameInfo ( ) ; const bool IsImmutable = ! Flags . isByVal ( ) ; int FI = MFI . CreateFixedObject ( Size , Offset , IsImmutable ) ; MPO = MachinePointerInfo :: getFixedStack ( MIRBuilder . getMF ( ) , FI ) ; return MIRBuilder . buildFrameIndex ( LLT :: pointer ( 0 , DL . getPointerSizeInBits ( 0 ) ) , FI ) . getReg ( 0 ) ; } </s>

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


<s> static void rs6000_split_v4si_init_di_reg ( rtx dest , rtx si1 , rtx si2 , rtx tmp ) { const unsigned HOST_WIDE_INT mask_32bit = HOST_WIDE_INT_C ( 0xffffffff ) ; if ( CONST_INT_P ( si1 ) && CONST_INT_P ( si2 ) ) { unsigned HOST_WIDE_INT const1 = ( UINTVAL ( si1 ) & mask_32bit ) << 32 ; unsigned HOST_WIDE_INT const2 = UINTVAL ( si2 ) & mask_32bit ; emit_move_insn ( dest , GEN_INT ( const1 | const2 ) ) ; return ; } if ( CONST_INT_P ( si1 ) ) emit_move_insn ( dest , GEN_INT ( ( UINTVAL ( si1 ) & mask_32bit ) << 32 ) ) ; else { rtx si1_di = gen_rtx_REG ( DImode , regno_or_subregno ( si1 ) ) ; rtx shift_rtx = gen_rtx_ASHIFT ( DImode , si1_di , GEN_INT ( 32 ) ) ; rtx mask_rtx = GEN_INT ( mask_32bit << 32 ) ; rtx and_rtx = gen_rtx_AND ( DImode , shift_rtx , mask_rtx ) ; gcc_assert ( ! reg_overlap_mentioned_p ( dest , si1 ) ) ; emit_insn ( gen_rtx_SET ( dest , and_rtx ) ) ; } gcc_assert ( ! reg_overlap_mentioned_p ( dest , tmp ) ) ; if ( CONST_INT_P ( si2 ) ) emit_move_insn ( tmp , GEN_INT ( UINTVAL ( si2 ) & mask_32bit ) ) ; else emit_insn ( gen_zero_extendsidi2 ( tmp , si2 ) ) ; emit_insn ( gen_iordi3 ( dest , dest , tmp ) ) ; return ; } </s>

Helper function for rs6000_split_v4si_init to build up a DImode value from two SImode values .


<s> static void s390_init_frame_layout ( void ) { HOST_WIDE_INT frame_size ; int base_used ; if ( reload_completed ) return ; do { frame_size = cfun_frame_layout . frame_size ; base_used = crtl -> uses_const_pool || ( ! DISP_IN_RANGE ( frame_size ) && ! CONST_OK_FOR_K ( frame_size ) ) ; if ( ! base_used ) cfun -> machine -> base_reg = NULL_RTX ; else { int br = 0 ; if ( crtl -> is_leaf ) for ( br = 5 ; br >= 2 && df_regs_ever_live_p ( br ) ; br -- ) ; cfun -> machine -> base_reg = gen_rtx_REG ( Pmode , ( br >= 2 ) ? br : BASE_REGNUM ) ; } s390_register_info ( ) ; s390_frame_info ( ) ; } while ( frame_size != cfun_frame_layout . frame_size ) ; } </s>

Generate frame layout . Fills in register and frame data for the current function in cfun- > machine . This routine can be called multiple times ; it will re-do the complete frame layout every time .


<s> int sparc_check_64 ( rtx x , rtx_insn * insn ) { int set_once = 0 ; rtx y = x ; gcc_assert ( GET_CODE ( x ) == REG ) ; if ( GET_MODE ( x ) == DImode ) y = gen_rtx_REG ( SImode , REGNO ( x ) + WORDS_BIG_ENDIAN ) ; if ( flag_expensive_optimizations && df && DF_REG_DEF_COUNT ( REGNO ( y ) ) == 1 ) set_once = 1 ; if ( insn == 0 ) { if ( set_once ) insn = get_last_insn_anywhere ( ) ; else return 0 ; } while ( ( insn = PREV_INSN ( insn ) ) ) { switch ( GET_CODE ( insn ) ) { case JUMP_INSN : case NOTE : break ; case CODE_LABEL : case CALL_INSN : default : if ( ! set_once ) return 0 ; break ; case INSN : { rtx pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) != SET ) return 0 ; if ( rtx_equal_p ( x , SET_DEST ( pat ) ) ) return set_extends ( insn ) ; if ( y && rtx_equal_p ( y , SET_DEST ( pat ) ) ) return set_extends ( insn ) ; if ( reg_overlap_mentioned_p ( SET_DEST ( pat ) , y ) ) return 0 ; } } } return 0 ; } </s>

Return 0 if the high 32 bits of X ( the low word of X , if DImode ) are unknown . Return 1 if the high bits are zero , -1 if the register is sign extended .


<s> const CAHPInstrInfo * getInstrInfo ( ) const override { return & InstrInfo ; } </s>


<s> static bool fits_dispatch_window ( rtx_insn * insn ) { dispatch_windows * window_list = dispatch_window_list ; dispatch_windows * window_list_next = dispatch_window_list -> next ; unsigned int num_restrict ; enum dispatch_group group = get_insn_group ( insn ) ; enum insn_path path = get_insn_path ( insn ) ; int sum ; if ( group == disp_jcc || group == disp_cmp ) return false ; if ( group == disp_no_group || group == disp_branch ) return true ; if ( window_list_next ) window_list = window_list_next ; if ( window_list -> window_num == 1 ) { sum = window_list -> prev -> window_size + window_list -> window_size ; if ( sum == 32 || ( min_insn_size ( insn ) + sum ) >= 48 ) return true ; } num_restrict = count_num_restricted ( insn , window_list ) ; if ( num_restrict > num_allowable_groups [ group ] ) return false ; if ( window_list -> window_num == 0 ) { if ( path == path_double && ( window_list -> num_uops + 2 ) > MAX_INSN ) return false ; else if ( path != path_single ) return false ; } return true ; } </s>

This function returns true if insn satisfies dispatch rules on the last window scheduled .


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

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


"block as it would convert a WLS from forward to a "

Checks if loop has a backwards branching WLS , and if possible , fixes it .


<s> const MCPhysReg * MSP430RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { const MSP430FrameLowering * TFI = getFrameLowering ( * MF ) ; const Function * F = & MF -> getFunction ( ) ; static const MCPhysReg CalleeSavedRegs [ ] = { MSP430 :: FP , MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , 0 } ; static const MCPhysReg CalleeSavedRegsFP [ ] = { MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , 0 } ; static const MCPhysReg CalleeSavedRegsIntr [ ] = { MSP430 :: FP , MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , MSP430 :: R11 , MSP430 :: R12 , MSP430 :: R13 , MSP430 :: R14 , MSP430 :: R15 , 0 } ; static const MCPhysReg CalleeSavedRegsIntrFP [ ] = { MSP430 :: R5 , MSP430 :: R6 , MSP430 :: R7 , MSP430 :: R8 , MSP430 :: R9 , MSP430 :: R10 , MSP430 :: R11 , MSP430 :: R12 , MSP430 :: R13 , MSP430 :: R14 , MSP430 :: R15 , 0 } ; if ( TFI -> hasFP ( * MF ) ) return ( F -> getCallingConv ( ) == CallingConv :: MSP430_INTR ? CalleeSavedRegsIntrFP : CalleeSavedRegsFP ) ; else return ( F -> getCallingConv ( ) == CallingConv :: MSP430_INTR ? CalleeSavedRegsIntr : CalleeSavedRegs ) ; } </s>


<s> static rsqrts_type get_rsqrts_type ( machine_mode mode ) { switch ( mode ) { case E_DFmode : return gen_aarch64_rsqrtsdf ; case E_SFmode : return gen_aarch64_rsqrtssf ; case E_V2DFmode : return gen_aarch64_rsqrtsv2df ; case E_V2SFmode : return gen_aarch64_rsqrtsv2sf ; case E_V4SFmode : return gen_aarch64_rsqrtsv4sf ; default : gcc_unreachable ( ) ; } } </s>

Select reciprocal square root series step insn depending on machine mode .


<s> void PPCELFStreamer :: emitInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI ) { PPCMCCodeEmitter * Emitter = static_cast < PPCMCCodeEmitter * > ( getAssembler ( ) . getEmitterPtr ( ) ) ; if ( ! Emitter -> isPrefixedInstruction ( Inst ) ) { MCELFStreamer :: emitInstruction ( Inst , STI ) ; return ; } emitCodeAlignment ( 64 , 4 ) ; MCELFStreamer :: emitInstruction ( Inst , STI ) ; MCFragment * InstructionFragment = getCurrentFragment ( ) ; SMLoc InstLoc = Inst . getLoc ( ) ; if ( LastLabel && ! LastLabel -> isUnset ( ) && LastLabelLoc . isValid ( ) && InstLoc . isValid ( ) ) { const SourceMgr * SourceManager = getContext ( ) . getSourceManager ( ) ; unsigned InstLine = SourceManager -> FindLineNumber ( InstLoc ) ; unsigned LabelLine = SourceManager -> FindLineNumber ( LastLabelLoc ) ; if ( InstLine == LabelLine ) { AssignFragment ( LastLabel , InstructionFragment ) ; LastLabel -> setOffset ( 0 ) ; } } } </s>

Targets should implement this to emit instructions .


<s>
MCSection
*
HexagonTargetObjectFile
::
getExplicitSectionGlobal
(
const
GlobalValue
*
GV
,
SectionKind
Kind
,
Mangler
&
Mang
,
const
TargetMachine
&
TM
)
const
{
TRACE
(
"[getExplicitSectionGlobal] GV("
<<
GV
->
getName
(
)
<<
") from("
<<
GV
->
getSection
(
)
<<
") "
)
;
TRACE
(
(
GV
->
hasPrivateLinkage
(
)
"private_linkage "
:
""
)
<<
(
GV
->
hasLocalLinkage
(
)
"local_linkage "
:
""
)
<<
(
GV
->
hasInternalLinkage
(
)
"internal "
:
""
)
<<
(
GV
->
hasExternalLinkage
(
)
"external "
:
""
)
<<
(
GV
->
hasCommonLinkage
(
)
"common_linkage "
:
""
)
<<
(
GV
->
hasCommonLinkage
(
)
"common "
:
""
)
<<
(
Kind
.
isCommon
(
)
"kind_common "
:
""
)
<<
(
Kind
.
isBSS
(
)
"kind_bss "
:
""
)
<<
(
Kind
.
isBSSLocal
(
)
"kind_bss_local "
:
""
)
)
;
if
(
GV
->
hasSection
(
)
)
{
StringRef
Section
=
GV
->
getSection
(
)
;
if
(
Section
.
find
(
".access.text.group"
)
!=
StringRef
::
npos
)
return
getContext
(
)
.
getELFSection
(
GV
->
getSection
(
)
,
ELF
::
SHT_PROGBITS
,
ELF
::
SHF_ALLOC
|
ELF
::
SHF_EXECINSTR
)
;
if
(
Section
.
find
(
".access.data.group"
)
!=
StringRef
::
npos
)
return
getContext
(
)
.
getELFSection
(
GV
->
getSection
(
)
,
ELF
::
SHT_PROGBITS
,
ELF
::
SHF_WRITE
|
ELF
::
SHF_ALLOC
)
;
}
if
(
isGlobalInSmallSection
(
GV
,
TM
)
)
return
selectSmallSectionForGlobal
(
GV
,
Kind
,
Mang
,
TM
)
;
TRACE
(
"default_ELF_section\n"
)
;
return
TargetLoweringObjectFileELF
::
getExplicitSectionGlobal
(
GV
,
Kind
,
Mang
,
TM
)
;
}
</s>

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

Hexagon
Hexagon
"[getExplicitSectionGlobal] GV("
") from("
") "
"private_linkage "
""
"local_linkage "
""
"internal "
""
"external "
""
"common_linkage "
""
"common "
""
"kind_common "
""
"kind_bss "
""
"kind_bss_local "
""
".access.text.group"
".access.data.group"
"default_ELF_section\n"


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

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


<s> const TargetRegisterClass * ARMBaseRegisterInfo :: getLargestLegalSuperClass ( const TargetRegisterClass * RC ) const { const TargetRegisterClass * Super = RC ; TargetRegisterClass :: sc_iterator I = RC -> getSuperClasses ( ) ; do { switch ( Super -> getID ( ) ) { case ARM :: GPRRegClassID : case ARM :: SPRRegClassID : case ARM :: DPRRegClassID : case ARM :: QPRRegClassID : case ARM :: QQPRRegClassID : case ARM :: QQQQPRRegClassID : return Super ; } Super = * I ++ ; } while ( Super ) ; return RC ; } </s>

Returns the largest super class of RC that is legal to use in the current sub-target and has the same spill size .

ARM ARM ARM::GPRRegClassID ARM::SPRRegClassID ARM::DPRRegClassID ARM::QPRRegClassID ARM::QQPRRegClassID ARM::QQQQPRRegClassID


"alignment (%u) for %s exceeds maximum alignment "

Both the HP and GNU assemblers under HP-UX provide a .comm directive that does n't allow the alignment of global common storage to be directly specified . The SOM linker aligns common storage based on the rounded value of the NUM_BYTES parameter in the .comm directive . It 's not possible to use the .align directive as it does n't affect the alignment of the label associated with a .comm directive .


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

runOnMachineFunction - Emit the function body .


<s> MCSection * RISCVELFTargetObjectFile :: getSectionForConstant ( const DataLayout & DL , SectionKind Kind , const Constant * C , unsigned & Align ) const { if ( isConstantInSmallSection ( DL , C ) ) return SmallDataSection ; return TargetLoweringObjectFileELF :: getSectionForConstant ( DL , Kind , C , Align ) ; } </s>

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


<s> static void s390_z10_prevent_earlyload_conflicts ( rtx_insn * * ready , int * nready_p ) { unsigned int regno ; int nready = * nready_p ; rtx_insn * tmp ; int i ; rtx_insn * insn ; rtx set ; enum attr_type flag ; int distance ; for ( insn = last_scheduled_insn , distance = Z10_EARLYLOAD_DISTANCE - 1 ; distance > 0 && insn != NULL_RTX ; distance -- , insn = prev_active_insn ( insn ) ) if ( CALL_P ( insn ) || JUMP_P ( insn ) ) return ; if ( insn == NULL_RTX ) return ; set = single_set ( insn ) ; if ( set == NULL_RTX || ! REG_P ( SET_DEST ( set ) ) || GET_MODE_CLASS ( GET_MODE ( SET_DEST ( set ) ) ) != MODE_FLOAT ) return ; flag = s390_safe_attr_type ( insn ) ; if ( flag == TYPE_FLOADSF || flag == TYPE_FLOADDF ) return ; regno = REGNO ( SET_DEST ( set ) ) ; i = nready - 1 ; while ( ! s390_fpload_toreg ( ready [ i ] , regno ) && i > 0 ) i -- ; if ( ! i ) return ; tmp = ready [ i ] ; memmove ( & ready [ 1 ] , & ready [ 0 ] , sizeof ( rtx_insn * ) * i ) ; ready [ 0 ] = tmp ; } </s>

Rearrange the ready list in order to avoid the situation described for Z10_EARLYLOAD_DISTANCE . A problematic load instruction is moved to the very end of the ready list .


<s> static rtx frv_expand_cut_builtin ( enum insn_code icode , tree call , rtx target ) { rtx pat ; rtx op0 = frv_read_argument ( call , 0 ) ; rtx op1 = frv_read_argument ( call , 1 ) ; rtx op2 ; target = frv_legitimize_target ( icode , target ) ; op0 = frv_int_to_acc ( icode , 1 , op0 ) ; if ( ! op0 ) return NULL_RTX ; if ( icode == CODE_FOR_mdcutssi || GET_CODE ( op1 ) == CONST_INT ) { if ( ! frv_check_constant_argument ( icode , 2 , op1 ) ) return NULL_RTX ; } else op1 = frv_legitimize_argument ( icode , 2 , op1 ) ; op2 = frv_matching_accg_for_acc ( op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 , op2 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; return target ; } </s>

Expand cut-style builtins , which take two operands and an implicit ACCG one .


<s> static unsigned int sparc_hard_regno_nregs ( unsigned int regno , machine_mode mode ) { if ( regno == SPARC_GSR_REG ) return 1 ; if ( TARGET_ARCH64 ) { if ( SPARC_INT_REG_P ( regno ) || regno == FRAME_POINTER_REGNUM ) return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ; return CEIL ( GET_MODE_SIZE ( mode ) , 4 ) ; } return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ; } </s>

Implement TARGET_HARD_REGNO_NREGS . On SPARC , ordinary registers hold 32 bits worth ; this means both integer and floating point registers . On v9 , integer regs hold 64 bits worth ; floating point regs hold 32 bits worth ( this includes the new fp regs as even the odd ones are included in the hard register count ) .


<s> static bool nvptx_can_change_mode_class ( machine_mode , machine_mode , reg_class_t ) { return false ; } </s>


<s> void ix86_expand_sse2_abs ( rtx target , rtx input ) { machine_mode mode = GET_MODE ( target ) ; rtx tmp0 , tmp1 , x ; switch ( mode ) { case V4SImode : tmp0 = expand_simple_binop ( mode , ASHIFTRT , input , GEN_INT ( GET_MODE_UNIT_BITSIZE ( mode ) - 1 ) , NULL , 0 , OPTAB_DIRECT ) ; tmp1 = expand_simple_binop ( mode , XOR , tmp0 , input , NULL , 0 , OPTAB_DIRECT ) ; x = expand_simple_binop ( mode , MINUS , tmp1 , tmp0 , target , 0 , OPTAB_DIRECT ) ; break ; case V8HImode : tmp0 = expand_unop ( mode , neg_optab , input , NULL_RTX , 0 ) ; x = expand_simple_binop ( mode , SMAX , tmp0 , input , target , 0 , OPTAB_DIRECT ) ; break ; case V16QImode : tmp0 = expand_unop ( mode , neg_optab , input , NULL_RTX , 0 ) ; x = expand_simple_binop ( V16QImode , UMIN , tmp0 , input , target , 0 , OPTAB_DIRECT ) ; break ; default : gcc_unreachable ( ) ; } if ( x != target ) emit_move_insn ( target , x ) ; } </s>

Calculate integer abs ( ) using only SSE2 instructions .


ParseDirective - Parse a target specific assembler directive This method is deprecated , use 'parseDirective ' instead .


<s> bool enableEarlyIfConversion ( ) const override { return hasISEL ( ) ; } </s>

Enable the use of the early if conversion pass .


<s> bool isImm ( ) const { return Kind == CV_Immediate ; } </s>


<s> bool AArch64Subtarget :: supportsAddressTopByteIgnored ( ) const { if ( ! UseAddressTopByteIgnored ) return false ; if ( TargetTriple . isDriverKit ( ) ) return true ; if ( TargetTriple . isiOS ( ) ) { return TargetTriple . getiOSVersion ( ) >= VersionTuple ( 8 ) ; } return false ; } </s>

CPU has TBI ( top byte of addresses is ignored during HW address translation ) and OS enables it .


<s> int const_ok_for_arm ( HOST_WIDE_INT i ) { int lowbit ; if ( ( i & ~ ( unsigned HOST_WIDE_INT ) 0xffffffff ) != 0 && ( ( i & ~ ( unsigned HOST_WIDE_INT ) 0xffffffff ) != ( ( ~ ( unsigned HOST_WIDE_INT ) 0 ) & ~ ( unsigned HOST_WIDE_INT ) 0xffffffff ) ) ) return FALSE ; i &= ( unsigned HOST_WIDE_INT ) 0xffffffff ; if ( ( i & ~ ( unsigned HOST_WIDE_INT ) 0xff ) == 0 ) return TRUE ; lowbit = ffs ( ( int ) i ) - 1 ; if ( TARGET_ARM ) lowbit &= ~ 1 ; if ( ( i & ~ ( ( ( unsigned HOST_WIDE_INT ) 0xff ) << lowbit ) ) == 0 ) return TRUE ; if ( TARGET_ARM ) { if ( lowbit <= 4 && ( ( i & ~ 0xc000003f ) == 0 || ( i & ~ 0xf000000f ) == 0 || ( i & ~ 0xfc000003 ) == 0 ) ) return TRUE ; } else { HOST_WIDE_INT v ; v = i & 0xff ; v |= v << 16 ; if ( i == v || i == ( v | ( v << 8 ) ) ) return TRUE ; v = i & 0xff00 ; v |= v << 16 ; if ( i == v ) return TRUE ; } return FALSE ; } </s>

Return TRUE if int I is a valid immediate ARM constant .


<s> VariantKind getKind ( ) const { return Kind ; } </s>


<s> std :: pair < SDValue , SDValue > SystemZSelectionDAGInfo :: EmitTargetCodeForStrcmp ( SelectionDAG & DAG , SDLoc DL , SDValue Chain , SDValue Src1 , SDValue Src2 , MachinePointerInfo Op1PtrInfo , MachinePointerInfo Op2PtrInfo ) const { SDVTList VTs = DAG . getVTList ( Src1 . getValueType ( ) , MVT :: Other , MVT :: Glue ) ; SDValue Unused = DAG . getNode ( SystemZISD :: STRCMP , DL , VTs , Chain , Src1 , Src2 , DAG . getConstant ( 0 , DL , MVT :: i32 ) ) ; Chain = Unused . getValue ( 1 ) ; SDValue Glue = Chain . getValue ( 2 ) ; return std :: make_pair ( addIPMSequence ( DL , Glue , DAG ) , Chain ) ; } </s>

Emit target-specific code that performs a strcmp , in cases where that is faster than a libcall .


<s> bool CSKYConstantPool :: empty ( ) { return Entries . empty ( ) ; } </s>

Determine whether this version information is empty ( e.g. , all version components are zero ) .


<s> void AArch64PassConfig :: addPreLegalizeMachineIR ( ) { if ( getOptLevel ( ) == CodeGenOpt :: None ) addPass ( createAArch64O0PreLegalizerCombiner ( ) ) ; else { addPass ( createAArch64PreLegalizerCombiner ( ) ) ; if ( EnableGISelLoadStoreOptPreLegal ) addPass ( new LoadStoreOpt ( ) ) ; } } </s>

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


<s> void X86FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { const X86InstrInfo & TII = * TM . getInstrInfo ( ) ; const X86RegisterInfo & RegInfo = * TM . getRegisterInfo ( ) ; unsigned StackPtr = RegInfo . getStackRegister ( ) ; bool reseveCallFrame = hasReservedCallFrame ( MF ) ; int Opcode = I -> getOpcode ( ) ; bool isDestroy = Opcode == TII . getCallFrameDestroyOpcode ( ) ; bool IsLP64 = STI . isTarget64BitLP64 ( ) ; DebugLoc DL = I -> getDebugLoc ( ) ; uint64_t Amount = ! reseveCallFrame ? I -> getOperand ( 0 ) . getImm ( ) : 0 ; uint64_t CalleeAmt = isDestroy ? I -> getOperand ( 1 ) . getImm ( ) : 0 ; I = MBB . erase ( I ) ; if ( ! reseveCallFrame ) { if ( Amount == 0 ) return ; unsigned StackAlign = TM . getFrameLowering ( ) -> getStackAlignment ( ) ; Amount = ( Amount + StackAlign - 1 ) / StackAlign * StackAlign ; MachineInstr * New = 0 ; if ( Opcode == TII . getCallFrameSetupOpcode ( ) ) { New = BuildMI ( MF , DL , TII . get ( getSUBriOpcode ( IsLP64 , Amount ) ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } else { assert ( Opcode == TII . getCallFrameDestroyOpcode ( ) ) ; Amount -= CalleeAmt ; if ( Amount ) { unsigned Opc = getADDriOpcode ( IsLP64 , Amount ) ; New = BuildMI ( MF , DL , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addImm ( Amount ) ; } } if ( New ) { New -> getOperand ( 3 ) . setIsDead ( ) ; MBB . insert ( I , New ) ; } return ; } if ( Opcode == TII . getCallFrameDestroyOpcode ( ) && CalleeAmt ) { unsigned Opc = getSUBriOpcode ( IsLP64 , CalleeAmt ) ; MachineInstr * New = BuildMI ( MF , DL , TII . get ( Opc ) , StackPtr ) . addReg ( StackPtr ) . addImm ( CalleeAmt ) ; New -> getOperand ( 3 ) . setIsDead ( ) ; MachineBasicBlock :: iterator B = MBB . begin ( ) ; while ( I != B && ! std :: prev ( I ) -> isCall ( ) ) -- I ; MBB . insert ( I , New ) ; } } </s>

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


<s> bool LC2200FrameLowering :: hasFP ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const TargetRegisterInfo * TRI = STI . getRegisterInfo ( ) ; return MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || MFI . hasVarSizedObjects ( ) || MFI . isFrameAddressTaken ( ) || TRI -> needsStackRealignment ( MF ) ; } </s>

hasFP - Return true if the specified function should have a dedicated frame pointer register .


<s> SDValue SystemZTargetLowering :: PerformDAGCombine ( SDNode * N , DAGCombinerInfo & DCI ) const { switch ( N -> getOpcode ( ) ) { default : break ; case ISD :: ZERO_EXTEND : return combineZERO_EXTEND ( N , DCI ) ; case ISD :: SIGN_EXTEND : return combineSIGN_EXTEND ( N , DCI ) ; case ISD :: SIGN_EXTEND_INREG : return combineSIGN_EXTEND_INREG ( N , DCI ) ; case SystemZISD :: MERGE_HIGH : case SystemZISD :: MERGE_LOW : return combineMERGE ( N , DCI ) ; case ISD :: LOAD : return combineLOAD ( N , DCI ) ; case ISD :: STORE : return combineSTORE ( N , DCI ) ; case ISD :: EXTRACT_VECTOR_ELT : return combineEXTRACT_VECTOR_ELT ( N , DCI ) ; case SystemZISD :: JOIN_DWORDS : return combineJOIN_DWORDS ( N , DCI ) ; case ISD :: FP_ROUND : return combineFP_ROUND ( N , DCI ) ; case ISD :: BSWAP : return combineBSWAP ( N , DCI ) ; case SystemZISD :: BR_CCMASK : return combineBR_CCMASK ( N , DCI ) ; case SystemZISD :: SELECT_CCMASK : return combineSELECT_CCMASK ( N , DCI ) ; case SystemZISD :: GET_CCMASK : return combineGET_CCMASK ( N , DCI ) ; case ISD :: SDIV : case ISD :: UDIV : case ISD :: SREM : case ISD :: UREM : return combineIntDIVREM ( N , 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 .


Expand code to store the current VMS condition handler into TARGET and nullify it .


<s> static bool sh_can_follow_jump ( const rtx_insn * branch1 , const rtx_insn * branch2 ) { if ( flag_reorder_blocks_and_partition && simplejump_p ( branch2 ) && CROSSING_JUMP_P ( branch2 ) ) return false ; if ( flag_expensive_optimizations && simplejump_p ( branch2 ) ) { rtx dest = XEXP ( SET_SRC ( single_set ( branch2 ) ) , 0 ) ; rtx_insn * insn ; int distance ; for ( distance = 0 , insn = NEXT_INSN ( branch1 ) ; insn && distance < 256 ; insn = PREV_INSN ( insn ) ) { if ( insn == dest ) return true ; else distance += get_attr_length ( insn ) ; } for ( distance = 0 , insn = NEXT_INSN ( branch1 ) ; insn && distance < 256 ; insn = NEXT_INSN ( insn ) ) { if ( insn == dest ) return true ; else distance += get_attr_length ( insn ) ; } } return false ; } </s>

Return true if it 's possible to redirect BRANCH1 to the destination of an unconditional jump BRANCH2 . We only want to do this if the resulting branch will have a short displacement .


<s> void expand_prologue ( void ) { tree func_attr ; int size ; int regno ; rtx scratch ; gcc_assert ( reload_completed == 1 ) ; size = get_frame_size ( ) ; create_regs_rtx ( ) ; func_attr = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ; current_function_interrupt = lookup_attribute ( "interrupt" , func_attr ) != NULL_TREE ; current_function_trap = lookup_attribute ( "trap" , func_attr ) != NULL_TREE ; if ( lookup_attribute ( "far" , func_attr ) != NULL_TREE ) current_function_far = 1 ; else if ( lookup_attribute ( "near" , func_attr ) != NULL_TREE ) current_function_far = 0 ; else current_function_far = ( TARGET_LONG_CALLS != 0 && ! current_function_interrupt && ! current_function_trap ) ; if ( current_function_args_info . nregs == 2 ) scratch = iy_reg ; else scratch = ix_reg ; if ( frame_pointer_needed ) emit_move_after_reload ( stack_push_word , hard_frame_pointer_rtx , scratch ) ; if ( current_function_interrupt ) { emit_move_after_reload ( stack_push_word , m68hc11_soft_tmp_reg , scratch ) ; emit_move_after_reload ( stack_push_word , gen_rtx_REG ( HImode , SOFT_Z_REGNUM ) , scratch ) ; emit_move_after_reload ( stack_push_word , gen_rtx_REG ( HImode , SOFT_SAVED_XY_REGNUM ) , scratch ) ; } if ( TARGET_M6812 && ( size > 4 || size == 3 ) ) { emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) ) ) ; } else if ( ( ! optimize_size && size > 8 ) || ( optimize_size && size > 10 ) ) { rtx insn ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( 2 , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( HImode , stack_pointer_rtx , GEN_INT ( - size ) ) ) , gen_rtx_CLOBBER ( VOIDmode , scratch ) ) ) ; emit_insn ( insn ) ; } else { int i ; for ( i = 2 ; i <= size ; i += 2 ) emit_move_after_reload ( stack_push_word , ix_reg , 0 ) ; if ( size & 1 ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , constm1_rtx ) ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pointer_rtx , scratch ) ; for ( regno = SOFT_REG_FIRST ; regno <= SOFT_REG_LAST ; regno ++ ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) { emit_move_after_reload ( stack_push_word , gen_rtx_REG ( HImode , regno ) , scratch ) ; } } } </s>


<s> OR1KSubtarget & OR1KSubtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = CPU ; if ( CPUName . empty ( ) ) CPUName = "generic" ; ParseSubtargetFeatures ( CPUName , FS ) ; return * this ; } </s>

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


<s> void GCNPassConfig :: addPostRegAlloc ( ) { addPass ( createSIPrepareScratchRegs ( ) , false ) ; addPass ( createSIShrinkInstructionsPass ( ) , false ) ; } </s>

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


<s>
int
MSP430RegisterInfo
::
getDwarfRegNum
(
unsigned
RegNum
,
bool
isEH
)
const
{
assert
(
0
&&
"Not implemented yet!"
)
;
}
</s>

Map a target register to an equivalent dwarf register number .


<s> bool X86TargetLowering :: IsDesirableToPromoteOp ( SDValue Op , EVT & PVT ) const { EVT VT = Op . getValueType ( ) ; if ( VT != MVT :: i16 ) return false ; auto IsFoldableRMW = [ ] ( SDValue Load , SDValue Op ) { if ( ! Op . hasOneUse ( ) ) return false ; SDNode * User = * Op -> use_begin ( ) ; if ( ! ISD :: isNormalStore ( User ) ) return false ; auto * Ld = cast < LoadSDNode > ( Load ) ; auto * St = cast < StoreSDNode > ( User ) ; return Ld -> getBasePtr ( ) == St -> getBasePtr ( ) ; } ; auto IsFoldableAtomicRMW = [ ] ( SDValue Load , SDValue Op ) { if ( ! Load . hasOneUse ( ) || Load . getOpcode ( ) != ISD :: ATOMIC_LOAD ) return false ; if ( ! Op . hasOneUse ( ) ) return false ; SDNode * User = * Op -> use_begin ( ) ; if ( User -> getOpcode ( ) != ISD :: ATOMIC_STORE ) return false ; auto * Ld = cast < AtomicSDNode > ( Load ) ; auto * St = cast < AtomicSDNode > ( User ) ; return Ld -> getBasePtr ( ) == St -> getBasePtr ( ) ; } ; bool Commute = false ; switch ( Op . getOpcode ( ) ) { default : return false ; case ISD :: SIGN_EXTEND : case ISD :: ZERO_EXTEND : case ISD :: ANY_EXTEND : break ; case ISD :: SHL : case ISD :: SRL : { SDValue N0 = Op . getOperand ( 0 ) ; if ( MayFoldLoad ( N0 ) && IsFoldableRMW ( N0 , Op ) ) return false ; break ; } case ISD :: ADD : case ISD :: MUL : case ISD :: AND : case ISD :: OR : case ISD :: XOR : Commute = true ; LLVM_FALLTHROUGH ; case ISD :: SUB : { SDValue N0 = Op . getOperand ( 0 ) ; SDValue N1 = Op . getOperand ( 1 ) ; if ( MayFoldLoad ( N1 ) && ( ! Commute || ! isa < ConstantSDNode > ( N0 ) || ( Op . getOpcode ( ) != ISD :: MUL && IsFoldableRMW ( N1 , Op ) ) ) ) return false ; if ( MayFoldLoad ( N0 ) && ( ( Commute && ! isa < ConstantSDNode > ( N1 ) ) || ( Op . getOpcode ( ) != ISD :: MUL && IsFoldableRMW ( N0 , Op ) ) ) ) return false ; if ( IsFoldableAtomicRMW ( N0 , Op ) || ( Commute && IsFoldableAtomicRMW ( N1 , Op ) ) ) return false ; } } PVT = MVT :: i32 ; return true ; } </s>

Return true if the target has native support for the specified value type and it is 'desirable ' to use the type .


<s> bool LanaiInstrInfo :: analyzeBranch ( MachineBasicBlock & MBB , MachineBasicBlock * & TrueBlock , MachineBasicBlock * & FalseBlock , SmallVectorImpl < MachineOperand > & Condition , bool AllowModify ) const { MachineBasicBlock :: iterator Instruction = MBB . end ( ) ; while ( Instruction != MBB . begin ( ) ) { -- Instruction ; if ( Instruction -> isDebugValue ( ) ) continue ; if ( ! isUnpredicatedTerminator ( * Instruction ) ) break ; if ( ! Instruction -> isBranch ( ) ) return true ; if ( Instruction -> getOpcode ( ) == Lanai :: BT ) { if ( ! AllowModify ) { TrueBlock = Instruction -> getOperand ( 0 ) . getMBB ( ) ; continue ; } while ( std :: next ( Instruction ) != MBB . end ( ) ) { std :: next ( Instruction ) -> eraseFromParent ( ) ; } Condition . clear ( ) ; FalseBlock = nullptr ; if ( MBB . isLayoutSuccessor ( Instruction -> getOperand ( 0 ) . getMBB ( ) ) ) { TrueBlock = nullptr ; Instruction -> eraseFromParent ( ) ; Instruction = MBB . end ( ) ; continue ; } TrueBlock = Instruction -> getOperand ( 0 ) . getMBB ( ) ; continue ; } unsigned Opcode = Instruction -> getOpcode ( ) ; if ( Opcode != Lanai :: BRCC ) return true ; if ( Condition . empty ( ) ) { LPCC :: CondCode BranchCond = static_cast < LPCC :: CondCode > ( Instruction -> getOperand ( 1 ) . getImm ( ) ) ; FalseBlock = TrueBlock ; TrueBlock = Instruction -> getOperand ( 0 ) . getMBB ( ) ; Condition . push_back ( MachineOperand :: CreateImm ( BranchCond ) ) ; continue ; } return true ; } return false ; } </s>

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


<s> static void arc_asm_trampoline_template ( FILE * f ) { asm_fprintf ( f , "\tld_s\t%s,[pcl,8]\n" , ARC_TEMP_SCRATCH_REG ) ; asm_fprintf ( f , "\tld\t%s,[pcl,12]\n" , reg_names [ STATIC_CHAIN_REGNUM ] ) ; asm_fprintf ( f , "\tj_s\t[%s]\n" , ARC_TEMP_SCRATCH_REG ) ; assemble_aligned_integer ( UNITS_PER_WORD , const0_rtx ) ; assemble_aligned_integer ( UNITS_PER_WORD , const0_rtx ) ; } </s>

Output assembler code for a block containing the constant parts of a trampoline , leaving space for variable parts . A trampoline looks like this : ld_s r12 , [ pcl,8 ] ld r11 , [ pcl,12 ] j_s [ r12 ] .word function 's address .word static chain value


<s> bool SIRegisterInfo :: isFrameOffsetLegal ( const MachineInstr * MI , unsigned BaseReg , int64_t Offset ) const { return SIInstrInfo :: isMUBUF ( * MI ) && isUInt < 12 > ( Offset ) ; } </s>

Determine whether a given base register plus offset immediate is encodable to resolve a frame index .


<s> void tilepro_expand_builtin_vector_binop ( rtx ( * gen ) ( rtx , rtx , rtx ) , machine_mode dest_mode , rtx dest , machine_mode src_mode , rtx src0 , rtx src1 , bool do_src1 ) { dest = gen_lowpart ( dest_mode , dest ) ; if ( src0 == const0_rtx ) src0 = CONST0_RTX ( src_mode ) ; else src0 = gen_lowpart ( src_mode , src0 ) ; if ( do_src1 ) { if ( src1 == const0_rtx ) src1 = CONST0_RTX ( src_mode ) ; else src1 = gen_lowpart ( src_mode , src1 ) ; } emit_insn ( ( * gen ) ( dest , src0 , src1 ) ) ; } </s>

Expand a builtin vector binary op , by calling gen function GEN with operands in the proper modes . DEST is converted to DEST_MODE , and src0 and src1 ( if DO_SRC1 is true ) is converted to SRC_MODE .


<s> bool ARMTargetLowering :: isLegalAddressingMode ( const DataLayout & DL , const AddrMode & AM , Type * Ty , unsigned AS ) const { EVT VT = getValueType ( DL , Ty , true ) ; if ( ! isLegalAddressImmediate ( AM . BaseOffs , VT , Subtarget ) ) return false ; if ( AM . BaseGV ) return false ; switch ( AM . Scale ) { case 0 : break ; case 1 : if ( Subtarget -> isThumb1Only ( ) ) return false ; default : if ( AM . BaseOffs ) return false ; if ( ! VT . isSimple ( ) ) return false ; if ( Subtarget -> isThumb2 ( ) ) return isLegalT2ScaledAddressingMode ( AM , VT ) ; int Scale = AM . Scale ; switch ( VT . getSimpleVT ( ) . SimpleTy ) { default : return false ; case MVT :: i1 : case MVT :: i8 : case MVT :: i32 : if ( Scale < 0 ) Scale = - Scale ; if ( Scale == 1 ) return true ; return isPowerOf2_32 ( Scale & ~ 1 ) ; case MVT :: i16 : case MVT :: i64 : if ( ( ( unsigned ) AM . HasBaseReg + Scale ) <= 2 ) return true ; return false ; case MVT :: isVoid : if ( Scale & 1 ) return false ; return isPowerOf2_32 ( Scale ) ; } } return true ; } </s>

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


<s>
bool
processBlock
(
MachineBasicBlock
&
MBB
)
{
bool
Changed
=
false
;
MachineRegisterInfo
&
MRI
=
MBB
.
getParent
(
)
->
getRegInfo
(
)
;
for
(
MachineBasicBlock
::
iterator
I
=
MBB
.
begin
(
)
,
IE
=
MBB
.
end
(
)
;
I
!=
IE
;
++
I
)
{
MachineInstr
*
MI
=
I
;
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
=
IsVRReg
(
SrcMO
.
getReg
(
)
,
MRI
)
&
PPC
::
VSHRCRegClass
:
&
PPC
::
VSLRCRegClass
;
assert
(
(
IsF8Reg
(
SrcMO
.
getReg
(
)
,
MRI
)
||
IsVRReg
(
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
(
IsVRReg
(
SrcMO
.
getReg
(
)
,
MRI
)
PPC
::
sub_128
:
PPC
::
sub_64
)
;
SrcMO
.
setReg
(
NewVReg
)
;
}
else
if
(
!
IsVSReg
(
DstMO
.
getReg
(
)
,
MRI
)
&&
IsVSReg
(
SrcMO
.
getReg
(
)
,
MRI
)
)
{
Changed
=
true
;
const
TargetRegisterClass
*
DstRC
=
IsVRReg
(
DstMO
.
getReg
(
)
,
MRI
)
&
PPC
::
VSHRCRegClass
:
&
PPC
::
VSLRCRegClass
;
assert
(
(
IsF8Reg
(
DstMO
.
getReg
(
)
,
MRI
)
||
IsVSFReg
(
DstMO
.
getReg
(
)
,
MRI
)
||
IsVRReg
(
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
(
IsVRReg
(
DstMO
.
getReg
(
)
,
MRI
)
PPC
::
sub_128
:
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> MachineInstr * SystemZInstrInfo :: convertToThreeAddress ( MachineFunction :: iterator & MFI , MachineBasicBlock :: iterator & MBBI , LiveVariables * LV ) const { MachineInstr * MI = MBBI ; MachineBasicBlock * MBB = MI -> getParent ( ) ; unsigned Opcode = MI -> getOpcode ( ) ; unsigned NumOps = MI -> getNumOperands ( ) ; if ( TM . getSubtargetImpl ( ) -> hasDistinctOps ( ) ) { int ThreeOperandOpcode = SystemZ :: getThreeOperandOpcode ( Opcode ) ; if ( ThreeOperandOpcode >= 0 ) { MachineOperand & Dest = MI -> getOperand ( 0 ) ; MachineOperand & Src = MI -> getOperand ( 1 ) ; MachineInstrBuilder MIB = BuildMI ( * MBB , MBBI , MI -> getDebugLoc ( ) , get ( ThreeOperandOpcode ) ) . addOperand ( Dest ) ; MIB . addReg ( Src . getReg ( ) , getKillRegState ( Src . isKill ( ) ) , Src . getSubReg ( ) ) ; for ( unsigned I = 2 ; I < NumOps ; ++ I ) MIB . addOperand ( MI -> getOperand ( I ) ) ; return finishConvertToThreeAddress ( MI , MIB , LV ) ; } } if ( LogicOp And = interpretAndImmediate ( Opcode ) ) { unsigned NewOpcode ; if ( And . RegSize == 64 ) NewOpcode = SystemZ :: RISBG ; else if ( TM . getSubtargetImpl ( ) -> hasHighWord ( ) ) NewOpcode = SystemZ :: RISBLG32 ; else NewOpcode = 0 ; if ( NewOpcode ) { uint64_t Imm = MI -> getOperand ( 2 ) . getImm ( ) << And . ImmLSB ; Imm |= allOnes ( And . RegSize ) & ~ ( allOnes ( And . ImmSize ) << And . ImmLSB ) ; unsigned Start , End ; if ( isRxSBGMask ( Imm , And . RegSize , Start , End ) ) { if ( NewOpcode == SystemZ :: RISBLG32 ) { Start &= 31 ; End &= 31 ; } MachineOperand & Dest = MI -> getOperand ( 0 ) ; MachineOperand & Src = MI -> getOperand ( 1 ) ; MachineInstrBuilder MIB = BuildMI ( * MBB , MI , MI -> getDebugLoc ( ) , get ( NewOpcode ) ) . addOperand ( Dest ) . addReg ( 0 ) . addReg ( Src . getReg ( ) , getKillRegState ( Src . isKill ( ) ) , Src . getSubReg ( ) ) . addImm ( Start ) . addImm ( End + 128 ) . addImm ( 0 ) ; return finishConvertToThreeAddress ( MI , MIB , LV ) ; } } } return 0 ; } </s>

convertToThreeAddress - This method must be implemented by targets that set the M_CONVERTIBLE_TO_3_ADDR flag .


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

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s>
void
NVPTXAsmPrinter
::
emitImplicitDef
(
const
MachineInstr
*
MI
)
const
{
unsigned
RegNo
=
MI
->
getOperand
(
0
)
.
getReg
(
)
;
if
(
TargetRegisterInfo
::
isVirtualRegister
(
RegNo
)
)
{
OutStreamer
.
AddComment
(
Twine
(
"implicit-def: "
)
+
getVirtualRegisterName
(
RegNo
)
)
;
}
else
{
OutStreamer
.
AddComment
(
Twine
(
"implicit-def: "
)
+
nvptxSubtarget
->
getRegisterInfo
(
)
->
getName
(
RegNo
)
)
;
}
OutStreamer
.
AddBlankLine
(
)
;
}
</s>

Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode .

NVPTX
NVPTX
0
"implicit-def: "
"implicit-def: "


<s> const uint32_t * HexagonRegisterInfo :: getCallPreservedMask ( const MachineFunction & MF , CallingConv :: ID ) const { return HexagonCSR_RegMask ; } </s>

Return a mask of call-preserved registers for the given calling convention on the current function .


<s> bool RISCVPassConfig :: addRegBankSelect ( ) { addPass ( new RegBankSelect ( ) ) ; return false ; } </s>

This method should install a register bank selector pass , which assigns register banks to virtual registers without a register class or register banks .


<s> bool X86InstrInfo :: isCoalescableExtInstr ( const MachineInstr & MI , unsigned & SrcReg , unsigned & DstReg , unsigned & SubIdx ) const { switch ( MI . getOpcode ( ) ) { default : break ; case X86 :: MOVSX16rr8 : case X86 :: MOVZX16rr8 : case X86 :: MOVSX32rr8 : case X86 :: MOVZX32rr8 : case X86 :: MOVSX64rr8 : if ( ! Subtarget . is64Bit ( ) ) return false ; case X86 :: MOVSX32rr16 : case X86 :: MOVZX32rr16 : case X86 :: MOVSX64rr16 : case X86 :: MOVSX64rr32 : { if ( MI . getOperand ( 0 ) . getSubReg ( ) || MI . getOperand ( 1 ) . getSubReg ( ) ) return false ; SrcReg = MI . getOperand ( 1 ) . getReg ( ) ; DstReg = MI . getOperand ( 0 ) . getReg ( ) ; switch ( MI . getOpcode ( ) ) { default : llvm_unreachable ( "Unreachable!" ) ; case X86 :: MOVSX16rr8 : case X86 :: MOVZX16rr8 : case X86 :: MOVSX32rr8 : case X86 :: MOVZX32rr8 : case X86 :: MOVSX64rr8 : SubIdx = X86 :: sub_8bit ; break ; case X86 :: MOVSX32rr16 : case X86 :: MOVZX32rr16 : case X86 :: MOVSX64rr16 : SubIdx = X86 :: sub_16bit ; break ; case X86 :: MOVSX64rr32 : SubIdx = X86 :: sub_32bit ; break ; } return true ; } } return false ; } </s>

isCoalescableExtInstr - Return true if the instruction is a `` coalescable '' extension instruction .


<s> bool AArch64LoadStoreOpt :: runOnMachineFunction ( MachineFunction & Fn ) { if ( skipFunction ( Fn . getFunction ( ) ) ) return false ; Subtarget = & Fn . getSubtarget < AArch64Subtarget > ( ) ; TII = static_cast < const AArch64InstrInfo * > ( Subtarget -> getInstrInfo ( ) ) ; TRI = Subtarget -> getRegisterInfo ( ) ; AA = & getAnalysis < AAResultsWrapperPass > ( ) . getAAResults ( ) ; ModifiedRegUnits . init ( * TRI ) ; UsedRegUnits . init ( * TRI ) ; DefinedInBB . init ( * TRI ) ; bool Modified = false ; bool enableNarrowZeroStOpt = ! Subtarget -> requiresStrictAlign ( ) ; for ( auto & MBB : Fn ) { auto M = optimizeBlock ( MBB , enableNarrowZeroStOpt ) ; Modified |= M ; } return Modified ; } </s>

runOnMachineFunction - Emit the function body .


<s> static void avr_asm_named_section ( const char * name , unsigned int flags , tree decl ) { if ( flags & AVR_SECTION_PROGMEM ) { addr_space_t as = ( flags & AVR_SECTION_PROGMEM ) / SECTION_MACH_DEP ; const char * old_prefix = ".rodata" ; const char * new_prefix = avr_addrspace [ as ] . section_name ; if ( startswith ( name , old_prefix ) ) { const char * sname = ACONCAT ( ( new_prefix , name + strlen ( old_prefix ) , NULL ) ) ; default_elf_asm_named_section ( sname , flags , decl ) ; return ; } default_elf_asm_named_section ( new_prefix , flags , decl ) ; return ; } if ( ! avr_need_copy_data_p ) avr_need_copy_data_p = ( startswith ( name , ".data" ) || startswith ( name , ".gnu.linkonce.d" ) ) ; if ( ! avr_need_copy_data_p && avr_arch -> flash_pm_offset == 0 ) avr_need_copy_data_p = ( startswith ( name , ".rodata" ) || startswith ( name , ".gnu.linkonce.r" ) ) ; if ( ! avr_need_clear_bss_p ) avr_need_clear_bss_p = startswith ( name , ".bss" ) ; default_elf_asm_named_section ( name , flags , decl ) ; } </s>

Track need of __do_clear_bss , __do_copy_data for named sections .


<s> MachineBasicBlock :: iterator CSKYFrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI ) const { Register SPReg = CSKY :: R14 ; DebugLoc DL = MI -> getDebugLoc ( ) ; if ( ! hasReservedCallFrame ( MF ) ) { int64_t Amount = MI -> getOperand ( 0 ) . getImm ( ) ; if ( Amount != 0 ) { Amount = alignSPAdjust ( Amount ) ; if ( MI -> getOpcode ( ) == CSKY :: ADJCALLSTACKDOWN ) Amount = - Amount ; adjustReg ( MBB , MI , DL , SPReg , SPReg , Amount , MachineInstr :: NoFlags ) ; } } return MBB . erase ( MI ) ; } </s>

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


<s> int AArch64TTIImpl :: getArithmeticInstrCost ( unsigned Opcode , Type * Ty , TTI :: OperandValueKind Opd1Info , TTI :: OperandValueKind Opd2Info , TTI :: OperandValueProperties Opd1PropInfo , TTI :: OperandValueProperties Opd2PropInfo ) { std :: pair < int , MVT > LT = TLI -> getTypeLegalizationCost ( DL , Ty ) ; int ISD = TLI -> InstructionOpcodeToISD ( Opcode ) ; if ( ISD == ISD :: SDIV && Opd2Info == TargetTransformInfo :: OK_UniformConstantValue && Opd2PropInfo == TargetTransformInfo :: OP_PowerOf2 ) { int Cost = getArithmeticInstrCost ( Instruction :: Add , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; Cost += getArithmeticInstrCost ( Instruction :: Sub , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; Cost += getArithmeticInstrCost ( Instruction :: Select , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; Cost += getArithmeticInstrCost ( Instruction :: AShr , Ty , Opd1Info , Opd2Info , TargetTransformInfo :: OP_None , TargetTransformInfo :: OP_None ) ; return Cost ; } switch ( ISD ) { default : return BaseT :: getArithmeticInstrCost ( Opcode , Ty , Opd1Info , Opd2Info , Opd1PropInfo , Opd2PropInfo ) ; case ISD :: ADD : case ISD :: MUL : case ISD :: XOR : case ISD :: OR : case ISD :: AND : return 1 * LT . first ; } } </s>

This is an approximation of reciprocal throughput of a math/logic op .

AArch64 AArch64 ISD::SDIV ISD::ADD ISD::MUL ISD::XOR ISD::OR ISD::AND 1


<s> void X86PassConfig :: addIRPasses ( ) { addPass ( createAtomicExpandPass ( ) ) ; TargetPassConfig :: addIRPasses ( ) ; if ( TM -> getOptLevel ( ) != CodeGenOpt :: None ) { addPass ( createInterleavedAccessPass ( ) ) ; addPass ( createX86PartialReductionPass ( ) ) ; } addPass ( createIndirectBrExpandPass ( ) ) ; const Triple & TT = TM -> getTargetTriple ( ) ; if ( TT . isOSWindows ( ) ) { if ( TT . getArch ( ) == Triple :: x86_64 ) { addPass ( createCFGuardDispatchPass ( ) ) ; } else { addPass ( createCFGuardCheckPass ( ) ) ; } } } </s>

Add common target configurable passes that perform LLVM IR to IR transforms following machine independent optimization .


<s> SDValue PPCTargetLowering :: LowerCall ( SDValue Chain , SDValue Callee , CallingConv :: ID CallConv , bool isVarArg , bool doesNotRet , bool & isTailCall , const SmallVectorImpl < ISD :: OutputArg > & Outs , const SmallVectorImpl < SDValue > & OutVals , const SmallVectorImpl < ISD :: InputArg > & Ins , DebugLoc dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { if ( isTailCall ) isTailCall = IsEligibleForTailCallOptimization ( Callee , CallConv , isVarArg , Ins , DAG ) ; if ( PPCSubTarget . isSVR4ABI ( ) && ! PPCSubTarget . isPPC64 ( ) ) return LowerCall_SVR4 ( Chain , Callee , CallConv , isVarArg , isTailCall , Outs , OutVals , Ins , dl , DAG , InVals ) ; return LowerCall_Darwin ( Chain , Callee , CallConv , isVarArg , isTailCall , Outs , OutVals , Ins , dl , DAG , InVals ) ; } </s>

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

PowerPC PPC ISD::OutputArg ISD::InputArg PPC PPC PPC


"unrecognizable argument of option -foffload-abi"

Main program to convert flat files into built-in initialization code .


<s>
bool
SNESFrameLowering
::
spillCalleeSavedRegisters
(
MachineBasicBlock
&
MBB
,
MachineBasicBlock
::
iterator
MI
,
const
std
::
vector
<
CalleeSavedInfo
>
&
CSI
,
const
TargetRegisterInfo
*
TRI
)
const
{
if
(
CSI
.
empty
(
)
)
{
return
false
;
}
unsigned
CalleeFrameSize
=
0
;
DebugLoc
DL
=
MBB
.
findDebugLoc
(
MI
)
;
MachineFunction
&
MF
=
*
MBB
.
getParent
(
)
;
const
SNESSubtarget
&
STI
=
MF
.
getSubtarget
<
SNESSubtarget
>
(
)
;
const
TargetInstrInfo
&
TII
=
*
STI
.
getInstrInfo
(
)
;
SNESMachineFunctionInfo
*
SNESFI
=
MF
.
getInfo
<
SNESMachineFunctionInfo
>
(
)
;
for
(
unsigned
i
=
CSI
.
size
(
)
;
i
!=
0
;
i
)
{
unsigned
Reg
=
CSI
[
i
1
]
.
getReg
(
)
;
bool
IsNotLiveIn
=
!
MBB
.
isLiveIn
(
Reg
)
;
assert
(
TRI
->
getRegSizeInBits
(
*
TRI
->
getMinimalPhysRegClass
(
Reg
)
)
==
16
&&
"Invalid register size"
)
;
if
(
IsNotLiveIn
)
{
MBB
.
addLiveIn
(
Reg
)
;
}
BuildMI
(
MBB
,
MI
,
DL
,
TII
.
get
(
SNES
::
PHAstk
)
)
.
addReg
(
Reg
,
getKillRegState
(
IsNotLiveIn
)
)
.
setMIFlag
(
MachineInstr
::
FrameSetup
)
;
++
CalleeFrameSize
;
}
SNESFI
->
setCalleeSavedFrameSize
(
CalleeFrameSize
)
;
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 ( ) .

SNES
SNES
0
SNES
SNES
SNES
SNES
SNES
0
1
16
"Invalid register size"
SNES::PHAstk
SNES


<s>
bool
HexagonShuffler
::
check
(
)
{
const
HexagonPacketSummary
Summary
=
GetPacketSummary
(
)
;
if
(
!
applySlotRestrictions
(
Summary
)
)
return
false
;
if
(
!
ValidPacketMemoryOps
(
Summary
)
)
{
reportError
(
"invalid instruction packet"
)
;
return
false
;
}
ValidResourceUsage
(
Summary
)
;
return
!
CheckFailure
;
}
</s>

Check if the constraints are satisfiable .

Hexagon
Hexagon
Hexagon
"invalid instruction packet"


<s> int pru_get_ctable_base_index ( unsigned HOST_WIDE_INT caddr ) { unsigned int i ; for ( i = 0 ; i < ARRAY_SIZE ( pru_ctable ) ; i ++ ) { if ( pru_ctable [ i ] . valid && IN_RANGE ( caddr , pru_ctable [ i ] . base , pru_ctable [ i ] . base + 0xff ) ) return i ; } return - 1 ; } </s>

Check if the given address can be addressed via CTABLE_BASE + UBYTE_OFFS , and return the base CTABLE index if possible .


<s> RCPair ARMTargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , EVT VT ) const { if ( Constraint . size ( ) == 1 ) { switch ( Constraint [ 0 ] ) { case 'l' : if ( Subtarget -> isThumb ( ) ) return RCPair ( 0U , ARM :: tGPRRegisterClass ) ; else return RCPair ( 0U , ARM :: GPRRegisterClass ) ; case 'h' : if ( Subtarget -> isThumb ( ) ) return RCPair ( 0U , ARM :: hGPRRegisterClass ) ; break ; case 'r' : return RCPair ( 0U , ARM :: GPRRegisterClass ) ; case 'w' : if ( VT == MVT :: f32 ) return RCPair ( 0U , ARM :: SPRRegisterClass ) ; if ( VT . getSizeInBits ( ) == 64 ) return RCPair ( 0U , ARM :: DPRRegisterClass ) ; if ( VT . getSizeInBits ( ) == 128 ) return RCPair ( 0U , ARM :: QPRRegisterClass ) ; break ; case 'x' : if ( VT == MVT :: f32 ) return RCPair ( 0U , ARM :: SPR_8RegisterClass ) ; if ( VT . getSizeInBits ( ) == 64 ) return RCPair ( 0U , ARM :: DPR_8RegisterClass ) ; if ( VT . getSizeInBits ( ) == 128 ) return RCPair ( 0U , ARM :: QPR_8RegisterClass ) ; break ; case 't' : if ( VT == MVT :: f32 ) return RCPair ( 0U , ARM :: SPRRegisterClass ) ; break ; } } if ( StringRef ( "{cc}" ) . equals_lower ( Constraint ) ) return std :: make_pair ( unsigned ( ARM :: CPSR ) , ARM :: CCRRegisterClass ) ; return TargetLowering :: getRegForInlineAsmConstraint ( Constraint , VT ) ; } </s>

Given a physical register constraint ( e.g .


<s> bool movd44_insn_p ( rtx_insn * insn ) { if ( get_attr_type ( insn ) == TYPE_ALU && ( INSN_CODE ( insn ) == CODE_FOR_move_di || INSN_CODE ( insn ) == CODE_FOR_move_df ) ) { rtx body = PATTERN ( insn ) ; gcc_assert ( GET_CODE ( body ) == SET ) ; rtx src = SET_SRC ( body ) ; rtx dest = SET_DEST ( body ) ; if ( ( REG_P ( src ) || GET_CODE ( src ) == SUBREG ) && ( REG_P ( dest ) || GET_CODE ( dest ) == SUBREG ) ) return true ; return false ; } return false ; } </s>


<s> void AMDGPUInstrInfo :: insertNoop ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI ) const { } </s>

Insert a noop into the instruction stream at the specified point .


<s> int aarch64_asm_preferred_eh_data_format ( int code ATTRIBUTE_UNUSED , int global ) { int type ; switch ( aarch64_cmodel ) { case AARCH64_CMODEL_TINY : case AARCH64_CMODEL_TINY_PIC : case AARCH64_CMODEL_SMALL : case AARCH64_CMODEL_SMALL_PIC : type = DW_EH_PE_sdata4 ; break ; default : type = DW_EH_PE_sdata8 ; break ; } return ( global ? DW_EH_PE_indirect : 0 ) | DW_EH_PE_pcrel | type ; } </s>

Select a format to encode pointers in exception handling data .


<s> void TPCSymbolizer :: tryAddingPcLoadReferenceComment ( raw_ostream & cStream , int64_t Value , uint64_t Address ) { llvm_unreachable ( "unimplemented" ) ; } </s>

Try to add a comment on the PC-relative load .


<s> static bool sparc_cannot_force_const_mem ( machine_mode mode , rtx x ) { switch ( GET_CODE ( x ) ) { case CONST_INT : case CONST_WIDE_INT : case CONST_DOUBLE : case CONST_VECTOR : return false ; case LABEL_REF : return flag_pic != 0 ; case SYMBOL_REF : if ( SYMBOL_REF_TLS_MODEL ( x ) ) return true ; else return flag_pic != 0 ; case CONST : return sparc_cannot_force_const_mem ( mode , XEXP ( x , 0 ) ) ; case PLUS : case MINUS : return sparc_cannot_force_const_mem ( mode , XEXP ( x , 0 ) ) || sparc_cannot_force_const_mem ( mode , XEXP ( x , 1 ) ) ; case UNSPEC : return true ; default : gcc_unreachable ( ) ; } } </s>

Determine if it 's legal to put X into the constant pool . This is not possible if X contains the address of a symbol that is not constant ( TLS ) or not known at final link time ( PIC ) .


<s> static bool riscv_valid_base_register_p ( rtx x , machine_mode mode , bool strict_p ) { if ( ! strict_p && GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ; return ( REG_P ( x ) && riscv_regno_mode_ok_for_base_p ( REGNO ( x ) , mode , strict_p ) ) ; } </s>

Return true if X is a valid base register for mode MODE . STRICT_P is true if REG_OK_STRICT is in effect .


<s> void R600MCInstLower :: lower ( const MachineInstr * MI , MCInst & OutMI ) const { OutMI . setOpcode ( MI -> getOpcode ( ) ) ; for ( const MachineOperand & MO : MI -> explicit_operands ( ) ) { MCOperand MCOp ; lowerOperand ( MO , MCOp ) ; OutMI . addOperand ( MCOp ) ; } } </s>


<s> void BPFMCCodeEmitter :: encodeInstruction ( const MCInst & MI , raw_ostream & OS , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { verifyInstructionPredicates ( MI , computeAvailableFeatures ( STI . getFeatureBits ( ) ) ) ; unsigned Opcode = MI . getOpcode ( ) ; support :: endian :: Writer < support :: little > LE ( OS ) ; support :: endian :: Writer < support :: big > BE ( OS ) ; if ( Opcode == BPF :: LD_imm64 || Opcode == BPF :: LD_pseudo ) { uint64_t Value = getBinaryCodeForInstr ( MI , Fixups , STI ) ; LE . write < uint8_t > ( Value >> 56 ) ; if ( IsLittleEndian ) LE . write < uint8_t > ( ( Value >> 48 ) & 0xff ) ; else LE . write < uint8_t > ( SwapBits ( ( Value >> 48 ) & 0xff ) ) ; LE . write < uint16_t > ( 0 ) ; if ( IsLittleEndian ) LE . write < uint32_t > ( Value & 0xffffFFFF ) ; else BE . write < uint32_t > ( Value & 0xffffFFFF ) ; const MCOperand & MO = MI . getOperand ( 1 ) ; uint64_t Imm = MO . isImm ( ) ? MO . getImm ( ) : 0 ; LE . write < uint8_t > ( 0 ) ; LE . write < uint8_t > ( 0 ) ; LE . write < uint16_t > ( 0 ) ; if ( IsLittleEndian ) LE . write < uint32_t > ( Imm >> 32 ) ; else BE . write < uint32_t > ( Imm >> 32 ) ; } else { uint64_t Value = getBinaryCodeForInstr ( MI , Fixups , STI ) ; LE . write < uint8_t > ( Value >> 56 ) ; if ( IsLittleEndian ) { LE . write < uint8_t > ( ( Value >> 48 ) & 0xff ) ; LE . write < uint16_t > ( ( Value >> 32 ) & 0xffff ) ; LE . write < uint32_t > ( Value & 0xffffFFFF ) ; } else { LE . write < uint8_t > ( SwapBits ( ( Value >> 48 ) & 0xff ) ) ; BE . write < uint16_t > ( ( Value >> 32 ) & 0xffff ) ; BE . write < uint32_t > ( Value & 0xffffFFFF ) ; } } } </s>

Encode the given Inst to bytes and append to CB .


<s> void R600InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , DebugLoc DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { unsigned VectorComponents = 0 ; if ( AMDGPU :: R600_Reg128RegClass . contains ( DestReg ) && AMDGPU :: R600_Reg128RegClass . contains ( SrcReg ) ) { VectorComponents = 4 ; } else if ( AMDGPU :: R600_Reg64RegClass . contains ( DestReg ) && AMDGPU :: R600_Reg64RegClass . contains ( SrcReg ) ) { VectorComponents = 2 ; } if ( VectorComponents > 0 ) { for ( unsigned I = 0 ; I < VectorComponents ; I ++ ) { unsigned SubRegIndex = RI . getSubRegFromChannel ( I ) ; buildDefaultInstruction ( MBB , MI , AMDGPU :: MOV , RI . getSubReg ( DestReg , SubRegIndex ) , RI . getSubReg ( SrcReg , SubRegIndex ) ) . addReg ( DestReg , RegState :: Define | RegState :: Implicit ) ; } } else { MachineInstr * NewMI = buildDefaultInstruction ( MBB , MI , AMDGPU :: MOV , DestReg , SrcReg ) ; NewMI -> getOperand ( getOperandIdx ( * NewMI , AMDGPU :: OpName :: src0 ) ) . setIsKill ( KillSrc ) ; } } </s>


<s> bool MSP430TargetMachine :: addPreEmitPass ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) { PM . add ( createMSP430BranchSelectionPass ( ) ) ; return false ; } </s>

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


<s> static tree ix86_builtin_mpx_function ( unsigned fcode ) { switch ( fcode ) { case BUILT_IN_CHKP_BNDMK : return ix86_builtins [ IX86_BUILTIN_BNDMK ] ; case BUILT_IN_CHKP_BNDSTX : return ix86_builtins [ IX86_BUILTIN_BNDSTX ] ; case BUILT_IN_CHKP_BNDLDX : return ix86_builtins [ IX86_BUILTIN_BNDLDX ] ; case BUILT_IN_CHKP_BNDCL : return ix86_builtins [ IX86_BUILTIN_BNDCL ] ; case BUILT_IN_CHKP_BNDCU : return ix86_builtins [ IX86_BUILTIN_BNDCU ] ; case BUILT_IN_CHKP_BNDRET : return ix86_builtins [ IX86_BUILTIN_BNDRET ] ; case BUILT_IN_CHKP_INTERSECT : return ix86_builtins [ IX86_BUILTIN_BNDINT ] ; case BUILT_IN_CHKP_NARROW : return ix86_builtins [ IX86_BUILTIN_BNDNARROW ] ; case BUILT_IN_CHKP_SIZEOF : return ix86_builtins [ IX86_BUILTIN_SIZEOF ] ; case BUILT_IN_CHKP_EXTRACT_LOWER : return ix86_builtins [ IX86_BUILTIN_BNDLOWER ] ; case BUILT_IN_CHKP_EXTRACT_UPPER : return ix86_builtins [ IX86_BUILTIN_BNDUPPER ] ; default : return NULL_TREE ; } gcc_unreachable ( ) ; } </s>

Return function decl for target specific builtin for given MPX builtin passed i FCODE .


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

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

Patmos
Patmos
0
"unexpected inline asm memory operand"
"[$"
Patmos
"]"


<s> void aarch64_gen_atomic_cas ( rtx rval , rtx mem , rtx expected , rtx desired , rtx model ) { rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; machine_mode mode ; mode = GET_MODE ( mem ) ; switch ( mode ) { case E_QImode : gen = gen_aarch64_atomic_casqi ; break ; case E_HImode : gen = gen_aarch64_atomic_cashi ; break ; case E_SImode : gen = gen_aarch64_atomic_cassi ; break ; case E_DImode : gen = gen_aarch64_atomic_casdi ; break ; default : gcc_unreachable ( ) ; } emit_insn ( gen_rtx_SET ( rval , expected ) ) ; emit_insn ( gen ( rval , mem , desired , model ) ) ; aarch64_gen_compare_reg ( EQ , rval , expected ) ; } </s>

Emit an atomic compare-and-swap operation . RVAL is the destination register for the data in memory . EXPECTED is the value expected to be in memory . DESIRED is the value to store to memory . MEM is the memory location . MODEL is the memory ordering to use .


<s> bool isMem ( RegisterKind RegKind , MemoryKind MemKind ) const { return ( Kind == KindMem && Mem . RegKind == RegKind && ( MemKind == BDXMem || ! Mem . Index ) && ( MemKind == BDLMem ) == ( Mem . Length != nullptr ) ) ; } </s>


<s> bool RISCVTargetLowering :: isOffsetFoldingLegal ( const GlobalAddressSDNode * GA ) const { return false ; } </s>

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


<s> const uint16_t * Cpu0RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const uint16_t CalleeSavedRegs [ ] = { 0 } ; return CalleeSavedRegs ; } </s>


<s> bool SystemZXPLINKFrameLowering :: assignCalleeSavedSpillSlots ( MachineFunction & MF , const TargetRegisterInfo * TRI , std :: vector < CalleeSavedInfo > & CSI ) const { MachineFrameInfo & MFFrame = MF . getFrameInfo ( ) ; SystemZMachineFunctionInfo * MFI = MF . getInfo < SystemZMachineFunctionInfo > ( ) ; const SystemZSubtarget & Subtarget = MF . getSubtarget < SystemZSubtarget > ( ) ; auto & Regs = Subtarget . getSpecialRegisters < SystemZXPLINK64Registers > ( ) ; unsigned LowGPR = 0 ; int LowOffset = INT32_MAX ; unsigned HighGPR = LowGPR ; int HighOffset = - 1 ; unsigned RegSP = Regs . getStackPointerRegister ( ) ; auto & GRRegClass = SystemZ :: GR64BitRegClass ; const unsigned RegSize = 8 ; auto ProcessCSI = [ & ] ( std :: vector < CalleeSavedInfo > & CSIList ) { for ( auto & CS : CSIList ) { Register Reg = CS . getReg ( ) ; int Offset = RegSpillOffsets [ Reg ] ; if ( Offset >= 0 ) { if ( GRRegClass . contains ( Reg ) ) { if ( LowOffset > Offset ) { LowOffset = Offset ; LowGPR = Reg ; } if ( Offset > HighOffset ) { HighOffset = Offset ; HighGPR = Reg ; } } int FrameIdx = MFFrame . CreateFixedSpillStackObject ( RegSize , Offset ) ; CS . setFrameIdx ( FrameIdx ) ; } else CS . setFrameIdx ( INT32_MAX ) ; } } ; std :: vector < CalleeSavedInfo > Spills ; Spills . push_back ( CalleeSavedInfo ( Regs . getAddressOfCalleeRegister ( ) ) ) ; if ( hasFP ( MF ) || MF . getFunction ( ) . hasFnAttribute ( "backchain" ) ) Spills . push_back ( CalleeSavedInfo ( RegSP ) ) ; ProcessCSI ( CSI ) ; MFI -> setRestoreGPRRegs ( LowGPR , HighGPR , LowOffset ) ; ProcessCSI ( Spills ) ; MFI -> setSpillGPRRegs ( LowGPR , HighGPR , LowOffset ) ; for ( auto & CS : CSI ) { if ( CS . getFrameIdx ( ) != INT32_MAX ) continue ; Register Reg = CS . getReg ( ) ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; Align Alignment = TRI -> getSpillAlign ( * RC ) ; unsigned Size = TRI -> getSpillSize ( * RC ) ; Alignment = std :: min ( Alignment , getStackAlign ( ) ) ; int FrameIdx = MFFrame . CreateStackObject ( Size , Alignment , true ) ; CS . setFrameIdx ( FrameIdx ) ; } return true ; } </s>

This function will assign callee saved gprs to volatile vector registers for prologue spills when applicable .


<s> void GCNPassConfig :: addPreRegAlloc ( ) { const AMDGPUSubtarget & ST = * getAMDGPUTargetMachine ( ) . getSubtargetImpl ( ) ; if ( getOptLevel ( ) > CodeGenOpt :: None ) { insertPass ( & MachineSchedulerID , & SIFixControlFlowLiveIntervalsID ) ; } if ( getOptLevel ( ) > CodeGenOpt :: None && ST . loadStoreOptEnabled ( ) ) { insertPass ( & MachineSchedulerID , & SILoadStoreOptimizerID ) ; insertPass ( & MachineSchedulerID , & RegisterCoalescerID ) ; } addPass ( createSIShrinkInstructionsPass ( ) , false ) ; addPass ( createSIWholeQuadModePass ( ) ) ; } </s>

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


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

Returns true if the live-ins should be tracked after register allocation .


"LowerFormalArgments: Other types are not Implemented\n"

"Other types in stack are not supported yet!"

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


<s> bool SITargetLowering :: isEligibleForTailCallOptimization ( SDValue Callee , CallingConv :: ID CalleeCC , bool IsVarArg , const SmallVectorImpl < ISD :: OutputArg > & Outs , const SmallVectorImpl < SDValue > & OutVals , const SmallVectorImpl < ISD :: InputArg > & Ins , SelectionDAG & DAG ) const { if ( ! mayTailCallThisCC ( CalleeCC ) ) return false ; MachineFunction & MF = DAG . getMachineFunction ( ) ; const Function & CallerF = MF . getFunction ( ) ; CallingConv :: ID CallerCC = CallerF . getCallingConv ( ) ; const SIRegisterInfo * TRI = getSubtarget ( ) -> getRegisterInfo ( ) ; const uint32_t * CallerPreserved = TRI -> getCallPreservedMask ( MF , CallerCC ) ; if ( ! CallerPreserved ) return false ; bool CCMatch = CallerCC == CalleeCC ; if ( DAG . getTarget ( ) . Options . GuaranteedTailCallOpt ) { if ( canGuaranteeTCO ( CalleeCC ) && CCMatch ) return true ; return false ; } if ( IsVarArg ) return false ; for ( const Argument & Arg : CallerF . args ( ) ) { if ( Arg . hasByValAttr ( ) ) return false ; } LLVMContext & Ctx = * DAG . getContext ( ) ; if ( ! CCState :: resultsCompatible ( CalleeCC , CallerCC , MF , Ctx , Ins , CCAssignFnForCall ( CalleeCC , IsVarArg ) , CCAssignFnForCall ( CallerCC , IsVarArg ) ) ) return false ; if ( ! CCMatch ) { const uint32_t * CalleePreserved = TRI -> getCallPreservedMask ( MF , CalleeCC ) ; if ( ! TRI -> regmaskSubsetEqual ( CallerPreserved , CalleePreserved ) ) return false ; } if ( Outs . empty ( ) ) return true ; SmallVector < CCValAssign , 16 > ArgLocs ; CCState CCInfo ( CalleeCC , IsVarArg , MF , ArgLocs , Ctx ) ; CCInfo . AnalyzeCallOperands ( Outs , CCAssignFnForCall ( CalleeCC , IsVarArg ) ) ; const SIMachineFunctionInfo * FuncInfo = MF . getInfo < SIMachineFunctionInfo > ( ) ; if ( CCInfo . getNextStackOffset ( ) > FuncInfo -> getBytesInStackArgArea ( ) ) return false ; const MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; return parametersInCSRMatch ( MRI , CallerPreserved , ArgLocs , OutVals ) ; } </s>

Returns true if the call can be lowered as a tail call .

AMDGPU SI ISD::OutputArg ISD::InputArg SI 16 SI SI


<s> X86TargetMachine :: X86TargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) : LLVMTargetMachine ( T , computeDataLayout ( Triple ( TT ) ) , TT , CPU , FS , Options , RM , CM , OL ) , TLOF ( createTLOF ( Triple ( getTargetTriple ( ) ) ) ) , Subtarget ( TT , CPU , FS , * this , Options . StackAlignmentOverride ) { if ( Subtarget . isTargetWin64 ( ) ) this -> Options . TrapUnreachable = true ; this -> Options . Reciprocals . setDefaults ( "all" , false , 1 ) ; initAsmInfo ( ) ; } </s>


"Can only insert epilog into returning blocks"


<s> bool MBlazePassConfig :: addPreEmitPass ( ) { addPass ( createMBlazeDelaySlotFillerPass ( getMBlazeTargetMachine ( ) ) ) ; return true ; } </s>


<s> virtual void Initialize ( MCContext & ctx , const TargetMachine & TM ) { TargetLoweringObjectFile :: Initialize ( ctx , TM ) ; TextSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getText ( ) ) ; DataSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getDataRel ( ) ) ; BSSSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getBSS ( ) ) ; ReadOnlySection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getReadOnly ( ) ) ; StaticCtorSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; StaticDtorSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; LSDASection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; EHFrameSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfAbbrevSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfInfoSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfLineSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfFrameSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfPubTypesSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfDebugInlineSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfStrSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfLocSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfARangesSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfRangesSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; DwarfMacroInfoSection = new NVPTXSection ( MCSection :: SV_ELF , SectionKind :: getMetadata ( ) ) ; } </s>

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

NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX NVPTX


<s> static bool use_push_rts_p ( int nregs ) { if ( TARGET_INSNS_64PLUS && optimize_function_for_size_p ( cfun ) && ! cfun -> machine -> contains_sibcall && ! cfun -> returns_struct && ! TARGET_LONG_CALLS && nregs >= 6 && ! frame_pointer_needed ) return true ; return false ; } </s>

Examine the number of regs NREGS we 've determined we must save . Return true if we should use __c6xabi_push_rts/__c6xabi_pop_rts for prologue and epilogue .


<s> void GBZ80AsmPrinter :: EmitInstruction ( const MachineInstr * MI ) { GBZ80MCInstLower MCInstLowering ( OutContext , * this ) ; MCInst I ; MCInstLowering . lowerInstruction ( * MI , I ) ; EmitToStreamer ( * OutStreamer , I ) ; } </s>

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


<s> rtx s390_function_value ( tree type , enum machine_mode mode ) { if ( type ) { int unsignedp = TYPE_UNSIGNED ( type ) ; mode = promote_mode ( type , TYPE_MODE ( type ) , & unsignedp , 1 ) ; } gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_INT || GET_MODE_CLASS ( mode ) == MODE_FLOAT ) ; gcc_assert ( GET_MODE_SIZE ( mode ) <= 8 ) ; if ( TARGET_HARD_FLOAT && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return gen_rtx_REG ( mode , 16 ) ; else return gen_rtx_REG ( mode , 2 ) ; } </s>

Define where to return a ( scalar ) value of type TYPE . If TYPE is null , define where to return a ( scalar ) value of mode MODE from a libcall .


<s> void mips16_expand_get_fcsr ( rtx target ) { if ( ! mips16_get_fcsr_stub ) mips16_get_fcsr_stub = new mips16_get_fcsr_one_only_stub ( ) ; rtx fn = mips16_stub_call_address ( mips16_get_fcsr_stub ) ; emit_insn ( PMODE_INSN ( gen_mips_get_fcsr_mips16 , ( fn ) ) ) ; emit_move_insn ( target , gen_rtx_REG ( SImode , GET_FCSR_REGNUM ) ) ; } </s>

Implement `` TARGET = __builtin_mips_get_fcsr ( ) '' for MIPS16 , using a stub .


"the ABI of passing aggregates with %d-byte alignment"

If defined , a C expression that gives the alignment boundary , in bits , of an argument with the specified mode and type . If it is not defined , PARM_BOUNDARY is used for all arguments . V.4 wants long longs and doubles to be double word aligned . Just testing the mode size is a boneheaded way to do this as it means that other types such as complex int are also double word aligned . However , we 're stuck with this because changing the ABI might break existing library interfaces . Quadword align Altivec/VSX vectors . Quadword align large synthetic vector types .


<s> bool alpha_legitimate_constant_p ( machine_mode mode , rtx x ) { HOST_WIDE_INT i0 , i1 ; switch ( GET_CODE ( x ) ) { case LABEL_REF : case HIGH : return true ; case CONST : if ( GET_CODE ( XEXP ( x , 0 ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , 0 ) , 1 ) ) == CONST_INT ) x = XEXP ( XEXP ( x , 0 ) , 0 ) ; else return true ; if ( GET_CODE ( x ) != SYMBOL_REF ) return true ; case SYMBOL_REF : return SYMBOL_REF_TLS_MODEL ( x ) == 0 ; case CONST_DOUBLE : if ( x == CONST0_RTX ( mode ) ) return true ; if ( FLOAT_MODE_P ( mode ) ) return false ; goto do_integer ; case CONST_VECTOR : if ( x == CONST0_RTX ( mode ) ) return true ; if ( GET_MODE_CLASS ( mode ) != MODE_VECTOR_INT ) return false ; if ( GET_MODE_SIZE ( mode ) != 8 ) return false ; goto do_integer ; case CONST_INT : do_integer : if ( TARGET_BUILD_CONSTANTS ) return true ; alpha_extract_integer ( x , & i0 , & i1 ) ; if ( HOST_BITS_PER_WIDE_INT >= 64 || i1 == ( - i0 < 0 ) ) return alpha_emit_set_const_1 ( x , mode , i0 , 3 , true ) != NULL ; return false ; default : return false ; } } </s>

Implement LEGITIMATE_CONSTANT_P . This is all constants for which we are willing to load the value into a register via a move pattern . Normally this is all symbolic constants , integral constants that take three or fewer instructions , and floating-point zero .


<s> const MMIXRegisterInfo * getRegisterInfo ( ) const override { return & RegInfo ; } </s>

getRegisterInfo - TargetInstrInfo is a superset of MRegister info .


<s>
void
HexagonFrameLowering
::
emitEpilogue
(
MachineFunction
&
MF
,
MachineBasicBlock
&
MBB
)
const
{
MachineBasicBlock
::
iterator
MBBI
=
std
::
prev
(
MBB
.
end
(
)
)
;
DebugLoc
dl
=
MBBI
->
getDebugLoc
(
)
;
if
(
hasFP
(
MF
)
||
MF
.
getTarget
(
)
.
getOptLevel
(
)
==
CodeGenOpt
::
)
{
MachineBasicBlock
::
iterator
MBBI
=
std
::
prev
(
MBB
.
end
(
)
)
;
MachineBasicBlock
::
iterator
MBBI_end
=
MBB
.
end
(
)
;
const
TargetInstrInfo
&
TII
=
*
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
if
(
MBBI
->
getOpcode
(
)
==
Hexagon
::
EH_RETURN_JMPR
)
{
assert
(
MBBI
->
getOperand
(
0
)
.
isReg
(
)
&&
"Offset should be in register!"
)
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Hexagon
::
DEALLOCFRAME
)
)
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Hexagon
::
ADD_rr
)
,
Hexagon
::
R29
)
.
addReg
(
Hexagon
::
R29
)
.
addReg
(
Hexagon
::
R28
)
;
return
;
}
if
(
MF
.
getTarget
(
)
.
getSubtarget
<
HexagonSubtarget
>
(
)
.
hasV4TOps
(
)
&&
MBBI
->
getOpcode
(
)
==
Hexagon
::
JMPret
&&
!
DisableDeallocRet
)
{
MachineBasicBlock
::
iterator
BeforeJMPR
=
MBB
.
begin
(
)
==
MBBI
MBBI
:
std
::
prev
(
MBBI
)
;
if
(
BeforeJMPR
!=
MBBI
&&
BeforeJMPR
->
getOpcode
(
)
==
Hexagon
::
RESTORE_DEALLOC_RET_JMP_V4
)
{
MBB
.
erase
(
MBBI
)
;
return
;
}
MachineInstrBuilder
MIB
=
BuildMI
(
MBB
,
MBBI_end
,
dl
,
TII
.
get
(
Hexagon
::
DEALLOC_RET_V4
)
)
;
MIB
->
copyImplicitOps
(
*
MBB
.
getParent
(
)
,
&
*
MBBI
)
;
MBB
.
erase
(
MBBI
)
;
}
else
{
MachineBasicBlock
::
iterator
Term
=
MBB
.
getFirstTerminator
(
)
;
MachineBasicBlock
::
iterator
I
=
Term
==
MBB
.
begin
(
)
MBB
.
end
(
)
:
std
::
prev
(
Term
)
;
if
(
I
!=
MBB
.
end
(
)
&&
I
->
getOpcode
(
)
==
Hexagon
::
RESTORE_DEALLOC_BEFORE_TAILCALL_V4
)
return
;
BuildMI
(
MBB
,
MBBI
,
dl
,
TII
.
get
(
Hexagon
::
DEALLOCFRAME
)
)
;
}
}
}
</s>


"... Calling convention cannot be tail called.\n"

"... Cannot tail call from callers with byval "

"... Caller and callee have incompatible calling conventions.\n"

"... Call is eligible for tail call optimization.\n"


<s> static bool rs6000_vectorize_vec_perm_const ( machine_mode vmode , rtx target , rtx op0 , rtx op1 , const vec_perm_indices & sel ) { bool testing_p = ! target ; if ( TARGET_ALTIVEC && testing_p ) return true ; if ( op0 ) { rtx nop0 = force_reg ( vmode , op0 ) ; if ( op0 == op1 ) op1 = nop0 ; op0 = nop0 ; } if ( op1 ) op1 = force_reg ( vmode , op1 ) ; if ( ( vmode == V2DFmode || vmode == V2DImode ) && VECTOR_MEM_VSX_P ( vmode ) ) { if ( testing_p ) { op0 = gen_raw_REG ( vmode , LAST_VIRTUAL_REGISTER + 1 ) ; op1 = gen_raw_REG ( vmode , LAST_VIRTUAL_REGISTER + 2 ) ; } if ( rs6000_expand_vec_perm_const_1 ( target , op0 , op1 , sel [ 0 ] , sel [ 1 ] ) ) return true ; } if ( TARGET_ALTIVEC ) { if ( vmode != V16QImode ) return false ; if ( altivec_expand_vec_perm_const ( target , op0 , op1 , sel ) ) return true ; } return false ; } </s>


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


<s> LoadInst * X86TargetLowering :: lowerIdempotentRMWIntoFencedLoad ( AtomicRMWInst * AI ) const { unsigned NativeWidth = Subtarget . is64Bit ( ) ? 64 : 32 ; Type * MemType = AI -> getType ( ) ; if ( MemType -> getPrimitiveSizeInBits ( ) > NativeWidth ) return nullptr ; auto Builder = IRBuilder < > ( AI ) ; Module * M = Builder . GetInsertBlock ( ) -> getParent ( ) -> getParent ( ) ; auto SynchScope = AI -> getSynchScope ( ) ; auto Order = AtomicCmpXchgInst :: getStrongestFailureOrdering ( AI -> getOrdering ( ) ) ; auto Ptr = AI -> getPointerOperand ( ) ; if ( SynchScope == SingleThread ) return nullptr ; if ( ! Subtarget . hasMFence ( ) ) return nullptr ; Function * MFence = llvm :: Intrinsic :: getDeclaration ( M , Intrinsic :: x86_sse2_mfence ) ; Builder . CreateCall ( MFence , { } ) ; LoadInst * Loaded = Builder . CreateAlignedLoad ( Ptr , AI -> getType ( ) -> getPrimitiveSizeInBits ( ) ) ; Loaded -> setAtomic ( Order , SynchScope ) ; AI -> replaceAllUsesWith ( Loaded ) ; AI -> eraseFromParent ( ) ; return Loaded ; } </s>

On some platforms , an AtomicRMW that never actually modifies the value ( such as fetch_add of 0 ) can be turned into a fence followed by an atomic load .


<s> TargetLoweringObjectFile * getObjFileLowering ( ) const override { return TLOF . get ( ) ; } </s>

Return information about object file lowering .


<s> void pass_vsetvl :: transfer_before ( vector_insn_info & info , insn_info * insn ) const { if ( ! has_vtype_op ( insn -> rtl ( ) ) ) return ; const vector_insn_info require = m_vector_manager -> vector_insn_infos [ insn -> uid ( ) ] ; if ( info . valid_p ( ) && ! need_vsetvl ( require , info ) ) return ; info = require ; } </s>

Given an incoming state reaching INSN , modifies that state so that it is minimally compatible with INSN . The resulting state is guaranteed to be semantically legal for INSN , but may not be the state requested by INSN .


"AMDGPU Control Flow Graph structurizer Pass"

getPassName - Return a nice clean name for a pass .


<s> static HOST_WIDE_INT avr_starting_frame_offset ( void ) { return 1 + avr_outgoing_args_size ( ) ; } </s>

This is the offset from the frame pointer register to the first stack slot that contains a variable living in the frame .


<s> unsigned int arm_dbx_register_number ( unsigned int regno ) { if ( regno < 16 ) return regno ; if ( IS_FPA_REGNUM ( regno ) ) return ( TARGET_AAPCS_BASED ? 96 : 16 ) + regno - FIRST_FPA_REGNUM ; if ( IS_VFP_REGNUM ( regno ) ) return 64 + regno - FIRST_VFP_REGNUM ; if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return 104 + regno - FIRST_IWMMXT_GR_REGNUM ; if ( IS_IWMMXT_REGNUM ( regno ) ) return 112 + regno - FIRST_IWMMXT_REGNUM ; gcc_unreachable ( ) ; } </s>

Map internal gcc register numbers to DWARF2 register numbers .


<s>
bool
AMDGPUAsmParser
::
ParseInstruction
(
ParseInstructionInfo
&
Info
,
StringRef
Name
,
SMLoc
NameLoc
,
OperandVector
&
Operands
)
{
Name
=
parseMnemonicSuffix
(
Name
)
;
applyMnemonicAliases
(
Name
,
getAvailableFeatures
(
)
,
0
)
;
Operands
.
push_back
(
AMDGPUOperand
::
CreateToken
(
this
,
Name
,
NameLoc
)
)
;
bool
IsMIMG
=
Name
.
startswith
(
"image_"
)
;
while
(
!
trySkipToken
(
AsmToken
::
EndOfStatement
)
)
{
OperandMode
Mode
=
OperandMode_Default
;
if
(
IsMIMG
&&
isGFX10Plus
(
)
&&
Operands
.
size
(
)
==
2
)
Mode
=
OperandMode_NSA
;
CPolSeen
=
0
;
OperandMatchResultTy
Res
=
parseOperand
(
Operands
,
Name
,
Mode
)
;
if
(
Res
!=
MatchOperand_Success
)
{
checkUnsupportedInstruction
(
Name
,
NameLoc
)
;
if
(
!
Parser
.
hasPendingError
(
)
)
{
StringRef
Msg
=
(
Res
==
MatchOperand_ParseFail
)
"failed parsing operand."
:
"not a valid operand."
;
Error
(
getLoc
(
)
,
Msg
)
;
}
while
(
!
trySkipToken
(
AsmToken
::
EndOfStatement
)
)
{
lex
(
)
;
}
return
true
;
}
trySkipToken
(
AsmToken
::
Comma
)
;
}
return
false
;
}
</s>

ParseInstruction - Parse one assembly instruction .


<s> rtx mve_bool_vec_to_const ( rtx const_vec ) { int n_elts = GET_MODE_NUNITS ( GET_MODE ( const_vec ) ) ; int repeat = 16 / n_elts ; int i ; int hi_val = 0 ; for ( i = 0 ; i < n_elts ; i ++ ) { rtx el = CONST_VECTOR_ELT ( const_vec , i ) ; unsigned HOST_WIDE_INT elpart ; gcc_assert ( CONST_INT_P ( el ) ) ; elpart = INTVAL ( el ) ; for ( int j = 0 ; j < repeat ; j ++ ) hi_val |= elpart << ( i * repeat + j ) ; } return gen_int_mode ( hi_val , HImode ) ; } </s>

Return a HI representation of CONST_VEC suitable for MVE predicates .


<s>
bool
FPS
::
runOnMachineFunction
(
MachineFunction
&
MF
)
{
bool
FPIsUsed
=
false
;
assert
(
X86
::
FP6
==
X86
::
FP0
+
6
&&
"Register enums aren't sorted right!"
)
;
for
(
unsigned
i
=
0
;
i
<=
6
;
++
i
)
if
(
MF
.
getRegInfo
(
)
.
isPhysRegUsed
(
X86
::
FP0
+
i
)
)
{
FPIsUsed
=
true
;
break
;
}
if
(
!
FPIsUsed
)
return
false
;
Bundles
=
&
getAnalysis
<
EdgeBundles
>
(
)
;
TII
=
MF
.
getSubtarget
(
)
.
getInstrInfo
(
)
;
bundleCFG
(
MF
)
;
StackTop
=
0
;
SmallPtrSet
<
MachineBasicBlock
*
,
8
>
Processed
;
MachineBasicBlock
*
Entry
=
MF
.
begin
(
)
;
bool
Changed
=
false
;
for
(
MachineBasicBlock
*
BB
:
depth_first_ext
(
Entry
,
Processed
)
)
Changed
|=
processBasicBlock
(
MF
,
*
BB
)
;
if
(
MF
.
size
(
)
!=
Processed
.
size
(
)
)
for
(
MachineFunction
::
iterator
BB
=
MF
.
begin
(
)
,
E
=
MF
.
end
(
)
;
BB
!=
E
;
++
BB
)
if
(
Processed
.
insert
(
BB
)
.
second
)
Changed
|=
processBasicBlock
(
MF
,
*
BB
)
;
LiveBundles
.
clear
(
)
;
return
Changed
;
}
</s>

runOnMachineFunction - Emit the function body .


<s>
static
const
char
*
arm_invalid_within_doloop
(
const
rtx_insn
*
insn
)
{
if
(
!
TARGET_HAVE_LOB
)
return
default_invalid_within_doloop
(
insn
)
;
if
(
CALL_P
(
insn
)
)
return
"Function call in the loop."
;
if
(
reg_mentioned_p
(
gen_rtx_REG
(
SImode
,
LR_REGNUM
)
,
insn
)
)
return
"LR is used inside loop."
;
return
;
}
</s>

NULL if insn INSN is valid within a low-overhead loop . Otherwise return why doloop can not be applied .

arm
"Function call in the loop."
"LR is used inside loop."


<s> const char * PPCTargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { default : return 0 ; case PPCISD :: FSEL : return "PPCISD::FSEL" ; case PPCISD :: FCFID : return "PPCISD::FCFID" ; case PPCISD :: FCTIDZ : return "PPCISD::FCTIDZ" ; case PPCISD :: FCTIWZ : return "PPCISD::FCTIWZ" ; case PPCISD :: FRE : return "PPCISD::FRE" ; case PPCISD :: FRSQRTE : return "PPCISD::FRSQRTE" ; case PPCISD :: STFIWX : return "PPCISD::STFIWX" ; case PPCISD :: VMADDFP : return "PPCISD::VMADDFP" ; case PPCISD :: VNMSUBFP : return "PPCISD::VNMSUBFP" ; case PPCISD :: VPERM : return "PPCISD::VPERM" ; case PPCISD :: Hi : return "PPCISD::Hi" ; case PPCISD :: Lo : return "PPCISD::Lo" ; case PPCISD :: TOC_ENTRY : return "PPCISD::TOC_ENTRY" ; case PPCISD :: TOC_RESTORE : return "PPCISD::TOC_RESTORE" ; case PPCISD :: LOAD : return "PPCISD::LOAD" ; case PPCISD :: LOAD_TOC : return "PPCISD::LOAD_TOC" ; case PPCISD :: DYNALLOC : return "PPCISD::DYNALLOC" ; case PPCISD :: GlobalBaseReg : return "PPCISD::GlobalBaseReg" ; case PPCISD :: SRL : return "PPCISD::SRL" ; case PPCISD :: SRA : return "PPCISD::SRA" ; case PPCISD :: SHL : return "PPCISD::SHL" ; case PPCISD :: CALL : return "PPCISD::CALL" ; case PPCISD :: CALL_NOP : return "PPCISD::CALL_NOP" ; case PPCISD :: MTCTR : return "PPCISD::MTCTR" ; case PPCISD :: BCTRL : return "PPCISD::BCTRL" ; case PPCISD :: RET_FLAG : return "PPCISD::RET_FLAG" ; case PPCISD :: EH_SJLJ_SETJMP : return "PPCISD::EH_SJLJ_SETJMP" ; case PPCISD :: EH_SJLJ_LONGJMP : return "PPCISD::EH_SJLJ_LONGJMP" ; case PPCISD :: MFOCRF : return "PPCISD::MFOCRF" ; case PPCISD :: VCMP : return "PPCISD::VCMP" ; case PPCISD :: VCMPo : return "PPCISD::VCMPo" ; case PPCISD :: LBRX : return "PPCISD::LBRX" ; case PPCISD :: STBRX : return "PPCISD::STBRX" ; case PPCISD :: LARX : return "PPCISD::LARX" ; case PPCISD :: STCX : return "PPCISD::STCX" ; case PPCISD :: COND_BRANCH : return "PPCISD::COND_BRANCH" ; case PPCISD :: BDNZ : return "PPCISD::BDNZ" ; case PPCISD :: BDZ : return "PPCISD::BDZ" ; case PPCISD :: MFFS : return "PPCISD::MFFS" ; case PPCISD :: FADDRTZ : return "PPCISD::FADDRTZ" ; case PPCISD :: TC_RETURN : return "PPCISD::TC_RETURN" ; case PPCISD :: CR6SET : return "PPCISD::CR6SET" ; case PPCISD :: CR6UNSET : return "PPCISD::CR6UNSET" ; case PPCISD :: ADDIS_TOC_HA : return "PPCISD::ADDIS_TOC_HA" ; case PPCISD :: LD_TOC_L : return "PPCISD::LD_TOC_L" ; case PPCISD :: ADDI_TOC_L : return "PPCISD::ADDI_TOC_L" ; case PPCISD :: ADDIS_GOT_TPREL_HA : return "PPCISD::ADDIS_GOT_TPREL_HA" ; case PPCISD :: LD_GOT_TPREL_L : return "PPCISD::LD_GOT_TPREL_L" ; case PPCISD :: ADD_TLS : return "PPCISD::ADD_TLS" ; case PPCISD :: ADDIS_TLSGD_HA : return "PPCISD::ADDIS_TLSGD_HA" ; case PPCISD :: ADDI_TLSGD_L : return "PPCISD::ADDI_TLSGD_L" ; case PPCISD :: GET_TLS_ADDR : return "PPCISD::GET_TLS_ADDR" ; case PPCISD :: ADDIS_TLSLD_HA : return "PPCISD::ADDIS_TLSLD_HA" ; case PPCISD :: ADDI_TLSLD_L : return "PPCISD::ADDI_TLSLD_L" ; case PPCISD :: GET_TLSLD_ADDR : return "PPCISD::GET_TLSLD_ADDR" ; case PPCISD :: ADDIS_DTPREL_HA : return "PPCISD::ADDIS_DTPREL_HA" ; case PPCISD :: ADDI_DTPREL_L : return "PPCISD::ADDI_DTPREL_L" ; case PPCISD :: VADD_SPLAT : return "PPCISD::VADD_SPLAT" ; case PPCISD :: SC : return "PPCISD::SC" ; } } </s>

getTargetNodeName - This method returns the name of a target specific


<s> static rtx_insn * set_frame_related_p ( void ) { rtx_insn * seq = get_insns ( ) ; rtx_insn * insn ; end_sequence ( ) ; if ( ! seq ) return NULL ; if ( INSN_P ( seq ) ) { insn = seq ; while ( insn != NULL_RTX ) { RTX_FRAME_RELATED_P ( insn ) = 1 ; insn = NEXT_INSN ( insn ) ; } seq = emit_insn ( seq ) ; } else { seq = emit_insn ( seq ) ; RTX_FRAME_RELATED_P ( seq ) = 1 ; } return seq ; } </s>

Helper function to set RTX_FRAME_RELATED_P on instructions , including sequences .


<s>
bool
ARMDAGToDAGISel
::
SelectInlineAsmMemoryOperand
(
const
SDValue
&
Op
,
unsigned
ConstraintID
,
std
::
vector
<
SDValue
>
&
OutOps
)
{
assert
(
ConstraintID
==
InlineAsm
::
Constraint_m
&&
"unexpected asm memory constraint"
)
;
OutOps
.
push_back
(
Op
)
;
return
false
;
}
</s>

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

ARM
ARM
"unexpected asm memory constraint"


<s> void Cpu0TargetObjectFile :: 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 ) ; this -> TM = & static_cast < const Cpu0TargetMachine & > ( TM ) ; } </s>

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


<s> static enum sched_fusion_type fusion_load_store ( rtx_insn * insn , rtx * base , rtx * offset ) { rtx x , dest , src ; enum sched_fusion_type fusion = SCHED_FUSION_LD ; gcc_assert ( INSN_P ( insn ) ) ; x = PATTERN ( insn ) ; if ( GET_CODE ( x ) != SET ) return SCHED_FUSION_NONE ; src = SET_SRC ( x ) ; dest = SET_DEST ( x ) ; machine_mode dest_mode = GET_MODE ( dest ) ; if ( ! aarch64_mode_valid_for_sched_fusion_p ( dest_mode ) ) return SCHED_FUSION_NONE ; if ( GET_CODE ( src ) == SIGN_EXTEND ) { fusion = SCHED_FUSION_LD_SIGN_EXTEND ; src = XEXP ( src , 0 ) ; if ( GET_CODE ( src ) != MEM || GET_MODE ( src ) != SImode ) return SCHED_FUSION_NONE ; } else if ( GET_CODE ( src ) == ZERO_EXTEND ) { fusion = SCHED_FUSION_LD_ZERO_EXTEND ; src = XEXP ( src , 0 ) ; if ( GET_CODE ( src ) != MEM || GET_MODE ( src ) != SImode ) return SCHED_FUSION_NONE ; } if ( GET_CODE ( src ) == MEM && REG_P ( dest ) ) extract_base_offset_in_addr ( src , base , offset ) ; else if ( GET_CODE ( dest ) == MEM && ( REG_P ( src ) || src == const0_rtx ) ) { fusion = SCHED_FUSION_ST ; extract_base_offset_in_addr ( dest , base , offset ) ; } else return SCHED_FUSION_NONE ; if ( * base == NULL_RTX || * offset == NULL_RTX ) fusion = SCHED_FUSION_NONE ; return fusion ; } </s>

If INSN is a load or store of address in the form of [ base+offset ] , extract the two parts and set to BASE and OFFSET . IS_LOAD is set to TRUE if it 's a load . Return TRUE if INSN is such an instruction , otherwise return FALSE .


<s> static bool ia64_expand_vecint_compare ( enum rtx_code code , machine_mode mode , rtx dest , rtx op0 , rtx op1 ) { bool negate = false ; rtx x ; switch ( code ) { case EQ : case GT : case GTU : break ; case NE : case LE : case LEU : code = reverse_condition ( code ) ; negate = true ; break ; case GE : case GEU : code = reverse_condition ( code ) ; negate = true ; case LT : case LTU : code = swap_condition ( code ) ; x = op0 , op0 = op1 , op1 = x ; break ; default : gcc_unreachable ( ) ; } if ( code == GTU ) { switch ( mode ) { case E_V2SImode : { rtx t1 , t2 , mask ; mask = gen_int_mode ( 0x80000000 , SImode ) ; mask = gen_const_vec_duplicate ( V2SImode , mask ) ; mask = force_reg ( mode , mask ) ; t1 = gen_reg_rtx ( mode ) ; emit_insn ( gen_subv2si3 ( t1 , op0 , mask ) ) ; t2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_subv2si3 ( t2 , op1 , mask ) ) ; op0 = t1 ; op1 = t2 ; code = GT ; } break ; case E_V8QImode : case E_V4HImode : x = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( x , gen_rtx_US_MINUS ( mode , op0 , op1 ) ) ) ; code = EQ ; op0 = x ; op1 = CONST0_RTX ( mode ) ; negate = ! negate ; break ; default : gcc_unreachable ( ) ; } } x = gen_rtx_fmt_ee ( code , mode , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; return negate ; } </s>

Generate an integral vector comparison . Return true if the condition has been reversed , and so the sense of the comparison should be inverted .


<s> bool sparc_tls_referenced_p ( rtx x ) { if ( ! TARGET_HAVE_TLS ) return false ; return for_each_rtx ( & x , & sparc_tls_symbol_ref_1 , 0 ) ; } </s>

Return 1 if X contains a thread-local symbol .


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

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


<s>
const
char
*
emit_fusion_p9_store
(
rtx
mem
,
rtx
reg
,
rtx
tmp_reg
)
{
enum
machine_mode
mode
=
GET_MODE
(
reg
)
;
rtx
hi
;
rtx
lo
;
rtx
addr
;
const
char
*
store_string
;
int
r
;
if
(
GET_CODE
(
reg
)
==
SUBREG
)
{
gcc_assert
(
SUBREG_BYTE
(
reg
)
==
0
)
;
reg
=
SUBREG_REG
(
reg
)
;
}
if
(
!
REG_P
(
reg
)
)
fatal_insn
(
"emit_fusion_p9_store, bad reg #1"
,
reg
)
;
r
=
REGNO
(
reg
)
;
if
(
FP_REGNO_P
(
r
)
)
{
if
(
mode
==
SFmode
)
store_string
=
"stfs"
;
else
if
(
mode
==
DFmode
)
store_string
=
"stfd"
;
else
gcc_unreachable
(
)
;
}
else
if
(
ALTIVEC_REGNO_P
(
r
)
&&
TARGET_P9_DFORM_SCALAR
)
{
if
(
mode
==
SFmode
)
store_string
=
"stxssp"
;
else
if
(
mode
==
DFmode
||
mode
==
DImode
)
store_string
=
"stxsd"
;
else
gcc_unreachable
(
)
;
}
else
if
(
INT_REGNO_P
(
r
)
)
{
switch
(
mode
)
{
case
QImode
:
store_string
=
"stb"
;
break
;
case
HImode
:
store_string
=
"sth"
;
break
;
case
SImode
:
case
SFmode
:
store_string
=
"stw"
;
break
;
case
DImode
:
case
DFmode
:
if
(
!
TARGET_POWERPC64
)
gcc_unreachable
(
)
;
store_string
=
"std"
;
break
;
default
:
gcc_unreachable
(
)
;
}
}
else
fatal_insn
(
"emit_fusion_p9_store, bad reg #2"
,
reg
)
;
if
(
!
MEM_P
(
mem
)
)
fatal_insn
(
"emit_fusion_p9_store not MEM"
,
mem
)
;
addr
=
XEXP
(
mem
,
0
)
;
fusion_split_address
(
addr
,
&
hi
,
&
lo
)
;
emit_fusion_addis
(
tmp_reg
,
hi
,
"power9 store fusion"
,
GET_MODE_NAME
(
mode
)
)
;
emit_fusion_load_store
(
reg
,
tmp_reg
,
lo
,
store_string
)
;
return
""
;
}
</s>

Return a string to fuse an addis instruction with a store using extended fusion . The address that is used is the logical address that was formed during peephole2 : ( lo_sum ( high ) ( low-part ) ) The code is complicated , so we call output_asm_insn directly , and just return `` '' .

rs6000
0
"emit_fusion_p9_store, bad reg #1"
"stfs"
"stfd"
"stxssp"
"stxsd"
"stb"
"sth"
"stw"
"std"
"emit_fusion_p9_store, bad reg #2"
"emit_fusion_p9_store not MEM"
0
"power9 store fusion"
""


<s> EVT X86TargetLowering :: getSetCCResultType ( const DataLayout & DL , LLVMContext & Context , EVT VT ) const { if ( ! VT . isVector ( ) ) return MVT :: i8 ; if ( Subtarget . hasAVX512 ( ) ) { EVT LegalVT = VT ; while ( getTypeAction ( Context , LegalVT ) != TypeLegal ) LegalVT = getTypeToTransformTo ( Context , LegalVT ) ; if ( LegalVT . getSimpleVT ( ) . is512BitVector ( ) ) return EVT :: getVectorVT ( Context , MVT :: i1 , VT . getVectorElementCount ( ) ) ; if ( LegalVT . getSimpleVT ( ) . isVector ( ) && Subtarget . hasVLX ( ) ) { MVT EltVT = LegalVT . getSimpleVT ( ) . getVectorElementType ( ) ; if ( Subtarget . hasBWI ( ) || EltVT . getSizeInBits ( ) >= 32 ) return EVT :: getVectorVT ( Context , MVT :: i1 , VT . getVectorElementCount ( ) ) ; } } return VT . changeVectorElementTypeToInteger ( ) ; } </s>

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


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

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


<s> void getAnalysisUsage ( AnalysisUsage & AU ) const override { AU . addRequired < LegacyDivergenceAnalysis > ( ) ; AU . addRequired < MemorySSAWrapperPass > ( ) ; AU . setPreservesAll ( ) ; } </s>

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this .


<s> bool M68kFrameLowering :: restoreCalleeSavedRegisters ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , MutableArrayRef < CalleeSavedInfo > CSI , const TargetRegisterInfo * TRI ) const { auto & MRI = * static_cast < const M68kRegisterInfo * > ( TRI ) ; auto DL = MBB . findDebugLoc ( MI ) ; int FI = 0 ; unsigned Mask = 0 ; for ( const auto & Info : CSI ) { FI = std :: max ( FI , Info . getFrameIdx ( ) ) ; Register Reg = Info . getReg ( ) ; unsigned Shift = MRI . getSpillRegisterOrder ( Reg ) ; Mask |= 1 << Shift ; } auto I = M68k :: addFrameReference ( BuildMI ( MBB , MI , DL , TII . get ( M68k :: MOVM32mp ) ) . addImm ( Mask ) , FI ) . setMIFlag ( MachineInstr :: FrameDestroy ) ; for ( const auto & Info : CSI ) { I . addReg ( Info . getReg ( ) , RegState :: ImplicitDefine ) ; M68k :: addMemOperand ( I , Info . getFrameIdx ( ) , 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> RegisterRef PhysicalRegisterInfo :: normalize ( RegisterRef RR ) const { if ( PhysicalRegisterInfo :: isRegMaskId ( RR . Reg ) ) return RR ; RegisterId SuperReg = RegInfos [ RR . Reg ] . MaxSuper ; if ( RR . Reg == SuperReg ) return RR ; const TargetRegisterClass * RC = RegInfos [ RR . Reg ] . RegClass ; LaneBitmask RCMask = RC != nullptr ? RC -> LaneMask : LaneBitmask ( 0x00000001 ) ; LaneBitmask Common = RR . Mask & RCMask ; uint32_t Sub = TRI . getSubRegIndex ( SuperReg , RR . Reg ) ; LaneBitmask SuperMask = TRI . composeSubRegIndexLaneMask ( Sub , Common ) ; assert ( RR . Mask . none ( ) || SuperMask . any ( ) ) ; return RegisterRef ( SuperReg , SuperMask ) ; } </s>


<s> static enum tls_model tls_symbolic_operand_type ( rtx symbol ) { enum tls_model model ; if ( GET_CODE ( symbol ) != SYMBOL_REF ) return TLS_MODEL_NONE ; model = SYMBOL_REF_TLS_MODEL ( symbol ) ; if ( model == TLS_MODEL_LOCAL_EXEC && alpha_tls_size == 64 ) model = TLS_MODEL_INITIAL_EXEC ; return model ; } </s>

Return the TLS model to use for SYMBOL .


<s> bool empty ( ) const { return Masks . empty ( ) ; } </s>

Determine whether this version information is empty ( e.g. , all version components are zero ) .


<s> rtx extract_mem_rtx ( rtx_insn * insn ) { rtx body = PATTERN ( insn ) ; switch ( get_attr_type ( insn ) ) { case TYPE_LOAD : case TYPE_FLOAD : if ( MEM_P ( SET_SRC ( body ) ) ) return SET_SRC ( body ) ; if ( GET_CODE ( SET_SRC ( body ) ) == UNSPEC ) { gcc_assert ( MEM_P ( XVECEXP ( SET_SRC ( body ) , 0 , 0 ) ) ) ; return XVECEXP ( SET_SRC ( body ) , 0 , 0 ) ; } gcc_assert ( MEM_P ( XEXP ( SET_SRC ( body ) , 0 ) ) ) ; return XEXP ( SET_SRC ( body ) , 0 ) ; case TYPE_STORE : case TYPE_FSTORE : if ( MEM_P ( SET_DEST ( body ) ) ) return SET_DEST ( body ) ; if ( GET_CODE ( SET_DEST ( body ) ) == UNSPEC ) { gcc_assert ( MEM_P ( XVECEXP ( SET_DEST ( body ) , 0 , 0 ) ) ) ; return XVECEXP ( SET_DEST ( body ) , 0 , 0 ) ; } gcc_assert ( MEM_P ( XEXP ( SET_DEST ( body ) , 0 ) ) ) ; return XEXP ( SET_DEST ( body ) , 0 ) ; default : gcc_unreachable ( ) ; } } </s>

Extract the MEM rtx from a load/store insn .


"unrecognized interrupt vector argument of %qE attribute"

"numeric argument of %qE attribute must be in range 0..63"

"argument of %qE attribute is not a string constant or number"

"%qE attribute only applies to functions"

"critical functions cannot be reentrant"

"reentrant functions cannot be critical"


<s> int arc_initial_elimination_offset ( int from , int to ) { if ( ! cfun -> machine -> frame_info . initialized ) arc_compute_frame_size ( ) ; if ( from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM ) { return ( cfun -> machine -> frame_info . extra_size + cfun -> machine -> frame_info . reg_size ) ; } if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { return ( cfun -> machine -> frame_info . total_size - cfun -> machine -> frame_info . pretend_size ) ; } if ( ( from == FRAME_POINTER_REGNUM ) && ( to == STACK_POINTER_REGNUM ) ) { return ( cfun -> machine -> frame_info . total_size - ( cfun -> machine -> frame_info . pretend_size + cfun -> machine -> frame_info . extra_size + cfun -> machine -> frame_info . reg_size ) ) ; } gcc_unreachable ( ) ; } </s>

Define the offset between two registers , one to be eliminated , and the other its replacement , at the start of a routine .


<s> void AArch64AsmPrinter :: emitJumpTableInfo ( ) { const MachineJumpTableInfo * MJTI = MF -> getJumpTableInfo ( ) ; if ( ! MJTI ) return ; const std :: vector < MachineJumpTableEntry > & JT = MJTI -> getJumpTables ( ) ; if ( JT . empty ( ) ) return ; const Function & F = MF -> getFunction ( ) ; const TargetLoweringObjectFile & TLOF = getObjFileLowering ( ) ; bool JTInDiffSection = ! STI -> isTargetCOFF ( ) || ! TLOF . shouldPutJumpTableInFunctionSection ( MJTI -> getEntryKind ( ) == MachineJumpTableInfo :: EK_LabelDifference32 , F ) ; if ( JTInDiffSection ) { MCSection * ReadOnlySec = TLOF . getSectionForJumpTable ( F , TM ) ; OutStreamer -> SwitchSection ( ReadOnlySec ) ; } auto AFI = MF -> getInfo < AArch64FunctionInfo > ( ) ; for ( unsigned JTI = 0 , e = JT . size ( ) ; JTI != e ; ++ JTI ) { const std :: vector < MachineBasicBlock * > & JTBBs = JT [ JTI ] . MBBs ; if ( JTBBs . empty ( ) ) continue ; unsigned Size = AFI -> getJumpTableEntrySize ( JTI ) ; emitAlignment ( Align ( Size ) ) ; OutStreamer -> emitLabel ( GetJTISymbol ( JTI ) ) ; for ( auto * JTBB : JTBBs ) emitJumpTableEntry ( MJTI , JTBB , JTI ) ; } } </s>

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


<s> bool XCoreFrameLowering :: hasFP ( const MachineFunction & MF ) const { return MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ; } </s>

hasFP - Return true if the specified function should have a dedicated frame pointer register .