<s> putc ( 'd' , file ) ; break ; case <NUM_LIT> : break ; default : error ( <STR_LIT> ) ; break ; } return ; } reg = NULL ; switch ( code ) { case <NUM_LIT> : if ( STACK_TOP_P ( x ) ) { reg = <STR_LIT> ; break ; } case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : if ( ! ANY_FP_REG_P ( x ) && ! ANY_MASK_REG_P ( x ) && ! ANY_BND_REG_P ( x ) ) putc ( code == <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : case <NUM_LIT> : normal : reg = hi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; 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> : if ( SSE_REG_P ( x ) ) { gcc_assert ( ! duplicated ) ; putc ( 'y' , file ) ; fputs ( hi_reg_name [ regno ] + <NUM_LIT> , file ) ;


<s> v |= v << <NUM_LIT> ; if ( mode == DImode ) v |= ( v << <NUM_LIT> ) << <NUM_LIT> ; return copy_to_mode_reg ( mode , gen_int_mode ( v , mode ) ) ; } if ( valmode == VOIDmode ) valmode = QImode ; if ( valmode != QImode ) val = gen_lowpart ( QImode , val ) ; if ( mode == QImode ) return val ; if ( ! TARGET_PARTIAL_REG_STALL ) nops -- ; if ( ix86_cost -> mult_init [ mode == DImode ? <NUM_LIT> : <NUM_LIT> ] + ix86_cost -> mult_bit * ( mode == DImode ? <NUM_LIT> : <NUM_LIT> ) <= ( ix86_cost -> shift_const + ix86_cost -> add ) * nops + ( COSTS_N_INSNS ( TARGET_PARTIAL_REG_STALL == <NUM_LIT> ) ) ) { rtx reg = convert_modes ( mode , QImode , val , true ) ; tmp = promote_duplicated_reg ( mode , const1_rtx ) ; return expand_simple_binop ( mode , MULT , reg , tmp , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; } else { rtx reg = convert_modes ( mode , QImode , val , true ) ; if ( ! TARGET_PARTIAL_REG_STALL ) if ( mode == SImode ) emit_insn ( gen_movsi_insv_1 ( reg , reg ) ) ; else emit_insn ( gen_movdi_insv_1 ( reg , reg ) ) ; else { tmp = expand_simple_binop ( mode , ASHIFT , reg , GEN_INT ( <NUM_LIT> ) , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; reg = expand_simple_binop ( mode , IOR , reg , tmp , reg , <NUM_LIT> , OPTAB_DIRECT ) ; } tmp = expand_simple_binop ( mode , ASHIFT , reg , GEN_INT ( <NUM_LIT> ) , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; reg = expand_simple_binop ( mode , IOR , reg , tmp , reg , <NUM_LIT> , OPTAB_DIRECT ) ; if ( mode == SImode ) return reg ; tmp = expand_simple_binop ( mode , ASHIFT , reg , GEN_INT ( <NUM_LIT> ) , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; reg = expand_simple_binop ( mode , IOR , reg , tmp , reg , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> insn = emit_insn ( gen_rtx_SET ( DImode , tmp , offset ) ) ; if ( style < <NUM_LIT> ) add_frame_related_expr = true ; insn = gen_pro_epilogue_adjust_stack_di_add ( dest , src , tmp ) ; } insn = emit_insn ( insn ) ; if ( style >= <NUM_LIT> ) ix86_add_queued_cfa_restore_notes ( insn ) ; if ( set_cfa ) { rtx r ; gcc_assert ( m -> fs . cfa_reg == src ) ; m -> fs . cfa_offset += INTVAL ( offset ) ; m -> fs . cfa_reg = dest ; r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( VOIDmode , dest , r ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , r ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( style < <NUM_LIT> ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( add_frame_related_expr ) { rtx r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( VOIDmode , 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 ; if ( src == hard_frame_pointer_rtx ) { valid = m -> fs . fp_valid ; ooffset = m -> fs . fp_offset ; } else if ( src == crtl -> drap_reg ) { valid = m -> fs . drap_valid ; ooffset = <NUM_LIT> ; } else { gcc_checking_assert ( src == stack_pointer_rtx || offset == const0_rtx ) ; } m -> fs . sp_offset = ooffset - INTVAL ( offset ) ; m -> fs . sp_valid = valid ; }


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; x = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( UNITS_PER_WORD ) ) ; x = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , x ) ;

add_reg_note ( insn , REG_FRAME_RELATED_EXPR , x ) ;


<s> if ( sr -> saved ) { struct machine_function * m = cfun -> machine ; rtx x , insn = emit_insn ( gen_pop ( sr -> reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; x = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( UNITS_PER_WORD ) ) ; x = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , x ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , x ) ; m -> fs . sp_offset -= UNITS_PER_WORD ; }


<s> int i ; for ( i = <NUM_LIT> ; i < MAX_386_ENTITIES ; i ++ ) ix86_optimize_mode_switching [ i ] = <NUM_LIT> ; ix86_optimize_mode_switching [ AVX_U128 ] = <NUM_LIT> ;

g -> get_passes ( ) -> execute_pass_mode_switching ( ) ;


<s> if ( GET_CODE ( symbol ) == PLUS && CONST_INT_P ( XEXP ( symbol , <NUM_LIT> ) ) ) symbol = XEXP ( symbol , <NUM_LIT> ) ; 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> if ( crtl -> stack_alignment_needed < GET_MODE_ALIGNMENT ( smode ) ) crtl -> stack_alignment_needed = GET_MODE_ALIGNMENT ( smode ) ; max = cum -> sse_regno + cfun -> va_list_fpr_size / <NUM_LIT> ; if ( max > X86_64_SSE_REGPARM_MAX ) max = X86_64_SSE_REGPARM_MAX ; for ( i = cum -> sse_regno ; i < max ; ++ i ) { mem = plus_constant ( Pmode , save_area , i * <NUM_LIT> + ix86_varargs_gpr_size ) ; mem = gen_rtx_MEM ( smode , mem ) ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; set_mem_alias_set ( mem , set ) ; set_mem_align ( mem , GET_MODE_ALIGNMENT ( smode ) ) ; emit_move_insn ( mem , gen_rtx_REG ( smode , SSE_REGNO ( i ) ) ) ;


<s> for ( i = <NUM_LIT> ; i < X86_TUNE_LAST ; ++ i ) { if ( ix86_tune_no_default ) ix86_tune_features [ i ] = <NUM_LIT> ;

else ix86_tune_features [ i ] = ! ! ( initial_ix86_tune_features [ i ] & ix86_tune_mask ) ;


<s> static void set_pic_reg_ever_live ( ) {

if ( reload_in_progress ) df_set_regs_ever_live ( REGNO ( pic_offset_table_rtx ) , true ) ;


<s> if ( reload_in_progress ) df_set_regs_ever_live ( REGNO ( pic_offset_table_rtx ) , true ) ;


<s> for ( arg = arglist ; arg ; arg = TREE_CHAIN ( arg ) ) { const char * str = TREE_STRING_POINTER ( TREE_VALUE ( arg ) ) ; size_t len = strlen ( str ) ; str_len_sum += len + <NUM_LIT> ; if ( arg != arglist ) argnum ++ ; for ( i = <NUM_LIT> ; i < strlen ( str ) ; i ++ ) if ( str [ i ] == ',' ) argnum ++ ; } attr_str = XNEWVEC ( char , str_len_sum ) ; str_len_sum = <NUM_LIT> ; for ( arg = arglist ; arg ; arg = TREE_CHAIN ( arg ) ) { const char * str = TREE_STRING_POINTER ( TREE_VALUE ( arg ) ) ; size_t len = strlen ( str ) ; memcpy ( attr_str + str_len_sum , str , len ) ; attr_str [ str_len_sum + len ] = TREE_CHAIN ( arg ) ? ',' : '\0' ; str_len_sum += len + <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < strlen ( attr_str ) ; i ++ ) if ( attr_str [ i ] == '=' || attr_str [ i ] == '-' ) attr_str [ i ] = '_' ; if ( argnum == <NUM_LIT> ) return attr_str ; args = XNEWVEC ( char * , argnum ) ; i = <NUM_LIT> ;

attr = strtok ( attr_str , <STR_LIT> ) ;


<s> rtx op = operands [ num ] ; if ( MEM_P ( op ) ) { lo_half [ num ] = adjust_address ( op , half_mode , <NUM_LIT> ) ; hi_half [ num ] = adjust_address ( op , half_mode , byte ) ; } else { lo_half [ num ] = simplify_gen_subreg ( half_mode , op , GET_MODE ( op ) == VOIDmode ? mode : GET_MODE ( op ) , <NUM_LIT> ) ; hi_half [ num ] = simplify_gen_subreg ( half_mode , op , GET_MODE ( op ) == VOIDmode ? mode : GET_MODE ( op ) , byte ) ; }


<s> case TImode : half_mode = DImode ; break ; case DImode : half_mode = SImode ; break ; default : gcc_unreachable ( ) ; } byte = GET_MODE_SIZE ( half_mode ) ; while ( num -- ) { rtx op = operands [ num ] ; if ( MEM_P ( op ) ) { lo_half [ num ] = adjust_address ( op , half_mode , <NUM_LIT> ) ; hi_half [ num ] = adjust_address ( op , half_mode , byte ) ; } else { lo_half [ num ] = simplify_gen_subreg ( half_mode , op , GET_MODE ( op ) == VOIDmode ? mode : GET_MODE ( op ) , <NUM_LIT> ) ; hi_half [ num ] = simplify_gen_subreg ( half_mode , op , GET_MODE ( op ) == VOIDmode ? mode : GET_MODE ( op ) , byte ) ;


<s> 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 ; }


<s> 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 ;


<s> if ( ! ( X87_FLOAT_MODE_P ( mode ) && ( GET_CODE ( x ) == CONST_DOUBLE ) ) ) return - <NUM_LIT> ; if ( x == CONST0_RTX ( mode ) ) return <NUM_LIT> ; if ( x == CONST1_RTX ( mode ) ) return <NUM_LIT> ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; if ( mode == XFmode && ( optimize_function_for_size_p ( cfun ) || TARGET_EXT_80387_CONSTANTS ) ) { int i ; if ( ! ext_80387_constants_init ) init_ext_80387_constants ( ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( real_identical ( & r , & ext_80387_constants_table [ i ] ) ) return i + <NUM_LIT> ; } if ( real_isnegzero ( & r ) ) return <NUM_LIT> ; if ( real_identical ( & r , & dconstm1 ) ) return <NUM_LIT> ;


<s> case MODE_V4DF : return <STR_LIT> ; case MODE_V8SF : return <STR_LIT> ; default : break ; } case <NUM_LIT> : if ( TARGET_AVX512VL || get_attr_mode ( insn ) == MODE_XI || get_attr_mode ( insn ) == MODE_V8DF || get_attr_mode ( insn ) == MODE_V16SF ) return <STR_LIT> ; if ( TARGET_AVX ) return <STR_LIT> ;


<s> return TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ; case MODE_V2DF : return <STR_LIT> ; case MODE_V4SF : return <STR_LIT> ; case MODE_OI : return TARGET_AVX512VL ? <STR_LIT> : <STR_LIT> ; case MODE_V4DF : return <STR_LIT> ; case MODE_V8SF : return <STR_LIT> ; default : break ; }


<s> if ( vector_all_ones_operand ( x , mode ) ) switch ( mode ) { case V16QImode : case V8HImode : case V4SImode : case V2DImode : if ( TARGET_SSE2 ) return <NUM_LIT> ; case V32QImode : case V16HImode : case V8SImode : case V4DImode : if ( TARGET_AVX2 ) return <NUM_LIT> ; case V64QImode : case V32HImode : case V16SImode : case V8DImode : if ( TARGET_AVX512F ) return <NUM_LIT> ;


<s> 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 ( TREE_CODE ( TREE_TYPE ( type ) ) == REAL_TYPE ) mode = MIN_MODE_VECTOR_FLOAT ; else mode = MIN_MODE_VECTOR_INT ; for ( ; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE ( mode ) ) if ( GET_MODE_NUNITS ( mode ) == TYPE_VECTOR_SUBPARTS ( type ) && GET_MODE_INNER ( mode ) == innermode ) { if ( size == <NUM_LIT> && ! TARGET_AVX512F ) { 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 ) { 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 ) { 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 ) && ! TARGET_MMX ) {


<s> unsigned int flags = default_section_type_flags ( decl , name , reloc ) ; if ( decl == NULL_TREE && ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) ) flags |= SECTION_RELRO ;

if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || strncmp ( name , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> || strncmp ( name , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) flags |= SECTION_BSS ;


<s> const char * sname = NULL ; unsigned int flags = SECTION_WRITE ; switch ( categorize_decl_for_section ( decl , reloc ) ) { case SECCAT_DATA : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_LOCAL : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_RO : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_RO_LOCAL : sname = <STR_LIT> ; break ; case SECCAT_BSS : sname = <STR_LIT> ; flags |= SECTION_BSS ; break ; case SECCAT_RODATA : case SECCAT_RODATA_MERGE_STR : case SECCAT_RODATA_MERGE_STR_INIT : case SECCAT_RODATA_MERGE_CONST : sname = <STR_LIT> ; flags = <NUM_LIT> ; break ; case SECCAT_SRODATA : case SECCAT_SDATA : case SECCAT_SBSS : gcc_unreachable ( ) ; case SECCAT_TEXT : case SECCAT_TDATA : case SECCAT_TBSS : break ; } if ( sname ) { if ( ! DECL_P ( decl ) ) return get_section ( sname , flags , NULL ) ; return get_named_section ( decl , sname , reloc ) ;


<s> break ; case SECCAT_DATA_REL : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_LOCAL : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_RO : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_RO_LOCAL : sname = <STR_LIT> ; break ; case SECCAT_BSS : sname = <STR_LIT> ; flags |= SECTION_BSS ; break ; case SECCAT_RODATA : case SECCAT_RODATA_MERGE_STR : case SECCAT_RODATA_MERGE_STR_INIT : case SECCAT_RODATA_MERGE_CONST : sname = <STR_LIT> ; flags = <NUM_LIT> ; break ; case SECCAT_SRODATA : case SECCAT_SDATA : case SECCAT_SBSS : gcc_unreachable ( ) ; case SECCAT_TEXT : case SECCAT_TDATA : case SECCAT_TBSS : break ; } if ( sname ) {

if ( ! DECL_P ( decl ) ) return get_section ( sname , flags , NULL ) ;


<s> void x86_elf_aligned_common ( FILE * file , const char * name , unsigned HOST_WIDE_INT size , int align ) { if ( ( ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC ) && size > ( unsigned int ) ix86_section_threshold ) fputs ( <STR_LIT> , file ) ; else fputs ( COMMON_ASM_OP , file ) ;


<s> inmode = GET_MODE ( operands [ <NUM_LIT> ] ) ; gcc_assert ( inmode == SImode || inmode == DImode ) ; out = operands [ <NUM_LIT> ] ; in = force_reg ( inmode , operands [ <NUM_LIT> ] ) ; mode = GET_MODE ( out ) ; neglab = gen_label_rtx ( ) ; donelab = gen_label_rtx ( ) ; f0 = gen_reg_rtx ( mode ) ; emit_cmp_and_jump_insns ( in , const0_rtx , LT , const0_rtx , inmode , <NUM_LIT> , neglab ) ; expand_float ( out , in , <NUM_LIT> ) ; emit_jump_insn ( gen_jump ( donelab ) ) ; emit_barrier ( ) ; emit_label ( neglab ) ;

i0 = expand_simple_binop ( inmode , LSHIFTRT , in , const1_rtx , NULL , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> donelab = gen_label_rtx ( ) ; f0 = gen_reg_rtx ( mode ) ; emit_cmp_and_jump_insns ( in , const0_rtx , LT , const0_rtx , inmode , <NUM_LIT> , neglab ) ; expand_float ( out , in , <NUM_LIT> ) ; emit_jump_insn ( gen_jump ( donelab ) ) ; emit_barrier ( ) ; emit_label ( neglab ) ; i0 = expand_simple_binop ( inmode , LSHIFTRT , in , const1_rtx , NULL , <NUM_LIT> , OPTAB_DIRECT ) ;

i1 = expand_simple_binop ( inmode , AND , in , const1_rtx , NULL , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> if ( TARGET_64BIT || TARGET_ALIGN_DOUBLE ) return computed ; mode = TYPE_MODE ( strip_array_types ( type ) ) ; if ( mode == DFmode || mode == DCmode || GET_MODE_CLASS ( mode ) == MODE_INT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT ) return MIN ( <NUM_LIT> , computed ) ;


<s> if ( TARGET_64BIT ) { fprintf ( file , <STR_LIT> , LPREFIX , labelno ) ; if ( ! TARGET_PECOFF && flag_pic ) fprintf ( file , <STR_LIT> , mcount_name ) ; else x86_print_call_or_nop ( file , mcount_name ) ; } else if ( flag_pic ) { fprintf ( file , <STR_LIT> PROFILE_COUNT_REGISTER <STR_LIT> , LPREFIX , labelno ) ; fprintf ( file , <STR_LIT> , mcount_name ) ; } else { fprintf ( file , <STR_LIT> PROFILE_COUNT_REGISTER <STR_LIT> , LPREFIX , labelno ) ; x86_print_call_or_nop ( file , mcount_name ) ; } if ( flag_record_mcount ) { fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> ) ;


<s> switch ( mode ) { case DImode : gcc_assert ( x86_64_immediate_operand ( * loc , mode ) ) ; mode = SImode ; break ; case SImode : case HImode : case QImode : break ; default : gcc_unreachable ( ) ; } if ( mode_signbit_p ( mode , * loc ) ) return false ; val = INTVAL ( * loc ) ; if ( ( val < <NUM_LIT> && val != - <NUM_LIT> ) || val == <NUM_LIT> ) { * loc = GEN_INT ( - val ) ; return true ; } return false ;


<s> int i ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( GENERAL_REGNO_P ( i ) && call_used_regs [ i ] ) reg_alloc_order [ pos ++ ] = i ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( GENERAL_REGNO_P ( i ) && ! call_used_regs [ i ] ) reg_alloc_order [ pos ++ ] = i ; if ( ! TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_SSE_REG ; i <= LAST_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;

for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;


<s> for ( i = FIRST_SSE_REG ; i <= LAST_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_MASK_REG ; i <= LAST_MASK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_BND_REG ; i <= LAST_BND_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; if ( TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;

for ( i = FIRST_MMX_REG ; i <= LAST_MMX_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;


<s> if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) tmp_regno = AX_REG ; else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) tmp_regno = DX_REG ; else tmp_regno = CX_REG ; } emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( REG_P ( this_param ) ) this_reg = this_param ; else if ( vcall_offset ) { this_reg = gen_rtx_REG ( Pmode , AX_REG ) ; emit_move_insn ( this_reg , this_param ) ; } else this_reg = NULL_RTX ; if ( delta ) { rtx delta_rtx = GEN_INT ( delta ) ; rtx delta_dst = this_reg ? this_reg : this_param ; if ( TARGET_64BIT ) { if ( ! x86_64_general_operand ( delta_rtx , Pmode ) ) { tmp = gen_rtx_REG ( Pmode , tmp_regno ) ; emit_move_insn ( tmp , delta_rtx ) ; delta_rtx = tmp ; } } ix86_emit_binop ( PLUS , Pmode , delta_dst , delta_rtx ) ; } if ( vcall_offset ) { rtx vcall_addr , vcall_mem , this_mem ; tmp = gen_rtx_REG ( Pmode , tmp_regno ) ; this_mem = gen_rtx_MEM ( ptr_mode , this_reg ) ; if ( Pmode != ptr_mode ) this_mem = gen_rtx_ZERO_EXTEND ( Pmode , this_mem ) ; emit_move_insn ( tmp , this_mem ) ; vcall_addr = plus_constant ( Pmode , tmp , vcall_offset ) ; if ( TARGET_64BIT && ! ix86_legitimate_address_p ( ptr_mode , vcall_addr , true ) ) { rtx tmp2 = gen_rtx_REG ( Pmode , R11_REG ) ; emit_move_insn ( tmp2 , GEN_INT ( vcall_offset ) ) ; vcall_addr = gen_rtx_PLUS ( Pmode , tmp , tmp2 ) ; } vcall_mem = gen_rtx_MEM ( ptr_mode , vcall_addr ) ; if ( Pmode != ptr_mode ) emit_insn ( gen_addsi_1_zext ( this_reg , gen_rtx_REG ( ptr_mode , REGNO ( this_reg ) ) , vcall_mem ) ) ; else ix86_emit_binop ( PLUS , Pmode , this_reg , vcall_mem ) ; } if ( this_reg && this_reg != this_param ) emit_move_insn ( this_param , this_reg ) ; fnaddr = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; if ( TARGET_64BIT ) { if ( ! flag_pic || targetm . binds_local_p ( function ) || TARGET_PECOFF ) ; else { tmp = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , fnaddr ) , UNSPEC_GOTPCREL ) ; tmp = gen_rtx_CONST ( Pmode , tmp ) ; fnaddr = gen_const_mem ( Pmode , tmp ) ; } } else {

if ( ! flag_pic || targetm . binds_local_p ( function ) ) ;


<s> static void x86_print_call_or_nop ( FILE * file , const char * target ) { if ( flag_nop_mcount ) fprintf ( file , <STR_LIT> ) ;

else fprintf ( file , <STR_LIT> , target ) ;


<s> bitmap_set_bit ( insns , insn_uid ) ; rtx_insn * insn = DF_INSN_UID_GET ( insn_uid ) -> insn ; rtx def_set = single_set ( insn ) ; if ( def_set && REG_P ( SET_DEST ( def_set ) ) && ! HARD_REGISTER_P ( SET_DEST ( def_set ) ) ) bitmap_set_bit ( defs , REGNO ( SET_DEST ( def_set ) ) ) ; df_ref ref ; df_ref def ; for ( ref = DF_INSN_UID_DEFS ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! HARD_REGISTER_P ( DF_REF_REG ( ref ) ) ) for ( def = DF_REG_DEF_CHAIN ( DF_REF_REGNO ( ref ) ) ;


<s> rtx_insn * insn = DF_INSN_UID_GET ( insn_uid ) -> insn ; rtx def_set = single_set ( insn ) ; if ( def_set && REG_P ( SET_DEST ( def_set ) ) && ! HARD_REGISTER_P ( SET_DEST ( def_set ) ) ) bitmap_set_bit ( defs , REGNO ( SET_DEST ( def_set ) ) ) ; df_ref ref ; df_ref def ; for ( ref = DF_INSN_UID_DEFS ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! HARD_REGISTER_P ( DF_REF_REG ( ref ) ) ) for ( def = DF_REG_DEF_CHAIN ( DF_REF_REGNO ( ref ) ) ; def ; def = DF_REF_NEXT_REG ( def ) ) analyze_register_chain ( candidates , def ) ;

for ( ref = DF_INSN_UID_USES ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! DF_REF_REG_MEM_P ( ref ) ) analyze_register_chain ( candidates , ref ) ;


<s> case V16QImode : mode = V8HImode ; break ; case V32QImode : mode = V16HImode ; break ; case V64QImode : mode = V32HImode ; break ; case V8HImode : mode = V4SImode ; break ; case V16HImode : mode = V8SImode ; break ; case V32HImode : mode = V16SImode ; break ; case V4SImode : mode = V2DImode ; break ; case V8SImode : mode = V4DImode ; break ; case V16SImode : mode = V8DImode ; break ; default : return false ; } for ( i = <NUM_LIT> ; i < d -> nelt ; i += <NUM_LIT> ) if ( ( d -> perm [ i ] & <NUM_LIT> ) || d -> perm [ i + <NUM_LIT> ] != d -> perm [ i ] + <NUM_LIT> ) return false ; nd -> vmode = mode ; nd -> nelt = d -> nelt / <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nd -> nelt ; i ++ ) nd -> perm [ i ] = d -> perm [ <NUM_LIT> * i ] / <NUM_LIT> ; if ( GET_MODE_INNER ( mode ) != DImode ) canonicalize_vector_int_perm ( nd , nd ) ; if ( nd != d ) { nd -> one_operand_p = d -> one_operand_p ; nd -> testing_p = d -> testing_p ; if ( d -> op0 == d -> op1 ) nd -> op0 = nd -> op1 = gen_lowpart ( nd -> vmode , d -> op0 ) ; else { nd -> op0 = gen_lowpart ( nd -> vmode , d -> op0 ) ; nd -> op1 = gen_lowpart ( nd -> vmode , d -> op1 ) ; } if ( d -> testing_p ) nd -> target = gen_raw_REG ( nd -> vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; else nd -> target = gen_reg_rtx ( nd -> vmode ) ; } return true ;


<s> int i ; enum machine_mode mode = VOIDmode ; switch ( d -> vmode ) { case V16QImode : mode = V8HImode ; break ; case V32QImode : mode = V16HImode ; break ; case V64QImode : mode = V32HImode ; break ; case V8HImode : mode = V4SImode ; break ; case V16HImode : mode = V8SImode ; break ; case V32HImode : mode = V16SImode ; break ; case V4SImode : mode = V2DImode ; break ; case V8SImode : mode = V4DImode ; break ; case V16SImode : mode = V8DImode ; break ; default : return false ; } for ( i = <NUM_LIT> ; i < d -> nelt ; i += <NUM_LIT> ) if ( ( d -> perm [ i ] & <NUM_LIT> ) || d -> perm [ i + <NUM_LIT> ] != d -> perm [ i ] + <NUM_LIT> ) return false ; nd -> vmode = mode ; nd -> nelt = d -> nelt / <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nd -> nelt ; i ++ ) nd -> perm [ i ] = d -> perm [ <NUM_LIT> * i ] / <NUM_LIT> ; if ( GET_MODE_INNER ( mode ) != DImode ) canonicalize_vector_int_perm ( nd , nd ) ; if ( nd != d ) { nd -> one_operand_p = d -> one_operand_p ; nd -> testing_p = d -> testing_p ;

if ( d -> op0 == d -> op1 ) nd -> op0 = nd -> op1 = gen_lowpart ( nd -> vmode , d -> op0 ) ;


<s> EXECUTE_IF_SET_IN_BITMAP ( defs , <NUM_LIT> , id , bi ) convert_reg ( id ) ; EXECUTE_IF_AND_COMPL_IN_BITMAP ( defs_conv , defs , <NUM_LIT> , id , bi ) make_vector_copies ( id ) ; EXECUTE_IF_SET_IN_BITMAP ( insns , <NUM_LIT> , id , bi ) { convert_insn ( DF_INSN_UID_GET ( id ) -> insn ) ; converted_insns ++ ; }


<s> rtx op2 = XEXP ( src , <NUM_LIT> ) ; if ( op2 != CONST0_RTX ( GET_MODE ( op2 ) ) ) return false ; if ( GET_CODE ( op1 ) != IOR ) return false ; op2 = XEXP ( op1 , <NUM_LIT> ) ; op1 = XEXP ( op1 , <NUM_LIT> ) ; if ( ! SUBREG_P ( op1 ) || ! SUBREG_P ( op2 ) || GET_MODE ( op1 ) != SImode || GET_MODE ( op2 ) != SImode || ( ( SUBREG_BYTE ( op1 ) != <NUM_LIT> || SUBREG_BYTE ( op2 ) != GET_MODE_SIZE ( SImode ) ) && ( SUBREG_BYTE ( op2 ) != <NUM_LIT> || SUBREG_BYTE ( op1 ) != GET_MODE_SIZE ( SImode ) ) ) ) return false ; op1 = SUBREG_REG ( op1 ) ;


<s> PUT_MODE ( src , V2DImode ) ; break ; case MEM : if ( ! REG_P ( dst ) ) convert_op ( & src , insn ) ; break ; case REG : if ( ! MEM_P ( dst ) ) convert_op ( & src , insn ) ; break ; case SUBREG : gcc_assert ( GET_MODE ( src ) == V2DImode ) ; break ; case COMPARE : src = SUBREG_REG ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ; gcc_assert ( ( REG_P ( src ) && GET_MODE ( src ) == DImode ) || ( SUBREG_P ( src ) && GET_MODE ( src ) == V2DImode ) ) ; if ( REG_P ( src ) ) subreg = gen_rtx_SUBREG ( V2DImode , src , <NUM_LIT> ) ;

else subreg = copy_rtx_if_shared ( src ) ;


<s> conv = BITMAP_ALLOC ( NULL ) ; bitmap_copy ( conv , insns ) ; if ( scalar_copy ) scopy = gen_reg_rtx ( DImode ) ; for ( ref = DF_REG_DEF_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) { rtx_insn * insn = DF_REF_INSN ( ref ) ; rtx def_set = single_set ( insn ) ; rtx src = SET_SRC ( def_set ) ; rtx reg = DF_REF_REG ( ref ) ; if ( ! MEM_P ( src ) ) { replace_with_subreg_in_insn ( insn , reg , reg ) ; bitmap_clear_bit ( conv , INSN_UID ( insn ) ) ; } if ( scalar_copy ) { rtx vcopy = gen_reg_rtx ( V2DImode ) ; start_sequence ( ) ; if ( TARGET_INTER_UNIT_MOVES_FROM_VEC ) { emit_move_insn ( vcopy , gen_rtx_SUBREG ( V2DImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , vcopy , <NUM_LIT> ) ) ; emit_move_insn ( vcopy , gen_rtx_LSHIFTRT ( V2DImode , vcopy , GEN_INT ( <NUM_LIT> ) ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , vcopy , <NUM_LIT> ) ) ; } else { rtx tmp = assign_386_stack_local ( DImode , SLOT_TEMP ) ; emit_move_insn ( tmp , reg ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; emit_conversion_insns ( seq , insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( scopy ) , INSN_UID ( insn ) ) ; } } for ( ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { if ( bitmap_bit_p ( conv , DF_REF_INSN_UID ( ref ) ) ) { rtx def_set = single_set ( DF_REF_INSN ( ref ) ) ; if ( ! MEM_P ( SET_DEST ( def_set ) ) || ! REG_P ( SET_SRC ( def_set ) ) ) replace_with_subreg_in_insn ( DF_REF_INSN ( ref ) , reg , reg ) ; bitmap_clear_bit ( conv , DF_REF_INSN_UID ( ref ) ) ; } } else if ( DF_REF_CHAIN ( ref ) && NONDEBUG_INSN_P ( DF_REF_INSN ( ref ) ) ) { gcc_assert ( scopy ) ; replace_rtx ( DF_REF_INSN ( ref ) , reg , scopy ) ;

df_insn_rescan ( DF_REF_INSN ( ref ) ) ;


<s> calculate_dominance_info ( CDI_DOMINATORS ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; df_chain_add_problem ( DF_DU_CHAIN | DF_UD_CHAIN ) ; df_md_add_problem ( ) ; df_analyze ( ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; FOR_EACH_BB_FN ( bb , cfun ) { rtx_insn * insn ; FOR_BB_INSNS ( bb , insn ) if ( scalar_to_vector_candidate_p ( insn ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) ) ; bitmap_set_bit ( candidates , INSN_UID ( insn ) ) ; } } remove_non_convertible_regs ( candidates ) ; if ( bitmap_empty_p ( candidates ) ) if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; while ( ! bitmap_empty_p ( candidates ) ) { unsigned uid = bitmap_first_set_bit ( candidates ) ; scalar_chain chain ; chain . build ( candidates , uid ) ; if ( chain . compute_convert_gain ( ) > <NUM_LIT> ) converted_insns += chain . convert ( ) ; else if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain . chain_id ) ; } if ( dump_file ) fprintf ( dump_file , <STR_LIT> , converted_insns ) ; BITMAP_FREE ( candidates ) ;


<s> int converted_insns = <NUM_LIT> ; bitmap_obstack_initialize ( NULL ) ; candidates = BITMAP_ALLOC ( NULL ) ; calculate_dominance_info ( CDI_DOMINATORS ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; df_chain_add_problem ( DF_DU_CHAIN | DF_UD_CHAIN ) ; df_md_add_problem ( ) ; df_analyze ( ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; FOR_EACH_BB_FN ( bb , cfun ) { rtx_insn * insn ; FOR_BB_INSNS ( bb , insn ) if ( scalar_to_vector_candidate_p ( insn ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) ) ; bitmap_set_bit ( candidates , INSN_UID ( insn ) ) ; } } remove_non_convertible_regs ( candidates ) ; if ( bitmap_empty_p ( candidates ) ) if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; while ( ! bitmap_empty_p ( candidates ) ) { unsigned uid = bitmap_first_set_bit ( candidates ) ; scalar_chain chain ; chain . build ( candidates , uid ) ;

if ( chain . compute_convert_gain ( ) > <NUM_LIT> ) converted_insns += chain . convert ( ) ;


<s> if ( ! ( mask & OPTION_MASK_ISA_64BIT ) || TARGET_64BIT ) { ix86_builtins_isa [ ( int ) code ] . isa = mask ; if ( mask & ix86_isa_flags & OPTION_MASK_ISA_AVX512VL ) mask &= ~ OPTION_MASK_ISA_AVX512VL ; mask &= ~ OPTION_MASK_ISA_64BIT ; if ( mask == <NUM_LIT> || ( mask & ix86_isa_flags ) != <NUM_LIT> || ( lang_hooks . builtin_function == lang_hooks . builtin_function_ext_scope ) ) { tree type = ix86_get_builtin_func_type ( tcode ) ; decl = add_builtin_function ( name , type , code , BUILT_IN_MD , NULL , NULL_TREE ) ; ix86_builtins [ ( int ) code ] = decl ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = false ; } else { deferred_isa_values |= mask ;

ix86_builtins [ ( int ) code ] = NULL_TREE ;


<s> if ( mask & ix86_isa_flags & OPTION_MASK_ISA_AVX512VL ) mask &= ~ OPTION_MASK_ISA_AVX512VL ; mask &= ~ OPTION_MASK_ISA_64BIT ; if ( mask == <NUM_LIT> || ( mask & ix86_isa_flags ) != <NUM_LIT> || ( lang_hooks . builtin_function == lang_hooks . builtin_function_ext_scope ) ) { tree type = ix86_get_builtin_func_type ( tcode ) ; decl = add_builtin_function ( name , type , code , BUILT_IN_MD , NULL , NULL_TREE ) ; ix86_builtins [ ( int ) code ] = decl ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = false ; } else { deferred_isa_values |= mask ; ix86_builtins [ ( int ) code ] = NULL_TREE ; ix86_builtins_isa [ ( int ) code ] . tcode = tcode ; ix86_builtins_isa [ ( int ) code ] . name = name ; ix86_builtins_isa [ ( int ) code ] . leaf_p = false ; ix86_builtins_isa [ ( int ) code ] . nothrow_p = false ; ix86_builtins_isa [ ( int ) code ] . const_p = false ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = true ; } } return decl ;


<s> gimple * ifunc_cpu_init_stmt ; gimple_seq gseq ; int ix ; tree ele ; vec < tree > * fndecls ; unsigned int num_versions = <NUM_LIT> ; unsigned int actual_versions = <NUM_LIT> ; unsigned int i ; struct _function_version_info { tree version_decl ; tree predicate_chain ; unsigned int dispatch_priority ; } * function_version_info ; gcc_assert ( dispatch_decl != NULL && fndecls_p != NULL && empty_bb != NULL ) ; fndecls = static_cast < vec < tree > * > ( fndecls_p ) ; num_versions = fndecls -> length ( ) ; gcc_assert ( num_versions >= <NUM_LIT> ) ; function_version_info = ( struct _function_version_info * ) XNEWVEC ( struct _function_version_info , ( num_versions - <NUM_LIT> ) ) ; default_decl = ( * fndecls ) [ <NUM_LIT> ] ; push_cfun ( DECL_STRUCT_FUNCTION ( dispatch_decl ) ) ; gseq = bb_seq ( * empty_bb ) ; ifunc_cpu_init_stmt = gimple_build_call_vec ( ix86_builtins [ ( int ) IX86_BUILTIN_CPU_INIT ] , vNULL ) ; gimple_seq_add_stmt ( & gseq , ifunc_cpu_init_stmt ) ; gimple_set_bb ( ifunc_cpu_init_stmt , * empty_bb ) ; set_bb_seq ( * empty_bb , gseq ) ; pop_cfun ( ) ; for ( ix = <NUM_LIT> ; fndecls -> iterate ( ix , & ele ) ; ++ ix ) { tree version_decl = ele ; tree predicate_chain = NULL_TREE ; unsigned int priority ; priority = get_builtin_code_for_version ( version_decl , & predicate_chain ) ; if ( predicate_chain == NULL_TREE ) continue ; function_version_info [ actual_versions ] . version_decl = version_decl ; function_version_info [ actual_versions ] . predicate_chain = predicate_chain ;

function_version_info [ actual_versions ] . dispatch_priority = priority ;


<s> emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_CEIL ; break ; case I387_CW_MASK_PM : emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_MASK_PM ; break ; default : gcc_unreachable ( ) ; } } else { switch ( mode ) { case I387_CW_TRUNC : emit_insn ( gen_insvsi_1 ( reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_TRUNC ; break ; case I387_CW_FLOOR : emit_insn ( gen_insvsi_1 ( reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_FLOOR ; break ;


<s> break ; case I387_CW_FLOOR : emit_insn ( gen_andhi3 ( reg , reg , GEN_INT ( ~ <NUM_LIT> ) ) ) ; emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_FLOOR ; break ; case I387_CW_CEIL : emit_insn ( gen_andhi3 ( reg , reg , GEN_INT ( ~ <NUM_LIT> ) ) ) ; emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_CEIL ; break ; case I387_CW_MASK_PM : emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_MASK_PM ; break ; default : gcc_unreachable ( ) ; } }


<s> virtual unsigned int execute ( function * ) { return convert_scalars_to_vector ( ) ;


<s> } if ( ! issetmem ) srcmem = change_address ( srcmem , mode , * srcptr ) ; destmem = change_address ( destmem , mode , * destptr ) ; modesize = GEN_INT ( GET_MODE_SIZE ( mode ) ) ; for ( n = <NUM_LIT> ; prolog_size < desired_align - align ; n ++ ) { if ( issetmem ) emit_move_insn ( destmem , mode_value ) ; else { emit_move_insn ( destmem , srcmem ) ; srcmem = offset_address ( srcmem , modesize , GET_MODE_SIZE ( mode ) ) ; } destmem = offset_address ( destmem , modesize , GET_MODE_SIZE ( mode ) ) ; prolog_size += GET_MODE_SIZE ( mode ) ; } destmem = offset_address ( destmem , * count , <NUM_LIT> ) ; destmem = offset_address ( destmem , GEN_INT ( - size - prolog_size ) , <NUM_LIT> ) ; if ( issetmem ) emit_move_insn ( destmem , mode_value ) ; else { srcmem = offset_address ( srcmem , * count , <NUM_LIT> ) ; srcmem = offset_address ( srcmem , GEN_INT ( - size - prolog_size ) , <NUM_LIT> ) ; emit_move_insn ( destmem , srcmem ) ; } for ( n = <NUM_LIT> ; n * GET_MODE_SIZE ( mode ) < size ; n ++ ) { destmem = offset_address ( destmem , modesize , <NUM_LIT> ) ; if ( issetmem ) emit_move_insn ( destmem , mode_value ) ; else { srcmem = offset_address ( srcmem , modesize , <NUM_LIT> ) ; emit_move_insn ( destmem , srcmem ) ; } } if ( desired_align > <NUM_LIT> && desired_align > align ) { rtx saveddest = * destptr ; gcc_assert ( desired_align <= size ) ; * destptr = expand_simple_binop ( GET_MODE ( * destptr ) , PLUS , * destptr , GEN_INT ( prolog_size ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; if ( REG_P ( * destptr ) && REG_P ( saveddest ) && REG_POINTER ( saveddest ) ) REG_POINTER ( * destptr ) = <NUM_LIT> ; * destptr = expand_simple_binop ( GET_MODE ( * destptr ) , AND , * destptr , GEN_INT ( - desired_align ) , * destptr , <NUM_LIT> , OPTAB_DIRECT ) ; saveddest = expand_simple_binop ( GET_MODE ( * destptr ) , MINUS , saveddest , * destptr , saveddest , <NUM_LIT> , OPTAB_DIRECT ) ;

if ( ! issetmem ) * srcptr = expand_simple_binop ( GET_MODE ( * srcptr ) , MINUS , * srcptr , saveddest , * srcptr , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> countreg = ix86_zero_extend_to_Pmode ( scale_counter ( count , GET_MODE_SIZE ( mode ) ) ) ; if ( mode != QImode ) { destexp = gen_rtx_ASHIFT ( Pmode , countreg , GEN_INT ( exact_log2 ( GET_MODE_SIZE ( mode ) ) ) ) ; destexp = gen_rtx_PLUS ( Pmode , destexp , destptr ) ; } else destexp = gen_rtx_PLUS ( Pmode , destptr , countreg ) ; if ( ( ! issetmem || orig_value == const0_rtx ) && CONST_INT_P ( count ) ) { rounded_count = ROUND_DOWN ( INTVAL ( count ) , ( HOST_WIDE_INT ) GET_MODE_SIZE ( mode ) ) ; destmem = shallow_copy_rtx ( destmem ) ; set_mem_size ( destmem , rounded_count ) ; } else if ( MEM_SIZE_KNOWN_P ( destmem ) ) clear_mem_size ( destmem ) ; if ( issetmem ) { value = force_reg ( mode , gen_lowpart ( mode , value ) ) ; emit_insn ( gen_rep_stos ( destptr , countreg , destmem , value , destexp ) ) ; } else { if ( srcptr != XEXP ( srcmem , <NUM_LIT> ) || GET_MODE ( srcmem ) != BLKmode ) srcmem = adjust_automodify_address_nv ( srcmem , BLKmode , srcptr , <NUM_LIT> ) ; if ( mode != QImode ) { srcexp = gen_rtx_ASHIFT ( Pmode , countreg , GEN_INT ( exact_log2 ( GET_MODE_SIZE ( mode ) ) ) ) ; srcexp = gen_rtx_PLUS ( Pmode , srcexp , srcptr ) ; } else srcexp = gen_rtx_PLUS ( Pmode , srcptr , countreg ) ; if ( CONST_INT_P ( count ) ) { rounded_count = ROUND_DOWN ( INTVAL ( count ) , ( HOST_WIDE_INT ) GET_MODE_SIZE ( mode ) ) ; srcmem = shallow_copy_rtx ( srcmem ) ; set_mem_size ( srcmem , rounded_count ) ;


<s> } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , nd . perm , nelt , d -> testing_p ) ) return true ; } } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op1 , d -> perm , nelt , d -> testing_p ) ) return true ; if ( ! d -> one_operand_p ) { for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned e = d -> perm [ i ] ; if ( e >= nelt ) e -= nelt ; else e += nelt ; nd . perm [ i ] = e ; } if ( expand_vselect_vconcat ( d -> target , d -> op1 , d -> op0 , nd . perm , nelt , d -> testing_p ) ) return true ; } if ( expand_vec_perm_blend ( d ) ) return true ; if ( expand_vec_perm_vpermil ( d ) ) return true ; if ( expand_vec_perm_pshufb ( d ) ) return true ; if ( expand_vec_perm_palignr ( d , true ) ) return true ; if ( ix86_expand_vec_perm_vpermi2 ( NULL_RTX , NULL_RTX , NULL_RTX , NULL_RTX , d ) ) return true ; if ( canonicalize_vector_int_perm ( d , & nd ) && expand_vec_perm_1 ( & nd ) ) { if ( ! d -> testing_p ) emit_move_insn ( d -> target , gen_lowpart ( d -> vmode , nd . target ) ) ; return true ;


<s> case V8DImode : if ( TARGET_AVX512F ) gen = gen_avx512f_vec_dupv8di_1 ; break ; default : break ; } if ( gen != NULL ) { if ( ! d -> testing_p ) emit_insn ( gen ( d -> target , d -> op0 ) ) ; return true ; } } if ( expand_vselect ( d -> target , d -> op0 , nd . perm , nelt , d -> testing_p ) ) return true ; for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { nd . perm [ i ] = d -> perm [ i ] & mask ; nd . perm [ i + <NUM_LIT> ] = ( d -> perm [ i + <NUM_LIT> ] & mask ) + nelt ; } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , nd . perm , nelt , d -> testing_p ) ) return true ; if ( nelt >= <NUM_LIT> ) { for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { nd . perm [ i + <NUM_LIT> ] = d -> perm [ i + <NUM_LIT> ] & mask ; nd . perm [ i + <NUM_LIT> ] = d -> perm [ i + <NUM_LIT> ] & mask ; nd . perm [ i + <NUM_LIT> ] = ( d -> perm [ i + <NUM_LIT> ] & mask ) + nelt ; nd . perm [ i + <NUM_LIT> ] = ( d -> perm [ i + <NUM_LIT> ] & mask ) + nelt ; } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , nd . perm , nelt , d -> testing_p ) ) return true ; } } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op1 , d -> perm , nelt , d -> testing_p ) ) return true ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) mask |= ( d -> perm [ i * <NUM_LIT> ] >= <NUM_LIT> ) << i ; vmode = V16HImode ; goto do_subreg ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) mask |= ( d -> perm [ i * <NUM_LIT> ] >= <NUM_LIT> ) << i ; vmode = V8SImode ; goto do_subreg ; case V16HImode : for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i += <NUM_LIT> ) if ( d -> perm [ i ] + <NUM_LIT> != d -> perm [ i + <NUM_LIT> ] ) break ; if ( i < <NUM_LIT> ) { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( d -> perm [ i ] + <NUM_LIT> != d -> perm [ i + <NUM_LIT> ] ) { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) rperm [ i ] = ( d -> perm [ i / <NUM_LIT> ] < <NUM_LIT> ? const0_rtx : constm1_rtx ) ; vmode = V32QImode ; nelt = <NUM_LIT> ; target = gen_reg_rtx ( vmode ) ; op0 = gen_lowpart ( vmode , op0 ) ; op1 = gen_lowpart ( vmode , op1 ) ; goto finish_pblendvb ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) mask |= ( d -> perm [ i ] >= <NUM_LIT> ) << i ; break ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) mask |= ( d -> perm [ i * <NUM_LIT> ] >= <NUM_LIT> ) << i ; vmode = V8SImode ; goto do_subreg ; case V4DImode : for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) mask |= ( d -> perm [ i ] >= <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) << ( i * <NUM_LIT> ) ; vmode = V8SImode ; goto do_subreg ; default : gcc_unreachable ( ) ; } switch ( vmode ) { case V8DFmode : case V8DImode : mmode = QImode ; break ;


<s> return false ; } if ( valid_perm_using_mode_p ( V16SImode , d ) ) vmode = V16SImode ; } else if ( d -> vmode == V16SFmode ) vmode = V16SImode ; if ( vmode == V64QImode ) { for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( ( d -> perm [ i ] ^ i ) & ( nelt / <NUM_LIT> ) ) return false ; } } else return false ; } if ( d -> testing_p ) return true ; if ( vmode == V8SImode ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) rperm [ i ] = GEN_INT ( ( d -> perm [ i * nelt / <NUM_LIT> ] * <NUM_LIT> / nelt ) & <NUM_LIT> ) ; else if ( vmode == V16SImode ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) rperm [ i ] = GEN_INT ( ( d -> perm [ i * nelt / <NUM_LIT> ] * <NUM_LIT> / nelt ) & <NUM_LIT> ) ; else { eltsz = GET_MODE_UNIT_SIZE ( d -> vmode ) ; if ( ! d -> one_operand_p ) mask = <NUM_LIT> * nelt - <NUM_LIT> ; else if ( vmode == V16QImode ) mask = nelt - <NUM_LIT> ; else if ( vmode == V64QImode ) mask = nelt / <NUM_LIT> - <NUM_LIT> ; else mask = nelt / <NUM_LIT> - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned j , e = d -> perm [ i ] & mask ; for ( j = <NUM_LIT> ; j < eltsz ; ++ j ) rperm [ i * eltsz + j ] = GEN_INT ( e * eltsz + j ) ; } } vperm = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( GET_MODE_NUNITS ( vmode ) , rperm ) ) ; vperm = force_reg ( vmode , vperm ) ; target = d -> target ; if ( d -> vmode != vmode ) target = gen_reg_rtx ( vmode ) ; op0 = gen_lowpart ( vmode , d -> op0 ) ; if ( d -> one_operand_p ) { if ( vmode == V16QImode ) emit_insn ( gen_ssse3_pshufbv16qi3 ( target , op0 , vperm ) ) ; else if ( vmode == V32QImode ) emit_insn ( gen_avx2_pshufbv32qi3 ( target , op0 , vperm ) ) ; else if ( vmode == V64QImode ) emit_insn ( gen_avx512bw_pshufbv64qi3 ( target , op0 , vperm ) ) ;

else if ( vmode == V8SFmode ) emit_insn ( gen_avx2_permvarv8sf ( target , op0 , vperm ) ) ;


<s> case CONST_DOUBLE : case CONST_WIDE_INT : ( imm_values -> imm ) ++ ; ( imm_values -> imm64 ) ++ ; break ; case CODE_LABEL : if ( LABEL_KIND ( x ) == LABEL_NORMAL ) { ( imm_values -> imm ) ++ ; ( imm_values -> imm32 ) ++ ;


<s> const char * const name ; const enum processor_features feature ; } const isa_names_table [ ] = { { <STR_LIT> , F_CMOV } , { <STR_LIT> , F_MMX } , { <STR_LIT> , F_POPCNT } , { <STR_LIT> , F_SSE } , { <STR_LIT> , F_SSE2 } , { <STR_LIT> , F_SSE3 } , { <STR_LIT> , F_SSSE3 } , { <STR_LIT> , F_SSE4_A } , { <STR_LIT> , F_SSE4_1 } , { <STR_LIT> , F_SSE4_2 } , { <STR_LIT> , F_AVX } , { <STR_LIT> , F_FMA4 } , { <STR_LIT> , F_XOP } , { <STR_LIT> , F_FMA } , { <STR_LIT> , F_AVX2 } , { <STR_LIT> , F_AVX512F } , { <STR_LIT> , F_BMI } , { <STR_LIT> , F_BMI2 } , { <STR_LIT> , F_AES } , { <STR_LIT> , F_PCLMUL } , { <STR_LIT> , F_AVX512VL } , { <STR_LIT> , F_AVX512BW } , { <STR_LIT> , F_AVX512DQ } , { <STR_LIT> , F_AVX512CD } , { <STR_LIT> , F_AVX512ER } , { <STR_LIT> , F_AVX512PF } , { <STR_LIT> , F_AVX512VBMI } , { <STR_LIT> , F_AVX512IFMA } , } ; tree __processor_model_type = build_processor_model_struct ( ) ; tree __cpu_model_var = make_var_decl ( __processor_model_type , <STR_LIT> ) ; varpool_node :: add ( __cpu_model_var ) ; gcc_assert ( ( args != NULL ) && ( * args != NULL ) ) ; param_string_cst = * args ; while ( param_string_cst && TREE_CODE ( param_string_cst ) != STRING_CST ) { if ( ! EXPR_P ( param_string_cst ) ) { error ( <STR_LIT> ) ; return integer_zero_node ; } param_string_cst = TREE_OPERAND ( EXPR_CHECK ( param_string_cst ) , <NUM_LIT> ) ; } gcc_assert ( param_string_cst ) ; if ( fn_code == IX86_BUILTIN_CPU_IS ) { tree ref ; tree field ; tree final ; unsigned int field_val = <NUM_LIT> ; unsigned int NUM_ARCH_NAMES = sizeof ( arch_names_table ) / sizeof ( struct _arch_names_table ) ; for ( i = <NUM_LIT> ; i < NUM_ARCH_NAMES ; i ++ ) if ( strcmp ( arch_names_table [ i ] . name , TREE_STRING_POINTER ( param_string_cst ) ) == <NUM_LIT> ) break ; if ( i == NUM_ARCH_NAMES ) { error ( <STR_LIT> , TREE_STRING_POINTER ( param_string_cst ) ) ; return integer_zero_node ; } field = TYPE_FIELDS ( __processor_model_type ) ; field_val = arch_names_table [ i ] . model ; if ( field_val > M_CPU_TYPE_START && field_val < M_CPU_SUBTYPE_START ) { field = DECL_CHAIN ( field ) ; field_val -= M_CPU_TYPE_START ; } if ( field_val > M_CPU_SUBTYPE_START ) { field = DECL_CHAIN ( DECL_CHAIN ( field ) ) ; field_val -= M_CPU_SUBTYPE_START ; } ref = build3 ( COMPONENT_REF , TREE_TYPE ( field ) , __cpu_model_var , field , NULL_TREE ) ; final = build2 ( EQ_EXPR , unsigned_type_node , ref , build_int_cstu ( unsigned_type_node , field_val ) ) ; return build1 ( CONVERT_EXPR , integer_type_node , final ) ; } else if ( fn_code == IX86_BUILTIN_CPU_SUPPORTS ) {


<s> param_string_cst = TREE_OPERAND ( EXPR_CHECK ( param_string_cst ) , <NUM_LIT> ) ; } gcc_assert ( param_string_cst ) ; if ( fn_code == IX86_BUILTIN_CPU_IS ) { tree ref ; tree field ; tree final ; unsigned int field_val = <NUM_LIT> ; unsigned int NUM_ARCH_NAMES = sizeof ( arch_names_table ) / sizeof ( struct _arch_names_table ) ; for ( i = <NUM_LIT> ; i < NUM_ARCH_NAMES ; i ++ ) if ( strcmp ( arch_names_table [ i ] . name , TREE_STRING_POINTER ( param_string_cst ) ) == <NUM_LIT> ) break ; if ( i == NUM_ARCH_NAMES ) { error ( <STR_LIT> , TREE_STRING_POINTER ( param_string_cst ) ) ; return integer_zero_node ; } field = TYPE_FIELDS ( __processor_model_type ) ; field_val = arch_names_table [ i ] . model ; if ( field_val > M_CPU_TYPE_START && field_val < M_CPU_SUBTYPE_START ) { field = DECL_CHAIN ( field ) ; field_val -= M_CPU_TYPE_START ; } if ( field_val > M_CPU_SUBTYPE_START ) { field = DECL_CHAIN ( DECL_CHAIN ( field ) ) ; field_val -= M_CPU_SUBTYPE_START ; } ref = build3 ( COMPONENT_REF , TREE_TYPE ( field ) , __cpu_model_var , field , NULL_TREE ) ; final = build2 ( EQ_EXPR , unsigned_type_node , ref , build_int_cstu ( unsigned_type_node , field_val ) ) ; return build1 ( CONVERT_EXPR , integer_type_node , final ) ; } else if ( fn_code == IX86_BUILTIN_CPU_SUPPORTS ) { tree ref ; tree array_elt ; tree field ; tree final ; unsigned int field_val = <NUM_LIT> ; unsigned int NUM_ISA_NAMES = sizeof ( isa_names_table ) / sizeof ( struct _isa_names_table ) ; for ( i = <NUM_LIT> ; i < NUM_ISA_NAMES ; i ++ ) if ( strcmp ( isa_names_table [ i ] . name , TREE_STRING_POINTER ( param_string_cst ) ) == <NUM_LIT> ) break ; if ( i == NUM_ISA_NAMES ) { error ( <STR_LIT> , TREE_STRING_POINTER ( param_string_cst ) ) ; return integer_zero_node ; } field = TYPE_FIELDS ( __processor_model_type ) ; while ( DECL_CHAIN ( field ) ) field = DECL_CHAIN ( field ) ; ref = build3 ( COMPONENT_REF , TREE_TYPE ( field ) , __cpu_model_var , field , NULL_TREE ) ;


<s> if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( insn ) , REGNO ( oldreg ) , reg_class_names [ alt [ opno1 ] . cl ] ) ; HARD_REG_SET unavailable ; REG_SET_TO_HARD_REG_SET ( unavailable , & live ) ; SET_HARD_REG_BIT ( unavailable , REGNO ( oldreg ) ) ; IOR_COMPL_HARD_REG_SET ( unavailable , call_used_reg_set ) ; IOR_HARD_REG_SET ( unavailable , fixed_reg_set ) ; IOR_HARD_REG_SET ( unavailable , output_risky ) ; IOR_COMPL_HARD_REG_SET ( unavailable , reg_class_contents [ alt [ opno1 ] . cl ] ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! TEST_HARD_REG_BIT ( unavailable , i ) ) break ; if ( i == FIRST_PSEUDO_REGISTER ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; continue ; } if ( dump_file ) fprintf ( dump_file , <STR_LIT> , i ) ; rtx newreg = gen_rtx_REG ( recog_data . operand_mode [ opno1 ] , i ) ; validate_change ( insn , recog_data . operand_loc [ opno1 ] , newreg , false ) ;

insn = emit_insn_before ( gen_move_insn ( newreg , oldreg ) , insn ) ;


<s> int modrm = ix86_get_modrm_for_rop ( insn , recog_data . operand , recog_data . n_operands , & opno0 , & opno1 ) ; if ( modrm < <NUM_LIT> || ! ix86_rop_should_change_byte_p ( modrm ) || opno0 == opno1 ) continue ; rtx oldreg = recog_data . operand [ opno1 ] ; preprocess_constraints ( insn ) ; const operand_alternative * alt = which_op_alt ( ) ; int i ; for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) if ( i != opno1 && alt [ i ] . earlyclobber && reg_overlap_mentioned_p ( recog_data . operand [ i ] , oldreg ) ) break ; if ( i < recog_data . n_operands ) continue ;

if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( insn ) , REGNO ( oldreg ) , reg_class_names [ alt [ opno1 ] . cl ] ) ;


<s> int modrm = ix86_get_modrm_for_rop ( insn , recog_data . operand , recog_data . n_operands , & opno0 , & opno1 ) ; if ( modrm < <NUM_LIT> || ! ix86_rop_should_change_byte_p ( modrm ) || opno0 == opno1 ) continue ; rtx oldreg = recog_data . operand [ opno1 ] ; preprocess_constraints ( insn ) ; const operand_alternative * alt = which_op_alt ( ) ; int i ; for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) if ( i != opno1 && alt [ i ] . earlyclobber && reg_overlap_mentioned_p ( recog_data . operand [ i ] , oldreg ) ) break ; if ( i < recog_data . n_operands ) continue ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( insn ) , REGNO ( oldreg ) , reg_class_names [ alt [ opno1 ] . cl ] ) ; HARD_REG_SET unavailable ; REG_SET_TO_HARD_REG_SET ( unavailable , & live ) ; SET_HARD_REG_BIT ( unavailable , REGNO ( oldreg ) ) ; IOR_COMPL_HARD_REG_SET ( unavailable , call_used_reg_set ) ; IOR_HARD_REG_SET ( unavailable , fixed_reg_set ) ; IOR_HARD_REG_SET ( unavailable , output_risky ) ; IOR_COMPL_HARD_REG_SET ( unavailable , reg_class_contents [ alt [ opno1 ] . cl ] ) ;

for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! TEST_HARD_REG_BIT ( unavailable , i ) ) break ;


<s> old_reg = head -> regno ; best_reg = find_rename_reg ( head , superclass , & unavailable , old_reg , false ) ; bool ok = regrename_do_replace ( head , best_reg ) ; gcc_assert ( ok ) ;

if ( dump_file ) fprintf ( dump_file , <STR_LIT> , head -> id , reg_names [ best_reg ] , reg_class_names [ superclass ] ) ;


<s> HARD_REG_SET unavailable ; CLEAR_HARD_REG_SET ( unavailable ) ; if ( head -> target_data_1 ) IOR_HARD_REG_SET ( unavailable , output_risky ) ; if ( head -> target_data_2 ) IOR_HARD_REG_SET ( unavailable , input_risky ) ; int n_uses ;

reg_class superclass = regrename_find_superclass ( head , & n_uses , & unavailable ) ;


<s> case V8SFmode : case V8SImode : case V32QImode : case V16HImode : case V4DFmode : case V4DImode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { if ( cum -> sse_nregs ) return gen_reg_or_parallel ( mode , orig_mode , cum -> sse_regno + FIRST_SSE_REG ) ; } break ; case V8QImode : case V4HImode : case V2SImode : case V2SFmode : case V1TImode : case V1DImode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { if ( cum -> mmx_nregs ) return gen_reg_or_parallel ( mode , orig_mode , cum -> mmx_regno + FIRST_MMX_REG ) ; } break ; } if ( error_p ) { cum -> float_in_sse = <NUM_LIT> ; error ( <STR_LIT> <STR_LIT> , cum -> decl ) ;


<s> case DFmode : if ( cum -> float_in_sse == - <NUM_LIT> ) error_p = <NUM_LIT> ; if ( cum -> float_in_sse < <NUM_LIT> ) break ; case SFmode : if ( cum -> float_in_sse == - <NUM_LIT> ) error_p = <NUM_LIT> ; if ( cum -> float_in_sse < <NUM_LIT> ) break ; case V8SFmode : case V8SImode : case V64QImode : case V32HImode : case V16SImode : case V8DImode : case V16SFmode : case V8DFmode : case V32QImode : case V16HImode : case V4DFmode : case V4DImode : case TImode : case V16QImode : case V8HImode : case V4SImode : case V2DImode : case V4SFmode : case V2DFmode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { cum -> sse_words += words ; cum -> sse_nregs -= <NUM_LIT> ; cum -> sse_regno += <NUM_LIT> ; if ( cum -> sse_nregs <= <NUM_LIT> ) { cum -> sse_nregs = <NUM_LIT> ; cum -> sse_regno = <NUM_LIT> ; } } break ; case V8QImode : case V4HImode : case V2SImode : case V2SFmode : case V1TImode : case V1DImode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { cum -> mmx_words += words ; cum -> mmx_nregs -= <NUM_LIT> ; cum -> mmx_regno += <NUM_LIT> ; if ( cum -> mmx_nregs <= <NUM_LIT> ) { cum -> mmx_nregs = <NUM_LIT> ; cum -> mmx_regno = <NUM_LIT> ;


<s> case HImode : case QImode : pass_in_reg : cum -> words += words ; cum -> nregs -= words ; cum -> regno += words ; if ( cum -> nregs >= <NUM_LIT> ) res = words ; if ( cum -> nregs <= <NUM_LIT> ) { cum -> nregs = <NUM_LIT> ; cfun -> machine -> arg_reg_available = false ; cum -> regno = <NUM_LIT> ; } break ; case OImode : gcc_unreachable ( ) ; case DFmode : if ( cum -> float_in_sse == - <NUM_LIT> ) error_p = <NUM_LIT> ; if ( cum -> float_in_sse < <NUM_LIT> ) break ; case SFmode : if ( cum -> float_in_sse == - <NUM_LIT> ) error_p = <NUM_LIT> ; if ( cum -> float_in_sse < <NUM_LIT> ) break ; case V8SFmode : case V8SImode : case V64QImode : case V32HImode : case V16SImode : case V8DImode : case V16SFmode : case V8DFmode : case V32QImode : case V16HImode :


<s> unsigned int regno ; if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_MMX_REG ; else if ( mode == TImode || ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ) regno = FIRST_SSE_REG ; else if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_SSE_REG ; else if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_SSE_REG ; else if ( X87_FLOAT_MODE_P ( mode ) && TARGET_FLOAT_RETURNS_IN_80387 ) regno = FIRST_FLOAT_REG ; else regno = AX_REG ;

if ( ( fn || fntype ) && ( mode == SFmode || mode == DFmode ) ) {


<s> unsigned int regno ; if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_MMX_REG ; else if ( mode == TImode || ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ) regno = FIRST_SSE_REG ; else if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_SSE_REG ;


<s> return ! TARGET_64BIT && TARGET_STV && TARGET_SSE2 && optimize > <NUM_LIT> ;


<s> return gen_rtx_SET ( arg , gen_rtx_MEM ( word_mode , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ) ;


<s> struct machine_function * m = cfun -> machine ;

if ( m -> fs . cfa_reg == stack_pointer_rtx ) m -> fs . cfa_offset += UNITS_PER_WORD ;


<s> priority = P_PROC_BMI ; break ; case PROCESSOR_BDVER1 : arg_str = <STR_LIT> ; priority = P_PROC_XOP ; break ; case PROCESSOR_BDVER2 : arg_str = <STR_LIT> ; priority = P_PROC_FMA ; break ; case PROCESSOR_BDVER3 : arg_str = <STR_LIT> ; priority = P_PROC_FMA ; break ; case PROCESSOR_BDVER4 : arg_str = <STR_LIT> ; priority = P_PROC_AVX2 ; break ; case PROCESSOR_ZNVER1 : arg_str = <STR_LIT> ; priority = P_PROC_AVX2 ; break ; } } cl_target_option_restore ( & global_options , & cur_target ) ; if ( predicate_list && arg_str == NULL ) { error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> ) ; return <NUM_LIT> ; } if ( predicate_list ) { predicate_decl = ix86_builtins [ ( int ) IX86_BUILTIN_CPU_IS ] ; predicate_arg = build_string_literal ( strlen ( arg_str ) + <NUM_LIT> , arg_str ) ; predicate_chain = tree_cons ( predicate_decl , predicate_arg , predicate_chain ) ; } } tok_str = ( char * ) xmalloc ( strlen ( attrs_str ) + <NUM_LIT> ) ; strcpy ( tok_str , attrs_str ) ; token = strtok ( tok_str , <STR_LIT> ) ; predicate_decl = ix86_builtins [ ( int ) IX86_BUILTIN_CPU_SUPPORTS ] ; while ( token != NULL ) { if ( strncmp ( token , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { token = strtok ( NULL , <STR_LIT> ) ; continue ; } for ( i = <NUM_LIT> ; i < NUM_FEATURES ; ++ i ) { if ( strcmp ( token , feature_list [ i ] . name ) == <NUM_LIT> ) { if ( predicate_list ) { predicate_arg = build_string_literal ( strlen ( feature_list [ i ] . name ) + <NUM_LIT> , feature_list [ i ] . name ) ; predicate_chain = tree_cons ( predicate_decl , predicate_arg , predicate_chain ) ; } if ( feature_list [ i ] . priority > priority ) priority = feature_list [ i ] . priority ; break ; } } if ( predicate_list && i == NUM_FEATURES ) { error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> , token ) ; return <NUM_LIT> ; } token = strtok ( NULL , <STR_LIT> ) ; } free ( tok_str ) ; if ( predicate_list && predicate_chain == NULL_TREE ) { error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> , attrs_str ) ; return <NUM_LIT> ;


<s> bool fastcall_p = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) != NULL_TREE ; bool thiscall_p = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) != NULL_TREE ; bool static_chain_p = DECL_STATIC_CHAIN ( decl ) ; int regparm = ix86_function_regparm ( fntype , decl ) ; int drap_regno = crtl -> drap_reg ? REGNO ( crtl -> drap_reg ) : INVALID_REGNUM ; if ( ( regparm < <NUM_LIT> || ( fastcall_p && ! static_chain_p ) ) && drap_regno != AX_REG ) regno = AX_REG ; else if ( thiscall_p && ! static_chain_p && drap_regno != AX_REG ) regno = AX_REG ; else if ( regparm < <NUM_LIT> && ! thiscall_p && drap_regno != DX_REG ) regno = DX_REG ;

else if ( regparm < <NUM_LIT> && ! fastcall_p && ! thiscall_p && ! static_chain_p && drap_regno != CX_REG ) regno = CX_REG ;


<s> struct machine_function GTY ( ( ) ) { struct stack_local_entry * stack_locals ; const char * some_ld_name ; rtx force_align_arg_pointer ; int save_varrargs_registers ; int accesses_prev_frame ; int optimize_mode_switching [ MAX_386_ENTITIES ] ; int use_fast_prologue_epilogue ; int use_fast_prologue_epilogue_nregs ;


<s> int num_imm32_operand ; int num_imm64_operand ; if ( insn ) return get_num_immediates ( insn , & num_imm_operand , & num_imm32_operand , & num_imm64_operand ) ;


<s> case PROCESSOR_PENTIUM : case PROCESSOR_LAKEMONT : return <NUM_LIT> ; case PROCESSOR_PENTIUMPRO : case PROCESSOR_K6 : return <NUM_LIT> ; case PROCESSOR_BDVER1 : case PROCESSOR_BDVER2 : case PROCESSOR_BDVER3 : case PROCESSOR_BDVER4 : return <NUM_LIT> ; case PROCESSOR_CORE2 : case PROCESSOR_NEHALEM : case PROCESSOR_SANDYBRIDGE : case PROCESSOR_HASWELL :


<s> default : return <NUM_LIT> ; } if ( in ) return MAX ( ix86_cost -> mmx_load [ index ] , ix86_cost -> mmx_store [ index ] ) ; return in ? ix86_cost -> mmx_load [ index ] : ix86_cost -> mmx_store [ index ] ; } switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : if ( Q_CLASS_P ( regclass ) || TARGET_64BIT ) { if ( ! in ) return ix86_cost -> int_store [ <NUM_LIT> ] ; if ( TARGET_PARTIAL_REG_DEPENDENCY && optimize_function_for_speed_p ( cfun ) ) cost = ix86_cost -> movzbl_load ; else cost = ix86_cost -> int_load [ <NUM_LIT> ] ; if ( in == <NUM_LIT> ) return MAX ( cost , ix86_cost -> int_store [ <NUM_LIT> ] ) ; return cost ; } else { if ( in == <NUM_LIT> ) return MAX ( ix86_cost -> movzbl_load , ix86_cost -> int_store [ <NUM_LIT> ] + <NUM_LIT> ) ; if ( in ) return ix86_cost -> movzbl_load ; else return ix86_cost -> int_store [ <NUM_LIT> ] + <NUM_LIT> ; } break ; case <NUM_LIT> : if ( in == <NUM_LIT> ) return MAX ( ix86_cost -> int_load [ <NUM_LIT> ] , ix86_cost -> int_store [ <NUM_LIT> ] ) ;


<s> } if ( SSE_CLASS_P ( regclass ) ) { int index ; switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : index = <NUM_LIT> ; break ; case <NUM_LIT> : index = <NUM_LIT> ; break ; case <NUM_LIT> : index = <NUM_LIT> ; break ; default : return <NUM_LIT> ; } if ( in == <NUM_LIT> ) return MAX ( ix86_cost -> sse_load [ index ] , ix86_cost -> sse_store [ index ] ) ; return in ? ix86_cost -> sse_load [ index ] : ix86_cost -> sse_store [ index ] ; } if ( MMX_CLASS_P ( regclass ) ) { int index ; switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : index = <NUM_LIT> ; break ; case <NUM_LIT> : index = <NUM_LIT> ; break ; default : return <NUM_LIT> ; } if ( in ) return MAX ( ix86_cost -> mmx_load [ index ] , ix86_cost -> mmx_store [ index ] ) ; return in ? ix86_cost -> mmx_load [ index ] : ix86_cost -> mmx_store [ index ] ; } switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : if ( Q_CLASS_P ( regclass ) || TARGET_64BIT ) { if ( ! in ) return ix86_cost -> int_store [ <NUM_LIT> ] ; if ( TARGET_PARTIAL_REG_DEPENDENCY && optimize_function_for_speed_p ( cfun ) ) cost = ix86_cost -> movzbl_load ;

else cost = ix86_cost -> int_load [ <NUM_LIT> ] ;


<s> FOR_EACH_INSN_DEF ( def , insn ) if ( DF_REF_REG_DEF_P ( def ) && ! DF_REF_IS_ARTIFICIAL ( def ) && ( regno1 == DF_REF_REGNO ( def ) || regno2 == DF_REF_REGNO ( def ) ) ) return true ; return false ;


<s> static bool is_branch ( rtx_insn * insn ) { return ( CALL_P ( insn ) || JUMP_P ( insn ) ) ;


<s> static bool is_prefetch ( rtx_insn * insn ) {

return NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == PREFETCH ;


<s> rounded_size = ROUND_DOWN ( size , PROBE_INTERVAL ) ; emit_insn ( gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( PROBE_INTERVAL + dope ) ) ) ) ; if ( rounded_size <= ( HOST_WIDE_INT_1 << <NUM_LIT> ) ) emit_insn ( gen_rtx_SET ( sr . reg , plus_constant ( Pmode , stack_pointer_rtx , - rounded_size ) ) ) ; else { emit_move_insn ( sr . reg , GEN_INT ( - rounded_size ) ) ; emit_insn ( gen_rtx_SET ( sr . reg , gen_rtx_PLUS ( Pmode , sr . reg , stack_pointer_rtx ) ) ) ; } emit_insn ( ix86_gen_adjust_stack_and_probe ( sr . reg , sr . reg , size_rtx ) ) ; if ( size != rounded_size ) { emit_insn ( gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , rounded_size - size ) ) ) ; emit_stack_probe ( stack_pointer_rtx ) ; } last = emit_insn ( gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , PROBE_INTERVAL + dope ) ) ) ; release_scratch_register_on_entry ( & sr ) ; } if ( size > <NUM_LIT> ) { rtx expr = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ;

XVECEXP ( expr , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - size ) ) ;


