<s> break ; case LABEL_REF : x = XEXP ( x , <NUM_LIT> ) ; case CODE_LABEL : ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , CODE_LABEL_NUMBER ( x ) ) ; assemble_name ( asm_out_file , buf ) ; break ; case CONST_INT : fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( x ) ) ; break ; case CONST : output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; break ; case CONST_DOUBLE : if ( GET_MODE ( x ) == VOIDmode ) { if ( CONST_DOUBLE_HIGH ( x ) || CONST_DOUBLE_LOW ( x ) < <NUM_LIT> ) fprintf ( file , <STR_LIT> , ( unsigned long ) CONST_DOUBLE_HIGH ( x ) , ( unsigned long ) CONST_DOUBLE_LOW ( x ) ) ; else fprintf ( file , HOST_WIDE_INT_PRINT_DEC , CONST_DOUBLE_LOW ( x ) ) ; } else output_operand_lossage ( <STR_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '+' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } else { gcc_assert ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '+' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } break ; case MINUS : if ( ! TARGET_MACHO ) putc ( ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '-' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; if ( ! TARGET_MACHO ) putc ( ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']' , file ) ; break ; case UNSPEC : gcc_assert ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) ; output_pic_addr_const ( file , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , code ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_GOT : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTPCREL : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTTPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_TPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_NTPOFF : if ( TARGET_64BIT ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_DTPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTNTPOFF : if ( TARGET_64BIT ) fputs ( <STR_LIT> , file ) ;


<s> rtx xops [ <NUM_LIT> ] ; xops [ <NUM_LIT> ] = dest ; xops [ <NUM_LIT> ] = gen_rtx_SYMBOL_REF ( Pmode , GOT_SYMBOL_NAME ) ; if ( ! TARGET_DEEP_BRANCH_PREDICTION || ! flag_pic ) { xops [ <NUM_LIT> ] = gen_rtx_LABEL_REF ( Pmode , gen_label_rtx ( ) ) ; if ( ! flag_pic ) output_asm_insn ( <STR_LIT> , xops ) ; else output_asm_insn ( <STR_LIT> , xops ) ; ASM_OUTPUT_LABEL ( asm_out_file , machopic_function_base_name ( ) ) ;

( * targetm . asm_out . internal_label ) ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( XEXP ( xops [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ;


<s> fputs ( <STR_LIT> , file ) ; break ; } case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : if ( ! ANY_FP_REG_P ( x ) ) putc ( code == <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : case <NUM_LIT> : normal : fputs ( hi_reg_name [ REGNO ( x ) ] , file ) ; break ; case <NUM_LIT> : if ( REGNO ( x ) >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; fputs ( qi_reg_name [ REGNO ( x ) ] , file ) ; break ; case <NUM_LIT> : if ( REGNO ( x ) >= ARRAY_SIZE ( qi_high_reg_name ) ) goto normal ; fputs ( qi_high_reg_name [ REGNO ( x ) ] , file ) ; break ; default :


<s> r11 = gen_rtx_REG ( DImode , FIRST_REX_INT_REG + <NUM_LIT> ) ; insn = emit_insn ( gen_rtx_SET ( DImode , r11 , offset ) ) ; if ( style < <NUM_LIT> ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

insn = emit_insn ( gen_pro_epilogue_adjust_stack_rex64_2 ( dest , src , r11 , offset ) ) ;


<s> rtx insn ; if ( ! TARGET_64BIT ) insn = emit_insn ( gen_pro_epilogue_adjust_stack_1 ( dest , src , offset ) ) ; else if ( x86_64_immediate_operand ( offset , DImode ) ) insn = emit_insn ( gen_pro_epilogue_adjust_stack_rex64 ( dest , src , offset ) ) ; else { rtx r11 ; gcc_assert ( style ) ;


<s> case GE : switch ( mode ) { case CCNOmode : case CCGOCmode : suffix = <STR_LIT> ; break ; case CCmode : case CCGCmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case GEU : gcc_assert ( mode == CCmode ) ; suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; case LE : gcc_assert ( mode == CCmode || mode == CCGCmode || mode == CCNOmode ) ; suffix = <STR_LIT> ; break ; case LEU : gcc_assert ( mode == CCmode ) ; suffix = <STR_LIT> ; break ; case UNORDERED : suffix = fp ? <STR_LIT> : <STR_LIT> ;


<s> gcc_assert ( bypass_code == UNKNOWN && second_code == UNKNOWN ) ; code = ix86_fp_compare_code_to_integer ( code ) ; mode = CCmode ; } if ( reverse ) code = reverse_condition ( code ) ; switch ( code ) { case EQ : suffix = <STR_LIT> ; break ; case NE : suffix = <STR_LIT> ; break ; case GT : gcc_assert ( mode == CCmode || mode == CCNOmode || mode == CCGCmode ) ; suffix = <STR_LIT> ; break ; case GTU : gcc_assert ( mode == CCmode ) ; suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; case LT : switch ( mode ) { case CCNOmode : case CCGOCmode : suffix = <STR_LIT> ; break ; case CCmode : case CCGCmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case LTU : gcc_assert ( mode == CCmode ) ; suffix = <STR_LIT> ; break ; case GE : switch ( mode ) { case CCNOmode : case CCGOCmode : suffix = <STR_LIT> ; break ; case CCmode : case CCGCmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case GEU : gcc_assert ( mode == CCmode ) ; suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; case LE : gcc_assert ( mode == CCmode || mode == CCGCmode || mode == CCNOmode ) ; suffix = <STR_LIT> ; break ; case LEU : gcc_assert ( mode == CCmode ) ; suffix = <STR_LIT> ; break ; case UNORDERED : suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; case ORDERED : suffix = fp ? <STR_LIT> : <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } fputs ( suffix , file ) ;


<s> void split_di ( rtx operands [ ] , int num , rtx lo_half [ ] , rtx hi_half [ ] ) { while ( num -- ) { rtx op = operands [ num ] ; if ( GET_CODE ( op ) == MEM ) { lo_half [ num ] = adjust_address ( op , SImode , <NUM_LIT> ) ; hi_half [ num ] = adjust_address ( op , SImode , <NUM_LIT> ) ; } else { lo_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , <NUM_LIT> ) ; hi_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , <NUM_LIT> ) ;


<s> } else { lo_half [ num ] = simplify_gen_subreg ( DImode , op , TImode , <NUM_LIT> ) ;

hi_half [ num ] = simplify_gen_subreg ( DImode , op , TImode , <NUM_LIT> ) ;


<s> while ( num -- ) { rtx op = operands [ num ] ; if ( GET_CODE ( op ) == MEM ) { lo_half [ num ] = adjust_address ( op , DImode , <NUM_LIT> ) ; hi_half [ num ] = adjust_address ( op , DImode , <NUM_LIT> ) ; } else {

lo_half [ num ] = simplify_gen_subreg ( DImode , op , TImode , <NUM_LIT> ) ;


<s> if ( GET_MODE ( x ) == XFmode && ( optimize_size || x86_ext_80387_constants & TUNEMASK ) ) { REAL_VALUE_TYPE r ; int i ; if ( ! ext_80387_constants_init ) init_ext_80387_constants ( ) ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ;

for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( real_identical ( & r , & ext_80387_constants_table [ i ] ) ) return i + <NUM_LIT> ;


<s> int i ; if ( ! ext_80387_constants_init ) init_ext_80387_constants ( ) ; switch ( idx ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : i = idx - <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } return CONST_DOUBLE_FROM_REAL_VALUE ( ext_80387_constants_table [ i ] , XFmode ) ;


<s> int standard_sse_constant_p ( rtx x ) { if ( x == const0_rtx ) return <NUM_LIT> ;

return ( x == CONST0_RTX ( GET_MODE ( x ) ) ) ;


<s> if ( x == const0_rtx ) return <NUM_LIT> ;


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


<s> for ( ; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE ( mode ) ) if ( GET_MODE_NUNITS ( mode ) == TYPE_VECTOR_SUBPARTS ( type ) && GET_MODE_INNER ( mode ) == innermode ) return mode ; gcc_unreachable ( ) ; } }


<s> enum machine_mode mode = TYPE_MODE ( type ) ; if ( TREE_CODE ( type ) == VECTOR_TYPE && ! VECTOR_MODE_P ( mode ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( ( size == <NUM_LIT> || size == <NUM_LIT> ) && TYPE_VECTOR_SUBPARTS ( type ) > <NUM_LIT> ) {

enum machine_mode innermode = TYPE_MODE ( TREE_TYPE ( type ) ) ;


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


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


<s> const char * name ; size_t nlen , plen ; char * string ; plen = strlen ( prefix ) ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = targetm . strip_name_encoding ( name ) ; nlen = strlen ( name ) ; string = alloca ( nlen + plen + <NUM_LIT> ) ; memcpy ( string , prefix , plen ) ;

memcpy ( string + plen , name , nlen + <NUM_LIT> ) ;


<s> if ( ix86_function_regparm ( TREE_TYPE ( function ) , function ) < <NUM_LIT> ) return true ; if ( vcall_offset ) return false ;

if ( flag_pic && ! ( * targetm . binds_local_p ) ( function ) ) return false ;


<s> if ( TARGET_64BIT ) return true ; if ( ix86_function_regparm ( TREE_TYPE ( function ) , function ) < <NUM_LIT> ) return true ; if ( vcall_offset ) return false ; if ( flag_pic && ! ( * targetm . binds_local_p ) ( function ) ) return false ;


<s> rtx neglab , donelab , i0 , i1 , f0 , in , out ; enum machine_mode mode , inmode ; 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 ( ) ; i1 = gen_reg_rtx ( Pmode ) ;


for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) if ( REG_P ( recog_data . operand [ i ] ) && REGNO ( recog_data . operand [ i ] ) >= <NUM_LIT> ) return true ;


<s> bool x86_extended_reg_mentioned_p ( rtx insn ) {

return for_each_rtx ( & PATTERN ( insn ) , extended_reg_mentioned_1 , NULL ) ;


<s> enum machine_mode mode ; tree type = TREE_TYPE ( field ) ; if ( TARGET_64BIT || TARGET_ALIGN_DOUBLE ) return computed ; mode = TYPE_MODE ( TREE_CODE ( type ) == ARRAY_TYPE ? get_inner_array_type ( type ) : 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> enum machine_mode mode ; tree type = TREE_TYPE ( field ) ; if ( TARGET_64BIT || TARGET_ALIGN_DOUBLE ) return computed ;

mode = TYPE_MODE ( TREE_CODE ( type ) == ARRAY_TYPE ? get_inner_array_type ( type ) : type ) ;


<s> default_file_start ( ) ; if ( X86_FILE_START_VERSION_DIRECTIVE ) fputs ( <STR_LIT> , asm_out_file ) ; if ( X86_FILE_START_FLTUSED ) fputs ( <STR_LIT> , asm_out_file ) ; if ( ix86_asm_dialect == ASM_INTEL ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> if ( TARGET_64BIT ) if ( flag_pic ) { fprintf ( file , <STR_LIT> , LPREFIX , labelno ) ; fprintf ( file , <STR_LIT> , MCOUNT_NAME ) ; } else { fprintf ( file , <STR_LIT> , LPREFIX , labelno ) ; fprintf ( file , <STR_LIT> , MCOUNT_NAME ) ; } else if ( flag_pic ) { fprintf ( file , <STR_LIT> , LPREFIX , labelno , PROFILE_COUNT_REGISTER ) ;


<s> 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 ; 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> void x86_output_aligned_bss ( FILE * file , tree decl ATTRIBUTE_UNUSED , 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 ) named_section ( decl , <STR_LIT> , <NUM_LIT> ) ; else bss_section ( ) ; ASM_OUTPUT_ALIGN ( file , floor_log2 ( align / BITS_PER_UNIT ) ) ;


<s> int n = aggregate_value_p ( TREE_TYPE ( type ) , type ) != <NUM_LIT> ; return gen_rtx_REG ( DImode , x86_64_int_parameter_registers [ n ] ) ; } if ( ix86_function_regparm ( type , function ) > <NUM_LIT> ) { tree parm ; parm = TYPE_ARG_TYPES ( type ) ;

for ( ; parm ; parm = TREE_CHAIN ( parm ) ) if ( TREE_VALUE ( parm ) == void_type_node ) break ;


<s> static void add_insn_window ( rtx_insn * insn , dispatch_windows * window_list , int num_uops ) { int byte_len = min_insn_size ( insn ) ; int num_insn = window_list -> num_insn ; int imm_size ; sched_insn_info * window = window_list -> window ; enum dispatch_group group = get_insn_group ( insn ) ; enum insn_path path = get_insn_path ( insn ) ; int num_imm_operand ; int num_imm32_operand ; int num_imm64_operand ;

if ( ! window_list -> violation && group != disp_cmp && ! fits_dispatch_window ( insn ) ) window_list -> violation = true ;


<s> enum insn_path path ; enum dispatch_group insn_group ; bool insn_fits ; int num_insn ; int num_uops ; int window_num ; int insn_num_uops ; int sum ; if ( INSN_CODE ( insn ) < <NUM_LIT> ) return ; byte_len = min_insn_size ( insn ) ; window_list = dispatch_window_list ; next_list = window_list -> next ; path = get_insn_path ( insn ) ; insn_group = get_insn_group ( insn ) ; if ( next_list ) window_list = dispatch_window_list -> next ; if ( path == path_single ) insn_num_uops = <NUM_LIT> ; else if ( path == path_double ) insn_num_uops = <NUM_LIT> ; else insn_num_uops = ( int ) path ; num_insn = window_list -> num_insn ; num_uops = window_list -> num_uops ; window_num = window_list -> window_num ; insn_fits = fits_dispatch_window ( insn ) ; if ( num_insn >= MAX_INSN || num_uops + insn_num_uops > MAX_INSN || ! ( insn_fits ) ) { window_num = ~ window_num & <NUM_LIT> ; window_list = allocate_next_window ( window_num ) ; } if ( window_num == <NUM_LIT> ) { add_insn_window ( insn , window_list , insn_num_uops ) ; if ( window_list -> num_insn >= MAX_INSN && insn_group == disp_branch ) { process_end_window ( ) ; return ; } } else if ( window_num == <NUM_LIT> ) { window0_list = window_list -> prev ; sum = window0_list -> window_size + window_list -> window_size ; if ( sum == <NUM_LIT> || ( byte_len + sum ) >= <NUM_LIT> ) { process_end_window ( ) ; window_list = dispatch_window_list ; } add_insn_window ( insn , window_list , insn_num_uops ) ; } else gcc_unreachable ( ) ;

if ( is_end_basic_block ( insn_group ) ) {


<s> if ( alg == vector_loop ) return TARGET_SSE || TARGET_AVX ; if ( alg == rep_prefix_1_byte || alg == rep_prefix_4_byte || alg == rep_prefix_8_byte ) return ! ( fixed_regs [ CX_REG ] || fixed_regs [ DI_REG ] || ( memset ? fixed_regs [ AX_REG ] : fixed_regs [ SI_REG ] ) ) ; return true ;


<s> if ( window_num == <NUM_LIT> ) { if ( dispatch_window_list -> next ) init_window ( <NUM_LIT> ) ; init_window ( <NUM_LIT> ) ; return dispatch_window_list ; }

dispatch_window_list -> next = dispatch_window_list1 ;


<s> new_list -> window = XNEWVEC ( struct sched_insn_info_s , MAX_INSN + <NUM_LIT> ) ; return new_list ;


<s> const char * c2 = * ( char * const * ) v2 ; return strcmp ( c1 , c2 ) ;


<s> HOST_WIDE_INT toffset ; int len = <NUM_LIT> , tlen ; if ( m -> fs . sp_valid ) { base_reg = stack_pointer_rtx ; base_offset = m -> fs . sp_offset - cfa_offset ; len = choose_baseaddr_len ( STACK_POINTER_REGNUM , base_offset ) ; } if ( m -> fs . drap_valid ) { toffset = <NUM_LIT> - cfa_offset ; tlen = choose_baseaddr_len ( REGNO ( crtl -> drap_reg ) , toffset ) ; if ( tlen <= len ) { base_reg = crtl -> drap_reg ; base_offset = toffset ; len = tlen ; } } if ( m -> fs . fp_valid ) { toffset = m -> fs . fp_offset - cfa_offset ; tlen = choose_baseaddr_len ( HARD_FRAME_POINTER_REGNUM , toffset ) ; if ( tlen <= len ) { base_reg = hard_frame_pointer_rtx ; base_offset = toffset ;


<s> if ( m -> fs . fp_valid ) { base_reg = hard_frame_pointer_rtx ; base_offset = m -> fs . fp_offset - cfa_offset ; } else if ( m -> fs . drap_valid ) { base_reg = crtl -> drap_reg ; base_offset = <NUM_LIT> - cfa_offset ; } else if ( m -> fs . sp_valid ) { base_reg = stack_pointer_rtx ; base_offset = m -> fs . sp_offset - cfa_offset ; } } else { HOST_WIDE_INT toffset ; int len = <NUM_LIT> , tlen ; if ( m -> fs . sp_valid ) { base_reg = stack_pointer_rtx ; base_offset = m -> fs . sp_offset - cfa_offset ; len = choose_baseaddr_len ( STACK_POINTER_REGNUM , base_offset ) ; }


<s> gcc_assert ( Pmode == DImode ) ; tmp = gen_reg_rtx ( Pmode ) ; unspec = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , symbol ) , UNSPEC_PLTOFF ) ; emit_move_insn ( tmp , gen_rtx_CONST ( Pmode , unspec ) ) ; emit_insn ( ix86_gen_add3 ( tmp , tmp , pic_offset_table_rtx ) ) ;


<s> ix86_first_cycle_multipass_data_t data = ix86_first_cycle_multipass_data ; gcc_assert ( data -> ifetch_block_n_insns <= core2i7_ifetch_block_max_insns ) ; data -> ifetch_block_len = <NUM_LIT> ;

data -> ifetch_block_n_insns = <NUM_LIT> ;


<s> const_ix86_first_cycle_multipass_data_t data = ( const_ix86_first_cycle_multipass_data_t ) _data ; unsigned int i = <NUM_LIT> ; sbitmap_iterator sbi ;

gcc_assert ( bitmap_last_set_bit ( data -> ready_try_change ) < n_ready ) ;


<s> static void core2i7_first_cycle_multipass_end ( const void * _data ) { const_ix86_first_cycle_multipass_data_t data = ( const_ix86_first_cycle_multipass_data_t ) _data ; ix86_first_cycle_multipass_data_t next_data = ix86_first_cycle_multipass_data ; if ( data != NULL ) { next_data -> ifetch_block_len = data -> ifetch_block_len ; next_data -> ifetch_block_n_insns = data -> ifetch_block_n_insns ; }


<s> while ( n_ready -- ) { rtx_insn * insn ; int insn_size ; if ( ready_try [ n_ready ] ) continue ; insn = get_ready_element ( n_ready ) ; insn_size = min_insn_size ( insn ) ;

if ( ( ! first_cycle_insn_p && insn_size > core2i7_secondary_decoder_max_insn_size ) || data -> ifetch_block_len + insn_size > core2i7_ifetch_block_size || data -> ifetch_block_n_insns + <NUM_LIT> > core2i7_ifetch_block_max_insns ) {


<s> while ( n_ready -- ) { rtx_insn * insn ; int insn_size ; if ( ready_try [ n_ready ] ) continue ; insn = get_ready_element ( n_ready ) ;


<s> static void core2i7_first_cycle_multipass_fini ( void * _data ) { ix86_first_cycle_multipass_data_t data = ( ix86_first_cycle_multipass_data_t ) _data ; if ( data -> ready_try_change ) { sbitmap_free ( data -> ready_try_change ) ;


<s> data -> ready_try_change = NULL ; data -> ready_try_change_size = <NUM_LIT> ; }


<s> data -> ifetch_block_n_insns = <NUM_LIT> ; data -> ready_try_change = NULL ;

data -> ready_try_change_size = <NUM_LIT> ;


<s> ix86_first_cycle_multipass_data_t data = ( ix86_first_cycle_multipass_data_t ) _data ;


<s> data -> ifetch_block_n_insns = prev_data -> ifetch_block_n_insns + <NUM_LIT> ; gcc_assert ( data -> ifetch_block_len <= core2i7_ifetch_block_size && data -> ifetch_block_n_insns <= core2i7_ifetch_block_max_insns ) ; if ( ! data -> ready_try_change ) { data -> ready_try_change = sbitmap_alloc ( n_ready ) ; data -> ready_try_change_size = n_ready ; } else if ( data -> ready_try_change_size < n_ready ) { data -> ready_try_change = sbitmap_resize ( data -> ready_try_change , n_ready , <NUM_LIT> ) ; data -> ready_try_change_size = n_ready ; }

bitmap_clear ( data -> ready_try_change ) ;


<s> } else if ( data -> ready_try_change_size < n_ready ) { data -> ready_try_change = sbitmap_resize ( data -> ready_try_change , n_ready , <NUM_LIT> ) ; data -> ready_try_change_size = n_ready ; } bitmap_clear ( data -> ready_try_change ) ;


if ( ( group == disp_load_store && ( window_list -> num_loads >= MAX_LOAD || window_list -> num_stores >= MAX_STORE ) ) || ( ( group == disp_load || group == disp_prefetch ) && window_list -> num_loads >= MAX_LOAD ) || ( group == disp_store && window_list -> num_stores >= MAX_STORE ) ) return BIG ;


<s> debug_dispatch_window_file ( stdout , window_num ) ;


<s> dispatch_windows * list ; int i ; if ( window_num == <NUM_LIT> ) list = dispatch_window_list ; else list = dispatch_window_list1 ; fprintf ( file , <STR_LIT> , list -> window_num ) ; fprintf ( file , <STR_LIT> , list -> num_insn , list -> num_uops , list -> window_size ) ; fprintf ( file , <STR_LIT> , list -> num_imm , list -> num_imm_32 , list -> num_imm_64 , list -> imm_size ) ; fprintf ( file , <STR_LIT> , list -> num_loads , list -> num_stores ) ; fprintf ( file , <STR_LIT> ) ; for ( i = <NUM_LIT> ; i < MAX_INSN ; i ++ ) {

if ( ! list -> window [ i ] . insn ) break ;


<s> int num_imm32_operand ; int num_imm64_operand ; if ( INSN_CODE ( insn ) < <NUM_LIT> ) return ; byte_len = min_insn_size ( insn ) ; path = get_insn_path ( insn ) ; group = get_insn_group ( insn ) ; imm_size = get_num_immediates ( insn , & num_imm_operand , & num_imm32_operand , & num_imm64_operand ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> , group_name [ group ] , path , byte_len ) ; fprintf ( file , <STR_LIT> , num_imm_operand , num_imm32_operand , num_imm64_operand , imm_size ) ;


<s> int byte_len ; enum insn_path path ; enum dispatch_group group ; int imm_size ; int num_imm_operand ; int num_imm32_operand ; int num_imm64_operand ; if ( INSN_CODE ( insn ) < <NUM_LIT> ) return ; byte_len = min_insn_size ( insn ) ; path = get_insn_path ( insn ) ;


<s> int no_ready = number_in_ready ( ) ;

fprintf ( stdout , <STR_LIT> , no_ready ) ;


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


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


<s> static int dispatch_function_versions ( tree dispatch_decl , void * fndecls_p , basic_block * empty_bb ) { tree default_decl ; 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 ) {


<s> if ( dispatch_window_list -> next ) return dispatch_window_list -> next -> violation ;

return dispatch_window_list -> violation ;


<s> static void do_dispatch ( rtx_insn * insn , int mode ) {

if ( mode == DISPATCH_INIT ) init_dispatch_sched ( ) ;


<s> dep_t dep ; int index = - <NUM_LIT> ; int i ; if ( ! TARGET_BONNELL ) return index ; insn = ready [ n_ready - <NUM_LIT> ] ; set = single_set ( insn ) ; if ( ! set ) return index ; if ( ! ( GET_CODE ( SET_SRC ( set ) ) == MULT && GET_MODE ( SET_SRC ( set ) ) == SImode ) ) return index ; for ( i = n_ready - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { insn = ready [ i ] ; if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; insn2 = PATTERN ( insn ) ; if ( GET_CODE ( insn2 ) == PARALLEL ) insn2 = XVECEXP ( insn2 , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( insn2 ) == SET && GET_CODE ( SET_SRC ( insn2 ) ) == MULT && GET_MODE ( SET_SRC ( insn2 ) ) == SImode ) continue ; FOR_EACH_DEP ( insn , SD_LIST_FORW , sd_it , dep ) { rtx con ; con = DEP_CON ( dep ) ; if ( ! NONDEBUG_INSN_P ( con ) ) continue ; insn1 = PATTERN ( con ) ; if ( GET_CODE ( insn1 ) == PARALLEL ) insn1 = XVECEXP ( insn1 , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( insn1 ) == SET && GET_CODE ( SET_SRC ( insn1 ) ) == MULT && GET_MODE ( SET_SRC ( insn1 ) ) == SImode ) { sd_iterator_def sd_it1 ; dep_t dep1 ; index = i ; FOR_EACH_DEP ( con , SD_LIST_BACK , sd_it1 , dep1 ) { rtx pro ; pro = DEP_PRO ( dep1 ) ; if ( ! NONDEBUG_INSN_P ( pro ) ) continue ; if ( pro != insn ) index = - <NUM_LIT> ; } if ( index >= <NUM_LIT> ) break ;


<s> 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 ( ) ; } } else { switch ( mode ) { case I387_CW_TRUNC : emit_insn ( gen_movsi_insv_1 ( reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_TRUNC ;


<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 ( ) ; } } else { switch ( mode ) { case I387_CW_TRUNC : emit_insn ( gen_movsi_insv_1 ( reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_TRUNC ; break ;


<s> adjust = GEN_INT ( piece_size ) ; for ( i = <NUM_LIT> ; i < size_to_move ; i += piece_size ) { tempreg = gen_reg_rtx ( move_mode ) ; emit_insn ( GEN_FCN ( code ) ( tempreg , src ) ) ; emit_insn ( GEN_FCN ( code ) ( dst , tempreg ) ) ; emit_move_insn ( destptr , gen_rtx_PLUS ( Pmode , copy_rtx ( destptr ) , adjust ) ) ; emit_move_insn ( srcptr , gen_rtx_PLUS ( Pmode , copy_rtx ( srcptr ) , adjust ) ) ; dst = adjust_automodify_address_nv ( dst , move_mode , destptr , piece_size ) ; src = adjust_automodify_address_nv ( src , move_mode , srcptr , piece_size ) ; }


<s> switch ( GET_MODE ( src ) ) { case V4SFmode : if ( i == <NUM_LIT> ) tem = gen_sse_movhlps ( dest , src , src ) ; else tem = gen_sse_shufps_v4sf ( dest , src , src , const1_rtx , const1_rtx , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ; break ; case V2DFmode : tem = gen_vec_interleave_highv2df ( dest , src , src ) ; break ; case V16QImode : case V8HImode : case V4SImode : case V2DImode : d = gen_reg_rtx ( V1TImode ) ; tem = gen_sse2_lshrv1ti3 ( d , gen_lowpart ( V1TImode , src ) , GEN_INT ( i / <NUM_LIT> ) ) ; break ; case V8SFmode : if ( i == <NUM_LIT> ) tem = gen_avx_vperm2f128v8sf3 ( dest , src , src , const1_rtx ) ; else tem = gen_avx_shufps256 ( dest , src , src , GEN_INT ( i == <NUM_LIT> ? <NUM_LIT> + ( <NUM_LIT> << <NUM_LIT> ) : <NUM_LIT> ) ) ; break ; case V4DFmode : if ( i == <NUM_LIT> ) tem = gen_avx_vperm2f128v4df3 ( dest , src , src , const1_rtx ) ; else tem = gen_avx_shufpd256 ( dest , src , src , const1_rtx ) ; break ; case V32QImode : case V16HImode : case V8SImode : case V4DImode : if ( i == <NUM_LIT> ) { if ( GET_MODE ( dest ) != V4DImode ) d = gen_reg_rtx ( V4DImode ) ;

tem = gen_avx2_permv2ti ( d , gen_lowpart ( V4DImode , src ) , gen_lowpart ( V4DImode , src ) , const1_rtx ) ;


<s> break ; case REG : CASE_CONST_ANY : case SYMBOL_REF : case CODE_LABEL : case PC : case CC0 : case EXPR_LIST : return false ; default : break ; } format_ptr = GET_RTX_FORMAT ( code ) ; for ( i = <NUM_LIT> ; i < GET_RTX_LENGTH ( code ) ; i ++ ) { switch ( * format_ptr ++ ) { case 'e' : if ( exact_dependency_1 ( addr , XEXP ( insn , i ) ) ) return true ; break ;


<s> } format_ptr = GET_RTX_FORMAT ( code ) ; for ( i = <NUM_LIT> ; i < GET_RTX_LENGTH ( code ) ; i ++ ) { switch ( * format_ptr ++ ) { case 'e' : if ( exact_dependency_1 ( addr , XEXP ( insn , i ) ) ) return true ; break ; case 'E' : for ( j = <NUM_LIT> ; j < XVECLEN ( insn , i ) ; j ++ ) if ( exact_dependency_1 ( addr , XVECEXP ( insn , i , j ) ) ) return true ; break ; } }


<s> set2 = single_set ( load ) ; if ( ! set2 ) return false ;

if ( exact_dependency_1 ( SET_DEST ( set1 ) , SET_SRC ( set2 ) ) ) return true ;


<s> emit_insn ( gen_strmov ( destptr , dest , srcptr , src ) ) ; emit_label ( label ) ; LABEL_NUSES ( label ) = <NUM_LIT> ; } } else { rtx offset = force_reg ( Pmode , const0_rtx ) ; rtx tmp ; if ( max_size > <NUM_LIT> ) { rtx_code_label * label = ix86_expand_aligntest ( count , <NUM_LIT> , true ) ; src = change_address ( srcmem , SImode , srcptr ) ; dest = change_address ( destmem , SImode , destptr ) ; emit_move_insn ( dest , src ) ; tmp = expand_simple_binop ( Pmode , PLUS , offset , GEN_INT ( <NUM_LIT> ) , NULL , true , OPTAB_LIB_WIDEN ) ; if ( tmp != offset ) emit_move_insn ( offset , tmp ) ; emit_label ( label ) ; LABEL_NUSES ( label ) = <NUM_LIT> ; } if ( max_size > <NUM_LIT> ) { rtx_code_label * label = ix86_expand_aligntest ( count , <NUM_LIT> , true ) ; tmp = gen_rtx_PLUS ( Pmode , srcptr , offset ) ; src = change_address ( srcmem , HImode , tmp ) ; tmp = gen_rtx_PLUS ( Pmode , destptr , offset ) ; dest = change_address ( destmem , HImode , tmp ) ; emit_move_insn ( dest , src ) ; tmp = expand_simple_binop ( Pmode , PLUS , offset , GEN_INT ( <NUM_LIT> ) , tmp , true , OPTAB_LIB_WIDEN ) ; if ( tmp != offset ) emit_move_insn ( offset , tmp ) ; emit_label ( label ) ; LABEL_NUSES ( label ) = <NUM_LIT> ; } if ( max_size > <NUM_LIT> ) { rtx_code_label * label = ix86_expand_aligntest ( count , <NUM_LIT> , true ) ; tmp = gen_rtx_PLUS ( Pmode , srcptr , offset ) ; src = change_address ( srcmem , QImode , tmp ) ; tmp = gen_rtx_PLUS ( Pmode , destptr , offset ) ; dest = change_address ( destmem , QImode , tmp ) ; emit_move_insn ( dest , src ) ;


<s> count = expand_simple_binop ( counter_mode ( count ) , AND , count , GEN_INT ( max_size - <NUM_LIT> ) , count , <NUM_LIT> , OPTAB_DIRECT ) ; expand_set_or_movmem_via_loop ( destmem , NULL , destptr , NULL , gen_lowpart ( QImode , value ) , count , QImode , <NUM_LIT> , max_size / <NUM_LIT> , true ) ;


<s> if ( MEM_SIZE_KNOWN_P ( orig_dst ) ) set_mem_size ( dst , MEM_SIZE ( orig_dst ) - align_bytes ) ; if ( ! issetmem ) { int src_align_bytes = get_mem_align_offset ( src , desired_align * BITS_PER_UNIT ) ; if ( src_align_bytes >= <NUM_LIT> ) src_align_bytes = desired_align - src_align_bytes ; if ( src_align_bytes >= <NUM_LIT> ) { unsigned int src_align ; for ( src_align = desired_align ; src_align >= <NUM_LIT> ; src_align >>= <NUM_LIT> ) { if ( ( src_align_bytes & ( src_align - <NUM_LIT> ) ) == ( align_bytes & ( src_align - <NUM_LIT> ) ) ) break ; } if ( src_align > ( unsigned int ) desired_align ) src_align = desired_align ; if ( MEM_ALIGN ( src ) < src_align * BITS_PER_UNIT ) set_mem_align ( src , src_align * BITS_PER_UNIT ) ; }

if ( MEM_SIZE_KNOWN_P ( orig_src ) ) set_mem_size ( src , MEM_SIZE ( orig_src ) - align_bytes ) ;


<s> if ( vec_value && i > GET_MODE_SIZE ( GET_MODE ( value ) ) ) destmem = emit_memset ( destmem , destptr , vec_value , i ) ; else destmem = emit_memset ( destmem , destptr , value , i ) ; } else destmem = emit_memmov ( destmem , & srcmem , destptr , srcptr , i ) ;


<s> rtx size ; int i ; top_label = gen_label_rtx ( ) ; out_label = gen_label_rtx ( ) ; iter = gen_reg_rtx ( iter_mode ) ; size = expand_simple_binop ( iter_mode , AND , count , piece_size_mask , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; if ( piece_size == const1_rtx ) { emit_cmp_and_jump_insns ( size , const0_rtx , EQ , NULL_RTX , iter_mode , true , out_label ) ; predict_jump ( REG_BR_PROB_BASE * <NUM_LIT> / <NUM_LIT> ) ; } emit_move_insn ( iter , const0_rtx ) ; emit_label ( top_label ) ; tmp = convert_modes ( Pmode , iter_mode , iter , true ) ; gcc_assert ( ( piece_size_n & ( piece_size_n - <NUM_LIT> ) ) == <NUM_LIT> ) ; destmem = offset_address ( destmem , tmp , piece_size_n ) ; destmem = adjust_address ( destmem , mode , <NUM_LIT> ) ; if ( ! issetmem ) { srcmem = offset_address ( srcmem , copy_rtx ( tmp ) , piece_size_n ) ; srcmem = adjust_address ( srcmem , mode , <NUM_LIT> ) ; if ( ! TARGET_64BIT && <NUM_LIT> ) { for ( i = <NUM_LIT> ; i < unroll ; i ++ ) { if ( i ) { destmem = adjust_address ( copy_rtx ( destmem ) , mode , GET_MODE_SIZE ( mode ) ) ; srcmem = adjust_address ( copy_rtx ( srcmem ) , mode , GET_MODE_SIZE ( mode ) ) ; } emit_move_insn ( destmem , srcmem ) ; } } else { rtx tmpreg [ <NUM_LIT> ] ; gcc_assert ( unroll <= <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < unroll ; i ++ ) { tmpreg [ i ] = gen_reg_rtx ( mode ) ; if ( i ) { srcmem = adjust_address ( copy_rtx ( srcmem ) , mode , GET_MODE_SIZE ( mode ) ) ; } emit_move_insn ( tmpreg [ i ] , srcmem ) ; } for ( i = <NUM_LIT> ; i < unroll ; i ++ ) { if ( i ) { destmem = adjust_address ( copy_rtx ( destmem ) , mode , GET_MODE_SIZE ( mode ) ) ; } emit_move_insn ( destmem , tmpreg [ i ] ) ; } }


<s> 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 = ( INTVAL ( count ) & ~ ( ( HOST_WIDE_INT ) GET_MODE_SIZE ( mode ) - <NUM_LIT> ) ) ; 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 = ( INTVAL ( count ) & ~ ( ( HOST_WIDE_INT ) GET_MODE_SIZE ( mode ) - <NUM_LIT> ) ) ; srcmem = shallow_copy_rtx ( srcmem ) ; set_mem_size ( srcmem , rounded_count ) ; } else {

if ( MEM_SIZE_KNOWN_P ( srcmem ) ) clear_mem_size ( srcmem ) ;


<s> case V16HImode : gen = gen_avx2_pbroadcastv16hi_1 ; break ; case V16SImode : if ( TARGET_AVX512F ) gen = gen_avx512f_vec_dupv16si_1 ; break ; case V8SImode : gen = gen_avx2_pbroadcastv8si_1 ; break ; case V16QImode : gen = gen_avx2_pbroadcastv16qi ; break ; case V8HImode : gen = gen_avx2_pbroadcastv8hi ; break ; case V16SFmode : if ( TARGET_AVX512F ) gen = gen_avx512f_vec_dupv16sf_1 ; break ; case V8SFmode : gen = gen_avx2_vec_dupv8sf_1 ; break ; case V8DFmode : if ( TARGET_AVX512F ) gen = gen_avx512f_vec_dupv8df_1 ; break ; 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 , perm2 , nelt , d -> testing_p ) ) return true ; for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { perm2 [ i ] = d -> perm [ i ] & mask ; perm2 [ i + <NUM_LIT> ] = ( d -> perm [ i + <NUM_LIT> ] & mask ) + nelt ; } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , perm2 , nelt , d -> testing_p ) ) return true ; if ( nelt >= <NUM_LIT> ) { for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { perm2 [ i + <NUM_LIT> ] = d -> perm [ i + <NUM_LIT> ] & mask ; perm2 [ i + <NUM_LIT> ] = d -> perm [ i + <NUM_LIT> ] & mask ; perm2 [ i + <NUM_LIT> ] = ( d -> perm [ i + <NUM_LIT> ] & mask ) + nelt ; perm2 [ i + <NUM_LIT> ] = ( d -> perm [ i + <NUM_LIT> ] & mask ) + nelt ; } if ( expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , perm2 , 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 ) {


<s> use_pblendvb : for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rperm [ i ] = ( d -> perm [ i ] < nelt ? const0_rtx : constm1_rtx ) ; finish_pblendvb : vperm = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( nelt , rperm ) ) ; vperm = force_reg ( vmode , vperm ) ; if ( GET_MODE_SIZE ( vmode ) == <NUM_LIT> ) emit_insn ( gen_sse4_1_pblendvb ( target , op0 , op1 , vperm ) ) ; else emit_insn ( gen_avx2_pblendvb ( target , op0 , op1 , vperm ) ) ; if ( target != d -> target ) emit_move_insn ( d -> target , gen_lowpart ( d -> vmode , target ) ) ; return true ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) mask |= ( d -> perm [ i * <NUM_LIT> ] >= <NUM_LIT> ) << i ; vmode = V8HImode ; do_subreg : target = gen_reg_rtx ( vmode ) ; op0 = gen_lowpart ( vmode , op0 ) ; op1 = gen_lowpart ( vmode , op1 ) ; break ; case V32QImode : for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i += <NUM_LIT> ) if ( d -> perm [ i ] + <NUM_LIT> != d -> perm [ i + <NUM_LIT> ] ) goto use_pblendvb ; 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 += <NUM_LIT> ) if ( d -> perm [ i ] + <NUM_LIT> != d -> perm [ i + <NUM_LIT> ] ) goto use_pblendvb ; 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 ) ;


<s> op0 = gen_lowpart ( vmode , dest ) ; } while ( vmode != V4SImode ) ; memset ( perm2 , elt , <NUM_LIT> ) ; dest = gen_reg_rtx ( V4SImode ) ; ok = expand_vselect ( dest , op0 , perm2 , <NUM_LIT> , d -> testing_p ) ; gcc_assert ( ok ) ; if ( ! d -> testing_p ) emit_move_insn ( d -> target , gen_lowpart ( d -> vmode , dest ) ) ; return true ; case V64QImode : case V32QImode : case V16HImode : case V8SImode : case V4DImode : gcc_assert ( ! TARGET_AVX2 || d -> perm [ <NUM_LIT> ] ) ; return false ; default : gcc_unreachable ( ) ;


<s> break ; case V16QImode : return expand_vec_perm_even_odd_pack ( d ) ; case V16HImode : case V32QImode : return expand_vec_perm_even_odd_pack ( d ) ; case V4DImode : if ( ! TARGET_AVX2 ) { struct expand_vec_perm_d d_copy = * d ; d_copy . vmode = V4DFmode ; if ( d -> testing_p ) d_copy . target = gen_lowpart ( V4DFmode , d -> target ) ; else d_copy . target = gen_reg_rtx ( V4DFmode ) ; d_copy . op0 = gen_lowpart ( V4DFmode , d -> op0 ) ; d_copy . op1 = gen_lowpart ( V4DFmode , d -> op1 ) ; if ( expand_vec_perm_even_odd_1 ( & d_copy , odd ) ) { if ( ! d -> testing_p ) emit_move_insn ( d -> target , gen_lowpart ( V4DImode , d_copy . target ) ) ; return true ; } return false ; } if ( d -> testing_p ) break ; t1 = gen_reg_rtx ( V4DImode ) ; t2 = gen_reg_rtx ( V4DImode ) ; emit_insn ( gen_avx2_permv2ti ( t1 , d -> op0 , d -> op1 , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_avx2_permv2ti ( t2 , d -> op0 , d -> op1 , GEN_INT ( <NUM_LIT> ) ) ) ; if ( odd ) t3 = gen_avx2_interleave_highv4di ( d -> target , t1 , t2 ) ; else t3 = gen_avx2_interleave_lowv4di ( d -> target , t1 , t2 ) ; emit_insn ( t3 ) ; break ; case V8SImode : if ( ! TARGET_AVX2 ) { struct expand_vec_perm_d d_copy = * d ; d_copy . vmode = V8SFmode ; if ( d -> testing_p ) d_copy . target = gen_lowpart ( V8SFmode , d -> target ) ; else d_copy . target = gen_reg_rtx ( V8SFmode ) ; d_copy . op0 = gen_lowpart ( V8SFmode , d -> op0 ) ; d_copy . op1 = gen_lowpart ( V8SFmode , d -> op1 ) ; if ( expand_vec_perm_even_odd_1 ( & d_copy , odd ) ) { if ( ! d -> testing_p ) emit_move_insn ( d -> target , gen_lowpart ( V8SImode , d_copy . target ) ) ; return true ; } return false ; } if ( d -> testing_p ) break ; t1 = gen_reg_rtx ( V8SImode ) ; t2 = gen_reg_rtx ( V8SImode ) ; t3 = gen_reg_rtx ( V4DImode ) ; t4 = gen_reg_rtx ( V4DImode ) ; t5 = gen_reg_rtx ( V4DImode ) ; emit_insn ( gen_avx2_permv2ti ( t3 , gen_lowpart ( V4DImode , d -> op0 ) , gen_lowpart ( V4DImode , d -> op1 ) , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_avx2_permv2ti ( t4 , gen_lowpart ( V4DImode , d -> op0 ) , gen_lowpart ( V4DImode , d -> op1 ) , GEN_INT ( <NUM_LIT> ) ) ) ;


<s> c = <NUM_LIT> ; s = <NUM_LIT> ; half_mode = V4SImode ; gen_and = gen_andv4si3 ; gen_pack = gen_sse4_1_packusdw ; gen_shift = gen_lshrv4si3 ; break ; case V16QImode : c = <NUM_LIT> ; s = <NUM_LIT> ; half_mode = V8HImode ; gen_and = gen_andv8hi3 ; gen_pack = gen_sse2_packuswb ; gen_shift = gen_lshrv8hi3 ; break ; case V16HImode : if ( ! TARGET_AVX2 ) return false ; c = <NUM_LIT> ; s = <NUM_LIT> ; half_mode = V8SImode ; gen_and = gen_andv8si3 ; gen_pack = gen_avx2_packusdw ; gen_shift = gen_lshrv8si3 ; end_perm = true ; break ; case V32QImode : if ( ! TARGET_AVX2 ) return false ; c = <NUM_LIT> ; s = <NUM_LIT> ; half_mode = V16HImode ; gen_and = gen_andv16hi3 ; gen_pack = gen_avx2_packuswb ; gen_shift = gen_lshrv16hi3 ; end_perm = true ; break ; default : return false ; } odd = d -> perm [ <NUM_LIT> ] ; if ( odd > <NUM_LIT> ) return false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != <NUM_LIT> * i + odd ) return false ; if ( d -> testing_p ) return true ; dop0 = gen_reg_rtx ( half_mode ) ; dop1 = gen_reg_rtx ( half_mode ) ; if ( odd == <NUM_LIT> ) { for ( i = <NUM_LIT> ; i < nelt / <NUM_LIT> ; i ++ ) rperm [ i ] = GEN_INT ( c ) ; t = gen_rtx_CONST_VECTOR ( half_mode , gen_rtvec_v ( nelt / <NUM_LIT> , rperm ) ) ; t = force_reg ( half_mode , t ) ; emit_insn ( gen_and ( dop0 , t , gen_lowpart ( half_mode , d -> op0 ) ) ) ; emit_insn ( gen_and ( dop1 , t , gen_lowpart ( half_mode , d -> op1 ) ) ) ; } else {

emit_insn ( gen_shift ( dop0 , gen_lowpart ( half_mode , d -> op0 ) , GEN_INT ( s ) ) ) ;


<s> if ( TARGET_AVX2 && GET_MODE_SIZE ( d -> vmode ) == <NUM_LIT> ) ; else if ( TARGET_AVX && ( d -> vmode == V8SFmode || d -> vmode == V4DFmode ) ) ; else return false ; nelt = d -> nelt ; if ( d -> perm [ <NUM_LIT> ] != <NUM_LIT> && d -> perm [ <NUM_LIT> ] != nelt / <NUM_LIT> ) return false ; for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) if ( d -> perm [ i ] != d -> perm [ <NUM_LIT> ] + i / <NUM_LIT> || d -> perm [ i + <NUM_LIT> ] != d -> perm [ <NUM_LIT> ] + i / <NUM_LIT> + nelt ) return false ; if ( d -> testing_p ) return true ; switch ( d -> vmode ) {


<s> unsigned j , e = d -> perm [ i ] ; unsigned which = ( e >= nelt ) ; if ( e >= nelt ) e -= nelt ; for ( j = <NUM_LIT> ; j < eltsz ; ++ j ) { rperm [ which ] [ i * eltsz + j ] = GEN_INT ( e * eltsz + j ) ; rperm [ <NUM_LIT> - which ] [ i * eltsz + j ] = m128 ; } } vperm = gen_rtx_CONST_VECTOR ( V16QImode , gen_rtvec_v ( <NUM_LIT> , rperm [ <NUM_LIT> ] ) ) ; vperm = force_reg ( V16QImode , vperm ) ; l = gen_reg_rtx ( V16QImode ) ; op = gen_lowpart ( V16QImode , d -> op0 ) ;

emit_insn ( gen_ssse3_pshufbv16qi3 ( l , op , vperm ) ) ;


<s> } vperm = gen_rtx_CONST_VECTOR ( V16QImode , gen_rtvec_v ( <NUM_LIT> , rperm [ <NUM_LIT> ] ) ) ; vperm = force_reg ( V16QImode , vperm ) ; l = gen_reg_rtx ( V16QImode ) ; op = gen_lowpart ( V16QImode , d -> op0 ) ; emit_insn ( gen_ssse3_pshufbv16qi3 ( l , op , vperm ) ) ; vperm = gen_rtx_CONST_VECTOR ( V16QImode , gen_rtvec_v ( <NUM_LIT> , rperm [ <NUM_LIT> ] ) ) ; vperm = force_reg ( V16QImode , vperm ) ; h = gen_reg_rtx ( V16QImode ) ; op = gen_lowpart ( V16QImode , d -> op1 ) ; emit_insn ( gen_ssse3_pshufbv16qi3 ( h , op , vperm ) ) ; op = d -> target ; if ( d -> vmode != V16QImode ) op = gen_reg_rtx ( V16QImode ) ; emit_insn ( gen_iorv16qi3 ( op , l , h ) ) ;

if ( op != d -> target ) emit_move_insn ( d -> target , gen_lowpart ( d -> vmode , op ) ) ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { ds [ i ] = * d ; ds [ i ] . vmode = V32HImode ; ds [ i ] . nelt = <NUM_LIT> ; ds [ i ] . target = gen_reg_rtx ( V32HImode ) ; ds [ i ] . op0 = gen_lowpart ( V32HImode , d -> op0 ) ; ds [ i ] . op1 = gen_lowpart ( V32HImode , d -> op1 ) ; } for ( i = <NUM_LIT> ; i < nelt ; i ++ ) { ds [ i & <NUM_LIT> ] . perm [ i / <NUM_LIT> ] = d -> perm [ i ] / <NUM_LIT> ; if ( i & <NUM_LIT> ) { rperm [ i ] = constm1_rtx ; rperm [ i + <NUM_LIT> ] = GEN_INT ( ( i & <NUM_LIT> ) + ( d -> perm [ i ] & <NUM_LIT> ) ) ; } else { rperm [ i ] = GEN_INT ( ( i & <NUM_LIT> ) + ( d -> perm [ i ] & <NUM_LIT> ) ) ;


<s> ds [ i ] . vmode = V32HImode ; ds [ i ] . nelt = <NUM_LIT> ; ds [ i ] . target = gen_reg_rtx ( V32HImode ) ; ds [ i ] . op0 = gen_lowpart ( V32HImode , d -> op0 ) ; ds [ i ] . op1 = gen_lowpart ( V32HImode , d -> op1 ) ; } for ( i = <NUM_LIT> ; i < nelt ; i ++ ) { ds [ i & <NUM_LIT> ] . perm [ i / <NUM_LIT> ] = d -> perm [ i ] / <NUM_LIT> ; if ( i & <NUM_LIT> ) { rperm [ i ] = constm1_rtx ; rperm [ i + <NUM_LIT> ] = GEN_INT ( ( i & <NUM_LIT> ) + ( d -> perm [ i ] & <NUM_LIT> ) ) ; } else { rperm [ i ] = GEN_INT ( ( i & <NUM_LIT> ) + ( d -> perm [ i ] & <NUM_LIT> ) ) ; rperm [ i + <NUM_LIT> ] = constm1_rtx ; } } bool ok = expand_vec_perm_1 ( & ds [ <NUM_LIT> ] ) ; gcc_assert ( ok ) ; ds [ <NUM_LIT> ] . target = gen_lowpart ( V64QImode , ds [ <NUM_LIT> ] . target ) ; ok = expand_vec_perm_1 ( & ds [ <NUM_LIT> ] ) ; gcc_assert ( ok ) ;


<s> for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned j , e = d -> perm [ i ] & ( nelt / <NUM_LIT> - <NUM_LIT> ) ; unsigned which = ( ( d -> perm [ i ] ^ i ) & ( nelt / <NUM_LIT> ) ) * eltsz ; for ( j = <NUM_LIT> ; j < eltsz ; ++ j ) { rperm [ ! ! which ] [ ( i * eltsz + j ) ^ which ] = GEN_INT ( e * eltsz + j ) ; rperm [ ! which ] [ ( i * eltsz + j ) ^ ( which ^ <NUM_LIT> ) ] = m128 ; } } vperm = gen_rtx_CONST_VECTOR ( V32QImode , gen_rtvec_v ( <NUM_LIT> , rperm [ <NUM_LIT> ] ) ) ; vperm = force_reg ( V32QImode , vperm ) ; h = gen_reg_rtx ( V32QImode ) ; op = gen_lowpart ( V32QImode , d -> op0 ) ; emit_insn ( gen_avx2_pshufbv32qi3 ( h , op , vperm ) ) ; hp = gen_reg_rtx ( V4DImode ) ;


<s> for ( i = <NUM_LIT> ; i < d -> nelt ; ++ i ) if ( ( d -> perm [ i ] ^ ( i * <NUM_LIT> ) ) & ( <NUM_LIT> * d -> nelt / <NUM_LIT> ) ) return false ; if ( d -> testing_p ) return true ; nelt = d -> nelt ; eltsz = GET_MODE_SIZE ( GET_MODE_INNER ( d -> vmode ) ) ; m128 = GEN_INT ( - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned j , e = d -> perm [ i ] & ( nelt / <NUM_LIT> - <NUM_LIT> ) ; unsigned which = d -> perm [ i ] >= nelt ; unsigned xorv = ( i >= nelt / <NUM_LIT> && i < <NUM_LIT> * nelt / <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ; for ( j = <NUM_LIT> ; j < eltsz ; ++ j ) { rperm [ which ] [ ( i * eltsz + j ) ^ xorv ] = GEN_INT ( e * eltsz + j ) ; rperm [ <NUM_LIT> - which ] [ ( i * eltsz + j ) ^ xorv ] = m128 ; } } vperm = gen_rtx_CONST_VECTOR ( V32QImode , gen_rtvec_v ( <NUM_LIT> , rperm [ <NUM_LIT> ] ) ) ; vperm = force_reg ( V32QImode , vperm ) ; l = gen_reg_rtx ( V32QImode ) ;

op = gen_lowpart ( V32QImode , d -> op0 ) ;


<s> emit_insn ( gen_avx2_permv4di_1 ( op , gen_lowpart ( V4DImode , h [ i ] ) , const2_rtx , GEN_INT ( <NUM_LIT> ) , const0_rtx , const1_rtx ) ) ; h [ i ] = gen_lowpart ( V32QImode , op ) ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { if ( ! used [ <NUM_LIT> * i ] ) { l [ i ] = NULL_RTX ; continue ; } vperm = gen_rtx_CONST_VECTOR ( V32QImode , gen_rtvec_v ( <NUM_LIT> , rperm [ <NUM_LIT> * i ] ) ) ; vperm = force_reg ( V32QImode , vperm ) ; l [ i ] = gen_reg_rtx ( V32QImode ) ; op = gen_lowpart ( V32QImode , i ? d -> op1 : d -> op0 ) ; emit_insn ( gen_avx2_pshufbv32qi3 ( l [ i ] , op , vperm ) ) ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { if ( h [ i ] && l [ i ] ) { op = gen_reg_rtx ( V32QImode ) ; emit_insn ( gen_iorv32qi3 ( op , l [ i ] , h [ i ] ) ) ; l [ i ] = op ; } else if ( h [ i ] ) l [ i ] = h [ i ] ; } gcc_assert ( l [ <NUM_LIT> ] && l [ <NUM_LIT> ] ) ; op = d -> target ; if ( d -> vmode != V32QImode ) op = gen_reg_rtx ( V32QImode ) ; emit_insn ( gen_iorv32qi3 ( op , l [ <NUM_LIT> ] , l [ <NUM_LIT> ] ) ) ;


<s> x = XEXP ( SET_SRC ( PATTERN ( vselect_insn ) ) , <NUM_LIT> ) ; PUT_MODE ( x , v2mode ) ; XEXP ( x , <NUM_LIT> ) = op0 ; XEXP ( x , <NUM_LIT> ) = op1 ; ok = expand_vselect ( target , x , perm , nelt , testing_p ) ; XEXP ( x , <NUM_LIT> ) = const0_rtx ; XEXP ( x , <NUM_LIT> ) = const0_rtx ; return ok ;


<s> if ( x86_64_immediate_operand ( CONST_CAST_RTX ( x ) , SImode ) ) ( imm_values -> imm32 ) ++ ; else ( imm_values -> imm64 ) ++ ; break ; case CONST_DOUBLE : ( imm_values -> imm ) ++ ; ( imm_values -> imm64 ) ++ ; break ; case CODE_LABEL : if ( LABEL_KIND ( x ) == LABEL_NORMAL ) {


<s> tree decl = cfun -> decl ; if ( TARGET_64BIT ) { if ( DECL_STATIC_CHAIN ( decl ) || crtl -> tail_call_emit ) return R13_REG ; return R10_REG ; }


<s> if ( sum == <NUM_LIT> || ( min_insn_size ( insn ) + sum ) >= <NUM_LIT> ) return true ; } num_restrict = count_num_restricted ( insn , window_list ) ; if ( num_restrict > num_allowable_groups [ group ] ) return false ; if ( window_list -> window_num == <NUM_LIT> ) {

if ( path == path_double && ( window_list -> num_uops + <NUM_LIT> ) > MAX_INSN ) return false ;


<s> rtx_insn * insn ; FOR_BB_INSNS ( bb , insn ) if ( NONDEBUG_INSN_P ( insn ) && requires_stack_frame_p ( insn , prologue_used , set_up_by_prologue ) ) { crtl -> stack_realign_needed = stack_realign ;

crtl -> stack_realign_finalized = true ;


<s> FOR_EACH_BB_FN ( bb , cfun ) { rtx_insn * insn ; FOR_BB_INSNS ( bb , insn ) if ( NONDEBUG_INSN_P ( insn ) && requires_stack_frame_p ( insn , prologue_used , set_up_by_prologue ) ) { crtl -> stack_realign_needed = stack_realign ;


<s> if ( ! NONDEBUG_INSN_P ( pro ) ) continue ;

if ( INSN_TICK ( pro ) > clock2 ) clock2 = INSN_TICK ( pro ) ;


<s> FOR_EACH_DEP ( next , SD_LIST_RES_BACK , sd_it , dep ) { rtx pro ; pro = DEP_PRO ( dep ) ; if ( ! NONDEBUG_INSN_P ( pro ) ) continue ;


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

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


<s> rtx_insn * insn , * next ; for ( insn = BB_END ( e -> src ) ; insn != NULL ; insn = PREV_INSN ( insn ) ) if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_EPILOGUE_BEG ) break ; if ( insn == NULL ) continue ; insn = prev_active_insn ( insn ) ; if ( insn == NULL || ! can_throw_internal ( insn ) ) continue ; for ( next = NEXT_INSN ( insn ) ; next != NULL ; next = NEXT_INSN ( next ) ) if ( NOTE_P ( next ) && ( NOTE_KIND ( next ) == NOTE_INSN_VAR_LOCATION || NOTE_KIND ( next ) == NOTE_INSN_CALL_ARG_LOCATION ) ) insn = next ; else break ; emit_insn_after ( gen_nops ( const1_rtx ) , insn ) ;


<s> case V4DFmode : case V4DImode : case V16SFmode : case V16SImode : case V64QImode : case V32HImode : case V8DFmode : case V8DImode : if ( ! named ) return NULL ; break ; } return construct_container ( mode , orig_mode , type , <NUM_LIT> , cum -> nregs , cum -> sse_nregs , & x86_64_int_parameter_registers [ cum -> regno ] , cum -> sse_regno ) ;


<s> return int_nregs ; } else { int align = ix86_function_arg_boundary ( mode , type ) / BITS_PER_WORD ; cum -> words = ( cum -> words + align - <NUM_LIT> ) & ~ ( align - <NUM_LIT> ) ; cum -> words += words ;


<s> t1 = gen_rtx_EXPR_LIST ( VOIDmode , t1 , const0_rtx ) ; t2 = gen_rtx_EXPR_LIST ( VOIDmode , t2 , const0_rtx ) ; return gen_rtx_PARALLEL ( mode , gen_rtvec ( <NUM_LIT> , t1 , t2 ) ) ; } } if ( orig_mode == BLKmode ) { if ( bytes > <NUM_LIT> && bytes <= <NUM_LIT> ) mode = ( bytes > <NUM_LIT> ? DImode : SImode ) ; if ( mode == BLKmode ) mode = DImode ; } return gen_reg_or_parallel ( mode , orig_mode , regno ) ;


<s> 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 ) ) { int sse_level = ix86_function_sseregparm ( fntype , fn , false ) ; if ( ( sse_level >= <NUM_LIT> && mode == SFmode ) || ( sse_level == <NUM_LIT> && mode == DFmode ) ) regno = FIRST_SSE_REG ;


<s> 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 ) ) { int sse_level = ix86_function_sseregparm ( fntype , fn , false ) ; if ( ( sse_level >= <NUM_LIT> && mode == SFmode ) || ( sse_level == <NUM_LIT> && mode == DFmode ) ) regno = FIRST_SSE_REG ; } gcc_assert ( mode != OImode ) ;

return gen_rtx_REG ( orig_mode , regno ) ;


<s> unsigned int regno ; switch ( mode ) { case SFmode : case SCmode : case DFmode : case DCmode : case TFmode : case SDmode : case DDmode : case TDmode : regno = FIRST_SSE_REG ; break ; case XFmode : case XCmode : regno = FIRST_FLOAT_REG ; break ; case TCmode : return NULL ; default : regno = AX_REG ; } return gen_rtx_REG ( mode , regno ) ; } else if ( POINTER_TYPE_P ( valtype ) ) { mode = word_mode ; }

ret = construct_container ( mode , orig_mode , valtype , <NUM_LIT> , X86_64_REGPARM_MAX , X86_64_SSE_REGPARM_MAX , x86_64_int_return_registers , <NUM_LIT> ) ;


<s> return gen_rtx_REG ( mode , regno ) ; } else if ( POINTER_TYPE_P ( valtype ) ) { mode = word_mode ; } ret = construct_container ( mode , orig_mode , valtype , <NUM_LIT> , X86_64_REGPARM_MAX , X86_64_SSE_REGPARM_MAX , x86_64_int_return_registers , <NUM_LIT> ) ; if ( ! ret ) ret = gen_rtx_REG ( orig_mode , AX_REG ) ; return ret ;


<s> if ( TARGET_SSE ) { switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : if ( valtype != NULL_TREE && ! VECTOR_INTEGER_TYPE_P ( valtype ) && ! VECTOR_INTEGER_TYPE_P ( valtype ) && ! INTEGRAL_TYPE_P ( valtype ) && ! VECTOR_FLOAT_TYPE_P ( valtype ) ) break ; if ( ( SCALAR_INT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) && ! COMPLEX_MODE_P ( mode ) ) regno = FIRST_SSE_REG ;


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


<s> m -> fs . sp_offset += UNITS_PER_WORD ;

if ( REG_P ( arg ) && GET_MODE ( arg ) != word_mode ) arg = gen_rtx_REG ( word_mode , REGNO ( arg ) ) ;


<s> if ( REG_P ( arg ) && GET_MODE ( arg ) != word_mode ) arg = gen_rtx_REG ( word_mode , REGNO ( arg ) ) ; return gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( word_mode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) , arg ) ;


<s> static int get_element_number ( tree vec_type , tree arg ) { unsigned HOST_WIDE_INT elt , max = TYPE_VECTOR_SUBPARTS ( vec_type ) - <NUM_LIT> ; if ( ! tree_fits_uhwi_p ( arg ) || ( elt = tree_to_uhwi ( arg ) , elt > max ) ) { error ( <STR_LIT> , max ) ; return <NUM_LIT> ; } return elt ;


<s> static enum dispatch_group get_insn_group ( rtx_insn * insn ) { enum dispatch_group group = get_mem_group ( insn ) ; if ( group ) return group ; if ( is_branch ( insn ) ) return disp_branch ;

if ( is_cmp ( insn ) ) return disp_cmp ;


<s> static enum dispatch_group get_insn_group ( rtx_insn * insn ) { enum dispatch_group group = get_mem_group ( insn ) ; if ( group ) return group ; if ( is_branch ( insn ) ) return disp_branch ; if ( is_cmp ( insn ) ) return disp_cmp ; if ( has_immediate ( insn ) ) return disp_imm ; if ( is_prefetch ( insn ) ) return disp_prefetch ;


<s> enum attr_amdfam10_decode path = get_attr_amdfam10_decode ( insn ) ; if ( ( int ) path == <NUM_LIT> ) return path_single ;

if ( ( int ) path == <NUM_LIT> ) return path_double ;


<s> static enum dispatch_group get_mem_group ( rtx_insn * insn ) { enum attr_memory memory ; if ( INSN_CODE ( insn ) < <NUM_LIT> ) return disp_no_group ; memory = get_attr_memory ( insn ) ; if ( memory == MEMORY_STORE ) return disp_store ; if ( memory == MEMORY_LOAD ) return disp_load ; if ( memory == MEMORY_BOTH ) return disp_load_store ; return disp_no_group ;


<s> gcc_assert ( GET_MODE_SIZE ( o ) == GET_MODE_SIZE ( n ) ) ; return n ;


<s> static inline machine_mode get_mode_wider_vector ( machine_mode o ) { machine_mode n = GET_MODE_WIDER_MODE ( o ) ;

gcc_assert ( GET_MODE_NUNITS ( o ) == GET_MODE_NUNITS ( n ) * <NUM_LIT> ) ;


<s> static int get_num_immediates ( rtx insn , int * imm , int * imm32 , int * imm64 ) { imm_info imm_values = { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } ; find_constant ( insn , & imm_values ) ; * imm = imm_values . imm ; * imm32 = imm_values . imm32 ; * imm64 = imm_values . imm64 ;


<s> tree decl = current_function_decl , fntype = TREE_TYPE ( decl ) ; 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 ; else if ( ix86_save_reg ( BX_REG , true ) ) regno = BX_REG ; else if ( ! ( regparm == <NUM_LIT> && static_chain_p ) && ix86_save_reg ( SI_REG , true ) ) regno = SI_REG ; else if ( ix86_save_reg ( DI_REG , true ) ) regno = DI_REG ; else { regno = ( drap_regno == AX_REG ? DX_REG : AX_REG ) ; sr -> saved = true ; } } sr -> reg = gen_rtx_REG ( Pmode , regno ) ; if ( sr -> saved ) {

rtx insn = emit_insn ( gen_push ( sr -> reg ) ) ;


<s> static void handle_cache_entry ( tree_map * & m ) { extern void gt_ggc_mx ( tree_map * & ) ; if ( m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY ) return ;

else if ( ggc_marked_p ( m -> base . from ) ) gt_ggc_mx ( m ) ;


<s> static void handle_cache_entry ( tree_map * & m ) { extern void gt_ggc_mx ( tree_map * & ) ; if ( m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY ) return ; else if ( ggc_marked_p ( m -> base . from ) ) gt_ggc_mx ( m ) ; else m = static_cast < tree_map * > ( HTAB_DELETED_ENTRY ) ;


<s> default : return false ; case IS_DISPATCH_ON : return true ; break ; case IS_CMP : return is_cmp ( insn ) ; case DISPATCH_VIOLATION : return dispatch_violation ( ) ; case FITS_DISPATCH_WINDOW : return fits_dispatch_window ( insn ) ;


if ( insn ) return get_num_immediates ( insn , & num_imm_operand , & num_imm32_operand , & num_imm64_operand ) ;


<s> int num_imm32_operand ; int num_imm64_operand ;


<s> fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_TPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_NTPOFF : output_addr_const ( file , op ) ; if ( TARGET_64BIT ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_DTPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTNTPOFF : output_addr_const ( file , op ) ; if ( TARGET_64BIT ) fputs ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_INDNTPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_MACHOPIC_OFFSET : output_addr_const ( file , op ) ; putc ( '-' , file ) ; machopic_output_function_base_name ( file ) ; break ; case UNSPEC_STACK_CHECK : { int offset ; gcc_assert ( flag_split_stack ) ; offset = TARGET_THREAD_SPLIT_STACK_OFFSET ; gcc_unreachable ( ) ; fprintf ( file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> , offset ) ; } break ; default : return false ; } return true ;


<s> if ( TARGET_64BIT && strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , name , flags & SECTION_WRITE ? <STR_LIT> : <STR_LIT> ) ; return ; } if ( HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE ) { solaris_elf_asm_comdat_section ( name , flags , decl ) ; return ;


<s> 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 : case PROCESSOR_BONNELL : case PROCESSOR_SILVERMONT : case PROCESSOR_KNL : case PROCESSOR_INTEL : if ( reload_completed ) return ix86_issue_rate ( ) ; return <NUM_LIT> ; default : return <NUM_LIT> ;


<s> case PROCESSOR_BDVER3 : case PROCESSOR_BDVER4 : return <NUM_LIT> ; case PROCESSOR_CORE2 : case PROCESSOR_NEHALEM : case PROCESSOR_SANDYBRIDGE : case PROCESSOR_HASWELL : case PROCESSOR_BONNELL : case PROCESSOR_SILVERMONT :


<s> struct cgraph_node * target = NULL ; memset ( cum , <NUM_LIT> , sizeof ( * cum ) ) ; if ( fndecl ) { target = cgraph_node :: get ( fndecl ) ; if ( target ) { target = target -> function_symbol ( ) ; i = cgraph_node :: local_info ( target -> decl ) ; cum -> call_abi = ix86_function_abi ( target -> decl ) ; } else cum -> call_abi = ix86_function_abi ( fndecl ) ; } else cum -> call_abi = ix86_function_type_abi ( fntype ) ; cum -> caller = caller ; cum -> nregs = ix86_regparm ; if ( TARGET_64BIT ) { cum -> nregs = ( cum -> call_abi == SYSV_ABI ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX ) ; } if ( TARGET_SSE ) { cum -> sse_nregs = SSE_REGPARM_MAX ; if ( TARGET_64BIT ) { cum -> sse_nregs = ( cum -> call_abi == SYSV_ABI ? X86_64_SSE_REGPARM_MAX : X86_64_MS_SSE_REGPARM_MAX ) ; } } if ( TARGET_MMX ) cum -> mmx_nregs = MMX_REGPARM_MAX ; cum -> warn_avx512f = true ; cum -> warn_avx = true ; cum -> warn_sse = true ; cum -> warn_mmx = true ; if ( i && i -> local && i -> can_change_signature ) fntype = TREE_TYPE ( target -> decl ) ;


<s> x = gen_rtx_VEC_SELECT ( V2DFmode , gen_rtx_VEC_CONCAT ( V4DFmode , const0_rtx , const0_rtx ) , x ) ;

x = gen_rtx_SET ( VOIDmode , const0_rtx , x ) ;


<s> for ( i = <NUM_LIT> ; i < MAX_VECT_LEN ; ++ i ) XVECEXP ( x , <NUM_LIT> , i ) = const0_rtx ; x = gen_rtx_VEC_SELECT ( V2DFmode , gen_rtx_VEC_CONCAT ( V4DFmode , const0_rtx , const0_rtx ) , x ) ;


<s> 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> ] ; 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> ] ) ; return in ? ix86_cost -> int_load [ <NUM_LIT> ] : ix86_cost -> int_store [ <NUM_LIT> ] ; default : if ( mode == TFmode ) mode = XFmode ;

if ( in == <NUM_LIT> ) cost = MAX ( ix86_cost -> int_load [ <NUM_LIT> ] , ix86_cost -> int_store [ <NUM_LIT> ] ) ;


<s> break ; case XFmode : index = <NUM_LIT> ; break ; default : return <NUM_LIT> ; } if ( in == <NUM_LIT> ) return MAX ( ix86_cost -> fp_load [ index ] , ix86_cost -> fp_store [ index ] ) ; return in ? ix86_cost -> fp_load [ index ] : ix86_cost -> fp_store [ index ] ; } 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 ;


<s> if ( MAYBE_FLOAT_CLASS_P ( class1 ) != FLOAT_CLASS_P ( class1 ) || MAYBE_FLOAT_CLASS_P ( class2 ) != FLOAT_CLASS_P ( class2 ) || MAYBE_SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class1 ) || MAYBE_SSE_CLASS_P ( class2 ) != SSE_CLASS_P ( class2 ) || MAYBE_MMX_CLASS_P ( class1 ) != MMX_CLASS_P ( class1 ) || MAYBE_MMX_CLASS_P ( class2 ) != MMX_CLASS_P ( class2 ) ) { gcc_assert ( ! strict || lra_in_progress ) ; return true ; } if ( FLOAT_CLASS_P ( class1 ) != FLOAT_CLASS_P ( class2 ) ) return true ; if ( ( MAYBE_MASK_CLASS_P ( class1 ) != MAYBE_MASK_CLASS_P ( class2 ) ) && ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) ) return true ; if ( MMX_CLASS_P ( class1 ) != MMX_CLASS_P ( class2 ) ) return true ; if ( SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class2 ) ) { if ( ! TARGET_SSE2 ) return true ;

if ( ( SSE_CLASS_P ( class1 ) && ! TARGET_INTER_UNIT_MOVES_FROM_VEC ) || ( SSE_CLASS_P ( class2 ) && ! TARGET_INTER_UNIT_MOVES_TO_VEC ) ) return true ;


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


<s> return ( CALL_P ( insn ) || JUMP_P ( insn ) ) ;


<s> tree attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; gcc_assert ( attr ) ; attr = TREE_VALUE ( TREE_VALUE ( attr ) ) ;

return ( TREE_CODE ( attr ) == STRING_CST && strcmp ( TREE_STRING_POINTER ( attr ) , <STR_LIT> ) == <NUM_LIT> ) ;


<s> attr = TREE_VALUE ( TREE_VALUE ( attr ) ) ; return ( TREE_CODE ( attr ) == STRING_CST && strcmp ( TREE_STRING_POINTER ( attr ) , <STR_LIT> ) == <NUM_LIT> ) ;


<s> static bool is_prefetch ( rtx insn ) {

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


<s> if ( parts . index && ( ! REG_P ( parts . index ) || REGNO ( parts . index ) >= FIRST_PSEUDO_REGISTER ) && ( current_pass -> type == GIMPLE_PASS || ! pic_offset_table_rtx || ! REG_P ( parts . index ) || REGNO ( pic_offset_table_rtx ) != REGNO ( parts . index ) ) ) cost ++ ;

if ( TARGET_K6 && ( ( ! parts . disp && parts . base && parts . index && parts . scale != <NUM_LIT> ) || ( parts . disp && ! parts . base && parts . index && parts . scale != <NUM_LIT> ) || ( ! parts . disp && parts . base && parts . index && parts . scale == <NUM_LIT> ) ) ) cost += <NUM_LIT> ;


<s> struct ix86_address parts ; int cost = <NUM_LIT> ; int ok = ix86_decompose_address ( x , & parts ) ; gcc_assert ( ok ) ; if ( parts . base && GET_CODE ( parts . base ) == SUBREG ) parts . base = SUBREG_REG ( parts . base ) ; if ( parts . index && GET_CODE ( parts . index ) == SUBREG ) parts . index = SUBREG_REG ( parts . index ) ;

if ( parts . base && ( ! REG_P ( parts . base ) || REGNO ( parts . base ) >= FIRST_PSEUDO_REGISTER ) && ( current_pass -> type == GIMPLE_PASS || ! pic_offset_table_rtx || ! REG_P ( parts . base ) || REGNO ( pic_offset_table_rtx ) != REGNO ( parts . base ) ) ) cost ++ ;


<s> add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else queued_cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , reg , queued_cfa_restores ) ;


<s> current_target_pragma = NULL_TREE ; for ( i = <NUM_LIT> ; i < ( int ) IX86_BUILTIN_MAX ; i ++ ) { if ( ( ix86_builtins_isa [ i ] . isa & isa ) != <NUM_LIT> && ix86_builtins_isa [ i ] . set_and_not_built_p ) { tree decl , type ; ix86_builtins_isa [ i ] . set_and_not_built_p = false ;

type = ix86_get_builtin_func_type ( ix86_builtins_isa [ i ] . tcode ) ;


<s> tree vectype = stmt_info ? stmt_vectype ( stmt_info ) : NULL_TREE ; int stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( stmt_info ) ) count *= <NUM_LIT> ; retval = ( unsigned ) ( count * stmt_cost ) ;

if ( TARGET_SILVERMONT || TARGET_INTEL ) if ( stmt_info && stmt_info -> stmt ) {


<s> tree vectype = stmt_info ? stmt_vectype ( stmt_info ) : NULL_TREE ; int stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( stmt_info ) ) count *= <NUM_LIT> ; retval = ( unsigned ) ( count * stmt_cost ) ; if ( TARGET_SILVERMONT || TARGET_INTEL ) if ( stmt_info && stmt_info -> stmt ) { tree lhs_op = gimple_get_lhs ( stmt_info -> stmt ) ;

if ( lhs_op && TREE_CODE ( TREE_TYPE ( lhs_op ) ) == INTEGER_TYPE ) retval = ( retval * <NUM_LIT> ) / <NUM_LIT> ;


<s> static void ix86_adjust_counter ( rtx countreg , HOST_WIDE_INT value ) { rtx ( * gen_add ) ( rtx , rtx , rtx ) = GET_MODE ( countreg ) == DImode ? gen_adddi3 : gen_addsi3 ; emit_insn ( gen_add ( countreg , countreg , GEN_INT ( - value ) ) ) ;


<s> rtx ( * gen_add ) ( rtx , rtx , rtx ) = GET_MODE ( countreg ) == DImode ? gen_adddi3 : gen_addsi3 ; emit_insn ( gen_add ( countreg , countreg , GEN_INT ( - value ) ) ) ;


<s> emit_stack_probe ( stack_pointer_rtx ) ; last = emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , PROBE_INTERVAL + dope ) ) ) ; } else { HOST_WIDE_INT rounded_size ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; rounded_size = size & - PROBE_INTERVAL ; emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( PROBE_INTERVAL + dope ) ) ) ) ; emit_move_insn ( sr . reg , GEN_INT ( - rounded_size ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , 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 ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , rounded_size - size ) ) ) ; emit_stack_probe ( stack_pointer_rtx ) ; } last = emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , PROBE_INTERVAL + dope ) ) ) ; release_scratch_register_on_entry ( & sr ) ; } gcc_assert ( cfun -> machine -> fs . cfa_reg != stack_pointer_rtx ) ; if ( size > <NUM_LIT> ) { rtx expr = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( expr , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - size ) ) ; XVECEXP ( expr , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , PROBE_INTERVAL + dope + size ) ) ; add_reg_note ( last , REG_FRAME_RELATED_EXPR , expr ) ; RTX_FRAME_RELATED_P ( last ) = <NUM_LIT> ; cfun -> machine -> fs . sp_offset += size ; }


<s> int i ; extract_insn_cached ( use_insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( MEM_P ( recog_data . operand [ i ] ) ) { rtx addr = XEXP ( recog_data . operand [ i ] , <NUM_LIT> ) ; return modified_in_p ( addr , set_insn ) != <NUM_LIT> ; }


<s> bool ix86_agi_dependent ( rtx_insn * set_insn , rtx_insn * use_insn ) { int i ; extract_insn_cached ( use_insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( MEM_P ( recog_data . operand [ i ] ) ) { rtx addr = XEXP ( recog_data . operand [ i ] , <NUM_LIT> ) ; return modified_in_p ( addr , set_insn ) != <NUM_LIT> ; } return false ;


<s> for ( i = <NUM_LIT> ; i < filler_count ; i += <NUM_LIT> ) fprintf ( asm_out_file , ASM_LONG <STR_LIT> , filler_cc ) ; } SUBTARGET_ASM_UNWIND_INIT ( asm_out_file ) ; ASM_OUTPUT_LABEL ( asm_out_file , fname ) ; if ( is_ms_hook ) { if ( TARGET_64BIT ) { asm_fprintf ( asm_out_file , ASM_BYTE <STR_LIT> ) ; } else { asm_fprintf ( asm_out_file , ASM_BYTE <STR_LIT> ) ; }


<s> } if ( TARGET_SSE_MATH ) { tree mxcsr_orig_var = create_tmp_var ( unsigned_type_node ) ; tree mxcsr_mod_var = create_tmp_var ( unsigned_type_node ) ; tree stmxcsr = ix86_builtins [ IX86_BUILTIN_STMXCSR ] ; tree ldmxcsr = ix86_builtins [ IX86_BUILTIN_LDMXCSR ] ; tree stmxcsr_hold_call = build_call_expr ( stmxcsr , <NUM_LIT> ) ; tree hold_assign_orig = build2 ( MODIFY_EXPR , unsigned_type_node , mxcsr_orig_var , stmxcsr_hold_call ) ; tree hold_mod_val = build2 ( BIT_IOR_EXPR , unsigned_type_node , mxcsr_orig_var , build_int_cst ( unsigned_type_node , <NUM_LIT> ) ) ; hold_mod_val = build2 ( BIT_AND_EXPR , unsigned_type_node , hold_mod_val , build_int_cst ( unsigned_type_node , <NUM_LIT> ) ) ; tree hold_assign_mod = build2 ( MODIFY_EXPR , unsigned_type_node , mxcsr_mod_var , hold_mod_val ) ; tree ldmxcsr_hold_call = build_call_expr ( ldmxcsr , <NUM_LIT> , mxcsr_mod_var ) ; tree hold_all = build2 ( COMPOUND_EXPR , unsigned_type_node , hold_assign_orig , hold_assign_mod ) ; hold_all = build2 ( COMPOUND_EXPR , void_type_node , hold_all , ldmxcsr_hold_call ) ; if ( * hold ) * hold = build2 ( COMPOUND_EXPR , void_type_node , * hold , hold_all ) ; else * hold = hold_all ; tree ldmxcsr_clear_call = build_call_expr ( ldmxcsr , <NUM_LIT> , mxcsr_mod_var ) ; if ( * clear ) * clear = build2 ( COMPOUND_EXPR , void_type_node , * clear , ldmxcsr_clear_call ) ; else * clear = ldmxcsr_clear_call ; tree stxmcsr_update_call = build_call_expr ( stmxcsr , <NUM_LIT> ) ; tree exceptions_sse = fold_convert ( integer_type_node , stxmcsr_update_call ) ; if ( * update ) { tree exceptions_mod = build2 ( BIT_IOR_EXPR , integer_type_node , exceptions_var , exceptions_sse ) ;


<s> if ( get_attr_type ( insn ) == TYPE_LEA ) { rtx set = PATTERN ( insn ) , addr ; if ( GET_CODE ( set ) == PARALLEL ) set = XVECEXP ( set , <NUM_LIT> , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; addr = SET_SRC ( set ) ; return memory_address_length ( addr , true ) ; } extract_insn_cached ( insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( MEM_P ( recog_data . operand [ i ] ) ) { constrain_operands_cached ( insn , reload_completed ) ; if ( which_alternative != - <NUM_LIT> ) {

const char * constraints = recog_data . constraints [ i ] ;


<s> int max_skip = label_to_max_skip ( insn ) ; if ( max_skip > <NUM_LIT> ) max_skip = <NUM_LIT> ; if ( align <= <NUM_LIT> || ( align <= <NUM_LIT> && max_skip != ( <NUM_LIT> << align ) - <NUM_LIT> ) ) max_skip = <NUM_LIT> ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) , max_skip ) ; if ( max_skip ) { while ( nbytes + max_skip >= <NUM_LIT> ) { start = NEXT_INSN ( start ) ; if ( ( JUMP_P ( start ) && asm_noperands ( PATTERN ( start ) ) < <NUM_LIT> ) || CALL_P ( start ) ) njumps -- , isjump = true ; else isjump = false ; nbytes -= min_insn_size ( start ) ; } } continue ; } min_size = min_insn_size ( insn ) ; nbytes += min_size ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) , min_size ) ; if ( ( JUMP_P ( insn ) && asm_noperands ( PATTERN ( insn ) ) < <NUM_LIT> ) || CALL_P ( insn ) ) njumps ++ ; else continue ; while ( njumps > <NUM_LIT> ) { start = NEXT_INSN ( start ) ; if ( ( JUMP_P ( start ) && asm_noperands ( PATTERN ( start ) ) < <NUM_LIT> ) || CALL_P ( start ) ) njumps -- , isjump = true ; else isjump = false ; nbytes -= min_insn_size ( start ) ;


<s> if ( REG_P ( operands [ <NUM_LIT> ] ) || ( SImode_address_operand ( operands [ <NUM_LIT> ] , VOIDmode ) && REG_P ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ) return false ; if ( ! ix86_ok_to_clobber_flags ( insn ) ) return false ; ok = ix86_decompose_address ( operands [ <NUM_LIT> ] , & parts ) ; gcc_assert ( ok ) ; if ( ( parts . base != NULL_RTX ) + ( parts . index != NULL_RTX ) + ( parts . disp != NULL_RTX ) + ( parts . scale > <NUM_LIT> ) < <NUM_LIT> ) return false ; if ( parts . disp && flag_pic && ! LEGITIMATE_PIC_OPERAND_P ( parts . disp ) ) return false ;

regno0 = true_regnum ( operands [ <NUM_LIT> ] ) ;


<s> struct ix86_address parts ; int ok ; if ( ! TARGET_AVOID_LEA_FOR_ADDR || optimize_function_for_size_p ( cfun ) ) return false ; if ( REG_P ( operands [ <NUM_LIT> ] ) || ( SImode_address_operand ( operands [ <NUM_LIT> ] , VOIDmode ) && REG_P ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ) return false ; if ( ! ix86_ok_to_clobber_flags ( insn ) ) return false ; ok = ix86_decompose_address ( operands [ <NUM_LIT> ] , & parts ) ; gcc_assert ( ok ) ; if ( ( parts . base != NULL_RTX ) + ( parts . index != NULL_RTX ) + ( parts . disp != NULL_RTX ) + ( parts . scale > <NUM_LIT> ) < <NUM_LIT> ) return false ; if ( parts . disp && flag_pic && ! LEGITIMATE_PIC_OPERAND_P ( parts . disp ) ) return false ; regno0 = true_regnum ( operands [ <NUM_LIT> ] ) ; regno1 = INVALID_REGNUM ; regno2 = INVALID_REGNUM ; if ( parts . base ) regno1 = true_regnum ( parts . base ) ; if ( parts . index ) regno2 = true_regnum ( parts . index ) ;


<s> case V8SFmode : extract = gen_avx_vextractf128v8sf ; load_unaligned = gen_avx_loadups256 ; store_unaligned = gen_avx_storeups256 ; mode = V4SFmode ; break ; case V4DFmode : extract = gen_avx_vextractf128v4df ; load_unaligned = gen_avx_loadupd256 ; store_unaligned = gen_avx_storeupd256 ; mode = V2DFmode ; break ; } if ( MEM_P ( op1 ) ) { if ( TARGET_AVX256_SPLIT_UNALIGNED_LOAD && optimize_insn_for_speed_p ( ) ) { rtx r = gen_reg_rtx ( mode ) ; m = adjust_address ( op1 , mode , <NUM_LIT> ) ; emit_move_insn ( r , m ) ; 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 ( VOIDmode , 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> ) ;


<s> extract = gen_avx_vextractf128v32qi ; load_unaligned = gen_avx_loaddquv32qi ; store_unaligned = gen_avx_storedquv32qi ; mode = V16QImode ; break ; case V8SFmode : extract = gen_avx_vextractf128v8sf ; load_unaligned = gen_avx_loadups256 ; store_unaligned = gen_avx_storeups256 ; mode = V4SFmode ; break ; case V4DFmode : extract = gen_avx_vextractf128v4df ; load_unaligned = gen_avx_loadupd256 ; store_unaligned = gen_avx_storeupd256 ; mode = V2DFmode ; break ; } if ( MEM_P ( op1 ) ) { if ( TARGET_AVX256_SPLIT_UNALIGNED_LOAD && optimize_insn_for_speed_p ( ) ) { rtx r = gen_reg_rtx ( mode ) ; m = adjust_address ( op1 , mode , <NUM_LIT> ) ; emit_move_insn ( r , m ) ; 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 ( VOIDmode , 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 ) ) ; m = adjust_address ( op0 , mode , <NUM_LIT> ) ; emit_insn ( extract ( m , op1 , const1_rtx ) ) ;


<s> for ( i = FIRST_SSE_REG ; i <= LAST_SSE_REG ; i ++ ) if ( TEST_HARD_REG_BIT ( regs_live , i ) && ! call_used_regs [ i ] ) return ; if ( TARGET_64BIT ) for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) if ( TEST_HARD_REG_BIT ( regs_live , i ) && ! call_used_regs [ i ] ) return ; emit_insn ( gen_avx_vzeroupper ( ) ) ;


<s> if ( vzeroupper_operation ( pat , VOIDmode ) || vzeroall_operation ( pat , VOIDmode ) ) return AVX_U128_CLEAN ; if ( CALL_P ( insn ) ) { bool avx_reg256_found = false ; note_stores ( pat , ix86_check_avx256_stores , & avx_reg256_found ) ; return avx_reg256_found ? AVX_U128_DIRTY : AVX_U128_CLEAN ; }


<s> static int ix86_avx_u128_mode_after ( int mode , rtx_insn * insn ) { rtx pat = PATTERN ( insn ) ; if ( vzeroupper_operation ( pat , VOIDmode ) || vzeroall_operation ( pat , VOIDmode ) ) return AVX_U128_CLEAN ; if ( CALL_P ( insn ) ) {


<s> if ( incoming && ix86_check_avx256_register ( incoming ) ) return AVX_U128_DIRTY ; } return AVX_U128_CLEAN ;


<s> for ( arg = DECL_ARGUMENTS ( current_function_decl ) ; arg ; arg = TREE_CHAIN ( arg ) ) { rtx incoming = DECL_INCOMING_RTL ( arg ) ; if ( incoming && ix86_check_avx256_register ( incoming ) ) return AVX_U128_DIRTY ; }


<s> rtx reg = crtl -> return_rtx ; if ( reg && ix86_check_avx256_register ( reg ) ) return AVX_U128_DIRTY ; return AVX_U128_CLEAN ;


<s> static int ix86_avx_u128_mode_needed ( rtx_insn * insn ) { if ( CALL_P ( insn ) ) { rtx link ; for ( link = CALL_INSN_FUNCTION_USAGE ( insn ) ; link ; link = XEXP ( link , <NUM_LIT> ) ) { if ( GET_CODE ( XEXP ( link , <NUM_LIT> ) ) == USE ) { rtx arg = XEXP ( XEXP ( link , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ix86_check_avx256_register ( arg ) ) return AVX_U128_DIRTY ; } } return AVX_U128_CLEAN ; }


<s> if ( GET_CODE ( XEXP ( link , <NUM_LIT> ) ) == USE ) { rtx arg = XEXP ( XEXP ( link , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ix86_check_avx256_register ( arg ) ) return AVX_U128_DIRTY ;


<s> if ( insn && CALL_P ( insn ) ) { rtx call = get_call_rtx_from ( insn ) ; if ( call ) return CALL_EXPR_WITH_BOUNDS_P ( call ) ; } return chkp_function_instrumented_p ( current_function_decl ) ;


<s> rtx call = get_call_rtx_from ( insn ) ; if ( call ) return CALL_EXPR_WITH_BOUNDS_P ( call ) ;


<s> tree t ; if ( ix86_abi == MS_ABI ) { t = ix86_build_builtin_va_list_abi ( SYSV_ABI ) ; if ( TREE_CODE ( t ) != RECORD_TYPE ) t = build_variant_type_copy ( t ) ; sysv_va_list_type_node = t ; } else { t = ret ; if ( TREE_CODE ( t ) != RECORD_TYPE ) t = build_variant_type_copy ( t ) ;


<s> if ( ix86_abi == MS_ABI ) { t = ix86_build_builtin_va_list_abi ( SYSV_ABI ) ; if ( TREE_CODE ( t ) != RECORD_TYPE ) t = build_variant_type_copy ( t ) ; sysv_va_list_type_node = t ; } else { t = ret ; if ( TREE_CODE ( t ) != RECORD_TYPE ) t = build_variant_type_copy ( t ) ; sysv_va_list_type_node = t ; } if ( ix86_abi != MS_ABI ) { t = ix86_build_builtin_va_list_abi ( MS_ABI ) ; if ( TREE_CODE ( t ) != RECORD_TYPE ) t = build_variant_type_copy ( t ) ; ms_va_list_type_node = t ; } else { t = ret ; if ( TREE_CODE ( t ) != RECORD_TYPE ) t = build_variant_type_copy ( t ) ;


<s> int i , n_elt ; rtvec v ; machine_mode scalar_mode ; switch ( mode ) { case V64QImode : case V32QImode : case V16QImode : case V32HImode : case V16HImode : case V8HImode : case V16SImode : case V8SImode : case V4SImode : case V8DImode : case V4DImode : case V2DImode : gcc_assert ( vect ) ; case V16SFmode : case V8SFmode : case V4SFmode : case V8DFmode : case V4DFmode : case V2DFmode : n_elt = GET_MODE_NUNITS ( mode ) ; v = rtvec_alloc ( n_elt ) ; scalar_mode = GET_MODE_INNER ( mode ) ; RTVEC_ELT ( v , <NUM_LIT> ) = value ; for ( i = <NUM_LIT> ; i < n_elt ; ++ i ) RTVEC_ELT ( v , i ) = vect ? value : CONST0_RTX ( scalar_mode ) ;

return gen_rtx_CONST_VECTOR ( mode , v ) ;


<s> case V8SImode : case V4SImode : case V8SFmode : case V4SFmode : vec_mode = mode ; mode = GET_MODE_INNER ( mode ) ; imode = SImode ; lo = <NUM_LIT> , hi = lo < <NUM_LIT> ; break ; case V8DImode : case V4DImode : case V2DImode : case V8DFmode : case V4DFmode : case V2DFmode : vec_mode = mode ; mode = GET_MODE_INNER ( mode ) ; imode = DImode ; if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) lo = ( HOST_WIDE_INT ) <NUM_LIT> << shift , hi = - <NUM_LIT> ; else lo = <NUM_LIT> , hi = ( HOST_WIDE_INT ) <NUM_LIT> << ( shift - HOST_BITS_PER_WIDE_INT ) ; break ; case TImode : case TFmode : vec_mode = VOIDmode ; if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) {


<s> if ( code >= IX86_BUILTIN_MAX ) return error_mark_node ; return ix86_builtins [ code ] ;


<s> case BUILT_IN_CHKP_BNDMK : return ix86_builtins [ IX86_BUILTIN_BNDMK ] ; case BUILT_IN_CHKP_BNDSTX : return ix86_builtins [ IX86_BUILTIN_BNDSTX ] ; case BUILT_IN_CHKP_BNDLDX : return ix86_builtins [ IX86_BUILTIN_BNDLDX ] ; case BUILT_IN_CHKP_BNDCL : return ix86_builtins [ IX86_BUILTIN_BNDCL ] ; case BUILT_IN_CHKP_BNDCU : return ix86_builtins [ IX86_BUILTIN_BNDCU ] ;


<s> return ix86_get_builtin ( IX86_BUILTIN_RSQRTPS_NR256 ) ; default : return NULL_TREE ; } else switch ( fn ) { case BUILT_IN_SQRTF : return ix86_get_builtin ( IX86_BUILTIN_RSQRTF ) ; default : return NULL_TREE ; }


<s> if ( TREE_CODE ( type ) == VECTOR_TYPE ) { switch ( tree_to_uhwi ( TYPE_SIZE ( type ) ) ) { case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_LOAD_M64 ) ; case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_LOAD_M128 ) ; case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_LOAD_M256 ) ;


<s> case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_LOAD_M128 ) ; case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_LOAD_M256 ) ;


<s> if ( TREE_CODE ( type ) == VECTOR_TYPE ) { switch ( tree_to_uhwi ( TYPE_SIZE ( type ) ) ) { case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_STORE_M64 ) ; case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_STORE_M128 ) ; case <NUM_LIT> : return builtin_decl_explicit ( BUILT_IN_TM_STORE_M256 ) ; }


<s> if ( fndecl == NULL_TREE ) cfun -> machine -> call_abi = ix86_abi ;

else cfun -> machine -> call_abi = ix86_function_type_abi ( TREE_TYPE ( fndecl ) ) ;


<s> bool ix86_cannot_change_mode_class ( machine_mode from , machine_mode to , enum reg_class regclass ) { if ( from == to ) return false ; if ( MAYBE_FLOAT_CLASS_P ( regclass ) ) return true ;

if ( MAYBE_SSE_CLASS_P ( regclass ) || MAYBE_MMX_CLASS_P ( regclass ) ) {


<s> bool ix86_cannot_change_mode_class ( machine_mode from , machine_mode to , enum reg_class regclass ) { if ( from == to ) return false ; if ( MAYBE_FLOAT_CLASS_P ( regclass ) ) return true ; if ( MAYBE_SSE_CLASS_P ( regclass ) || MAYBE_MMX_CLASS_P ( regclass ) ) { if ( GET_MODE_SIZE ( from ) < <NUM_LIT> ) return true ;


<s> else if ( ! caller_tree ) ret = false ; else { struct cl_target_option * caller_opts = TREE_TARGET_OPTION ( caller_tree ) ; struct cl_target_option * callee_opts = TREE_TARGET_OPTION ( callee_tree ) ; if ( ( caller_opts -> x_ix86_isa_flags & callee_opts -> x_ix86_isa_flags ) != callee_opts -> x_ix86_isa_flags ) ret = false ; else if ( caller_opts -> x_target_flags != callee_opts -> x_target_flags ) ret = false ; else if ( caller_opts -> arch != callee_opts -> arch ) ret = false ; else if ( caller_opts -> tune != callee_opts -> tune ) ret = false ; else if ( caller_opts -> x_ix86_fpmath != callee_opts -> x_ix86_fpmath ) ret = false ; else if ( caller_opts -> branch_cost != callee_opts -> branch_cost ) ret = false ; else ret = true ;


<s> if ( ! reload_completed || frame_pointer_needed ) return <NUM_LIT> ; if ( crtl -> args . pops_args && crtl -> args . size >= <NUM_LIT> ) return <NUM_LIT> ;


<s> ix86_compute_frame_layout ( & frame ) ;

return ( frame . stack_pointer_offset == UNITS_PER_WORD && ( frame . nregs + frame . nsseregs ) == <NUM_LIT> ) ;


<s> if ( GET_CODE ( op0 ) == PLUS && 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 ;


<s> return ( REG_P ( exp ) && VALID_AVX256_REG_OR_OI_MODE ( GET_MODE ( exp ) ) ) ;


<s> static void ix86_check_avx256_stores ( rtx dest , const_rtx , void * data ) { if ( ix86_check_avx256_register ( dest ) ) {


<s> gcc_assert ( GET_CODE ( set ) == SET ) ; mem = XEXP ( set , opnum ) ; while ( GET_CODE ( mem ) == SUBREG ) mem = SUBREG_REG ( mem ) ; gcc_assert ( MEM_P ( mem ) ) ; return volatile_ok || ! MEM_VOLATILE_P ( mem ) ;


<s> case CREG : case BREG : case AD_REGS : case SIREG : case DIREG : case SSE_FIRST_REG : case FP_TOP_REG : case FP_SECOND_REG :


<s> else if ( mode == XCmode ) return ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ; else return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; } else { if ( COMPLEX_MODE_P ( mode ) ) return <NUM_LIT> ; else return <NUM_LIT> ;


<s> 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> ) ) ; 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 ) ; current_function_decl = decl ; init_function_start ( decl ) ; first_function_block_is_cold = false ; final_start_function ( emit_barrier ( ) , asm_out_file , <NUM_LIT> ) ; if ( TARGET_PAD_SHORT_FUNCTION ) { int i = <NUM_LIT> ; while ( i -- ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> 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 = ( TARGET_64BIT_MS_ABI ? ( <NUM_LIT> << <NUM_LIT> ) : TARGET_64BIT ? ( <NUM_LIT> << <NUM_LIT> ) : ( <NUM_LIT> << <NUM_LIT> ) ) ; 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 ) ; if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) GENERAL_REGS ] , i ) && call_used_regs [ i ] ) SET_HARD_REG_BIT ( reg_class_contents [ ( int ) CLOBBERED_REGS ] , i ) ; }

if ( ! TARGET_MMX ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) MMX_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ;


<s> if ( call_used_regs [ i ] > <NUM_LIT> ) call_used_regs [ i ] = ! ! ( call_used_regs [ i ] & c_mask ) ; if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) GENERAL_REGS ] , i ) && call_used_regs [ i ] ) SET_HARD_REG_BIT ( reg_class_contents [ ( int ) CLOBBERED_REGS ] , i ) ; } if ( ! TARGET_MMX ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) MMX_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; if ( ! TARGET_SSE ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) SSE_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; if ( ! ( TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ) ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) FLOAT_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; if ( ! TARGET_AVX512F ) { 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> ; for ( i = FIRST_MASK_REG ; i <= LAST_MASK_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ;


<s> if ( TREE_CODE ( exp ) == REAL_CST || TREE_CODE ( exp ) == VECTOR_CST || TREE_CODE ( exp ) == INTEGER_CST ) { if ( TYPE_MODE ( TREE_TYPE ( exp ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; else if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( exp ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ;


<s> else if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( exp ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; }

else if ( ! optimize_size && TREE_CODE ( exp ) == STRING_CST && TREE_STRING_LENGTH ( exp ) >= <NUM_LIT> && align < BITS_PER_WORD ) return BITS_PER_WORD ;


<s> if ( max_align < BITS_PER_WORD ) max_align = BITS_PER_WORD ; switch ( ix86_align_data_type ) { case ix86_align_data_type_abi : opt = false ; break ; case ix86_align_data_type_compat : max_align = BITS_PER_WORD ; break ; case ix86_align_data_type_cacheline : break ; } if ( opt && AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST ) { if ( wi :: geu_p ( TYPE_SIZE ( type ) , max_align_compat ) && align < max_align_compat ) align = max_align_compat ; if ( wi :: geu_p ( TYPE_SIZE ( type ) , max_align ) && align < max_align ) align = max_align ; } if ( TARGET_64BIT ) { if ( ( opt ? AGGREGATE_TYPE_P ( type ) : TREE_CODE ( type ) == ARRAY_TYPE ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( TYPE_SIZE ( type ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( ! opt ) return align ; if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ;

if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( wi :: geu_p ( TYPE_SIZE ( type ) , max_align ) && align < max_align ) align = max_align ; } if ( TARGET_64BIT ) { if ( ( opt ? AGGREGATE_TYPE_P ( type ) : TREE_CODE ( type ) == ARRAY_TYPE ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( TYPE_SIZE ( type ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( ! opt ) return align ; if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } 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> void ATTRIBUTE_UNUSED ix86_debug_options ( void ) { char * opts = ix86_target_string ( ix86_isa_flags , target_flags , ix86_arch_string , ix86_tune_string , ix86_fpmath , true ) ; if ( opts ) { fprintf ( stderr , <STR_LIT> , opts ) ; free ( opts ) ; } else fputs ( <STR_LIT> , stderr ) ; return ;