<s> bool ix86_libc_has_function ( enum function_class fn_class ) {

return targetm . libc_has_function ( fn_class , NULL_TREE ) ;


<s> bitmap_set_bit ( regs , split_stack_prologue_scratch_regno ( ) ) ; }


<s> unsigned int ix86_local_alignment ( tree exp , machine_mode mode , unsigned int align , bool may_lower ) { tree type , decl ; if ( exp && DECL_P ( exp ) ) { type = TREE_TYPE ( exp ) ; decl = exp ; } else { type = exp ; decl = NULL ; } if ( may_lower && ! TARGET_64BIT && align == <NUM_LIT> && ix86_preferred_stack_boundary < <NUM_LIT> && ( mode == DImode || ( type && TYPE_MODE ( type ) == DImode ) ) && ( ! type || ( ! TYPE_USER_ALIGN ( type ) && ! TYPE_ATOMIC ( strip_array_types ( type ) ) ) ) && ( ! decl || ! DECL_USER_ALIGN ( decl ) ) ) align = <NUM_LIT> ; if ( ! type ) { if ( mode == XFmode && align < GET_MODE_ALIGNMENT ( DFmode ) ) align = GET_MODE_ALIGNMENT ( DFmode ) ; return align ; } if ( TARGET_IAMCU ) return align ; if ( TARGET_64BIT && optimize_function_for_speed_p ( cfun ) && TARGET_SSE ) { if ( AGGREGATE_TYPE_P ( type ) && ( va_list_type_node == NULL_TREE || ( TYPE_MAIN_VARIANT ( type ) != TYPE_MAIN_VARIANT ( va_list_type_node ) ) ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( wi :: to_wide ( TYPE_SIZE ( type ) ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ;


<s> unsigned int ix86_local_alignment ( tree exp , machine_mode mode , unsigned int align , bool may_lower ) { tree type , decl ; if ( exp && DECL_P ( exp ) ) { type = TREE_TYPE ( exp ) ; decl = exp ; } else { type = exp ; decl = NULL ; } if ( may_lower && ! TARGET_64BIT && align == <NUM_LIT> && ix86_preferred_stack_boundary < <NUM_LIT> && ( mode == DImode || ( type && TYPE_MODE ( type ) == DImode ) ) && ( ! type || ( ! TYPE_USER_ALIGN ( type ) && ! TYPE_ATOMIC ( strip_array_types ( type ) ) ) ) && ( ! decl || ! DECL_USER_ALIGN ( decl ) ) ) align = <NUM_LIT> ; if ( ! type ) { if ( mode == XFmode && align < GET_MODE_ALIGNMENT ( DFmode ) ) align = GET_MODE_ALIGNMENT ( DFmode ) ; return align ; } if ( TARGET_IAMCU ) return align ; if ( TARGET_64BIT && optimize_function_for_speed_p ( cfun ) && TARGET_SSE ) {

if ( AGGREGATE_TYPE_P ( type ) && ( va_list_type_node == NULL_TREE || ( TYPE_MAIN_VARIANT ( type ) != TYPE_MAIN_VARIANT ( va_list_type_node ) ) ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( wi :: to_wide ( TYPE_SIZE ( type ) ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ;


<s> unsigned mem_count = <NUM_LIT> ; if ( ! TARGET_ADJUST_UNROLL ) return nunroll ; subrtx_iterator :: array_type array ; bbs = get_loop_body ( loop ) ;

for ( i = <NUM_LIT> ; i < loop -> num_nodes ; i ++ ) FOR_BB_INSNS ( bbs [ i ] , insn ) if ( NONDEBUG_INSN_P ( insn ) ) FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( const_rtx x = * iter ) if ( MEM_P ( x ) ) {


<s> if ( new_align < DECL_ALIGN ( decl ) ) SET_DECL_ALIGN ( decl , new_align ) ;


<s> if ( TREE_CODE ( type ) != VOID_TYPE && TREE_CODE ( type ) != BOOLEAN_TYPE && TREE_CODE ( type ) != INTEGER_TYPE && TREE_CODE ( type ) != REAL_TYPE ) return NULL ; switch ( TYPE_MODE ( type ) ) { case E_HFmode :


<s> if ( ( mask | ( HOST_WIDE_INT_M1U << elems ) ) != HOST_WIDE_INT_M1U ) return false ; return true ;


<s> if ( TREE_CODE ( arg_mask ) != INTEGER_CST ) return false ; unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW ( arg_mask ) ;

if ( ( mask | ( HOST_WIDE_INT_M1U << elems ) ) != HOST_WIDE_INT_M1U ) return false ;


<s> switch ( set_mode ) { case E_CCNOmode : if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , <NUM_LIT> ) != const0_rtx ) ) return false ; break ; case E_CCmode : if ( req_mode == CCGCmode ) return false ; case E_CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return false ; case E_CCGOCmode : if ( req_mode == CCZmode ) return false ; case E_CCZmode : break ; case E_CCGZmode :


<s> machine_mode set_mode ; set = PATTERN ( insn ) ; if ( GET_CODE ( set ) == PARALLEL ) set = XVECEXP ( set , <NUM_LIT> , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; gcc_assert ( GET_CODE ( SET_SRC ( set ) ) == COMPARE ) ; set_mode = GET_MODE ( SET_DEST ( set ) ) ; switch ( set_mode ) { case E_CCNOmode : if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , <NUM_LIT> ) != const0_rtx ) ) return false ; break ; case E_CCmode : if ( req_mode == CCGCmode ) return false ; case E_CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return false ; case E_CCGOCmode : if ( req_mode == CCZmode ) return false ; case E_CCZmode : break ; case E_CCGZmode : case E_CCAmode : case E_CCCmode : case E_CCOmode : case E_CCPmode : case E_CCSmode : if ( set_mode != req_mode ) return false ; break ; default : gcc_unreachable ( ) ; } return GET_MODE ( SET_SRC ( set ) ) == set_mode ;


return BRANCH_COST ( true , predictable_p ) * COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> con += <NUM_LIT> ; if ( strchr ( con , ',' ) != NULL ) { error_at ( loc , <STR_LIT> ) ; continue ; } bool invert = false ; if ( con [ <NUM_LIT> ] == 'n' ) invert = true , con ++ ; machine_mode mode = CCmode ; rtx_code code = UNKNOWN ; switch ( con [ <NUM_LIT> ] ) { case 'a' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCAmode , code = EQ ; else if ( con [ <NUM_LIT> ] == 'e' && con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCCmode , code = NE ; break ; case 'b' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCCmode , code = EQ ; else if ( con [ <NUM_LIT> ] == 'e' && con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCAmode , code = NE ; break ; case 'c' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCCmode , code = EQ ; break ; case 'e' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCZmode , code = EQ ; break ; case 'g' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCGCmode , code = GT ; else if ( con [ <NUM_LIT> ] == 'e' && con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCGCmode , code = GE ; break ; case 'l' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCGCmode , code = LT ; else if ( con [ <NUM_LIT> ] == 'e' && con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCGCmode , code = LE ; break ; case 'o' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCOmode , code = EQ ; break ; case 'p' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCPmode , code = EQ ; break ; case 's' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCSmode , code = EQ ; break ; case 'z' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCZmode , code = EQ ; break ; } if ( code == UNKNOWN ) { error_at ( loc , <STR_LIT> , constraints [ i ] ) ; continue ; } if ( invert ) code = reverse_condition ( code ) ; rtx dest = outputs [ i ] ;


<s> static bool ix86_member_type_forces_blk ( const_tree field , machine_mode mode ) { return ( mode == XFmode && ( TREE_CODE ( DECL_FIELD_CONTEXT ( field ) ) == UNION_TYPE || TREE_CODE ( DECL_FIELD_CONTEXT ( field ) ) == QUAL_UNION_TYPE ) ) ;


<s> static unsigned HOST_WIDE_INT ix86_memmodel_check ( unsigned HOST_WIDE_INT val ) { enum memmodel model = memmodel_from_int ( val ) ; bool strong ; if ( val & ~ ( unsigned HOST_WIDE_INT ) ( IX86_HLE_ACQUIRE | IX86_HLE_RELEASE | MEMMODEL_MASK ) || ( ( val & IX86_HLE_ACQUIRE ) && ( val & IX86_HLE_RELEASE ) ) ) { warning ( OPT_Winvalid_memory_model , <STR_LIT> ) ; return MEMMODEL_SEQ_CST ; } strong = ( is_mm_acq_rel ( model ) || is_mm_seq_cst ( model ) ) ;

if ( val & IX86_HLE_ACQUIRE && ! ( is_mm_acquire ( model ) || strong ) ) {


<s> static int ix86_memory_move_cost ( machine_mode mode , reg_class_t regclass , bool in ) { return inline_memory_move_cost ( mode , ( enum reg_class ) regclass , in ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( exp && DECL_P ( exp ) ) { type = TREE_TYPE ( exp ) ; decl = exp ; } else { type = exp ; decl = NULL ; }

if ( TARGET_64BIT || align != <NUM_LIT> || ix86_preferred_stack_boundary >= <NUM_LIT> ) return align ;


<s> type = TREE_TYPE ( exp ) ; decl = exp ; } else { type = exp ; decl = NULL ; } if ( TARGET_64BIT || align != <NUM_LIT> || ix86_preferred_stack_boundary >= <NUM_LIT> ) return align ; if ( ( mode == DImode || ( type && TYPE_MODE ( type ) == DImode ) ) && ( ! type || ( ! TYPE_USER_ALIGN ( type ) && ! TYPE_ATOMIC ( strip_array_types ( type ) ) ) ) && ( ! decl || ! DECL_USER_ALIGN ( decl ) ) ) { gcc_checking_assert ( ! TARGET_STV ) ;


<s> else if ( ix86_user_incoming_stack_boundary ) incoming_stack_boundary = ix86_user_incoming_stack_boundary ; else if ( ! sibcall && ix86_force_align_arg_pointer && crtl -> stack_alignment_estimated == <NUM_LIT> ) incoming_stack_boundary = MIN_STACK_BOUNDARY ; else incoming_stack_boundary = ix86_default_incoming_stack_boundary ;


<s> unsigned int incoming_stack_boundary ; if ( cfun -> machine -> func_type != TYPE_NORMAL ) incoming_stack_boundary = TARGET_64BIT ? <NUM_LIT> : MIN_STACK_BOUNDARY ; else if ( ix86_user_incoming_stack_boundary ) incoming_stack_boundary = ix86_user_incoming_stack_boundary ; else if ( ! sibcall && ix86_force_align_arg_pointer && crtl -> stack_alignment_estimated == <NUM_LIT> ) incoming_stack_boundary = MIN_STACK_BOUNDARY ; else incoming_stack_boundary = ix86_default_incoming_stack_boundary ;


<s> len = get_attr_length ( insn ) ; if ( len <= <NUM_LIT> ) return <NUM_LIT> ; if ( ! JUMP_P ( insn ) ) { enum attr_type type = get_attr_type ( insn ) ; switch ( type ) { case TYPE_MULTI : if ( GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT || asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> ) return <NUM_LIT> ; break ; case TYPE_OTHER : case TYPE_FCMP : break ; default : return len ; } l = get_attr_length_address ( insn ) ; if ( l < <NUM_LIT> && symbolic_reference_mentioned_p ( PATTERN ( insn ) ) ) l = <NUM_LIT> ; } if ( l ) return <NUM_LIT> + l ;


<s> case TYPE_MULTI : if ( GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT || asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> ) return <NUM_LIT> ; break ; case TYPE_OTHER : case TYPE_FCMP : break ; default : return len ; } l = get_attr_length_address ( insn ) ; if ( l < <NUM_LIT> && symbolic_reference_mentioned_p ( PATTERN ( insn ) ) ) l = <NUM_LIT> ; }


<s> static int ix86_mode_after ( int entity , int mode , rtx_insn * insn ) { switch ( entity ) { case X86_DIRFLAG : return mode ;


<s> case AVX_U128 : return ix86_avx_u128_mode_after ( mode , insn ) ; case I387_ROUNDEVEN : case I387_TRUNC : case I387_FLOOR : case I387_CEIL : return mode ; default :


<s> switch ( entity ) { case X86_DIRFLAG : return ix86_dirflag_mode_entry ( ) ; case AVX_U128 :


<s> case I387_FLOOR : case I387_CEIL : return I387_CW_ANY ; default : gcc_unreachable ( ) ;


<s> case AVX_U128 : return ix86_avx_u128_mode_needed ( insn ) ; case I387_ROUNDEVEN : case I387_TRUNC : case I387_FLOOR : case I387_CEIL : return ix86_i387_mode_needed ( entity , insn ) ; default : gcc_unreachable ( ) ; } return <NUM_LIT> ;


<s> return ix86_dirflag_mode_needed ( insn ) ; case AVX_U128 : return ix86_avx_u128_mode_needed ( insn ) ; case I387_ROUNDEVEN : case I387_TRUNC :


<s> static int ix86_mode_priority ( int , int n ) { return n ;


<s> return ( ( TARGET_MS_BITFIELD_LAYOUT && ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( record_type ) ) ) || lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( record_type ) ) ) ;


<s> if ( mode == V16QImode || mode == V32QImode ) { int extra = <NUM_LIT> ; if ( TARGET_XOP && mode == V16QImode ) extra = <NUM_LIT> ; else if ( TARGET_SSSE3 ) extra = <NUM_LIT> ; return ix86_vec_cost ( mode , cost -> mulss * <NUM_LIT> + cost -> sse_op * extra ) ; } else if ( mode == V2DImode || mode == V4DImode ) {

if ( TARGET_XOP && mode == V2DImode ) return ix86_vec_cost ( mode , cost -> mulss * <NUM_LIT> + cost -> sse_op * <NUM_LIT> ) ;


<s> if ( must_pass_in_stack_var_size_or_pad ( arg ) ) return true ; return ( ! TARGET_64BIT && arg . mode == TImode && arg . type && TREE_CODE ( arg . type ) != VECTOR_TYPE ) ;


<s> static bool ix86_noce_conversion_profitable_p ( rtx_insn * seq , struct noce_if_info * if_info ) { if ( TARGET_ONE_IF_CONV_INSN && if_info -> speed_p ) { int cmov_cnt = <NUM_LIT> ; for ( rtx_insn * insn = seq ; insn ; insn = NEXT_INSN ( insn ) ) { rtx set = single_set ( insn ) ; if ( ! set ) continue ; if ( GET_CODE ( SET_SRC ( set ) ) != IF_THEN_ELSE ) continue ; rtx src = SET_SRC ( set ) ; machine_mode mode = GET_MODE ( src ) ; if ( GET_MODE_CLASS ( mode ) != MODE_INT && GET_MODE_CLASS ( mode ) != MODE_FLOAT ) continue ; if ( ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) || ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) ) continue ; if ( ++ cmov_cnt > <NUM_LIT> ) return false ; } } return default_noce_conversion_profitable_p ( seq , if_info ) ;


<s> rtx set = single_set ( insn ) ; if ( ! set ) continue ; if ( GET_CODE ( SET_SRC ( set ) ) != IF_THEN_ELSE ) continue ; rtx src = SET_SRC ( set ) ; machine_mode mode = GET_MODE ( src ) ; if ( GET_MODE_CLASS ( mode ) != MODE_INT && GET_MODE_CLASS ( mode ) != MODE_FLOAT ) continue ; if ( ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) || ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) ) continue ;

if ( ++ cmov_cnt > <NUM_LIT> ) return false ;


<s> if ( flag_pic || ix86_cmodel == CM_LARGE || ! ( TARGET_64BIT || HAVE_AS_IX86_GOT32X ) || TARGET_MACHO || TARGET_SEH || TARGET_PECOFF || SYMBOL_REF_LOCAL_P ( call_op ) ) return false ; tree symbol_decl = SYMBOL_REF_DECL ( call_op ) ; if ( ! flag_plt || ( symbol_decl != NULL_TREE && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( symbol_decl ) ) ) ) return true ;


<s> if ( flag_pic || ix86_cmodel == CM_LARGE || ! ( TARGET_64BIT || HAVE_AS_IX86_GOT32X ) || TARGET_MACHO || TARGET_SEH || TARGET_PECOFF || SYMBOL_REF_LOCAL_P ( call_op ) ) return false ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) nregs ++ ;


<s> int regno ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) nregs ++ ;


<s> int nregs = <NUM_LIT> ; int regno ; if ( ! TARGET_64BIT_MS_ABI ) return <NUM_LIT> ;

for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) nregs ++ ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) nregs ++ ; return nregs ;


<s> basic_block bb = BLOCK_FOR_INSN ( insn ) ; df_ref use ; bitmap live ; while ( insn ) { if ( NONDEBUG_INSN_P ( insn ) ) { FOR_EACH_INSN_USE ( use , insn ) if ( DF_REF_REG_USE_P ( use ) && DF_REF_REGNO ( use ) == FLAGS_REG ) return false ; if ( insn_defines_reg ( FLAGS_REG , INVALID_REGNUM , insn ) ) return true ; } if ( insn == BB_END ( bb ) ) break ; insn = NEXT_INSN ( insn ) ;


<s> if ( insn == BB_END ( bb ) ) break ; insn = NEXT_INSN ( insn ) ; } live = df_get_live_out ( bb ) ; return ! REGNO_REG_SET_P ( live , FLAGS_REG ) ;


<s> case floor_optab : case ceil_optab : case btrunc_optab : if ( ( ( SSE_FLOAT_MODE_P ( mode1 ) && TARGET_SSE_MATH && TARGET_SSE4_1 ) || mode1 == HFmode ) && ! flag_trapping_math ) return true ; return opt_type == OPTIMIZE_FOR_SPEED ; case rsqrt_optab : return opt_type == OPTIMIZE_FOR_SPEED && use_rsqrt_p ( mode1 ) ; default : return true ;


<s> case exp2_optab : case expm1_optab : case ldexp_optab : case scalb_optab : case round_optab : return opt_type == OPTIMIZE_FOR_SPEED ; case rint_optab : if ( SSE_FLOAT_MODE_P ( mode1 ) && TARGET_SSE_MATH && ! flag_trapping_math && ! TARGET_SSE4_1 && mode1 != HFmode ) return opt_type == OPTIMIZE_FOR_SPEED ; return true ; case floor_optab : case ceil_optab : case btrunc_optab : if ( ( ( SSE_FLOAT_MODE_P ( mode1 ) && TARGET_SSE_MATH && TARGET_SSE4_1 ) || mode1 == HFmode ) && ! flag_trapping_math ) return true ; return opt_type == OPTIMIZE_FOR_SPEED ; case rsqrt_optab : return opt_type == OPTIMIZE_FOR_SPEED && use_rsqrt_p ( mode1 ) ; default : return true ;


<s> putc ( '\n' , file ) ; } else if ( HAVE_AS_GOTOFF_IN_DATA ) fprintf ( file , ASM_LONG <STR_LIT> , LPREFIX , value ) ; else asm_fprintf ( file , ASM_LONG <STR_LIT> , GOT_SYMBOL_NAME , LPREFIX , value ) ;


<s> const char * directive = ASM_LONG ; if ( TARGET_LP64 ) directive = ASM_QUAD ; gcc_assert ( ! TARGET_64BIT ) ; fprintf ( file , <STR_LIT> , directive , LPREFIX , value ) ;


<s> fprintf ( file , <STR_LIT> , directive , LPREFIX , value ) ;


<s> else xasm = <STR_LIT> ; } else if ( TARGET_SEH ) xasm = <STR_LIT> ; else { if ( output_indirect_p ) xasm = <STR_LIT> ; else xasm = <STR_LIT> ; } if ( output_indirect_p && ! direct_p ) ix86_output_indirect_branch ( call_op , xasm , true ) ; else { output_asm_insn ( xasm , & call_op ) ; if ( ! direct_p && ( ix86_harden_sls & harden_sls_indirect_jmp ) ) return <STR_LIT> ; } return <STR_LIT> ; } if ( TARGET_SEH ) { rtx_insn * i ; for ( i = NEXT_INSN ( insn ) ; i ; i = NEXT_INSN ( i ) ) { if ( JUMP_P ( i ) && CROSSING_JUMP_P ( i ) ) { seh_nop_p = true ; break ; } if ( INSN_P ( i ) ) break ; if ( NOTE_P ( i ) && NOTE_KIND ( i ) == NOTE_INSN_EPILOGUE_BEG && ! flag_non_call_exceptions && ! can_throw_internal ( insn ) ) { seh_nop_p = true ; break ; } } if ( i == NULL ) seh_nop_p = true ; } if ( direct_p ) { if ( ix86_nopic_noplt_attribute_p ( call_op ) ) { direct_p = false ; if ( TARGET_64BIT ) { if ( output_indirect_p ) xasm = <STR_LIT> ; else xasm = <STR_LIT> ; }


<s> putc ( '\n' , asm_out_file ) ; } else output_indirect_thunk ( INVALID_REGNUM ) ; return <STR_LIT> ; } output_asm_insn ( long_p ? <STR_LIT> : <STR_LIT> , nullptr ) ; return ( ix86_harden_sls & harden_sls_return ) ? <STR_LIT> : <STR_LIT> ;


<s> rtx addr = XEXP ( call_op , <NUM_LIT> ) ; if ( ix86_decompose_address ( addr , & parts ) && parts . base == stack_pointer_rtx ) { if ( parts . index ) { addr = gen_rtx_MULT ( Pmode , parts . index , GEN_INT ( parts . scale ) ) ; addr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , addr ) ; } else addr = stack_pointer_rtx ; rtx disp ; if ( parts . disp != NULL_RTX ) disp = plus_constant ( Pmode , parts . disp , UNITS_PER_WORD ) ; else disp = GEN_INT ( UNITS_PER_WORD ) ; addr = gen_rtx_PLUS ( Pmode , addr , disp ) ; call_op = gen_rtx_MEM ( GET_MODE ( call_op ) , addr ) ; } } output_asm_insn ( push_buf , & call_op ) ; ix86_output_jmp_thunk_or_indirect ( thunk_name , regno ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel2 ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel1 ) ;


<s> else { if ( thunk_name != NULL ) { if ( REX_INT_REGNO_P ( regno ) && ix86_indirect_branch_cs_prefix ) fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name ( asm_out_file , thunk_name ) ; putc ( '\n' , asm_out_file ) ; return ; } char indirectlabel1 [ <NUM_LIT> ] ; char indirectlabel2 [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel1 , INDIRECT_LABEL , indirectlabelno ++ ) ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel2 , INDIRECT_LABEL , indirectlabelno ++ ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel2 ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel1 ) ; ix86_output_jmp_thunk_or_indirect ( thunk_name , regno ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel2 ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel1 ) ; fputc ( '\n' , asm_out_file ) ;


<s> char indirectlabel1 [ <NUM_LIT> ] ; char indirectlabel2 [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel1 , INDIRECT_LABEL , indirectlabelno ++ ) ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel2 , INDIRECT_LABEL , indirectlabelno ++ ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel2 ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel1 ) ; ix86_output_jmp_thunk_or_indirect ( thunk_name , regno ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel2 ) ;


<s> bool need_thunk = ( cfun -> machine -> function_return_type == indirect_branch_thunk ) ; indirect_thunk_name ( thunk_name , regno , need_prefix , true ) ; if ( need_thunk ) { indirect_return_via_cx = true ; SET_HARD_REG_BIT ( indirect_thunks_used , CX_REG ) ; } fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name ( asm_out_file , thunk_name ) ; putc ( '\n' , asm_out_file ) ; } else output_indirect_thunk ( regno ) ; } else { output_asm_insn ( <STR_LIT> , & ret_op ) ; if ( ix86_harden_sls & harden_sls_indirect_jmp ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> } else output_asm_insn ( <STR_LIT> , & call_op ) ; return ( ix86_harden_sls & harden_sls_indirect_jmp ) ? <STR_LIT> : <STR_LIT> ;


<s> if ( ix86_red_zone_used ) gcc_unreachable ( ) ; ix86_output_indirect_branch ( call_op , <STR_LIT> , true ) ; }

else output_asm_insn ( <STR_LIT> , & call_op ) ;


<s> assemble_name ( asm_out_file , thunk_name ) ; putc ( '\n' , asm_out_file ) ; if ( ( ix86_harden_sls & harden_sls_indirect_jmp ) ) fputs ( <STR_LIT> , asm_out_file ) ; }


<s> enum attr_mode insn_mode = get_attr_mode ( insn ) ; switch ( insn_mode ) { case MODE_XI : case MODE_V8DF : case MODE_V16SF : return ix86_get_ssemov ( operands , <NUM_LIT> , insn_mode , mode ) ; case MODE_OI : case MODE_V4DF : case MODE_V8SF : return ix86_get_ssemov ( operands , <NUM_LIT> , insn_mode , mode ) ; case MODE_TI : case MODE_V2DF : case MODE_V4SF : return ix86_get_ssemov ( operands , <NUM_LIT> , insn_mode , mode ) ; case MODE_DI : if ( GENERAL_REG_P ( operands [ <NUM_LIT> ] ) ) { if ( HAVE_AS_IX86_INTERUNIT_MOVQ ) return <STR_LIT> ; else return <STR_LIT> ; } else if ( GENERAL_REG_P ( operands [ <NUM_LIT> ] ) ) { if ( HAVE_AS_IX86_INTERUNIT_MOVQ ) return <STR_LIT> ; else return <STR_LIT> ; } else return <STR_LIT> ; case MODE_SI :

if ( GENERAL_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ;


<s> edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( EDGE_FREQUENCY ( e ) && e -> src -> index >= <NUM_LIT> && ! ( e -> flags & EDGE_FALLTHRU ) ) { replace = true ; break ; } } if ( ! replace ) { prev = prev_active_insn ( ret ) ; if ( prev && ( ( JUMP_P ( prev ) && any_condjump_p ( prev ) ) || CALL_P ( prev ) ) ) replace = true ; if ( ! prev && ! optimize_function_for_size_p ( cfun ) ) replace = true ; } if ( replace ) { emit_jump_insn_before ( gen_simple_return_internal_long ( ) , ret ) ; delete_insn ( ret ) ; } }


<s> if ( JUMP_P ( ret ) && ANY_RETURN_P ( PATTERN ( ret ) ) ) { int insn_count = ix86_count_insn ( e -> src ) ; if ( insn_count < <NUM_LIT> ) { rtx_insn * insn = ret ; while ( insn && ( ! NOTE_P ( insn ) || NOTE_KIND ( insn ) != NOTE_INSN_EPILOGUE_BEG ) ) insn = PREV_INSN ( insn ) ; if ( ! insn ) insn = ret ; insn_count = <NUM_LIT> * ( <NUM_LIT> - insn_count ) ;

emit_insn_before ( gen_nops ( GEN_INT ( insn_count ) ) , insn ) ;


<s> if ( RECORD_OR_UNION_TYPE_P ( type ) ) { msize = int_size_in_bytes ( type ) ; } } return msize != <NUM_LIT> && msize != <NUM_LIT> && msize != <NUM_LIT> && msize != <NUM_LIT> ; } else if ( arg . type && int_size_in_bytes ( arg . type ) == - <NUM_LIT> ) return true ; }


<s> if ( GET_CODE ( x ) == VALUE && CSELIB_VAL_PTR ( x ) ) return ( pic_offset_table_rtx && rtx_equal_for_cselib_p ( x , pic_offset_table_rtx ) ) ; else if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_SET_GOT ) return true ; else if ( ! REG_P ( x ) ) return false ; else if ( pic_offset_table_rtx ) { if ( REGNO ( x ) == REGNO ( pic_offset_table_rtx ) ) return true ; if ( HARD_REGISTER_P ( x ) && ! HARD_REGISTER_P ( pic_offset_table_rtx ) && ORIGINAL_REGNO ( x ) == REGNO ( pic_offset_table_rtx ) ) return true ;


<s> else if ( ! REG_P ( x ) ) return false ; else if ( pic_offset_table_rtx ) { if ( REGNO ( x ) == REGNO ( pic_offset_table_rtx ) ) return true ;

if ( HARD_REGISTER_P ( x ) && ! HARD_REGISTER_P ( pic_offset_table_rtx ) && ORIGINAL_REGNO ( x ) == REGNO ( pic_offset_table_rtx ) ) return true ;


<s> machine_mode mode = GET_MODE ( x ) ; if ( SSE_FLOAT_MODE_P ( mode ) && TARGET_SSE_MATH ) return MAYBE_SSE_CLASS_P ( regclass ) ? ALL_SSE_REGS : NO_REGS ; if ( IS_STACK_MODE ( mode ) ) return FLOAT_CLASS_P ( regclass ) ? regclass : NO_REGS ; return regclass ;


<s> if ( regclass == NO_REGS ) return NO_REGS ; if ( x == CONST0_RTX ( mode ) ) return regclass ; if ( CONSTANT_P ( x ) && ( MAYBE_MMX_CLASS_P ( regclass ) || MAYBE_SSE_CLASS_P ( regclass ) || MAYBE_MASK_CLASS_P ( regclass ) ) ) return NO_REGS ; if ( CONST_DOUBLE_P ( x ) ) { if ( INTEGER_CLASS_P ( regclass ) ) return regclass ; if ( IS_STACK_MODE ( mode ) && standard_80387_constant_p ( x ) > <NUM_LIT> ) { if ( FLOAT_CLASS_P ( regclass ) ) return FLOAT_REGS ; }


<s> else return V4SImode ; case E_DImode : if ( TARGET_AVX512F && ! TARGET_PREFER_AVX256 ) return V8DImode ; else if ( TARGET_AVX && ! TARGET_PREFER_AVX128 ) return V4DImode ; else return V2DImode ; case E_HFmode : if ( TARGET_AVX512FP16 ) { if ( TARGET_AVX512VL ) { if ( TARGET_PREFER_AVX128 ) return V8HFmode ; else if ( TARGET_PREFER_AVX256 ) return V16HFmode ; } return V32HFmode ; } return word_mode ;


<s> return ( can_create_pseudo_p ( ) && ! ( cfun -> curr_properties & PROP_rtl_split_insns ) ) ;


<s> static void ix86_print_operand_address ( FILE * file , machine_mode , rtx addr ) { if ( this_is_asm_operands && ! address_operand ( addr , VOIDmode ) ) output_operand_lossage ( <STR_LIT> ) ;

else ix86_print_operand_address_as ( file , addr , ADDR_SPACE_GENERIC , false ) ;


<s> static bool ix86_print_operand_punct_valid_p ( unsigned char code ) {


<s> static bool ix86_profile_before_prologue ( void ) {


<s> static machine_mode ix86_promote_function_mode ( const_tree type , machine_mode mode , int * punsignedp , const_tree fntype , int for_return ) { if ( cfun -> machine -> func_type == TYPE_NORMAL && type != NULL_TREE && POINTER_TYPE_P ( type ) ) { * punsignedp = POINTERS_EXTEND_UNSIGNED ; return word_mode ; } return default_promote_function_mode ( type , mode , punsignedp , fntype , for_return ) ;


<s> return ( ( ! TARGET_SSE2 || npush < ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ) && TARGET_PUSH_ARGS && ! ACCUMULATE_OUTGOING_ARGS ) ;


<s> poly_int64 ix86_push_rounding ( poly_int64 bytes ) { return ROUND_UP ( bytes , UNITS_PER_WORD ) ;


<s> if ( width == <NUM_LIT> ) return <NUM_LIT> ; if ( ( ix86_tune == PROCESSOR_ZNVER1 || ix86_tune == PROCESSOR_ZNVER2 || ix86_tune == PROCESSOR_ZNVER3 ) && INTEGRAL_MODE_P ( mode ) && op != PLUS && op != MINUS ) return <NUM_LIT> ; if ( TARGET_AVX256_SPLIT_REGS && GET_MODE_BITSIZE ( mode ) > <NUM_LIT> ) div = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> ; else if ( TARGET_SSE_SPLIT_REGS && GET_MODE_BITSIZE ( mode ) > <NUM_LIT> ) div = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> ;

width = ( width + div - <NUM_LIT> ) / div ;


<s> cost += inline_memory_move_cost ( mode , class1 , <NUM_LIT> ) ; cost += inline_memory_move_cost ( mode , class2 , <NUM_LIT> ) ; if ( GET_MODE_BITSIZE ( mode ) > BITS_PER_WORD && TARGET_MEMORY_MISMATCH_STALL && targetm . class_max_nregs ( class1 , mode ) > targetm . class_max_nregs ( class2 , mode ) ) cost += <NUM_LIT> ; if ( ( MMX_CLASS_P ( class1 ) && MAYBE_FLOAT_CLASS_P ( class2 ) ) || ( MMX_CLASS_P ( class2 ) && MAYBE_FLOAT_CLASS_P ( class1 ) ) ) cost += <NUM_LIT> ; return cost ; } if ( MMX_CLASS_P ( class1 ) != MMX_CLASS_P ( class2 ) ) gcc_unreachable ( ) ; if ( SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class2 ) ) return ( SSE_CLASS_P ( class1 ) ? ix86_cost -> hard_register . sse_to_integer : ix86_cost -> hard_register . integer_to_sse ) ; if ( MASK_CLASS_P ( class1 ) != MASK_CLASS_P ( class2 ) ) { return ( MASK_CLASS_P ( class1 ) ? ix86_cost -> hard_register . mask_to_integer : ix86_cost -> hard_register . integer_to_mask ) ; } if ( MASK_CLASS_P ( class1 ) && MASK_CLASS_P ( class2 ) ) return ix86_cost -> hard_register . mask_move ; if ( MAYBE_FLOAT_CLASS_P ( class1 ) ) return ix86_cost -> hard_register . fp_move ; if ( MAYBE_SSE_CLASS_P ( class1 ) ) { if ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> ) return ix86_cost -> hard_register . xmm_move ; if ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> ) return ix86_cost -> hard_register . ymm_move ; return ix86_cost -> hard_register . zmm_move ; } if ( MAYBE_MMX_CLASS_P ( class1 ) ) return ix86_cost -> hard_register . mmx_move ; return <NUM_LIT> ;


<s> if ( hard_regno == BP_REG ) return <NUM_LIT> ; if ( REX_INT_REGNO_P ( hard_regno ) ) return <NUM_LIT> ;

if ( REX_SSE_REGNO_P ( hard_regno ) ) return <NUM_LIT> ;


<s> if ( fndecl != NULL_TREE && TREE_CODE ( fndecl ) == FUNCTION_DECL ) call_abi = ix86_function_abi ( fndecl ) ; else call_abi = ix86_function_type_abi ( fndecl ) ;


<s> static int ix86_reloc_rw_mask ( void ) {


<s> if ( optimize && optimize_function_for_speed_p ( cfun ) ) { if ( TARGET_SSE2 ) ix86_split_stlf_stall_load ( ) ; if ( TARGET_PAD_SHORT_FUNCTION ) ix86_pad_short_function ( ) ; else if ( TARGET_PAD_RETURNS ) ix86_pad_returns ( ) ;

if ( TARGET_FOUR_JUMP_LIMIT ) ix86_avoid_jump_mispredicts ( ) ;


<s> compute_bb_for_insn ( ) ; if ( TARGET_SEH && current_function_has_exception_handlers ( ) ) ix86_seh_fixup_eh_fallthru ( ) ; if ( optimize && optimize_function_for_speed_p ( cfun ) ) { if ( TARGET_SSE2 ) ix86_split_stlf_stall_load ( ) ; if ( TARGET_PAD_SHORT_FUNCTION ) ix86_pad_short_function ( ) ;

else if ( TARGET_PAD_RETURNS ) ix86_pad_returns ( ) ;


<s> return examine_argument ( mode , type , <NUM_LIT> , & needed_intregs , & needed_sseregs ) ; } } else { size = int_size_in_bytes ( type ) ; if ( TARGET_IAMCU ) return VECTOR_MODE_P ( mode ) || size < <NUM_LIT> || size > <NUM_LIT> ; if ( mode == BLKmode ) return true ; if ( MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P ( type ) && size <= <NUM_LIT> ) return false ; if ( VECTOR_MODE_P ( mode ) || mode == TImode ) { if ( size < <NUM_LIT> ) return false ; if ( size == <NUM_LIT> ) return TARGET_VECT8_RETURNS || ! TARGET_MMX ; if ( size == <NUM_LIT> ) return ! TARGET_SSE ;

if ( size == <NUM_LIT> ) return ! TARGET_AVX ;


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


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


<s> return ( mode == CCFPmode ? reverse_condition_maybe_unordered ( code ) : reverse_condition ( code ) ) ;


<s> enum rtx_code ix86_reverse_condition ( enum rtx_code code , machine_mode mode ) {

return ( mode == CCFPmode ? reverse_condition_maybe_unordered ( code ) : reverse_condition ( code ) ) ;


<s> pattern = copy_insn ( pattern ) ; ix86_rewrite_tls_address_1 ( & pattern ) ;


<s> FOR_EACH_SUBRTX_PTR ( iter , array , loc , ALL ) { rtx * loc = * iter ; if ( MEM_P ( * loc ) ) { rtx addr = XEXP ( * loc , <NUM_LIT> ) ; rtx * x = & addr ; while ( GET_CODE ( * x ) == PLUS ) { int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { rtx u = XEXP ( * x , i ) ; if ( GET_CODE ( u ) == ZERO_EXTEND ) u = XEXP ( u , <NUM_LIT> ) ; if ( GET_CODE ( u ) == UNSPEC && XINT ( u , <NUM_LIT> ) == UNSPEC_TP ) { addr_space_t as = DEFAULT_TLS_SEG_REG ; * x = XEXP ( * x , <NUM_LIT> - i ) ;

* loc = replace_equiv_address_nv ( * loc , addr , true ) ;


<s> rtx u = XEXP ( * x , i ) ; if ( GET_CODE ( u ) == ZERO_EXTEND ) u = XEXP ( u , <NUM_LIT> ) ; if ( GET_CODE ( u ) == UNSPEC && XINT ( u , <NUM_LIT> ) == UNSPEC_TP ) { addr_space_t as = DEFAULT_TLS_SEG_REG ; * x = XEXP ( * x , <NUM_LIT> - i ) ; * loc = replace_equiv_address_nv ( * loc , addr , true ) ; set_mem_addr_space ( * loc , as ) ; return ; } }


<s> if ( GET_CODE ( symbol ) == LABEL_REF || ( GET_CODE ( symbol ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( symbol ) == <NUM_LIT> ) || ( GET_CODE ( symbol ) == UNSPEC && ( XINT ( symbol , <NUM_LIT> ) == UNSPEC_GOTPCREL || XINT ( symbol , <NUM_LIT> ) == UNSPEC_PCREL || XINT ( symbol , <NUM_LIT> ) == UNSPEC_GOTNTPOFF ) ) ) return true ; } }


<s> ix86_test_loading_call_insn ( ) ; ix86_test_loading_full_dump ( ) ; ix86_test_loading_unspec ( ) ;


<s> if ( regno == REAL_PIC_OFFSET_TABLE_REGNUM && pic_offset_table_rtx ) { if ( ix86_use_pseudo_pic_reg ( ) ) { if ( ! TARGET_64BIT && flag_pic && crtl -> profile ) return true ; } else if ( df_regs_ever_live_p ( REAL_PIC_OFFSET_TABLE_REGNUM ) || crtl -> profile || crtl -> calls_eh_return || crtl -> uses_const_pool || cfun -> has_nonlocal_label ) return ix86_select_alt_pic_regnum ( ) == INVALID_REGNUM ; } if ( crtl -> calls_eh_return && maybe_eh_return ) { unsigned i ; for ( i = <NUM_LIT> ; ; i ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( ignore_outlined && cfun -> machine -> call_ms2sysv ) { unsigned count = cfun -> machine -> call_ms2sysv_extra_regs + xlogue_layout :: MIN_REGS ; if ( xlogue_layout :: is_stub_managed_reg ( regno , count ) ) return false ; } if ( crtl -> drap_reg && regno == REGNO ( crtl -> drap_reg ) && ! cfun -> machine -> no_drap_save_restore ) return true ; return ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) ) ;


<s> if ( cfun -> machine -> no_caller_saved_registers ) { rtx reg = crtl -> return_rtx ; if ( reg ) { unsigned int i = REGNO ( reg ) ; unsigned int nregs = REG_NREGS ( reg ) ; while ( nregs -- > <NUM_LIT> ) if ( ( i + nregs ) == regno ) return false ; } return ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ! STACK_REGNO_P ( regno ) && ! MMX_REGNO_P ( regno ) && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) ) ; } if ( regno == REAL_PIC_OFFSET_TABLE_REGNUM && pic_offset_table_rtx ) { if ( ix86_use_pseudo_pic_reg ( ) ) { if ( ! TARGET_64BIT && flag_pic && crtl -> profile ) return true ; } else if ( df_regs_ever_live_p ( REAL_PIC_OFFSET_TABLE_REGNUM ) || crtl -> profile || crtl -> calls_eh_return || crtl -> uses_const_pool || cfun -> has_nonlocal_label ) return ix86_select_alt_pic_regnum ( ) == INVALID_REGNUM ; } if ( crtl -> calls_eh_return && maybe_eh_return ) { unsigned i ; for ( i = <NUM_LIT> ; ; i ++ ) {

unsigned test = EH_RETURN_DATA_REGNO ( i ) ;


<s> else if ( mode == HFmode && TARGET_SSE2 ) return true ; else return default_scalar_mode_supported_p ( mode ) ;


<s> else if ( mode == HFmode && TARGET_SSE2 ) return true ;

else return default_scalar_mode_supported_p ( mode ) ;


<s> targetm . sched . first_cycle_multipass_init = NULL ; targetm . sched . first_cycle_multipass_begin = NULL ; targetm . sched . first_cycle_multipass_issue = NULL ; targetm . sched . first_cycle_multipass_backtrack = NULL ; targetm . sched . first_cycle_multipass_end = NULL ; targetm . sched . first_cycle_multipass_fini = NULL ;


<s> static machine_mode ix86_secondary_memory_needed_mode ( machine_mode mode ) { if ( GET_MODE_BITSIZE ( mode ) < <NUM_LIT> && INTEGRAL_MODE_P ( mode ) ) return mode_for_size ( <NUM_LIT> , GET_MODE_CLASS ( mode ) , <NUM_LIT> ) . require ( ) ; return mode ;


<s> int regno = true_regnum ( x ) ; if ( regno == - <NUM_LIT> ) return Q_REGS ; return NO_REGS ; } if ( ( mode == HFmode || mode == HImode || mode == V2QImode ) && ! TARGET_SSE4_1 && SSE_CLASS_P ( rclass ) && ! in_p && MEM_P ( x ) ) { sri -> extra_cost = <NUM_LIT> ;


<s> insn = prev_active_insn ( insn ) ; if ( insn == NULL || ! can_throw_internal ( insn ) ) continue ;

for ( next = NEXT_INSN ( insn ) ; next != NULL ; next = NEXT_INSN ( next ) ) if ( NOTE_P ( next ) && NOTE_KIND ( next ) == NOTE_INSN_VAR_LOCATION ) insn = next ;


<s> if ( crtl -> drap_reg ) drap = REGNO ( crtl -> drap_reg ) ; else drap = - <NUM_LIT> ; for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( i != drap && ! df_regs_ever_live_p ( i ) ) return i ; }


<s> void ix86_setup_frame_addresses ( void ) { cfun -> machine -> accesses_prev_frame = <NUM_LIT> ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; CUMULATIVE_ARGS next_cum ; tree fntype ; gcc_assert ( ! no_rtl ) ; if ( ! TARGET_64BIT ) return ;

fntype = TREE_TYPE ( current_function_decl ) ;


<s> switch ( GET_MODE_CLASS ( mode ) ) { default : break ; case MODE_CC : units = GET_MODE_SIZE ( CCmode ) ; break ; case MODE_FLOAT : if ( ( TARGET_SSE && mode == TFmode ) || ( TARGET_80387 && mode == XFmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DFmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SFmode ) ) units = GET_MODE_SIZE ( mode ) ;


<s> break ; case MODE_CC : units = GET_MODE_SIZE ( CCmode ) ; break ; case MODE_FLOAT : if ( ( TARGET_SSE && mode == TFmode ) || ( TARGET_80387 && mode == XFmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DFmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SFmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_COMPLEX_FLOAT : if ( ( TARGET_SSE && mode == TCmode ) || ( TARGET_80387 && mode == XCmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DCmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SCmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_VECTOR_INT : case MODE_VECTOR_FLOAT : if ( ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) || ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) || ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) || ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) || ( ( TARGET_MMX || TARGET_MMX_WITH_SSE ) && VALID_MMX_REG_MODE ( mode ) ) ) units = GET_MODE_SIZE ( mode ) ;


<s> if ( constant_op1 ) { if ( skip_op1 ) * skip_op1 = true ; return ix86_vec_cost ( mode , cost -> sse_op + ( speed ? <NUM_LIT> : COSTS_N_BYTES ( GET_MODE_UNIT_SIZE ( mode ) ) ) ) ; } count = <NUM_LIT> ; } else if ( TARGET_SSSE3 ) count = <NUM_LIT> ; return ix86_vec_cost ( mode , cost -> sse_op * count ) ; } else if ( code == ASHIFTRT && ( mode == V2DImode || mode == V4DImode ) && ! TARGET_XOP && ! TARGET_AVX512VL ) { int count = <NUM_LIT> ; if ( constant_op1 && op1_val == <NUM_LIT> && TARGET_SSE4_2 ) count = <NUM_LIT> ; else if ( constant_op1 ) count = <NUM_LIT> ; return ix86_vec_cost ( mode , cost -> sse_op * count ) ; } else return ix86_vec_cost ( mode , cost -> sse_op ) ; } if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) { if ( constant_op1 ) { if ( op1_val > <NUM_LIT> ) return cost -> shift_const + COSTS_N_INSNS ( <NUM_LIT> ) ; else return cost -> shift_const * <NUM_LIT> ; } else { if ( and_in_op1 ) return cost -> shift_var * <NUM_LIT> ; else return cost -> shift_var * <NUM_LIT> + COSTS_N_INSNS ( <NUM_LIT> ) ; } } else { if ( constant_op1 ) return cost -> shift_const ; else if ( shift_and_truncate ) { if ( skip_op0 ) * skip_op0 = * skip_op1 = true ;


<s> int count = <NUM_LIT> ; if ( constant_op1 && op1_val == <NUM_LIT> && TARGET_SSE4_2 ) count = <NUM_LIT> ; else if ( constant_op1 ) count = <NUM_LIT> ; return ix86_vec_cost ( mode , cost -> sse_op * count ) ; } else return ix86_vec_cost ( mode , cost -> sse_op ) ; } if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) { if ( constant_op1 ) { if ( op1_val > <NUM_LIT> ) return cost -> shift_const + COSTS_N_INSNS ( <NUM_LIT> ) ; else return cost -> shift_const * <NUM_LIT> ; } else { if ( and_in_op1 ) return cost -> shift_var * <NUM_LIT> ; else return cost -> shift_var * <NUM_LIT> + COSTS_N_INSNS ( <NUM_LIT> ) ; } } else { if ( constant_op1 ) return cost -> shift_const ; else if ( shift_and_truncate ) { if ( skip_op0 ) * skip_op0 = * skip_op1 = true ; return cost -> shift_var ; } else return cost -> shift_var ;


<s> warning_at ( DECL_SOURCE_LOCATION ( node -> decl ) , <NUM_LIT> , <STR_LIT> , ret_type ) ; return <NUM_LIT> ; } tree t ; int i ; tree type_arg_types = TYPE_ARG_TYPES ( TREE_TYPE ( node -> decl ) ) ; bool decl_arg_p = ( node -> definition || type_arg_types == NULL_TREE ) ; for ( t = ( decl_arg_p ? DECL_ARGUMENTS ( node -> decl ) : type_arg_types ) , i = <NUM_LIT> ; t && t != void_list_node ; t = TREE_CHAIN ( t ) , i ++ ) { tree arg_type = decl_arg_p ? TREE_TYPE ( t ) : TREE_VALUE ( t ) ; switch ( TYPE_MODE ( arg_type ) ) { case E_QImode : case E_HImode : case E_SImode : case E_DImode : case E_SFmode : case E_DFmode : if ( ! AGGREGATE_TYPE_P ( arg_type ) ) break ; default : if ( clonei -> args [ i ] . arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM ) break ; warning_at ( DECL_SOURCE_LOCATION ( node -> decl ) , <NUM_LIT> , <STR_LIT> , arg_type ) ; return <NUM_LIT> ; } } if ( ! TREE_PUBLIC ( node -> decl ) ) {

if ( TARGET_AVX512F ) clonei -> vecsize_mangle = 'e' ;


<s> if ( ! TARGET_AVX ) return - <NUM_LIT> ; return TARGET_AVX512F ? <NUM_LIT> : TARGET_AVX2 ? <NUM_LIT> : <NUM_LIT> ; case 'd' : if ( ! TARGET_AVX2 ) return - <NUM_LIT> ; return TARGET_AVX512F ? <NUM_LIT> : <NUM_LIT> ; case 'e' : if ( ! TARGET_AVX512F ) return - <NUM_LIT> ;


<s> static reg_class_t ix86_spill_class ( reg_class_t rclass , machine_mode mode ) {

if ( <NUM_LIT> && TARGET_GENERAL_REGS_SSE_SPILL && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_TO_VEC && TARGET_INTER_UNIT_MOVES_FROM_VEC && ( mode == SImode || ( TARGET_64BIT && mode == DImode ) ) && INTEGER_CLASS_P ( rclass ) ) return ALL_SSE_REGS ;


<s> addr_space_t as = DEFAULT_TLS_SEG_REG ; rtx r ; gcc_assert ( flag_split_stack ) ; offset = TARGET_THREAD_SPLIT_STACK_OFFSET ; gcc_unreachable ( ) ; r = GEN_INT ( offset ) ; r = gen_const_mem ( Pmode , r ) ; set_mem_addr_space ( r , as ) ; return r ;


<s> int offset ; addr_space_t as = DEFAULT_TLS_SEG_REG ; rtx r ; gcc_assert ( flag_split_stack ) ; offset = TARGET_THREAD_SPLIT_STACK_OFFSET ; gcc_unreachable ( ) ; r = GEN_INT ( offset ) ; r = gen_const_mem ( Pmode , r ) ; set_mem_addr_space ( r , as ) ;


<s> for ( insn = start ; insn ; insn = NEXT_INSN ( insn ) ) { if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; window ++ ; if ( window > ( unsigned ) x86_stlf_window_ninsns ) return ; if ( any_uncondjump_p ( insn ) || ANY_RETURN_P ( PATTERN ( insn ) ) || CALL_P ( insn ) ) return ; rtx set = single_set ( insn ) ; if ( ! set ) continue ; rtx src = SET_SRC ( set ) ; if ( ! MEM_P ( src ) || GET_MODE ( src ) != E_V2DFmode || ! MEM_EXPR ( src ) || TREE_CODE ( get_base_address ( MEM_EXPR ( src ) ) ) != PARM_DECL ) continue ; rtx zero = CONST0_RTX ( V2DFmode ) ; rtx dest = SET_DEST ( set ) ; rtx m = adjust_address ( src , DFmode , <NUM_LIT> ) ; rtx loadlpd = gen_sse2_loadlpd ( dest , zero , m ) ; emit_insn_before ( loadlpd , insn ) ; m = adjust_address ( src , DFmode , <NUM_LIT> ) ; rtx loadhpd = gen_sse2_loadhpd ( dest , dest , m ) ; if ( dump_file && ( dump_flags & TDF_DETAILS ) ) { fputs ( <STR_LIT> , dump_file ) ; print_rtl_single ( dump_file , insn ) ; fputs ( <STR_LIT> , dump_file ) ; print_rtl_single ( dump_file , loadlpd ) ; print_rtl_single ( dump_file , loadhpd ) ; }


<s> if ( TARGET_SSP_TLS_GUARD ) { tree type_node = lang_hooks . types . type_for_mode ( ptr_mode , <NUM_LIT> ) ; int qual = ENCODE_QUAL_ADDR_SPACE ( ix86_stack_protector_guard_reg ) ; tree type = build_qualified_type ( type_node , qual ) ; tree t ; if ( OPTION_SET_P ( ix86_stack_protector_guard_symbol_str ) ) { t = ix86_tls_stack_chk_guard_decl ; if ( t == NULL ) { rtx x ;

t = build_decl ( UNKNOWN_LOCATION , VAR_DECL , get_identifier ( ix86_stack_protector_guard_symbol_str ) , type ) ;


<s> if ( TARGET_SSP_TLS_GUARD ) { tree type_node = lang_hooks . types . type_for_mode ( ptr_mode , <NUM_LIT> ) ; int qual = ENCODE_QUAL_ADDR_SPACE ( ix86_stack_protector_guard_reg ) ; tree type = build_qualified_type ( type_node , qual ) ; tree t ; if ( OPTION_SET_P ( ix86_stack_protector_guard_symbol_str ) ) { t = ix86_tls_stack_chk_guard_decl ; if ( t == NULL ) { rtx x ; t = build_decl ( UNKNOWN_LOCATION , VAR_DECL , get_identifier ( ix86_stack_protector_guard_symbol_str ) , type ) ; TREE_STATIC ( t ) = <NUM_LIT> ; TREE_PUBLIC ( t ) = <NUM_LIT> ; DECL_EXTERNAL ( t ) = <NUM_LIT> ; TREE_USED ( t ) = <NUM_LIT> ; TREE_THIS_VOLATILE ( t ) = <NUM_LIT> ; DECL_ARTIFICIAL ( t ) = <NUM_LIT> ; DECL_IGNORED_P ( t ) = <NUM_LIT> ; x = DECL_RTL ( t ) ; RTX_FLAG ( x , used ) = <NUM_LIT> ; ix86_tls_stack_chk_guard_decl = t ; } }


<s> gcc_assert ( REG_P ( dst ) ) ; if ( src == NULL || ( SSE_REGNO_P ( REGNO ( dst ) ) && standard_sse_constant_p ( src , GET_MODE ( dst ) ) != <NUM_LIT> ) || ( STACK_REGNO_P ( REGNO ( dst ) ) && standard_80387_constant_p ( src ) < <NUM_LIT> ) ) return false ;


<s> const_tree fntype , fndecl ; unsigned int ccvt ; regno = CX_REG ; if ( TREE_CODE ( fndecl_or_type ) == FUNCTION_DECL ) { fntype = TREE_TYPE ( fndecl_or_type ) ; fndecl = fndecl_or_type ; } else { fntype = fndecl_or_type ; fndecl = NULL ; } ccvt = ix86_get_callcvt ( fntype ) ; if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) { regno = AX_REG ; } else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) { regno = AX_REG ; } else if ( ix86_function_regparm ( fntype , fndecl ) == <NUM_LIT> ) {


<s> } ccvt = ix86_get_callcvt ( fntype ) ; if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) { regno = AX_REG ; } else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) { regno = AX_REG ; } else if ( ix86_function_regparm ( fntype , fndecl ) == <NUM_LIT> ) { if ( incoming_p ) { if ( fndecl == current_function_decl && ! ix86_static_chain_on_stack ) { gcc_assert ( ! reload_completed ) ; ix86_static_chain_on_stack = true ; }

return gen_frame_mem ( SImode , plus_constant ( Pmode , arg_pointer_rtx , - <NUM_LIT> ) ) ;


<s> static HOST_WIDE_INT ix86_static_rtx_alignment ( machine_mode mode ) { if ( mode == DFmode ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( mode ) ) return MAX ( <NUM_LIT> , GET_MODE_ALIGNMENT ( mode ) ) ;


<s> bool ix86_target_stack_probe ( void ) { if ( flag_stack_check == STATIC_BUILTIN_STACK_CHECK ) return false ;


<s> bool ix86_target_stack_probe ( void ) {

if ( flag_stack_check == STATIC_BUILTIN_STACK_CHECK ) return false ;


<s> ASSERT_RTL_DUMP_EQ ( <STR_LIT> , gen_raw_REG ( SImode , <NUM_LIT> ) ) ;


<s> ASSERT_EQ ( CALL , GET_CODE ( SET_SRC ( pat ) ) ) ; { ASSERT_EQ ( EXPR_LIST , GET_CODE ( REG_NOTES ( insn ) ) ) ; rtx_expr_list * note0 = as_a < rtx_expr_list * > ( REG_NOTES ( insn ) ) ; ASSERT_EQ ( REG_CALL_DECL , REG_NOTE_KIND ( note0 ) ) ; rtx_expr_list * note1 = note0 -> next ( ) ; ASSERT_EQ ( REG_EH_REGION , REG_NOTE_KIND ( note1 ) ) ; ASSERT_EQ ( NULL , note1 -> next ( ) ) ; }


<s> rtx_expr_list * usage = as_a < rtx_expr_list * > ( CALL_INSN_FUNCTION_USAGE ( insn ) ) ; ASSERT_EQ ( EXPR_LIST , GET_CODE ( usage ) ) ; ASSERT_EQ ( DFmode , GET_MODE ( usage ) ) ; ASSERT_EQ ( USE , GET_CODE ( usage -> element ( ) ) ) ; ASSERT_EQ ( NULL , usage -> next ( ) ) ; }


<s> static void ix86_test_loading_dump_fragment_1 ( ) { rtl_dump_test t ( SELFTEST_LOCATION , locate_file ( <STR_LIT> ) ) ; rtx_insn * insn = get_insn_by_uid ( <NUM_LIT> ) ; tree mem_expr ; { rtx pat = PATTERN ( insn ) ; ASSERT_EQ ( SET , GET_CODE ( pat ) ) ; { rtx dest = SET_DEST ( pat ) ; ASSERT_EQ ( MEM , GET_CODE ( dest ) ) ; ASSERT_TRUE ( RTX_FLAG ( dest , call ) ) ; ASSERT_EQ ( SImode , GET_MODE ( dest ) ) ; { rtx addr = XEXP ( dest , <NUM_LIT> ) ; ASSERT_EQ ( PLUS , GET_CODE ( addr ) ) ; ASSERT_EQ ( DImode , GET_MODE ( addr ) ) ; { rtx lhs = XEXP ( addr , <NUM_LIT> ) ; ASSERT_RTX_PTR_EQ ( frame_pointer_rtx , lhs ) ; } { rtx rhs = XEXP ( addr , <NUM_LIT> ) ; ASSERT_EQ ( CONST_INT , GET_CODE ( rhs ) ) ; ASSERT_EQ ( - <NUM_LIT> , INTVAL ( rhs ) ) ; } } ASSERT_EQ ( <NUM_LIT> , MEM_ALIAS_SET ( dest ) ) ; mem_expr = MEM_EXPR ( dest ) ; ASSERT_NE ( mem_expr , NULL ) ; ASSERT_EQ ( VAR_DECL , TREE_CODE ( mem_expr ) ) ; ASSERT_EQ ( integer_type_node , TREE_TYPE ( mem_expr ) ) ; ASSERT_EQ ( IDENTIFIER_NODE , TREE_CODE ( DECL_NAME ( mem_expr ) ) ) ; ASSERT_STREQ ( <STR_LIT> , IDENTIFIER_POINTER ( DECL_NAME ( mem_expr ) ) ) ; ASSERT_TRUE ( MEM_OFFSET_KNOWN_P ( dest ) ) ; ASSERT_EQ ( <NUM_LIT> , MEM_OFFSET ( dest ) ) ; ASSERT_EQ ( <NUM_LIT> , MEM_SIZE ( dest ) ) ; ASSERT_EQ ( <NUM_LIT> , MEM_ALIGN ( dest ) ) ;


<s> ASSERT_STREQ ( <STR_LIT> , IDENTIFIER_POINTER ( DECL_NAME ( cfun -> decl ) ) ) ; rtx_insn * insn_1 = get_insn_by_uid ( <NUM_LIT> ) ; ASSERT_EQ ( NOTE , GET_CODE ( insn_1 ) ) ; rtx_insn * insn_7 = get_insn_by_uid ( <NUM_LIT> ) ; ASSERT_EQ ( INSN , GET_CODE ( insn_7 ) ) ; ASSERT_EQ ( PARALLEL , GET_CODE ( PATTERN ( insn_7 ) ) ) ; rtx_insn * insn_15 = get_insn_by_uid ( <NUM_LIT> ) ; ASSERT_EQ ( INSN , GET_CODE ( insn_15 ) ) ; ASSERT_EQ ( USE , GET_CODE ( PATTERN ( insn_15 ) ) ) ; ASSERT_EQ ( REG , GET_CODE ( crtl -> return_rtx ) ) ; ASSERT_EQ ( <NUM_LIT> , REGNO ( crtl -> return_rtx ) ) ;

ASSERT_EQ ( SImode , GET_MODE ( crtl -> return_rtx ) ) ;


<s> ASSERT_EQ ( UNSPEC , GET_CODE ( src ) ) ; ASSERT_EQ ( BLKmode , GET_MODE ( src ) ) ; ASSERT_EQ ( UNSPEC_MEMORY_BLOCKAGE , XINT ( src , <NUM_LIT> ) ) ; rtx v0 = XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) ; rtx scratch_a = XEXP ( dst , <NUM_LIT> ) ; ASSERT_EQ ( SCRATCH , GET_CODE ( scratch_a ) ) ; rtx scratch_b = XEXP ( v0 , <NUM_LIT> ) ; ASSERT_EQ ( SCRATCH , GET_CODE ( scratch_b ) ) ; ASSERT_EQ ( scratch_a , scratch_b ) ; ASSERT_TRUE ( rtx_equal_p ( dst , v0 ) ) ; ASSERT_NE ( - <NUM_LIT> , recog_memoized ( insn ) ) ; insn = NEXT_INSN ( insn ) ; ASSERT_EQ ( INSN , GET_CODE ( insn ) ) ; set = single_set ( insn ) ; ASSERT_NE ( NULL , set ) ; src = SET_SRC ( set ) ; ASSERT_EQ ( UNSPEC_VOLATILE , GET_CODE ( src ) ) ;

ASSERT_EQ ( UNSPECV_RDTSCP , XINT ( src , <NUM_LIT> ) ) ;


<s> case E_QImode : return TARGET_64BIT || ! TARGET_PARTIAL_REG_STALL ; case E_DImode : return TARGET_64BIT ; default : return false ;


<s> if ( GET_CODE ( u ) == ZERO_EXTEND ) u = XEXP ( u , <NUM_LIT> ) ; if ( GET_CODE ( u ) == UNSPEC && XINT ( u , <NUM_LIT> ) == UNSPEC_TP ) return true ; } x = & XEXP ( * x , <NUM_LIT> ) ; } iter . skip_subrtxes ( ) ; } } return false ;


<s> } if ( ix86_cmodel == CM_LARGE_PIC && ! TARGET_PECOFF ) { rtx unspec = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , ix86_tls_symbol ) , UNSPEC_PLTOFF ) ; return gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , gen_rtx_CONST ( Pmode , unspec ) ) ; } return ix86_tls_symbol ;


<s> emit_move_insn ( mem , chain_value ) ; offset += size ; mem = adjust_address ( m_tramp , SImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( <NUM_LIT> , SImode ) ) ; offset += <NUM_LIT> ; } else { rtx disp , chain ; chain = ix86_static_chain ( fndecl , true ) ; if ( REG_P ( chain ) ) { switch ( REGNO ( chain ) ) { case AX_REG : opcode = <NUM_LIT> ; break ; case CX_REG : opcode = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } } else opcode = <NUM_LIT> ; if ( need_endbr ) { mem = adjust_address ( m_tramp , SImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( <NUM_LIT> , SImode ) ) ; offset += <NUM_LIT> ; } mem = adjust_address ( m_tramp , QImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( opcode , QImode ) ) ; mem = adjust_address ( m_tramp , SImode , offset + <NUM_LIT> ) ; emit_move_insn ( mem , chain_value ) ; offset += <NUM_LIT> ; mem = adjust_address ( m_tramp , QImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( <NUM_LIT> , QImode ) ) ;


<s> if ( ( MEM_P ( operands [ <NUM_LIT> ] ) || MEM_P ( operands [ <NUM_LIT> ] ) ) && ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) return false ;


<s> if ( TARGET_64BIT && cfun -> stdarg && crtl -> stack_alignment_estimated < <NUM_LIT> ) crtl -> stack_alignment_estimated = <NUM_LIT> ;


<s> if ( ! REG_P ( operands [ <NUM_LIT> ] ) || ! REG_P ( operands [ <NUM_LIT> ] ) ) return false ; regno0 = true_regnum ( operands [ <NUM_LIT> ] ) ; regno1 = true_regnum ( operands [ <NUM_LIT> ] ) ;

return ix86_lea_outperforms ( insn , regno0 , regno1 , INVALID_REGNUM , <NUM_LIT> , false ) ;


<s> if ( ! TARGET_OPT_AGU || optimize_function_for_size_p ( cfun ) ) return false ; if ( ! REG_P ( operands [ <NUM_LIT> ] ) || ! REG_P ( operands [ <NUM_LIT> ] ) ) return false ; regno0 = true_regnum ( operands [ <NUM_LIT> ] ) ; regno1 = true_regnum ( operands [ <NUM_LIT> ] ) ; return ix86_lea_outperforms ( insn , regno0 , regno1 , INVALID_REGNUM , <NUM_LIT> , false ) ;


<s> if ( ( TARGET_64BIT && ( ix86_cmodel == CM_SMALL_PIC || TARGET_PECOFF ) ) || ! flag_pic ) return false ; return true ;


<s> mode = GET_MODE ( reg ) ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return NULL_RTX ; if ( register_no_elim_operand ( reg , mode ) ) return reg ; }


<s> static rtx ix86_validate_address_register ( rtx op ) { machine_mode mode = GET_MODE ( op ) ; if ( mode != SImode && mode != DImode ) return NULL_RTX ; if ( REG_P ( op ) ) return op ; else if ( SUBREG_P ( op ) ) { rtx reg = SUBREG_REG ( op ) ; if ( ! REG_P ( reg ) ) return NULL_RTX ; mode = GET_MODE ( reg ) ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return NULL_RTX ; if ( register_no_elim_operand ( reg , mode ) ) return reg ; }


<s> else if ( el_mode == SFmode && n == <NUM_LIT> ) { name [ <NUM_LIT> ] = 's' ; name [ <NUM_LIT> ] = '4' ; } else return NULL_TREE ; break ; default : return NULL_TREE ; } tree fndecl = mathfn_built_in ( el_mode == DFmode ? double_type_node : float_type_node , fn ) ; bname = IDENTIFIER_POINTER ( DECL_NAME ( fndecl ) ) ; sprintf ( name + <NUM_LIT> , <STR_LIT> , bname + <NUM_LIT> ) ; arity = <NUM_LIT> ;

for ( args = DECL_ARGUMENTS ( fndecl ) ; args ; args = TREE_CHAIN ( args ) ) arity ++ ;


<s> tree ix86_veclibabi_acml ( combined_fn fn , tree type_out , tree type_in ) { char name [ <NUM_LIT> ] = <STR_LIT> ; tree fntype , new_fndecl , args ; unsigned arity ; const char * bname ; machine_mode el_mode , in_mode ; int n , in_n ; if ( ! TARGET_64BIT || ! flag_unsafe_math_optimizations ) return NULL_TREE ; el_mode = TYPE_MODE ( TREE_TYPE ( type_out ) ) ; n = TYPE_VECTOR_SUBPARTS ( type_out ) ; in_mode = TYPE_MODE ( TREE_TYPE ( type_in ) ) ; in_n = TYPE_VECTOR_SUBPARTS ( type_in ) ; if ( el_mode != in_mode || n != in_n ) return NULL_TREE ; switch ( fn ) { CASE_CFN_SIN : CASE_CFN_COS : CASE_CFN_EXP : CASE_CFN_LOG : CASE_CFN_LOG2 :


<s> tree fntype , new_fndecl , args ; unsigned arity ; const char * bname ; machine_mode el_mode , in_mode ; int n , in_n ; if ( ! flag_unsafe_math_optimizations ) return NULL_TREE ; el_mode = TYPE_MODE ( TREE_TYPE ( type_out ) ) ; n = TYPE_VECTOR_SUBPARTS ( type_out ) ; in_mode = TYPE_MODE ( TREE_TYPE ( type_in ) ) ; in_n = TYPE_VECTOR_SUBPARTS ( type_in ) ; if ( el_mode != in_mode || n != in_n ) return NULL_TREE ; switch ( fn ) { CASE_CFN_EXP : CASE_CFN_LOG : CASE_CFN_LOG10 : CASE_CFN_POW : CASE_CFN_TANH : CASE_CFN_TAN : CASE_CFN_ATAN : CASE_CFN_ATAN2 : CASE_CFN_ATANH : CASE_CFN_CBRT : CASE_CFN_SINH : CASE_CFN_SIN : CASE_CFN_ASINH : CASE_CFN_ASIN : CASE_CFN_COSH : CASE_CFN_COS : CASE_CFN_ACOSH : CASE_CFN_ACOS : if ( ( el_mode != DFmode || n != <NUM_LIT> ) && ( el_mode != SFmode || n != <NUM_LIT> ) ) return NULL_TREE ; break ; default : return NULL_TREE ; } tree fndecl = mathfn_built_in ( el_mode == DFmode ? double_type_node : float_type_node , fn ) ; bname = IDENTIFIER_POINTER ( DECL_NAME ( fndecl ) ) ; if ( DECL_FUNCTION_CODE ( fndecl ) == BUILT_IN_LOGF ) strcpy ( name , <STR_LIT> ) ; else if ( DECL_FUNCTION_CODE ( fndecl ) == BUILT_IN_LOG ) strcpy ( name , <STR_LIT> ) ; else if ( n == <NUM_LIT> ) { sprintf ( name , <STR_LIT> , bname + <NUM_LIT> ) ; name [ strlen ( name ) - <NUM_LIT> ] = '4' ; } else sprintf ( name , <STR_LIT> , bname + <NUM_LIT> ) ; name [ <NUM_LIT> ] &= ~ <NUM_LIT> ; arity = <NUM_LIT> ; for ( args = DECL_ARGUMENTS ( fndecl ) ; args ; args = TREE_CHAIN ( args ) ) arity ++ ; if ( arity == <NUM_LIT> ) fntype = build_function_type_list ( type_out , type_in , NULL ) ; else fntype = build_function_type_list ( type_out , type_in , type_in , NULL ) ; new_fndecl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , get_identifier ( name ) , fntype ) ; TREE_PUBLIC ( new_fndecl ) = <NUM_LIT> ; DECL_EXTERNAL ( new_fndecl ) = <NUM_LIT> ;


<s> if ( TYPE_PRECISION ( index_type ) < POINTER_SIZE && TYPE_UNSIGNED ( index_type ) ) return NULL_TREE ; if ( scale <= <NUM_LIT> || scale > <NUM_LIT> || ( scale & ( scale - <NUM_LIT> ) ) != <NUM_LIT> ) return NULL_TREE ; si = TYPE_MODE ( index_type ) == SImode ; switch ( TYPE_MODE ( vectype ) ) { case E_V8DFmode : code = si ? IX86_BUILTIN_SCATTERALTSIV8DF : IX86_BUILTIN_SCATTERDIV8DF ; break ; case E_V8DImode : code = si ? IX86_BUILTIN_SCATTERALTSIV8DI : IX86_BUILTIN_SCATTERDIV8DI ; break ; case E_V16SFmode : code = si ? IX86_BUILTIN_SCATTERSIV16SF : IX86_BUILTIN_SCATTERALTDIV16SF ; break ; case E_V16SImode : code = si ? IX86_BUILTIN_SCATTERSIV16SI : IX86_BUILTIN_SCATTERALTDIV16SI ; break ; case E_V4DFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERALTSIV4DF : IX86_BUILTIN_SCATTERDIV4DF ; else return NULL_TREE ; break ; case E_V4DImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERALTSIV4DI : IX86_BUILTIN_SCATTERDIV4DI ; else return NULL_TREE ;


<s> si = TYPE_MODE ( index_type ) == SImode ; switch ( TYPE_MODE ( vectype ) ) { case E_V8DFmode : code = si ? IX86_BUILTIN_SCATTERALTSIV8DF : IX86_BUILTIN_SCATTERDIV8DF ; break ; case E_V8DImode : code = si ? IX86_BUILTIN_SCATTERALTSIV8DI : IX86_BUILTIN_SCATTERDIV8DI ; break ; case E_V16SFmode : code = si ? IX86_BUILTIN_SCATTERSIV16SF : IX86_BUILTIN_SCATTERALTDIV16SF ; break ; case E_V16SImode : code = si ? IX86_BUILTIN_SCATTERSIV16SI : IX86_BUILTIN_SCATTERALTDIV16SI ; break ; case E_V4DFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERALTSIV4DF : IX86_BUILTIN_SCATTERDIV4DF ; else return NULL_TREE ; break ; case E_V4DImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERALTSIV4DI : IX86_BUILTIN_SCATTERDIV4DI ; else return NULL_TREE ; break ; case E_V8SFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERSIV8SF : IX86_BUILTIN_SCATTERALTDIV8SF ; else return NULL_TREE ; break ; case E_V8SImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERSIV8SI : IX86_BUILTIN_SCATTERALTDIV8SI ; else return NULL_TREE ; break ; case E_V2DFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERALTSIV2DF : IX86_BUILTIN_SCATTERDIV2DF ; else return NULL_TREE ; break ; case E_V2DImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERALTSIV2DI : IX86_BUILTIN_SCATTERDIV2DI ; else return NULL_TREE ; break ; case E_V4SFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERSIV4SF : IX86_BUILTIN_SCATTERALTDIV4SF ; else return NULL_TREE ; break ; case E_V4SImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_SCATTERSIV4SI : IX86_BUILTIN_SCATTERALTDIV4SI ; else return NULL_TREE ; break ; default : return NULL_TREE ;


<s> return new ix86_vector_costs ( vinfo , costing_for_scalar ) ;


<s> static bool ix86_vector_mode_supported_p ( machine_mode mode ) { if ( ! TARGET_64BIT && GET_MODE_INNER ( mode ) == TImode ) return false ; if ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) return true ;

if ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) return true ;


<s> static tree ix86_vector_shift_count ( tree arg1 ) { if ( tree_fits_uhwi_p ( arg1 ) ) return arg1 ; else if ( TREE_CODE ( arg1 ) == VECTOR_CST && CHAR_BIT == <NUM_LIT> ) {


<s> int len = native_encode_expr ( arg1 , buf , <NUM_LIT> ) ; if ( len == <NUM_LIT> ) return NULL_TREE ; tree t = native_interpret_expr ( uint64_type_node , buf , len ) ; if ( t && tree_fits_uhwi_p ( t ) ) return t ; } return NULL_TREE ;


<s> static int ix86_vec_cost ( machine_mode mode , int cost ) { if ( ! VECTOR_MODE_P ( mode ) ) return cost ; if ( GET_MODE_BITSIZE ( mode ) == <NUM_LIT> && TARGET_SSE_SPLIT_REGS ) return cost * <NUM_LIT> ; if ( GET_MODE_BITSIZE ( mode ) > <NUM_LIT> && TARGET_AVX256_SPLIT_REGS ) return cost * GET_MODE_BITSIZE ( mode ) / <NUM_LIT> ; return cost ;


<s> static int ix86_vec_cost ( machine_mode mode , int cost ) {

if ( ! VECTOR_MODE_P ( mode ) ) return cost ;


<s> if ( MEM_P ( operands [ <NUM_LIT> ] ) && MEM_P ( operands [ <NUM_LIT> ] ) ) return TARGET_SSE3 && rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> bool ix86_vec_interleave_v2df_operator_ok ( rtx operands [ <NUM_LIT> ] , bool high ) { if ( MEM_P ( operands [ <NUM_LIT> ] ) ) return rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> + high ] ) ; if ( MEM_P ( operands [ <NUM_LIT> ] ) && MEM_P ( operands [ <NUM_LIT> ] ) ) return TARGET_SSE3 && rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return true ;


<s> static bool ix86_warn_func_return ( tree decl ) {


<s> if ( cum -> decl && ! TREE_PUBLIC ( cum -> decl ) ) return ; const_tree ctx = get_ultimate_context ( cum -> decl ) ; if ( ctx != NULL_TREE && ! TRANSLATION_UNIT_WARN_EMPTY_P ( ctx ) ) return ;

if ( int_size_in_bytes ( type ) == <NUM_LIT> ) return ;


<s> basic_cost = cost -> mulss * <NUM_LIT> + cost -> sse_op * <NUM_LIT> ; break ; case V2DImode : if ( ! TARGET_SSE4_1 && ! uns_p ) extra_cost = ( cost -> mulss + cost -> addss + cost -> sse_op ) * <NUM_LIT> + cost -> sse_op * <NUM_LIT> ; case V4DImode : basic_cost = cost -> mulss * <NUM_LIT> + cost -> sse_op * <NUM_LIT> ;


<s> if ( zero_all_vec_insn ) { emit_insn ( zero_all_vec_insn ) ; all_sse_zeroed = true ; } bool exit_with_mmx_mode = ( crtl -> return_rtx && ( MMX_REG_P ( crtl -> return_rtx ) ) ) ; if ( ! exit_with_mmx_mode ) { all_st_zeroed_num = zero_all_st_registers ( need_zeroed_hardregs ) ; if ( all_st_zeroed_num > <NUM_LIT> ) for ( unsigned int regno = FIRST_STACK_REG ; regno <= LAST_STACK_REG ; regno ++ ) if ( all_st_zeroed_num == <NUM_LIT> || ! ( ( all_st_zeroed_num >= <NUM_LIT> && regno == REGNO ( crtl -> return_rtx ) ) || ( all_st_zeroed_num == <NUM_LIT> && ( regno == ( REGNO ( crtl -> return_rtx ) + <NUM_LIT> ) ) ) ) ) SET_HARD_REG_BIT ( zeroed_hardregs , regno ) ; } else { unsigned int exit_mmx_regno = REGNO ( crtl -> return_rtx ) ; all_mm_zeroed = zero_all_mm_registers ( need_zeroed_hardregs , exit_mmx_regno ) ; if ( all_mm_zeroed ) for ( unsigned int regno = FIRST_MMX_REG ; regno <= LAST_MMX_REG ; regno ++ ) if ( regno != exit_mmx_regno ) SET_HARD_REG_BIT ( zeroed_hardregs , regno ) ; } rtx zero_gpr = NULL_RTX ; rtx zero_vector = NULL_RTX ; rtx zero_mask = NULL_RTX ; rtx zero_mmx = NULL_RTX ;

for ( unsigned int regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) {


<s> rtx ix86_zero_extend_to_Pmode ( rtx exp ) { return force_reg ( Pmode , convert_to_mode ( Pmode , exp , <NUM_LIT> ) ) ;


<s> return ggc_marked_p ( m -> base . from ) ;


<s> static int keep_cache_entry ( tree_map * & m ) {

return ggc_marked_p ( m -> base . from ) ;


<s> if ( SYMBOL_REF_TLS_MODEL ( op0 ) || ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P ( op0 ) ) ) return false ; if ( TARGET_PECOFF ) { if ( is_imported_p ( op0 ) ) return true ; if ( SYMBOL_REF_FAR_ADDR_P ( op0 ) || ! SYMBOL_REF_LOCAL_P ( op0 ) ) break ; if ( ( ix86_cmodel != CM_LARGE_PIC && SYMBOL_REF_FUNCTION_P ( op0 ) && ! ( SYMBOL_REF_EXTERNAL_P ( op0 ) && SYMBOL_REF_WEAK ( op0 ) ) ) || ! SYMBOL_REF_EXTERNAL_P ( op0 ) || ix86_cmodel == CM_SMALL_PIC ) return true ; } else if ( ! SYMBOL_REF_FAR_ADDR_P ( op0 ) && ( SYMBOL_REF_LOCAL_P ( op0 ) || ( ( ix86_direct_extern_access && ! ( SYMBOL_REF_DECL ( op0 ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( op0 ) ) ) ) ) && HAVE_LD_PIE_COPYRELOC && flag_pie && ! SYMBOL_REF_WEAK ( op0 ) && ! SYMBOL_REF_FUNCTION_P ( op0 ) ) ) && ix86_cmodel != CM_LARGE_PIC ) return true ; break ; default : break ; } } if ( GET_CODE ( disp ) != CONST ) return false ; disp = XEXP ( disp , <NUM_LIT> ) ; if ( TARGET_64BIT ) { if ( GET_CODE ( disp ) != UNSPEC || ( XINT ( disp , <NUM_LIT> ) != UNSPEC_GOTPCREL && XINT ( disp , <NUM_LIT> ) != UNSPEC_GOTOFF && XINT ( disp , <NUM_LIT> ) != UNSPEC_PCREL && XINT ( disp , <NUM_LIT> ) != UNSPEC_PLTOFF ) ) return false ; if ( GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) != SYMBOL_REF && GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) != LABEL_REF ) return false ; return true ; } saw_plus = false ; if ( GET_CODE ( disp ) == PLUS ) { if ( ! CONST_INT_P ( XEXP ( disp , <NUM_LIT> ) ) ) return false ; disp = XEXP ( disp , <NUM_LIT> ) ; saw_plus = true ; } if ( TARGET_MACHO && darwin_local_data_pic ( disp ) ) return true ; if ( GET_CODE ( disp ) != UNSPEC ) return false ; switch ( XINT ( disp , <NUM_LIT> ) ) { case UNSPEC_GOT : if ( saw_plus ) return false ; return ( GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == LABEL_REF ) ; case UNSPEC_GOTOFF : if ( ( GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == LABEL_REF ) && ! TARGET_64BIT ) return ! TARGET_PECOFF && gotoff_operand ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) , Pmode ) ; return false ;


<s> case UNSPEC_TPOFF : x = XVECEXP ( inner , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_EXEC ) ; case UNSPEC_MACHOPIC_OFFSET : return legitimate_pic_address_disp_p ( x ) ; default : return false ; }


<s> rtx x ; gcc_assert ( SYMBOL_REF_DECL ( symbol ) ) ; imp_decl = get_dllimport_decl ( SYMBOL_REF_DECL ( symbol ) , true ) ; x = DECL_RTL ( imp_decl ) ;

if ( want_reg ) x = force_reg ( Pmode , x ) ;


<s> gcc_assert ( SYMBOL_REF_DECL ( symbol ) ) ; imp_decl = get_dllimport_decl ( SYMBOL_REF_DECL ( symbol ) , false ) ; x = DECL_RTL ( imp_decl ) ;


<s> imp_decl = get_dllimport_decl ( SYMBOL_REF_DECL ( symbol ) , false ) ; x = DECL_RTL ( imp_decl ) ; if ( want_reg ) x = force_reg ( Pmode , x ) ; return x ;


<s> if ( TARGET_DLLIMPORT_DECL_ATTRIBUTES ) { if ( GET_CODE ( addr ) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P ( addr ) ) return legitimize_dllimport_symbol ( addr , inreg ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ) { rtx t = legitimize_dllimport_symbol ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , inreg ) ; return gen_rtx_PLUS ( Pmode , t , XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ; } } if ( ix86_cmodel != CM_LARGE_PIC && ix86_cmodel != CM_MEDIUM_PIC ) return NULL_RTX ; if ( GET_CODE ( addr ) == SYMBOL_REF && ! is_imported_p ( addr ) && SYMBOL_REF_EXTERNAL_P ( addr ) && SYMBOL_REF_DECL ( addr ) ) return legitimize_pe_coff_extern_decl ( addr , inreg ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && ! is_imported_p ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) && SYMBOL_REF_EXTERNAL_P ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) && SYMBOL_REF_DECL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ) { rtx t = legitimize_pe_coff_extern_decl ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , inreg ) ; return gen_rtx_PLUS ( Pmode , t , XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ; } return NULL_RTX ;


<s> } if ( ix86_cmodel != CM_LARGE_PIC && ix86_cmodel != CM_MEDIUM_PIC ) return NULL_RTX ; if ( GET_CODE ( addr ) == SYMBOL_REF && ! is_imported_p ( addr ) && SYMBOL_REF_EXTERNAL_P ( addr ) && SYMBOL_REF_DECL ( addr ) ) return legitimize_pe_coff_extern_decl ( addr , inreg ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && ! is_imported_p ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) && SYMBOL_REF_EXTERNAL_P ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) && SYMBOL_REF_DECL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ) { rtx t = legitimize_pe_coff_extern_decl ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , inreg ) ; return gen_rtx_PLUS ( Pmode , t , XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> } else if ( ( GET_CODE ( addr ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( addr ) == <NUM_LIT> ) || ( TARGET_VXWORKS_RTP && GET_CODE ( addr ) == LABEL_REF ) ) { rtx tmp = legitimize_pe_coff_symbol ( addr , true ) ; if ( tmp ) return tmp ; if ( TARGET_64BIT && TARGET_PECOFF ) { new_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , addr ) , UNSPEC_PCREL ) ; new_rtx = gen_rtx_CONST ( Pmode , new_rtx ) ; } else if ( TARGET_64BIT && ix86_cmodel != CM_LARGE_PIC ) { new_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , addr ) , UNSPEC_GOTPCREL ) ; new_rtx = gen_rtx_CONST ( Pmode , new_rtx ) ; new_rtx = gen_const_mem ( Pmode , new_rtx ) ; set_mem_alias_set ( new_rtx , ix86_GOT_alias_set ( ) ) ; } else { new_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , addr ) , UNSPEC_GOT ) ; new_rtx = gen_rtx_CONST ( Pmode , new_rtx ) ; if ( TARGET_64BIT ) new_rtx = copy_to_suggested_reg ( new_rtx , reg , Pmode ) ; if ( reg != <NUM_LIT> ) { gcc_assert ( REG_P ( reg ) ) ; new_rtx = expand_simple_binop ( Pmode , PLUS , pic_offset_table_rtx , new_rtx , reg , <NUM_LIT> , OPTAB_DIRECT ) ; } else new_rtx = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , new_rtx ) ; new_rtx = gen_const_mem ( Pmode , new_rtx ) ; set_mem_alias_set ( new_rtx , ix86_GOT_alias_set ( ) ) ; } new_rtx = copy_to_suggested_reg ( new_rtx , reg , Pmode ) ; } else { if ( CONST_INT_P ( addr ) && ! x86_64_immediate_operand ( addr , VOIDmode ) ) new_rtx = copy_to_suggested_reg ( addr , reg , Pmode ) ; else if ( GET_CODE ( addr ) == CONST ) { addr = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == UNSPEC || ( GET_CODE ( addr ) == PLUS && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == UNSPEC ) ) return orig ; gcc_assert ( GET_CODE ( addr ) == PLUS ) ; } if ( GET_CODE ( addr ) == PLUS ) { rtx op0 = XEXP ( addr , <NUM_LIT> ) , op1 = XEXP ( addr , <NUM_LIT> ) ; if ( ! TARGET_PECOFF && gotoff_operand ( op0 , Pmode ) && CONST_INT_P ( op1 ) ) { if ( ! TARGET_64BIT ) { new_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , op0 ) , UNSPEC_GOTOFF ) ; new_rtx = gen_rtx_PLUS ( Pmode , new_rtx , op1 ) ; new_rtx = gen_rtx_CONST ( Pmode , new_rtx ) ; if ( reg != <NUM_LIT> ) {


<s> int label = ++ current_machopic_label_num ; gcc_assert ( ! TARGET_64BIT ) ; symb = targetm . strip_name_encoding ( symb ) ; length = strlen ( stub ) ; binder_name = XALLOCAVEC ( char , length + <NUM_LIT> ) ; GEN_BINDER_NAME_FOR_STUB ( binder_name , stub , length ) ; length = strlen ( symb ) ; symbol_name = XALLOCAVEC ( char , length + <NUM_LIT> ) ; GEN_SYMBOL_NAME_FOR_SYMBOL ( symbol_name , symb , length ) ; sprintf ( lazy_ptr_name , <STR_LIT> , label ) ; if ( MACHOPIC_ATT_STUB ) switch_to_section ( darwin_sections [ machopic_picsymbol_stub3_section ] ) ; else if ( MACHOPIC_PURE ) switch_to_section ( darwin_sections [ machopic_picsymbol_stub2_section ] ) ; else switch_to_section ( darwin_sections [ machopic_symbol_stub_section ] ) ; fprintf ( file , <STR_LIT> , stub ) ; fprintf ( file , <STR_LIT> , symbol_name ) ; if ( MACHOPIC_ATT_STUB ) { fprintf ( file , <STR_LIT> ) ; } else if ( MACHOPIC_PURE ) { rtx tmp = gen_rtx_REG ( SImode , <NUM_LIT> ) ; output_set_got ( tmp , NULL_RTX ) ; fprintf ( file , <STR_LIT> , label , lazy_ptr_name , label ) ; fprintf ( file , <STR_LIT> ) ; } else fprintf ( file , <STR_LIT> , lazy_ptr_name ) ; if ( MACHOPIC_ATT_STUB ) return ; fprintf ( file , <STR_LIT> , binder_name ) ; if ( MACHOPIC_PURE ) { fprintf ( file , <STR_LIT> , lazy_ptr_name , binder_name ) ;


<s> if ( TARGET_64BIT && ! lea && ( SImode_address_operand ( addr , VOIDmode ) || ( parts . base && GET_MODE ( parts . base ) == SImode ) || ( parts . index && GET_MODE ( parts . index ) == SImode ) ) ) len ++ ; base = parts . base ; index = parts . index ; disp = parts . disp ; if ( base && SUBREG_P ( base ) ) base = SUBREG_REG ( base ) ; if ( index && SUBREG_P ( index ) ) index = SUBREG_REG ( index ) ; gcc_assert ( base == NULL_RTX || REG_P ( base ) ) ; gcc_assert ( index == NULL_RTX || REG_P ( index ) ) ; if ( base && ! index && ! disp ) { if ( base == arg_pointer_rtx || base == frame_pointer_rtx || REGNO ( base ) == SP_REG || REGNO ( base ) == BP_REG || REGNO ( base ) == R12_REG || REGNO ( base ) == R13_REG ) len ++ ; } else if ( disp && ! base && ! index ) { len += <NUM_LIT> ; if ( ! ix86_rip_relative_addr_p ( & parts ) ) len ++ ;


<s> if ( STACK_REG_P ( operands [ <NUM_LIT> ] ) && ( ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) && ( STACK_REG_P ( operands [ <NUM_LIT> ] ) || MEM_P ( operands [ <NUM_LIT> ] ) ) ) || ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) && ( STACK_REG_P ( operands [ <NUM_LIT> ] ) || MEM_P ( operands [ <NUM_LIT> ] ) ) ) ) && ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) || STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) ) ; else gcc_unreachable ( ) ; } switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case MULT : case PLUS : if ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; case MINUS : case DIV : if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } else if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; p = <STR_LIT> ; } else { p = <STR_LIT> ; p = <STR_LIT> ; } break ; default : gcc_unreachable ( ) ; } strcat ( buf , p ) ; return buf ;