<s> get_scratch_register_on_entry ( & sr ) ; rounded_size = ROUND_DOWN ( size , PROBE_INTERVAL ) ; emit_insn ( gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( PROBE_INTERVAL + dope ) ) ) ) ; if ( rounded_size <= ( HOST_WIDE_INT_1 << <NUM_LIT> ) ) emit_insn ( gen_rtx_SET ( sr . reg , plus_constant ( Pmode , stack_pointer_rtx , - rounded_size ) ) ) ; else { emit_move_insn ( sr . reg , GEN_INT ( - rounded_size ) ) ; emit_insn ( gen_rtx_SET ( sr . reg , gen_rtx_PLUS ( Pmode , sr . reg , stack_pointer_rtx ) ) ) ; } emit_insn ( ix86_gen_adjust_stack_and_probe ( sr . reg , sr . reg , size_rtx ) ) ; if ( size != rounded_size ) {

emit_insn ( gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , rounded_size - size ) ) ) ;


<s> m = adjust_address ( op1 , mode , <NUM_LIT> ) ; r = gen_rtx_VEC_CONCAT ( GET_MODE ( op0 ) , r , m ) ; emit_move_insn ( op0 , r ) ; } else if ( misaligned_operand ( op1 , GET_MODE ( op1 ) ) ) emit_insn ( gen_rtx_SET ( op0 , op1 ) ) ; else emit_insn ( load_unaligned ( op0 , op1 ) ) ; } else if ( MEM_P ( op0 ) ) { if ( TARGET_AVX256_SPLIT_UNALIGNED_STORE && optimize_insn_for_speed_p ( ) ) { m = adjust_address ( op0 , mode , <NUM_LIT> ) ;

emit_insn ( extract ( m , op1 , const0_rtx ) ) ;


return build_pointer_type ( char_type_node ) ;


<s> case V4SImode : case V8SFmode : case V4SFmode : vec_mode = mode ; imode = SImode ; break ; case V8DImode : case V4DImode : case V2DImode : case V8DFmode : case V4DFmode : case V2DFmode : vec_mode = mode ; imode = DImode ; break ; case TImode : case TFmode : vec_mode = VOIDmode ;


<s> static tree ix86_builtin_reciprocal ( tree fndecl ) { switch ( DECL_FUNCTION_CODE ( fndecl ) ) { case IX86_BUILTIN_SQRTPS_NR : return ix86_get_builtin ( IX86_BUILTIN_RSQRTPS_NR ) ;


<s> case CONST_INT : case CONST_WIDE_INT : case CONST_DOUBLE : case CONST_VECTOR : return false ; default : break ;


<s> case EQ : case NE : return CCZmode ; case GEU : case LTU : if ( GET_CODE ( op0 ) == PLUS && ( rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) || rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) ) ) return CCCmode ; else return CCmode ; case GTU : case LEU : return CCmode ; case GE : case LT : if ( op1 == const0_rtx ) return CCGOCmode ; else return CCGCmode ;


<s> case GEU : case LTU : if ( GET_CODE ( op0 ) == PLUS && ( rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) || rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) ) ) return CCCmode ; else return CCmode ; case GTU : case LEU : return CCmode ; case GE : case LT : if ( op1 == const0_rtx ) return CCGOCmode ; else return CCGCmode ; case GT : case LE : if ( op1 == const0_rtx ) return CCNOmode ; else return CCGCmode ; case USE :


<s> if ( ( m1 == CCGCmode && m2 == CCGOCmode ) || ( m1 == CCGOCmode && m2 == CCGCmode ) ) return CCGCmode ; if ( m1 == CCZmode && ( m2 == CCGCmode || m2 == CCGOCmode ) ) return m2 ; else if ( m2 == CCZmode && ( m1 == CCGCmode || m1 == CCGOCmode ) ) return m1 ; switch ( m1 ) { default : gcc_unreachable ( ) ; case CCmode : case CCGCmode : case CCGOCmode : case CCNOmode : case CCAmode : case CCCmode : case CCOmode : case CCPmode : case CCSmode : case CCZmode : switch ( m2 ) { default : return VOIDmode ; case CCmode : case CCGCmode : case CCGOCmode : case CCNOmode : case CCAmode : case CCCmode : case CCOmode : case CCPmode : case CCSmode : case CCZmode : return CCmode ; }


<s> if ( SUBREG_P ( exp ) ) exp = SUBREG_REG ( exp ) ; return ( REG_P ( exp ) && VALID_AVX256_REG_OR_OI_MODE ( GET_MODE ( exp ) ) ) ;


<s> TREE_PUBLIC ( decl ) = <NUM_LIT> ; TREE_STATIC ( decl ) = <NUM_LIT> ; DECL_IGNORED_P ( decl ) = <NUM_LIT> ; if ( TARGET_MACHO ) { switch_to_section ( darwin_sections [ text_coal_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> ) ) ;


<s> 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 ) ; } else { switch_to_section ( text_section ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; } DECL_INITIAL ( decl ) = make_node ( BLOCK ) ;


<s> gcc_assert ( preferred_alignment >= STACK_BOUNDARY / BITS_PER_UNIT ) ; gcc_assert ( preferred_alignment <= stack_alignment_needed ) ; if ( TARGET_SEH ) cfun -> machine -> use_fast_prologue_epilogue = false ; else if ( ! optimize_bb_for_size_p ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) && cfun -> machine -> use_fast_prologue_epilogue_nregs != frame -> nregs ) { int count = frame -> nregs ; struct cgraph_node * node = cgraph_node :: get ( current_function_decl ) ; cfun -> machine -> use_fast_prologue_epilogue_nregs = count ; if ( count ) count = ( count - <NUM_LIT> ) * FAST_PROLOGUE_INSN_COUNT ; if ( node -> frequency < NODE_FREQUENCY_NORMAL || ( flag_branch_probabilities && node -> frequency < NODE_FREQUENCY_HOT ) ) cfun -> machine -> use_fast_prologue_epilogue = false ; else cfun -> machine -> use_fast_prologue_epilogue = ! expensive_function_p ( count ) ; } frame -> save_regs_using_mov = ( TARGET_PROLOGUE_USING_MOVE && cfun -> machine -> use_fast_prologue_epilogue && flag_stack_check != STATIC_BUILTIN_STACK_CHECK ) ; offset = UNITS_PER_WORD ; if ( ix86_static_chain_on_stack ) offset += UNITS_PER_WORD ; if ( frame_pointer_needed ) offset += UNITS_PER_WORD ; frame -> hfp_save_offset = offset ; frame -> hard_frame_pointer_offset = offset ; offset += frame -> nregs * UNITS_PER_WORD ; frame -> reg_save_offset = offset ; if ( TARGET_SEH ) frame -> hard_frame_pointer_offset = offset ; if ( frame -> nsseregs ) { if ( ix86_incoming_stack_boundary >= <NUM_LIT> ) offset = ROUND_UP ( offset , <NUM_LIT> ) ; offset += frame -> nsseregs * <NUM_LIT> ; } frame -> sse_reg_save_offset = offset ; if ( stack_realign_fp ) offset = ROUND_UP ( offset , stack_alignment_needed ) ; frame -> va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size ;