<s> static const char * output_387_ffreep ( rtx * operands ATTRIBUTE_UNUSED , int opno ) { if ( TARGET_USE_FFREEP ) return opno ? <STR_LIT> : <STR_LIT> ;


<s> static const char * output_387_ffreep ( rtx * operands ATTRIBUTE_UNUSED , int opno ) { if ( TARGET_USE_FFREEP ) return opno ? <STR_LIT> : <STR_LIT> ; { static char retval [ <NUM_LIT> ] ; int regno = REGNO ( operands [ opno ] ) ; gcc_assert ( STACK_REGNO_P ( regno ) ) ; regno -= FIRST_STACK_REG ; snprintf ( retval , sizeof ( retval ) , ASM_SHORT <STR_LIT> , regno ) ; return retval ; } return opno ? <STR_LIT> : <STR_LIT> ;


<s> if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; return <STR_LIT> ; } else if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) return <STR_LIT> ; else {

if ( GET_MODE ( operands [ <NUM_LIT> ] ) == XFmode ) return <STR_LIT> ;


<s> char loop_lab [ <NUM_LIT> ] ; rtx xops [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = stack_pointer_rtx ; xops [ <NUM_LIT> ] = GEN_INT ( get_probe_interval ( ) ) ; output_asm_insn ( <STR_LIT> , xops ) ;


<s> bool stack_top_dies = find_regno_note ( insn , REG_DEAD , FIRST_STACK_REG ) ; bool dimode_p = GET_MODE ( operands [ <NUM_LIT> ] ) == DImode ; int round_mode = get_attr_i387_cw ( insn ) ; static char buf [ <NUM_LIT> ] ; const char * p ; if ( ( dimode_p || fisttp ) && ! stack_top_dies ) output_asm_insn ( <STR_LIT> , operands ) ; gcc_assert ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( MEM_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( GET_MODE ( operands [ <NUM_LIT> ] ) != TFmode ) ; if ( fisttp ) return <STR_LIT> ; strcpy ( buf , <STR_LIT> ) ; if ( round_mode != I387_CW_ANY ) output_asm_insn ( <STR_LIT> , operands ) ; p = <STR_LIT> ; strcat ( buf , p + ! ( stack_top_dies || dimode_p ) ) ;


<s> const char * p ; gcc_assert ( STACK_TOP_P ( xops [ <NUM_LIT> ] ) ) ; stack_top_dies = find_regno_note ( insn , REG_DEAD , FIRST_STACK_REG ) ; if ( eflags_p ) { p = unordered_p ? <STR_LIT> : <STR_LIT> ; strcpy ( buf , p ) ; p = <STR_LIT> ; strcat ( buf , p + ! stack_top_dies ) ; return buf ; } if ( STACK_REG_P ( xops [ <NUM_LIT> ] ) && stack_top_dies && find_regno_note ( insn , REG_DEAD , FIRST_STACK_REG + <NUM_LIT> ) ) { gcc_assert ( REGNO ( xops [ <NUM_LIT> ] ) == FIRST_STACK_REG + <NUM_LIT> ) ; p = unordered_p ? <STR_LIT> : <STR_LIT> ; strcpy ( buf , p ) ;


<s> xcfi -> dw_cfi_opc = DW_CFA_def_cfa_offset ; xcfi -> dw_cfi_oprnd1 . dw_cfi_offset = <NUM_LIT> * UNITS_PER_WORD ; vec_safe_push ( cfun -> fde -> dw_fde_cfi , xcfi ) ; dwarf2out_emit_cfi ( xcfi ) ; } if ( regno != INVALID_REGNUM ) { rtx xops [ <NUM_LIT> ] ; xops [ <NUM_LIT> ] = gen_rtx_MEM ( word_mode , stack_pointer_rtx ) ; xops [ <NUM_LIT> ] = gen_rtx_REG ( word_mode , regno ) ; output_asm_insn ( <STR_LIT> , xops ) ; } else { rtx xops [ <NUM_LIT> ] ; xops [ <NUM_LIT> ] = stack_pointer_rtx ; xops [ <NUM_LIT> ] = plus_constant ( Pmode , stack_pointer_rtx , UNITS_PER_WORD ) ; output_asm_insn ( <STR_LIT> , xops ) ; } fputs ( <STR_LIT> , asm_out_file ) ; if ( ( ix86_harden_sls & harden_sls_return ) ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> switch_to_section ( darwin_sections [ picbase_thunk_section ] ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; DECL_WEAK ( decl ) = <NUM_LIT> ; } else if ( USE_HIDDEN_LINKONCE ) { cgraph_node :: create ( decl ) -> set_comdat_group ( DECL_ASSEMBLER_NAME ( decl ) ) ; targetm . asm_out . unique_section ( decl , <NUM_LIT> ) ; switch_to_section ( get_named_section ( decl , NULL , <NUM_LIT> ) ) ; targetm . asm_out . globalize_label ( asm_out_file , name ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_DECLARE_FUNCTION_NAME ( asm_out_file , name , decl ) ; }


<s> putc ( '+' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } else { gcc_assert ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '+' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } break ; case MINUS : if ( ! TARGET_MACHO ) putc ( ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '-' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; if ( ! TARGET_MACHO ) putc ( ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']' , file ) ; break ; case UNSPEC : gcc_assert ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) ; output_pic_addr_const ( file , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , code ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_GOT : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_PLTOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_PCREL : fputs ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> , file ) ; break ; case UNSPEC_GOTPCREL : fputs ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> , file ) ; break ; case UNSPEC_GOTTPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_TPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_NTPOFF : if ( TARGET_64BIT ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_DTPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTNTPOFF : if ( TARGET_64BIT ) fputs ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_INDNTPOFF : fputs ( <STR_LIT> , file ) ; break ;


<s> if ( ix86_instrument_return != instrument_return_none && flag_fentry && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT ( cfun -> decl ) ) { if ( ix86_flag_record_return ) fprintf ( asm_out_file , <STR_LIT> ) ; switch ( ix86_instrument_return ) { case instrument_return_call : fprintf ( asm_out_file , <STR_LIT> ) ; break ; case instrument_return_nop5 : fprintf ( asm_out_file , ASM_BYTE <STR_LIT> ) ; break ; case instrument_return_none : break ; } if ( ix86_flag_record_return ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } }


<s> if ( ix86_flag_record_return ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; }


<s> xops [ <NUM_LIT> ] = gen_rtx_SYMBOL_REF ( Pmode , GOT_SYMBOL_NAME ) ; if ( flag_pic ) { char name [ <NUM_LIT> ] ; get_pc_thunk_name ( name , REGNO ( dest ) ) ; pic_labels_used |= <NUM_LIT> << REGNO ( dest ) ; xops [ <NUM_LIT> ] = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( name ) ) ; xops [ <NUM_LIT> ] = gen_rtx_MEM ( QImode , xops [ <NUM_LIT> ] ) ; output_asm_insn ( <STR_LIT> , xops ) ; if ( machopic_should_output_picbase_label ( ) || ! label ) ASM_OUTPUT_LABEL ( asm_out_file , MACHOPIC_FUNCTION_BASE_NAME ) ; if ( label ) targetm . asm_out . internal_label ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( label ) ) ; } else { if ( TARGET_MACHO ) gcc_unreachable ( ) ; xops [ <NUM_LIT> ] = gen_rtx_LABEL_REF ( Pmode , label ? label : gen_label_rtx ( ) ) ; output_asm_insn ( <STR_LIT> , xops ) ; targetm . asm_out . internal_label ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( XEXP ( xops [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ; }

if ( ! TARGET_MACHO ) output_asm_insn ( <STR_LIT> , xops ) ;


<s> fputs ( <STR_LIT> , file ) ; return ; } if ( code == 'y' && STACK_TOP_P ( x ) ) { fputs ( <STR_LIT> , file ) ; return ; } if ( code == 'w' ) msize = <NUM_LIT> ; else if ( code == 'b' ) msize = <NUM_LIT> ; else if ( code == 'k' ) msize = <NUM_LIT> ; else if ( code == 'q' ) msize = <NUM_LIT> ; else if ( code == 'h' ) msize = <NUM_LIT> ; else if ( code == 'x' ) msize = <NUM_LIT> ; else if ( code == 't' ) msize = <NUM_LIT> ; else if ( code == 'g' ) msize = <NUM_LIT> ; else msize = GET_MODE_SIZE ( GET_MODE ( x ) ) ; regno = REGNO ( x ) ; if ( regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM || regno == FPSR_REG ) { output_operand_lossage ( <STR_LIT> , reg_names [ regno ] ) ; return ; } else if ( regno == FLAGS_REG ) { output_operand_lossage ( <STR_LIT> ) ; return ; } if ( code == 'V' ) { if ( GENERAL_REGNO_P ( regno ) ) msize = GET_MODE_SIZE ( word_mode ) ; else error ( <STR_LIT> ) ; } duplicated = code == 'd' && TARGET_AVX ; switch ( msize ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : if ( GENERAL_REGNO_P ( regno ) && msize > GET_MODE_SIZE ( word_mode ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; case <NUM_LIT> : if ( LEGACY_INT_REGNO_P ( regno ) ) putc ( msize > <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : normal : reg = hi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; if ( ! ANY_QI_REGNO_P ( regno ) ) error ( <STR_LIT> ) ; reg = qi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_high_reg_name ) ) goto normal ; reg = qi_high_reg_name [ regno ] ; break ; case <NUM_LIT> : case <NUM_LIT> : if ( SSE_REGNO_P ( regno ) ) { gcc_assert ( ! duplicated ) ; putc ( msize == <NUM_LIT> ? 'y' : 'z' , file ) ; reg = hi_reg_name [ regno ] + <NUM_LIT> ; break ; } goto normal ; default : gcc_unreachable ( ) ; }


<s> fputs ( <STR_LIT> , file ) ; return ; } if ( code == 'w' ) msize = <NUM_LIT> ; else if ( code == 'b' ) msize = <NUM_LIT> ; else if ( code == 'k' ) msize = <NUM_LIT> ; else if ( code == 'q' ) msize = <NUM_LIT> ; else if ( code == 'h' ) msize = <NUM_LIT> ; else if ( code == 'x' ) msize = <NUM_LIT> ; else if ( code == 't' ) msize = <NUM_LIT> ; else if ( code == 'g' ) msize = <NUM_LIT> ; else msize = GET_MODE_SIZE ( GET_MODE ( x ) ) ; regno = REGNO ( x ) ; if ( regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM || regno == FPSR_REG ) { output_operand_lossage ( <STR_LIT> , reg_names [ regno ] ) ; return ; } else if ( regno == FLAGS_REG ) { output_operand_lossage ( <STR_LIT> ) ; return ; } if ( code == 'V' ) { if ( GENERAL_REGNO_P ( regno ) ) msize = GET_MODE_SIZE ( word_mode ) ; else error ( <STR_LIT> ) ; } duplicated = code == 'd' && TARGET_AVX ; switch ( msize ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : if ( GENERAL_REGNO_P ( regno ) && msize > GET_MODE_SIZE ( word_mode ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; case <NUM_LIT> : if ( LEGACY_INT_REGNO_P ( regno ) ) putc ( msize > <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : normal : reg = hi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; if ( ! ANY_QI_REGNO_P ( regno ) ) error ( <STR_LIT> ) ; reg = qi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_high_reg_name ) ) goto normal ; reg = qi_high_reg_name [ regno ] ; break ; case <NUM_LIT> : case <NUM_LIT> : if ( SSE_REGNO_P ( regno ) ) {


<s> if ( add_frame_related_expr ) { rtx r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( dest , r ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , r ) ; } } if ( dest == stack_pointer_rtx ) { HOST_WIDE_INT ooffset = m -> fs . sp_offset ; bool valid = m -> fs . sp_valid ; bool realigned = m -> fs . sp_realigned ; if ( src == hard_frame_pointer_rtx ) { valid = m -> fs . fp_valid ; realigned = false ; ooffset = m -> fs . fp_offset ; } else if ( src == crtl -> drap_reg ) { valid = m -> fs . drap_valid ; realigned = false ; ooffset = <NUM_LIT> ; }


<s> default : gcc_unreachable ( ) ; } break ; case LTU : if ( mode == CCmode || mode == CCGZmode ) suffix = <STR_LIT> ; else if ( mode == CCCmode ) suffix = fp ? <STR_LIT> : <STR_LIT> ; else gcc_unreachable ( ) ; break ; case GE : switch ( mode ) { case E_CCNOmode : case E_CCGOCmode : suffix = <STR_LIT> ; break ; case E_CCmode : case E_CCGCmode : case E_CCGZmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case GEU : if ( mode == CCmode || mode == CCGZmode ) suffix = <STR_LIT> ; else if ( mode == CCCmode ) suffix = fp ? <STR_LIT> : <STR_LIT> ; else gcc_unreachable ( ) ; break ; case LE : gcc_assert ( mode == CCmode || mode == CCGCmode || mode == CCNOmode ) ; suffix = <STR_LIT> ; break ; case LEU : if ( mode == CCmode ) suffix = <STR_LIT> ; else gcc_unreachable ( ) ; break ; case UNORDERED : suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; case ORDERED : suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; default : gcc_unreachable ( ) ; }


<s> mode = CCmode ; } if ( reverse ) code = reverse_condition ( code ) ; switch ( code ) { case EQ : gcc_assert ( mode != CCGZmode ) ; switch ( mode ) { case E_CCAmode : suffix = <STR_LIT> ; break ; case E_CCCmode : suffix = <STR_LIT> ; break ; case E_CCOmode : suffix = <STR_LIT> ; break ; case E_CCPmode : suffix = <STR_LIT> ; break ; case E_CCSmode : suffix = <STR_LIT> ; break ; default : suffix = <STR_LIT> ; break ; } break ; case NE : gcc_assert ( mode != CCGZmode ) ; switch ( mode ) { case E_CCAmode : suffix = <STR_LIT> ; break ; case E_CCCmode : suffix = <STR_LIT> ; break ; case E_CCOmode : suffix = <STR_LIT> ; break ; case E_CCPmode : suffix = <STR_LIT> ; break ; case E_CCSmode : suffix = <STR_LIT> ; break ; default : suffix = <STR_LIT> ; break ; } break ; case GT : gcc_assert ( mode == CCmode || mode == CCNOmode || mode == CCGCmode ) ; suffix = <STR_LIT> ; break ; case GTU : if ( mode == CCmode ) suffix = fp ? <STR_LIT> : <STR_LIT> ; else gcc_unreachable ( ) ; break ; case LT : switch ( mode ) { case E_CCNOmode : case E_CCGOCmode : suffix = <STR_LIT> ; break ; case E_CCmode : case E_CCGCmode : case E_CCGZmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case LTU : if ( mode == CCmode || mode == CCGZmode ) suffix = <STR_LIT> ; else if ( mode == CCCmode ) suffix = fp ? <STR_LIT> : <STR_LIT> ; else gcc_unreachable ( ) ; break ; case GE : switch ( mode ) { case E_CCNOmode : case E_CCGOCmode : suffix = <STR_LIT> ; break ; case E_CCmode : case E_CCGCmode : case E_CCGZmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; }


<s> x = gen_rtx_SET ( stack_pointer_rtx , x ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , x ) ; m -> fs . sp_offset -= UNITS_PER_WORD ; } else { rtx x = plus_constant ( Pmode , stack_pointer_rtx , offset ) ; x = gen_rtx_SET ( sr -> reg , gen_rtx_MEM ( word_mode , x ) ) ; emit_insn ( x ) ;


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; x = plus_constant ( Pmode , stack_pointer_rtx , UNITS_PER_WORD ) ; x = gen_rtx_SET ( stack_pointer_rtx , x ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , x ) ; m -> fs . sp_offset -= UNITS_PER_WORD ; }


<s> save_area = frame_pointer_rtx ; set = get_varargs_alias_set ( ) ; max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( max > X86_64_REGPARM_MAX ) max = X86_64_REGPARM_MAX ; for ( i = cum -> regno ; i < max ; i ++ ) { mem = gen_rtx_MEM ( word_mode , plus_constant ( Pmode , save_area , i * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; set_mem_alias_set ( mem , set ) ; emit_move_insn ( mem , gen_rtx_REG ( word_mode , x86_64_int_parameter_registers [ i ] ) ) ; } if ( ix86_varargs_fpr_size ) { machine_mode smode ; rtx_code_label * label ; rtx test ;


<s> MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; set_mem_alias_set ( mem , set ) ; reg = gen_rtx_REG ( Pmode , x86_64_ms_abi_int_parameter_registers [ i ] ) ; emit_move_insn ( mem , reg ) ; }


<s> int i ; ix86_varargs_gpr_size = <NUM_LIT> ; ix86_varargs_fpr_size = <NUM_LIT> ; for ( i = cum -> regno ; i < X86_64_MS_REGPARM_MAX ; i ++ ) { rtx reg , mem ; mem = gen_rtx_MEM ( Pmode , plus_constant ( Pmode , virtual_incoming_args_rtx , i * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; set_mem_alias_set ( mem , set ) ; reg = gen_rtx_REG ( Pmode , x86_64_ms_abi_int_parameter_registers [ i ] ) ;


<s> else { bool is_fastcall , is_thiscall ; int regparm ; is_fastcall = ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( cfun -> decl ) ) ) != NULL ) ; is_thiscall = ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( cfun -> decl ) ) ) != NULL ) ; regparm = ix86_function_regparm ( TREE_TYPE ( cfun -> decl ) , cfun -> decl ) ; if ( is_fastcall ) { if ( DECL_STATIC_CHAIN ( cfun -> decl ) ) { sorry ( <STR_LIT> <STR_LIT> ) ; return INVALID_REGNUM ; } return AX_REG ; } else if ( is_thiscall ) { if ( ! DECL_STATIC_CHAIN ( cfun -> decl ) ) return DX_REG ; return AX_REG ; } else if ( regparm < <NUM_LIT> ) { if ( ! DECL_STATIC_CHAIN ( cfun -> decl ) ) return CX_REG ; else { if ( regparm >= <NUM_LIT> ) { sorry ( <STR_LIT> <STR_LIT> ) ; return INVALID_REGNUM ; } return DX_REG ; } } else { sorry ( <STR_LIT> ) ;


<s> const struct machine_frame_state & fs = cfun -> machine -> fs ;

if ( fs . sp_realigned && cfa_offset <= fs . sp_realigned_offset ) {


<s> if ( fs . sp_realigned && cfa_offset <= fs . sp_realigned_offset ) { gcc_assert ( cfa_offset <= fs . sp_realigned_fp_last ) ;


<s> return <NUM_LIT> ; case <NUM_LIT> : return <NUM_LIT> ; case <NUM_LIT> : return <NUM_LIT> ; default : return - <NUM_LIT> ;


<s> const char * standard_80387_constant_opcode ( rtx x ) { switch ( standard_80387_constant_p ( x ) ) { case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> :


<s> case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : case <NUM_LIT> : return <STR_LIT> ; default : gcc_unreachable ( ) ;


<s> const REAL_VALUE_TYPE * r ; if ( ! ( CONST_DOUBLE_P ( x ) && X87_FLOAT_MODE_P ( mode ) ) ) return - <NUM_LIT> ; if ( x == CONST0_RTX ( mode ) ) return <NUM_LIT> ; if ( x == CONST1_RTX ( mode ) ) return <NUM_LIT> ; r = CONST_DOUBLE_REAL_VALUE ( x ) ; if ( mode == XFmode && ( optimize_function_for_size_p ( cfun ) || TARGET_EXT_80387_CONSTANTS ) && ! flag_rounding_math ) {


<s> if ( ! ext_80387_constants_init ) init_ext_80387_constants ( ) ; switch ( idx ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> :


<s> const char * standard_sse_constant_opcode ( rtx_insn * insn , rtx * operands ) { machine_mode mode ; rtx x = operands [ <NUM_LIT> ] ; gcc_assert ( TARGET_SSE ) ; mode = GET_MODE ( x ) ; if ( x == const0_rtx || const0_operand ( x , mode ) ) { switch ( get_attr_mode ( insn ) ) { case MODE_TI : if ( ! EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; case MODE_XI : case MODE_OI : if ( EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return ( TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ) ; return <STR_LIT> ; case MODE_V2DF : if ( ! EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; case MODE_V8DF : case MODE_V4DF : if ( ! EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; else if ( TARGET_AVX512DQ ) return ( TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ) ; else return ( TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ) ; case MODE_V4SF : if ( ! EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; case MODE_V16SF : case MODE_V8SF : if ( ! EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; else if ( TARGET_AVX512DQ ) return ( TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ) ; else return ( TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ) ; default : gcc_unreachable ( ) ; } } else if ( x == constm1_rtx || vector_all_ones_operand ( x , mode ) || ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT && float_vector_all_ones_operand ( x , mode ) ) ) { enum attr_mode insn_mode = get_attr_mode ( insn ) ; switch ( insn_mode ) { case MODE_XI : case MODE_V8DF : case MODE_V16SF : gcc_assert ( TARGET_AVX512F ) ; return <STR_LIT> ; case MODE_OI : case MODE_V4DF : case MODE_V8SF : gcc_assert ( TARGET_AVX2 ) ; case MODE_TI : case MODE_V2DF : case MODE_V4SF : gcc_assert ( TARGET_SSE2 ) ; if ( ! EXT_REX_SSE_REG_P ( operands [ <NUM_LIT> ] ) ) return ( TARGET_AVX ? <STR_LIT> : <STR_LIT> ) ; else if ( TARGET_AVX512VL ) return <STR_LIT> ; else return <STR_LIT> ; default :


<s> machine_mode mode ; if ( ! TARGET_SSE ) return <NUM_LIT> ; mode = GET_MODE ( x ) ; if ( x == const0_rtx || const0_operand ( x , mode ) ) return <NUM_LIT> ; if ( x == constm1_rtx || vector_all_ones_operand ( x , mode ) || ( ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT || GET_MODE_CLASS ( pred_mode ) == MODE_VECTOR_FLOAT ) && float_vector_all_ones_operand ( x , mode ) ) ) { if ( mode == VOIDmode ) mode = pred_mode ; switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : if ( TARGET_AVX512F ) return <NUM_LIT> ; break ; case <NUM_LIT> : if ( TARGET_AVX2 ) return <NUM_LIT> ; break ; case <NUM_LIT> : if ( TARGET_SSE2 ) return <NUM_LIT> ; break ; case <NUM_LIT> : gcc_unreachable ( ) ; default : break ; } }


<s> if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( op , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbolic_reference_mentioned_p ( XVECEXP ( op , i , j ) ) ) return true ;


<s> int i ; if ( GET_CODE ( op ) == SYMBOL_REF || GET_CODE ( op ) == LABEL_REF ) return true ; fmt = GET_RTX_FORMAT ( GET_CODE ( op ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( op ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( op , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbolic_reference_mentioned_p ( XVECEXP ( op , i , j ) ) ) return true ; } else if ( fmt [ i ] == 'e' && symbolic_reference_mentioned_p ( XEXP ( op , i ) ) ) return true ; }


<s> static machine_mode type_natural_mode ( const_tree type , const CUMULATIVE_ARGS * cum , bool in_return ) { machine_mode mode = TYPE_MODE ( type ) ; if ( TREE_CODE ( type ) == VECTOR_TYPE && ! VECTOR_MODE_P ( mode ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( ( size == <NUM_LIT> || size == <NUM_LIT> || size == <NUM_LIT> || size == <NUM_LIT> ) && TYPE_VECTOR_SUBPARTS ( type ) > <NUM_LIT> ) { machine_mode innermode = TYPE_MODE ( TREE_TYPE ( type ) ) ; if ( innermode == XFmode ) return mode ; if ( DECIMAL_FLOAT_MODE_P ( innermode ) ) return mode ; if ( TREE_CODE ( TREE_TYPE ( type ) ) == REAL_TYPE ) mode = MIN_MODE_VECTOR_FLOAT ; else mode = MIN_MODE_VECTOR_INT ; FOR_EACH_MODE_FROM ( mode , mode ) if ( GET_MODE_NUNITS ( mode ) == TYPE_VECTOR_SUBPARTS ( type ) && GET_MODE_INNER ( mode ) == innermode ) { if ( size == <NUM_LIT> && ! TARGET_AVX512F && ! TARGET_IAMCU ) { static bool warnedavx512f ; static bool warnedavx512f_ret ; if ( cum && cum -> warn_avx512f && ! warnedavx512f ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedavx512f = true ; } else if ( in_return && ! warnedavx512f_ret ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedavx512f_ret = true ; } return TYPE_MODE ( type ) ; } else if ( size == <NUM_LIT> && ! TARGET_AVX && ! TARGET_IAMCU ) { static bool warnedavx ; static bool warnedavx_ret ; if ( cum && cum -> warn_avx && ! warnedavx ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedavx = true ; } else if ( in_return && ! warnedavx_ret ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedavx_ret = true ; } return TYPE_MODE ( type ) ; } else if ( ( ( size == <NUM_LIT> && TARGET_64BIT ) || size == <NUM_LIT> ) && ! TARGET_SSE && ! TARGET_IAMCU ) { static bool warnedsse ; static bool warnedsse_ret ; if ( cum && cum -> warn_sse && ! warnedsse ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedsse = true ; } else if ( ! TARGET_64BIT && in_return && ! warnedsse_ret ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedsse_ret = true ; } } else if ( ( size == <NUM_LIT> && ! TARGET_64BIT ) && ( ! cfun || cfun -> machine -> func_type == TYPE_NORMAL ) && ! TARGET_MMX && ! TARGET_IAMCU ) { static bool warnedmmx ; static bool warnedmmx_ret ; if ( cum && cum -> warn_mmx && ! warnedmmx ) {

if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedmmx = true ;


<s> } return TYPE_MODE ( type ) ; } else if ( size == <NUM_LIT> && ! TARGET_AVX && ! TARGET_IAMCU ) { static bool warnedavx ; static bool warnedavx_ret ; if ( cum && cum -> warn_avx && ! warnedavx ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedavx = true ; } else if ( in_return && ! warnedavx_ret ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedavx_ret = true ; } return TYPE_MODE ( type ) ; } else if ( ( ( size == <NUM_LIT> && TARGET_64BIT ) || size == <NUM_LIT> ) && ! TARGET_SSE && ! TARGET_IAMCU ) { static bool warnedsse ; static bool warnedsse_ret ; if ( cum && cum -> warn_sse && ! warnedsse ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedsse = true ; } else if ( ! TARGET_64BIT && in_return && ! warnedsse_ret ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedsse_ret = true ; } } else if ( ( size == <NUM_LIT> && ! TARGET_64BIT ) && ( ! cfun || cfun -> machine -> func_type == TYPE_NORMAL ) && ! TARGET_MMX && ! TARGET_IAMCU ) { static bool warnedmmx ; static bool warnedmmx_ret ; if ( cum && cum -> warn_mmx && ! warnedmmx ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedmmx = true ; } else if ( in_return && ! warnedmmx_ret ) { if ( warning ( OPT_Wpsabi , <STR_LIT> <STR_LIT> ) ) warnedmmx_ret = true ; } } return mode ; } gcc_unreachable ( ) ; } }