<s> static void ix86_conditional_register_usage ( void ) { int i , c_mask ; if ( ! TARGET_64BIT ) { for ( i = FIRST_REX_INT_REG ; i <= LAST_REX_INT_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; } c_mask = CALL_USED_REGISTERS_MASK ( TARGET_64BIT_MS_ABI ) ; CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) CLOBBERED_REGS ] ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) {

if ( call_used_regs [ i ] > <NUM_LIT> ) call_used_regs [ i ] = ! ! ( call_used_regs [ i ] & c_mask ) ;


<s> else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ( TYPE_MODE ( type ) == XCmode || TYPE_MODE ( type ) == TCmode ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( ( TREE_CODE ( type ) == RECORD_TYPE || TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == QUAL_UNION_TYPE ) && TYPE_FIELDS ( type ) ) { if ( DECL_MODE ( TYPE_FIELDS ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( DECL_MODE ( TYPE_FIELDS ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; }

else if ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == VECTOR_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) {


<s> else if ( GET_CODE ( addr ) == PLUS ) { rtx addends [ <NUM_LIT> ] , op ; int n = <NUM_LIT> , i ; op = addr ; do { if ( n >= <NUM_LIT> ) return <NUM_LIT> ; addends [ n ++ ] = XEXP ( op , <NUM_LIT> ) ; op = XEXP ( op , <NUM_LIT> ) ; } while ( GET_CODE ( op ) == PLUS ) ; if ( n >= <NUM_LIT> ) return <NUM_LIT> ; addends [ n ] = op ; for ( i = n ; i >= <NUM_LIT> ; -- i ) { op = addends [ i ] ; switch ( GET_CODE ( op ) ) { case MULT : if ( index ) return <NUM_LIT> ; index = XEXP ( op , <NUM_LIT> ) ; scale_rtx = XEXP ( op , <NUM_LIT> ) ; break ; case ASHIFT : if ( index ) return <NUM_LIT> ; index = XEXP ( op , <NUM_LIT> ) ; tmp = XEXP ( op , <NUM_LIT> ) ; if ( ! CONST_INT_P ( tmp ) ) return <NUM_LIT> ; scale = INTVAL ( tmp ) ; if ( ( unsigned HOST_WIDE_INT ) scale > <NUM_LIT> ) return <NUM_LIT> ; scale = <NUM_LIT> << scale ; break ; case ZERO_EXTEND : op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) != UNSPEC ) return <NUM_LIT> ; case UNSPEC : if ( XINT ( op , <NUM_LIT> ) == UNSPEC_TP && TARGET_TLS_DIRECT_SEG_REFS && seg == ADDR_SPACE_GENERIC ) seg = DEFAULT_TLS_SEG_REG ; else return <NUM_LIT> ; break ; case SUBREG : if ( ! REG_P ( SUBREG_REG ( op ) ) ) return <NUM_LIT> ; case REG : if ( ! base ) base = op ; else if ( ! index ) index = op ;


<s> static void ix86_default_align ( struct gcc_options * opts ) { if ( opts -> x_align_loops == <NUM_LIT> ) { opts -> x_align_loops = processor_target_table [ ix86_tune ] . align_loop ; align_loops_max_skip = processor_target_table [ ix86_tune ] . align_loop_max_skip ; } if ( opts -> x_align_jumps == <NUM_LIT> ) { opts -> x_align_jumps = processor_target_table [ ix86_tune ] . align_jump ; align_jumps_max_skip = processor_target_table [ ix86_tune ] . align_jump_max_skip ; } if ( opts -> x_align_functions == <NUM_LIT> ) { opts -> x_align_functions = processor_target_table [ ix86_tune ] . align_func ; }


<s> opts -> x_align_jumps = processor_target_table [ ix86_tune ] . align_jump ; align_jumps_max_skip = processor_target_table [ ix86_tune ] . align_jump_max_skip ; } if ( opts -> x_align_functions == <NUM_LIT> ) { opts -> x_align_functions = processor_target_table [ ix86_tune ] . align_func ;


<s> clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ;

emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , op , clob ) ) ) ;


<s> op = gen_rtx_SET ( dst , gen_rtx_fmt_ee ( code , mode , dst , src ) ) ; clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ;


<s> t = ix86_expand_compare ( code , op1 , op2 ) ; emit_insn ( gen_rtx_SET ( dst , gen_rtx_IF_THEN_ELSE ( GET_MODE ( dst ) , t , src , dst ) ) ) ; }


<s> emit_insn ( gen_x86_sahf_1 ( reg ) ) ; temp = gen_rtx_REG ( CCmode , FLAGS_REG ) ; temp = gen_rtx_UNORDERED ( VOIDmode , temp , const0_rtx ) ; } else { emit_insn ( gen_testqi_ext_ccno_0 ( reg , GEN_INT ( <NUM_LIT> ) ) ) ; temp = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ;

temp = gen_rtx_NE ( VOIDmode , temp , const0_rtx ) ;


<s> rtx reg = gen_reg_rtx ( HImode ) ; rtx temp ; emit_insn ( gen_x86_fnstsw_1 ( reg ) ) ; if ( TARGET_SAHF && ( TARGET_USE_SAHF || optimize_insn_for_size_p ( ) ) ) { emit_insn ( gen_x86_sahf_1 ( reg ) ) ; temp = gen_rtx_REG ( CCmode , FLAGS_REG ) ;

temp = gen_rtx_UNORDERED ( VOIDmode , temp , const0_rtx ) ;


<s> rtx test ; emit_insn ( gen_absxf2 ( tmp , op1 ) ) ; test = gen_rtx_GE ( VOIDmode , tmp , const_double_from_real_value ( REAL_VALUE_ATOF ( <STR_LIT> , XFmode ) , XFmode ) ) ; emit_jump_insn ( gen_cbranchxf4 ( test , XEXP ( test , <NUM_LIT> ) , XEXP ( test , <NUM_LIT> ) , label1 ) ) ; emit_move_insn ( tmp2 , standard_80387_constant_rtx ( <NUM_LIT> ) ) ; emit_insn ( gen_fyl2xp1xf3_i387 ( op0 , op1 , tmp2 ) ) ; emit_jump ( label2 ) ; emit_label ( label1 ) ; emit_move_insn ( tmp , CONST1_RTX ( XFmode ) ) ; emit_insn ( gen_addxf3 ( tmp , op1 , tmp ) ) ;


<s> m -> fs . cfa_offset = m -> fs . sp_offset ; add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , m -> fs . sp_offset ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } ix86_add_cfa_restore_note ( insn , hard_frame_pointer_rtx , m -> fs . fp_offset ) ;


<s> static void ix86_emit_probe_stack_range ( HOST_WIDE_INT first , HOST_WIDE_INT size ) { if ( size <= <NUM_LIT> * PROBE_INTERVAL ) { HOST_WIDE_INT i ; for ( i = PROBE_INTERVAL ; i < size ; i += PROBE_INTERVAL ) emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + i ) ) ) ; emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + size ) ) ) ; } else { HOST_WIDE_INT rounded_size , last ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; rounded_size = ROUND_DOWN ( size , PROBE_INTERVAL ) ;

emit_move_insn ( sr . reg , GEN_INT ( - first ) ) ;


<s> struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; rounded_size = ROUND_DOWN ( size , PROBE_INTERVAL ) ; emit_move_insn ( sr . reg , GEN_INT ( - first ) ) ; last = first + rounded_size ; emit_insn ( ix86_gen_probe_stack_range ( sr . reg , sr . reg , GEN_INT ( - last ) ) ) ; if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , sr . reg ) , rounded_size - size ) ) ; release_scratch_register_on_entry ( & sr ) ; } emit_insn ( gen_blockage ( ) ) ;


<s> mem = choose_baseaddr ( cfa_offset ) ; mem = gen_frame_mem ( word_mode , mem ) ; insn = emit_move_insn ( reg , mem ) ; if ( m -> fs . cfa_reg == crtl -> drap_reg && regno == REGNO ( crtl -> drap_reg ) ) { add_reg_note ( insn , REG_CFA_DEF_CFA , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; m -> fs . drap_valid = true ;


<s> static void ix86_emit_restore_sse_regs_using_mov ( HOST_WIDE_INT cfa_offset , bool maybe_eh_return ) { unsigned int regno ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , maybe_eh_return ) ) { rtx reg = gen_rtx_REG ( V4SFmode , regno ) ; rtx mem ; unsigned int align ; mem = choose_baseaddr ( cfa_offset ) ; mem = gen_rtx_MEM ( V4SFmode , mem ) ; align = MIN ( GET_MODE_ALIGNMENT ( V4SFmode ) , INCOMING_STACK_BOUNDARY ) ; set_mem_align ( mem , align ) ; if ( align < <NUM_LIT> ) { rtx unspec = gen_rtx_UNSPEC ( V4SFmode , gen_rtvec ( <NUM_LIT> , mem ) , UNSPEC_LOADU ) ;

emit_insn ( gen_rtx_SET ( reg , unspec ) ) ;


<s> insn = emit_insn ( gen_push ( gen_rtx_REG ( word_mode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> unsigned int regno ; rtx_insn * insn ; for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno -- > <NUM_LIT> ; ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true ) ) { insn = emit_insn ( gen_push ( gen_rtx_REG ( word_mode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; }


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

ix86_emit_save_reg_using_mov ( word_mode , regno , cfa_offset ) ;


<s> unsigned int regno ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true ) ) { ix86_emit_save_reg_using_mov ( word_mode , regno , cfa_offset ) ; cfa_offset -= UNITS_PER_WORD ;


<s> if ( regno == REGNO ( crtl -> drap_reg ) ) { gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ; add_reg_note ( insn , REG_CFA_DEF_CFA , mem ) ; } else { gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ;

add_reg_note ( insn , REG_CFA_EXPRESSION , gen_rtx_SET ( mem , reg ) ) ;


<s> rtx unspec = NULL_RTX ; rtx mem , addr , base , insn ; unsigned int align ; addr = choose_baseaddr ( cfa_offset ) ; mem = gen_frame_mem ( mode , addr ) ; align = MIN ( GET_MODE_ALIGNMENT ( mode ) , INCOMING_STACK_BOUNDARY ) ; set_mem_align ( mem , align ) ; if ( mode == V4SFmode && align < <NUM_LIT> ) unspec = gen_rtx_UNSPEC ( mode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_STOREU ) ; insn = emit_insn ( gen_rtx_SET ( mem , unspec ? unspec : reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; base = addr ; if ( GET_CODE ( base ) == PLUS ) base = XEXP ( base , <NUM_LIT> ) ; gcc_checking_assert ( REG_P ( base ) ) ; if ( m -> fs . realigned ) { gcc_checking_assert ( stack_realign_drap ) ; if ( regno == REGNO ( crtl -> drap_reg ) ) { gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ; add_reg_note ( insn , REG_CFA_DEF_CFA , mem ) ; } else { gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ; add_reg_note ( insn , REG_CFA_EXPRESSION , gen_rtx_SET ( mem , reg ) ) ; } }


<s> unsigned int regno ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true ) ) { ix86_emit_save_reg_using_mov ( V4SFmode , regno , cfa_offset ) ; cfa_offset -= GET_MODE_SIZE ( V4SFmode ) ; }


<s> if ( mode == V16SFmode || mode == V8DFmode ) emit_insn ( gen_rtx_SET ( x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( <NUM_LIT> , b ) , UNSPEC_RCP14 ) ) ) ; else emit_insn ( gen_rtx_SET ( x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( <NUM_LIT> , b ) , UNSPEC_RCP ) ) ) ; emit_insn ( gen_rtx_SET ( e0 , gen_rtx_MULT ( mode , x0 , b ) ) ) ;


<s> e1 = gen_reg_rtx ( mode ) ; e2 = gen_reg_rtx ( mode ) ; e3 = gen_reg_rtx ( mode ) ; real_from_integer ( & r , VOIDmode , - <NUM_LIT> , SIGNED ) ; mthree = const_double_from_real_value ( r , SFmode ) ; real_arithmetic ( & r , NEGATE_EXPR , & dconsthalf , NULL ) ; mhalf = const_double_from_real_value ( r , SFmode ) ; unspec = UNSPEC_RSQRT ; if ( VECTOR_MODE_P ( mode ) ) { mthree = ix86_build_const_vector ( mode , true , mthree ) ; mhalf = ix86_build_const_vector ( mode , true , mhalf ) ; if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) unspec = UNSPEC_RSQRT14 ; } a = force_reg ( mode , a ) ; emit_insn ( gen_rtx_SET ( x0 , gen_rtx_UNSPEC ( mode , gen_rtvec ( <NUM_LIT> , a ) , unspec ) ) ) ; if ( ! recip ) { rtx zero = force_reg ( mode , CONST0_RTX ( mode ) ) ; rtx mask ; if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) { mask = gen_reg_rtx ( HImode ) ; emit_insn ( gen_avx512f_cmpv16sf3 ( mask , zero , a , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_avx512f_blendmv16sf ( x0 , zero , x0 , mask ) ) ; } else { mask = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( mask , gen_rtx_NE ( mode , zero , a ) ) ) ; emit_insn ( gen_rtx_SET ( x0 , gen_rtx_AND ( mode , x0 , mask ) ) ) ; } } emit_insn ( gen_rtx_SET ( e0 , gen_rtx_MULT ( mode , x0 , a ) ) ) ; emit_insn ( gen_rtx_SET ( e1 , gen_rtx_MULT ( mode , e0 , x0 ) ) ) ; mthree = force_reg ( mode , mthree ) ;

emit_insn ( gen_rtx_SET ( e2 , gen_rtx_PLUS ( mode , e1 , mthree ) ) ) ;


<s> two31r = force_reg ( mode , two31r ) ; switch ( mode ) { case V8SFmode : cmp = gen_avx_maskcmpv8sf3 ; break ; case V4SFmode : cmp = gen_sse_maskcmpv4sf3 ; break ; case V4DFmode : cmp = gen_avx_maskcmpv4df3 ; break ; case V2DFmode : cmp = gen_sse2_maskcmpv2df3 ; break ; default : gcc_unreachable ( ) ; } tmp [ <NUM_LIT> ] = gen_rtx_LE ( mode , two31r , val ) ; emit_insn ( cmp ( tmp [ <NUM_LIT> ] , two31r , val , tmp [ <NUM_LIT> ] ) ) ; tmp [ <NUM_LIT> ] = expand_simple_binop ( mode , AND , tmp [ <NUM_LIT> ] , two31r , tmp [ <NUM_LIT> ] , <NUM_LIT> , OPTAB_DIRECT ) ; if ( intmode == V4SImode || TARGET_AVX2 ) * xorp = expand_simple_binop ( intmode , ASHIFT , gen_lowpart ( intmode , tmp [ <NUM_LIT> ] ) , GEN_INT ( <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; else { rtx two31 = GEN_INT ( HOST_WIDE_INT_1U << <NUM_LIT> ) ; two31 = ix86_build_const_vector ( intmode , <NUM_LIT> , two31 ) ;

* xorp = expand_simple_binop ( intmode , AND , gen_lowpart ( intmode , tmp [ <NUM_LIT> ] ) , two31 , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> return ; } switch ( mode ) { case SFmode : case DFmode : case XFmode : case QImode : case HImode : case SImode : simple : tmp = ix86_expand_compare ( code , op0 , op1 ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp ) ) ; return ; case DImode : if ( TARGET_64BIT ) goto simple ; if ( ! optimize_insn_for_size_p ( ) && TARGET_STV && ( code == EQ || code == NE ) ) { op0 = force_reg ( mode , gen_rtx_XOR ( mode , op0 , op1 ) ) ; op1 = const0_rtx ; } case TImode : { rtx lo [ <NUM_LIT> ] , hi [ <NUM_LIT> ] ; rtx_code_label * label2 ; enum rtx_code code1 , code2 , code3 ; machine_mode submode ; if ( CONSTANT_P ( op0 ) && ! CONSTANT_P ( op1 ) ) { std :: swap ( op0 , op1 ) ; code = swap_condition ( code ) ; } split_double_mode ( mode , & op0 , <NUM_LIT> , lo + <NUM_LIT> , hi + <NUM_LIT> ) ; split_double_mode ( mode , & op1 , <NUM_LIT> , lo + <NUM_LIT> , hi + <NUM_LIT> ) ; submode = mode == DImode ? SImode : DImode ; if ( ( code == EQ || code == NE ) && ( ! optimize_insn_for_size_p ( ) || hi [ <NUM_LIT> ] == const0_rtx || lo [ <NUM_LIT> ] == const0_rtx ) ) { rtx xor0 , xor1 ; xor1 = hi [ <NUM_LIT> ] ; if ( hi [ <NUM_LIT> ] != const0_rtx ) xor1 = expand_binop ( submode , xor_optab , xor1 , hi [ <NUM_LIT> ] , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; xor0 = lo [ <NUM_LIT> ] ; if ( lo [ <NUM_LIT> ] != const0_rtx ) xor0 = expand_binop ( submode , xor_optab , xor0 , lo [ <NUM_LIT> ] , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; tmp = expand_binop ( submode , ior_optab , xor1 , xor0 , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; ix86_expand_branch ( code , tmp , const0_rtx , label ) ; return ; } if ( CONST_INT_P ( hi [ <NUM_LIT> ] ) ) switch ( code ) {

case LT : case LTU : case GE : case GEU :


<s> gcc_assert ( code == EQ || code == NE ) ; tmp = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_XOR ( mode , op0 , op1 ) ) ) ; tmp = gen_lowpart ( p_mode , tmp ) ; emit_insn ( gen_rtx_SET ( gen_rtx_REG ( CCmode , FLAGS_REG ) , gen_rtx_UNSPEC ( CCmode , gen_rtvec ( <NUM_LIT> , tmp , tmp ) , UNSPEC_PTEST ) ) ) ; tmp = gen_rtx_fmt_ee ( code , VOIDmode , flag , const0_rtx ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp ) ) ; return ; } switch ( mode ) { case SFmode : case DFmode : case XFmode : case QImode : case HImode : case SImode : simple : tmp = ix86_expand_compare ( code , op0 , op1 ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp ) ) ; return ; case DImode : if ( TARGET_64BIT ) goto simple ; if ( ! optimize_insn_for_size_p ( ) && TARGET_STV && ( code == EQ || code == NE ) ) { op0 = force_reg ( mode , gen_rtx_XOR ( mode , op0 , op1 ) ) ; op1 = const0_rtx ; } case TImode : { rtx lo [ <NUM_LIT> ] , hi [ <NUM_LIT> ] ; rtx_code_label * label2 ; enum rtx_code code1 , code2 , code3 ; machine_mode submode ; if ( CONSTANT_P ( op0 ) && ! CONSTANT_P ( op1 ) ) { std :: swap ( op0 , op1 ) ; code = swap_condition ( code ) ; } split_double_mode ( mode , & op0 , <NUM_LIT> , lo + <NUM_LIT> , hi + <NUM_LIT> ) ; split_double_mode ( mode , & op1 , <NUM_LIT> , lo + <NUM_LIT> , hi + <NUM_LIT> ) ; submode = mode == DImode ? SImode : DImode ; if ( ( code == EQ || code == NE ) && ( ! optimize_insn_for_size_p ( ) || hi [ <NUM_LIT> ] == const0_rtx || lo [ <NUM_LIT> ] == const0_rtx ) ) { rtx xor0 , xor1 ; xor1 = hi [ <NUM_LIT> ] ; if ( hi [ <NUM_LIT> ] != const0_rtx ) xor1 = expand_binop ( submode , xor_optab , xor1 , hi [ <NUM_LIT> ] , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; xor0 = lo [ <NUM_LIT> ] ; if ( lo [ <NUM_LIT> ] != const0_rtx ) xor0 = expand_binop ( submode , xor_optab , xor0 , lo [ <NUM_LIT> ] , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ;


<s> else copysign_insn = gen_copysigntf3_const ; emit_insn ( copysign_insn ( dest , op0 , op1 , mask ) ) ; } else { rtx ( * copysign_insn ) ( rtx , rtx , rtx , rtx , rtx , rtx ) ; nmask = ix86_build_signbit_mask ( vmode , <NUM_LIT> , <NUM_LIT> ) ; mask = ix86_build_signbit_mask ( vmode , <NUM_LIT> , <NUM_LIT> ) ; if ( mode == SFmode ) copysign_insn = gen_copysignsf3_var ; else if ( mode == DFmode ) copysign_insn = gen_copysigndf3_var ; else copysign_insn = gen_copysigntf3_var ; emit_insn ( copysign_insn ( dest , NULL_RTX , op0 , op1 , nmask , mask ) ) ;


<s> set = gen_rtx_fmt_e ( code , mode , src ) ; set = gen_rtx_SET ( dst , set ) ; if ( mask ) { rtx use , clob ; rtvec par ; use = gen_rtx_USE ( VOIDmode , mask ) ; if ( vector_mode ) par = gen_rtvec ( <NUM_LIT> , set , use ) ; else { clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; par = gen_rtvec ( <NUM_LIT> , set , use , clob ) ; } emit_insn ( gen_rtx_PARALLEL ( VOIDmode , par ) ) ; } else emit_insn ( set ) ;


<s> case LT : case UNLT : if ( code == LT && TARGET_IEEE_FP ) { emit_insn ( gen_andqi_ext_0 ( scratch , scratch , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_cmpqi_ext_3 ( scratch , const1_rtx ) ) ; intcmp_mode = CCmode ; code = EQ ; } else { emit_insn ( gen_testqi_ext_ccno_0 ( scratch , const1_rtx ) ) ; code = NE ; } break ; case GE : case UNGE : if ( code == GE || ! TARGET_IEEE_FP ) { emit_insn ( gen_testqi_ext_ccno_0 ( scratch , GEN_INT ( <NUM_LIT> ) ) ) ; code = EQ ; } else { emit_insn ( gen_andqi_ext_0 ( scratch , scratch , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_xorqi_cc_ext_1 ( scratch , scratch , const1_rtx ) ) ; code = NE ; } break ; case LE : case UNLE : if ( code == LE && TARGET_IEEE_FP ) { emit_insn ( gen_andqi_ext_0 ( scratch , scratch , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_addqi_ext_1 ( scratch , scratch , constm1_rtx ) ) ; emit_insn ( gen_cmpqi_ext_3 ( scratch , GEN_INT ( <NUM_LIT> ) ) ) ; intcmp_mode = CCmode ; code = LTU ; } else { emit_insn ( gen_testqi_ext_ccno_0 ( scratch , GEN_INT ( <NUM_LIT> ) ) ) ; code = NE ; } break ; case EQ : case UNEQ : if ( code == EQ && TARGET_IEEE_FP ) { emit_insn ( gen_andqi_ext_0 ( scratch , scratch , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_cmpqi_ext_3 ( scratch , GEN_INT ( <NUM_LIT> ) ) ) ; intcmp_mode = CCmode ; code = EQ ; } else { emit_insn ( gen_testqi_ext_ccno_0 ( scratch , GEN_INT ( <NUM_LIT> ) ) ) ; code = NE ; } break ; case NE : case LTGT : if ( code == NE && TARGET_IEEE_FP ) { emit_insn ( gen_andqi_ext_0 ( scratch , scratch , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_xorqi_cc_ext_1 ( scratch , scratch , GEN_INT ( <NUM_LIT> ) ) ) ; code = NE ; } else { emit_insn ( gen_testqi_ext_ccno_0 ( scratch , GEN_INT ( <NUM_LIT> ) ) ) ; code = EQ ; } break ; case UNORDERED :


<s> } if ( code == GTU ) { cop0 = force_reg ( mode , cop0 ) ; switch ( mode ) { case V16SImode : case V8DImode : case V8SImode : case V4DImode : case V4SImode : case V2DImode : { rtx t1 , t2 , mask ; rtx ( * gen_sub3 ) ( rtx , rtx , rtx ) ; switch ( mode ) { case V16SImode : gen_sub3 = gen_subv16si3 ; break ; case V8DImode : gen_sub3 = gen_subv8di3 ; break ; case V8SImode : gen_sub3 = gen_subv8si3 ; break ; case V4DImode : gen_sub3 = gen_subv4di3 ; break ; case V4SImode : gen_sub3 = gen_subv4si3 ; break ; case V2DImode : gen_sub3 = gen_subv2di3 ; break ; default : gcc_unreachable ( ) ; } mask = ix86_build_signbit_mask ( mode , true , false ) ; t1 = gen_reg_rtx ( mode ) ; emit_insn ( gen_sub3 ( t1 , cop0 , mask ) ) ; t2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_sub3 ( t2 , cop1 , mask ) ) ; cop0 = t1 ; cop1 = t2 ; code = GT ; } break ; case V64QImode : case V32HImode : case V32QImode : case V16HImode : case V16QImode : case V8HImode : x = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( x , gen_rtx_US_MINUS ( mode , cop0 , cop1 ) ) ) ; cop0 = x ; cop1 = CONST0_RTX ( mode ) ; code = EQ ;


<s> rtx tmp ; model = SYMBOL_REF_TLS_MODEL ( symbol ) ; if ( model ) tmp = legitimize_tls_address ( symbol , model , true ) ; else tmp = legitimize_pe_coff_symbol ( symbol , true ) ; if ( tmp ) { tmp = force_operand ( tmp , NULL ) ; tmp = expand_simple_binop ( Pmode , PLUS , tmp , addend , op0 , <NUM_LIT> , OPTAB_DIRECT ) ; if ( tmp == op0 ) return ; op1 = convert_to_mode ( mode , tmp , <NUM_LIT> ) ; } } if ( ( flag_pic || MACHOPIC_INDIRECT ) && symbolic_operand ( op1 , mode ) ) { if ( TARGET_MACHO && ! TARGET_64BIT ) { if ( MACHOPIC_INDIRECT ) { rtx temp = ( op0 && REG_P ( op0 ) && mode == Pmode ) ? op0 : gen_reg_rtx ( Pmode ) ; op1 = machopic_indirect_data_reference ( op1 , temp ) ; if ( MACHOPIC_PURE ) op1 = machopic_legitimize_pic_address ( op1 , mode , temp == op1 ? <NUM_LIT> : temp ) ; } if ( op0 != op1 && GET_CODE ( op0 ) != MEM ) { rtx insn = gen_rtx_SET ( op0 , op1 ) ; emit_insn ( insn ) ; return ; } if ( GET_CODE ( op0 ) == MEM ) op1 = force_reg ( Pmode , op1 ) ; else { rtx temp = op0 ; if ( GET_CODE ( temp ) != REG ) temp = gen_reg_rtx ( Pmode ) ; temp = legitimize_pic_address ( op1 , temp ) ; if ( temp == op0 ) return ; op1 = temp ; } } else { if ( MEM_P ( op0 ) ) op1 = force_reg ( mode , op1 ) ; else if ( ! ( TARGET_64BIT && x86_64_movabs_operand ( op1 , DImode ) ) ) { rtx reg = can_create_pseudo_p ( ) ? NULL_RTX : op0 ; op1 = legitimize_pic_address ( op1 , reg ) ; if ( op0 == op1 ) return ; op1 = convert_to_mode ( mode , op1 , <NUM_LIT> ) ; } } } else {

if ( MEM_P ( op0 ) && ( PUSH_ROUNDING ( GET_MODE_SIZE ( mode ) ) != GET_MODE_SIZE ( mode ) || ! push_operand ( op0 , mode ) ) && MEM_P ( op1 ) ) op1 = force_reg ( mode , op1 ) ;


<s> rtx dst = operands [ <NUM_LIT> ] ; rtx src = operands [ <NUM_LIT> ] ; unsigned int size = INTVAL ( operands [ <NUM_LIT> ] ) ; unsigned int pos = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( SUBREG_P ( dst ) ) { if ( SUBREG_BYTE ( dst ) > <NUM_LIT> ) return false ; dst = SUBREG_REG ( dst ) ; } if ( SUBREG_P ( src ) ) { pos += SUBREG_BYTE ( src ) * BITS_PER_UNIT ; src = SUBREG_REG ( src ) ; } switch ( GET_MODE ( src ) ) { case V16QImode : case V8HImode : case V4SImode : case V2DImode : case V1TImode : case TImode : { machine_mode srcmode , dstmode ; rtx d , pat ; dstmode = mode_for_size ( size , MODE_INT , <NUM_LIT> ) ; switch ( dstmode ) { case QImode : if ( ! TARGET_SSE4_1 ) return false ; srcmode = V16QImode ; break ; case HImode : if ( ! TARGET_SSE2 ) return false ; srcmode = V8HImode ; break ; case SImode : if ( ! TARGET_SSE4_1 ) return false ; srcmode = V4SImode ; break ; case DImode : gcc_assert ( TARGET_64BIT ) ; if ( ! TARGET_SSE4_1 ) return false ; srcmode = V2DImode ; break ; default : return false ; }

if ( pos & ( size - <NUM_LIT> ) ) return false ;


<s> case V8HImode : case V4SImode : case V2DImode : case V1TImode : case TImode : { machine_mode srcmode , dstmode ; rtx ( * pinsr ) ( rtx , rtx , rtx , rtx ) ; rtx d ; srcmode = mode_for_size ( size , MODE_INT , <NUM_LIT> ) ; switch ( srcmode ) { case QImode : if ( ! TARGET_SSE4_1 ) return false ; dstmode = V16QImode ; pinsr = gen_sse4_1_pinsrb ; break ; case HImode : if ( ! TARGET_SSE2 ) return false ; dstmode = V8HImode ; pinsr = gen_sse2_pinsrw ; break ; case SImode : if ( ! TARGET_SSE4_1 ) return false ; dstmode = V4SImode ; pinsr = gen_sse4_1_pinsrd ; break ; case DImode : gcc_assert ( TARGET_64BIT ) ; if ( ! TARGET_SSE4_1 ) return false ; dstmode = V2DImode ; pinsr = gen_sse4_1_pinsrq ; break ; default : return false ; } if ( pos & ( size - <NUM_LIT> ) ) return false ; if ( SUBREG_P ( src ) ) { unsigned int srcpos = SUBREG_BYTE ( src ) ; if ( srcpos > <NUM_LIT> ) { rtx extr_ops [ <NUM_LIT> ] ; extr_ops [ <NUM_LIT> ] = gen_reg_rtx ( srcmode ) ; extr_ops [ <NUM_LIT> ] = gen_lowpart ( srcmode , SUBREG_REG ( src ) ) ; extr_ops [ <NUM_LIT> ] = GEN_INT ( size ) ; extr_ops [ <NUM_LIT> ] = GEN_INT ( srcpos * BITS_PER_UNIT ) ; if ( ! ix86_expand_pextr ( extr_ops ) ) return false ; src = extr_ops [ <NUM_LIT> ] ; } else src = gen_lowpart ( srcmode , SUBREG_REG ( src ) ) ; } if ( GET_MODE ( dst ) == dstmode ) d = dst ;


<s> mhalf = expand_simple_binop ( mode , MINUS , half , one , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; tmp = gen_reg_rtx ( mode ) ; tmp = ix86_expand_sse_compare_mask ( UNGT , dxa , half , false ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_AND ( mode , one , tmp ) ) ) ; xa2 = expand_simple_binop ( mode , MINUS , xa2 , tmp , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; tmp = ix86_expand_sse_compare_mask ( UNGE , mhalf , dxa , false ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_AND ( mode , one , tmp ) ) ) ; xa2 = expand_simple_binop ( mode , PLUS , xa2 , tmp , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; ix86_sse_copysign_to_positive ( res , xa2 , force_reg ( mode , operand1 ) , mask ) ;


<s> } } else if ( i == nargs - <NUM_LIT> ) { if ( ! insn_p -> operand [ nargs ] . predicate ( op , SImode ) ) { error ( <STR_LIT> ) ; return const0_rtx ; } if ( INTVAL ( op ) == NO_ROUND ) redundant_embed_rnd = <NUM_LIT> ; } else { if ( VECTOR_MODE_P ( mode ) ) op = safe_vector_operand ( op , mode ) ; op = fixup_modeless_constant ( op , mode ) ; if ( GET_MODE ( op ) == mode || GET_MODE ( op ) == VOIDmode ) { if ( optimize || ! match ) op = copy_to_mode_reg ( mode , op ) ; } else { op = copy_to_reg ( op ) ; op = simplify_gen_subreg ( mode , op , GET_MODE ( op ) , <NUM_LIT> ) ; } } args [ i ] . op = op ; args [ i ] . mode = mode ; } switch ( nargs ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , args [ <NUM_LIT> ] . op ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op ) ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op , args [ <NUM_LIT> ] . op ) ; break ; default : gcc_unreachable ( ) ; } if ( ! pat ) return <NUM_LIT> ; if ( redundant_embed_rnd ) pat = ix86_erase_embedded_rounding ( pat ) ;


<s> void ix86_expand_round_sse4 ( rtx op0 , rtx op1 ) { machine_mode mode = GET_MODE ( op0 ) ; rtx e1 , e2 , res , half ; const struct real_format * fmt ; REAL_VALUE_TYPE pred_half , half_minus_pred_half ; rtx ( * gen_copysign ) ( rtx , rtx , rtx ) ; rtx ( * gen_round ) ( rtx , rtx , rtx ) ; switch ( mode ) { case SFmode : gen_copysign = gen_copysignsf3 ; gen_round = gen_sse4_1_roundsf2 ; break ; case DFmode : gen_copysign = gen_copysigndf3 ; gen_round = gen_sse4_1_rounddf2 ; break ; default :


<s> void ix86_expand_round_sse4 ( rtx op0 , rtx op1 ) { machine_mode mode = GET_MODE ( op0 ) ; rtx e1 , e2 , res , half ; const struct real_format * fmt ; REAL_VALUE_TYPE pred_half , half_minus_pred_half ; rtx ( * gen_copysign ) ( rtx , rtx , rtx ) ; rtx ( * gen_round ) ( rtx , rtx , rtx ) ; switch ( mode ) { case SFmode : gen_copysign = gen_copysignsf3 ; gen_round = gen_sse4_1_roundsf2 ; break ; case DFmode : gen_copysign = gen_copysigndf3 ; gen_round = gen_sse4_1_rounddf2 ; break ; default : gcc_unreachable ( ) ; } fmt = REAL_MODE_FORMAT ( mode ) ;

real_2expN ( & half_minus_pred_half , - ( fmt -> p ) - <NUM_LIT> , mode ) ;