<s> reg11 = gen_rtx_REG ( Pmode , R11_REG ) ; if ( DECL_STATIC_CHAIN ( cfun -> decl ) ) { rtx rax ; rax = gen_rtx_REG ( word_mode , AX_REG ) ; emit_move_insn ( rax , gen_rtx_REG ( word_mode , R10_REG ) ) ; use_reg ( & call_fusage , rax ) ; } if ( ( ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC ) && ! TARGET_PECOFF ) { HOST_WIDE_INT argval ; gcc_assert ( Pmode == DImode ) ; gcc_assert ( ( allocate & ( HOST_WIDE_INT ) <NUM_LIT> ) == allocate ) ; gcc_assert ( ( args_size & <NUM_LIT> ) == args_size ) ; if ( split_stack_fn_large == NULL_RTX ) { split_stack_fn_large = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; SYMBOL_REF_FLAGS ( split_stack_fn_large ) |= SYMBOL_FLAG_LOCAL ; } if ( ix86_cmodel == CM_LARGE_PIC ) { rtx_code_label * label ; rtx x ; label = gen_label_rtx ( ) ; emit_label ( label ) ; LABEL_PRESERVE_P ( label ) = <NUM_LIT> ; emit_insn ( gen_set_rip_rex64 ( reg10 , label ) ) ; emit_insn ( gen_set_got_offset_rex64 ( reg11 , label ) ) ; emit_insn ( ix86_gen_add3 ( reg10 , reg10 , reg11 ) ) ; x = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , split_stack_fn_large ) , UNSPEC_GOT ) ; x = gen_rtx_CONST ( Pmode , x ) ; emit_move_insn ( reg11 , x ) ; x = gen_rtx_PLUS ( Pmode , reg10 , reg11 ) ; x = gen_const_mem ( Pmode , x ) ; emit_move_insn ( reg11 , x ) ; } else emit_move_insn ( reg11 , split_stack_fn_large ) ; fn = reg11 ; argval = ( ( args_size << <NUM_LIT> ) << <NUM_LIT> ) + allocate ; emit_move_insn ( reg10 , GEN_INT ( argval ) ) ; } else { emit_move_insn ( reg10 , allocate_rtx ) ; emit_move_insn ( reg11 , GEN_INT ( args_size ) ) ; use_reg ( & call_fusage , reg11 ) ; } use_reg ( & call_fusage , reg10 ) ; } else { emit_insn ( gen_push ( GEN_INT ( args_size ) ) ) ;


<s> void ix86_expand_sse2_abs ( rtx target , rtx input ) { machine_mode mode = GET_MODE ( target ) ; rtx tmp0 , tmp1 , x ; switch ( mode ) { case V4SImode :

tmp0 = expand_simple_binop ( mode , ASHIFTRT , input , GEN_INT ( GET_MODE_UNIT_BITSIZE ( mode ) - <NUM_LIT> ) , NULL , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> cmp_mode = mode_for_size ( GET_MODE_NUNITS ( cmp_ops_mode ) , MODE_INT , <NUM_LIT> ) ; gcc_assert ( cmp_mode != BLKmode ) ; maskcmp = true ; } else cmp_mode = cmp_ops_mode ; cmp_op0 = force_reg ( cmp_ops_mode , cmp_op0 ) ; if ( ! nonimmediate_operand ( cmp_op1 , cmp_ops_mode ) ) cmp_op1 = force_reg ( cmp_ops_mode , cmp_op1 ) ; if ( optimize || ( op_true && reg_overlap_mentioned_p ( dest , op_true ) ) || ( op_false && reg_overlap_mentioned_p ( dest , op_false ) ) ) dest = gen_reg_rtx ( maskcmp ? cmp_mode : mode ) ; if ( maskcmp && ( code == GT || code == EQ ) ) { rtx ( * gen ) ( rtx , rtx , rtx ) ; switch ( cmp_ops_mode ) { case V64QImode : gcc_assert ( TARGET_AVX512BW ) ; gen = code == GT ? gen_avx512bw_gtv64qi3 : gen_avx512bw_eqv64qi3_1 ; break ; case V32HImode : gcc_assert ( TARGET_AVX512BW ) ; gen = code == GT ? gen_avx512bw_gtv32hi3 : gen_avx512bw_eqv32hi3_1 ; break ; case V16SImode : gen = code == GT ? gen_avx512f_gtv16si3 : gen_avx512f_eqv16si3_1 ; break ; case V8DImode : gen = code == GT ? gen_avx512f_gtv8di3 : gen_avx512f_eqv8di3_1 ; break ; default : gen = NULL ; } if ( gen ) { emit_insn ( gen ( dest , cmp_op0 , cmp_op1 ) ) ;


<s> tmp = gen_rtx_REG ( fpcmp_mode , FLAGS_REG ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_COMPARE ( fpcmp_mode , op0 , op1 ) ) ) ; tmp = gen_rtx_fmt_ee ( code , VOIDmode , tmp , const0_rtx ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ;

tmp = emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp ) ) ;


<s> if ( rtx_equal_p ( cmp_op0 , if_true ) && rtx_equal_p ( cmp_op1 , if_false ) ) is_min = true ; else if ( rtx_equal_p ( cmp_op1 , if_true ) && rtx_equal_p ( cmp_op0 , if_false ) ) is_min = false ; else return false ; mode = GET_MODE ( dest ) ;

if ( ! flag_finite_math_only || ! flag_unsafe_math_optimizations ) {


<s> if_true = force_reg ( mode , if_true ) ; v = gen_rtvec ( <NUM_LIT> , if_true , if_false ) ; tmp = gen_rtx_UNSPEC ( mode , v , u ) ; } else { code = is_min ? SMIN : SMAX ; tmp = gen_rtx_fmt_ee ( code , mode , if_true , if_false ) ; } emit_insn ( gen_rtx_SET ( dest , tmp ) ) ; return true ;


<s> op_false = force_reg ( mode , op_false ) ; x = gen_rtx_IOR ( mode , cmp , op_false ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; } else if ( TARGET_XOP && ! maskcmp ) { op_true = force_reg ( mode , op_true ) ; if ( ! nonimmediate_operand ( op_false , mode ) ) op_false = force_reg ( mode , op_false ) ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_IF_THEN_ELSE ( mode , cmp , op_true , op_false ) ) ) ; } else { rtx ( * gen ) ( rtx , rtx , rtx , rtx ) = NULL ; rtx d = dest ; if ( ! nonimmediate_operand ( op_true , mode ) ) op_true = force_reg ( mode , op_true ) ; op_false = force_reg ( mode , op_false ) ; switch ( mode ) { case V4SFmode : if ( TARGET_SSE4_1 ) gen = gen_sse4_1_blendvps ; break ; case V2DFmode : if ( TARGET_SSE4_1 ) gen = gen_sse4_1_blendvpd ; break ; case V16QImode : case V8HImode : case V4SImode : case V2DImode : if ( TARGET_SSE4_1 ) { gen = gen_sse4_1_pblendvb ; if ( mode != V16QImode ) d = gen_reg_rtx ( V16QImode ) ; op_false = gen_lowpart ( V16QImode , op_false ) ; op_true = gen_lowpart ( V16QImode , op_true ) ; cmp = gen_lowpart ( V16QImode , cmp ) ; } break ; case V8SFmode : if ( TARGET_AVX ) gen = gen_avx_blendvps256 ; break ; case V4DFmode : if ( TARGET_AVX ) gen = gen_avx_blendvpd256 ; break ; case V32QImode : case V16HImode : case V8SImode : case V4DImode : if ( TARGET_AVX2 ) { gen = gen_avx2_pblendvb ; if ( mode != V32QImode ) d = gen_reg_rtx ( V32QImode ) ; op_false = gen_lowpart ( V32QImode , op_false ) ; op_true = gen_lowpart ( V32QImode , op_true ) ; cmp = gen_lowpart ( V32QImode , cmp ) ; } break ; case V64QImode : gen = gen_avx512bw_blendmv64qi ; break ; case V32HImode : gen = gen_avx512bw_blendmv32hi ; break ; case V16SImode : gen = gen_avx512f_blendmv16si ; break ; case V8DImode : gen = gen_avx512f_blendmv8di ; break ; case V8DFmode : gen = gen_avx512f_blendmv8df ; break ; case V16SFmode : gen = gen_avx512f_blendmv16sf ; break ; default : break ; } if ( gen != NULL ) { emit_insn ( gen ( d , op_false , op_true , cmp ) ) ;

if ( d != dest ) emit_move_insn ( dest , gen_lowpart ( GET_MODE ( dest ) , d ) ) ;


<s> else { rtx unspec ; if ( fixed_regs [ AX_REG ] || fixed_regs [ CX_REG ] || fixed_regs [ DI_REG ] ) return false ; if ( ! ADDR_SPACE_GENERIC_P ( MEM_ADDR_SPACE ( src ) ) ) return false ; scratch2 = gen_reg_rtx ( Pmode ) ; scratch3 = gen_reg_rtx ( Pmode ) ; scratch4 = force_reg ( Pmode , constm1_rtx ) ; emit_move_insn ( scratch3 , addr ) ; eoschar = force_reg ( QImode , eoschar ) ; src = replace_equiv_address_nv ( src , scratch3 ) ; unspec = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , src , eoschar , align , scratch4 ) , UNSPEC_SCAS ) ; emit_insn ( gen_strlenqi_1 ( scratch1 , scratch3 , unspec ) ) ; emit_insn ( ix86_gen_one_cmpl2 ( scratch2 , scratch1 ) ) ; emit_insn ( ix86_gen_add3 ( out , scratch2 , constm1_rtx ) ) ; } return true ;


<s> emit_cmp_and_jump_insns ( align_rtx , const2_rtx , GTU , NULL , Pmode , <NUM_LIT> , align_3_label ) ; } else { align_rtx = expand_binop ( Pmode , and_optab , scratch1 , const2_rtx , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_cmp_and_jump_insns ( align_rtx , const0_rtx , EQ , NULL , Pmode , <NUM_LIT> , align_4_label ) ; } mem = change_address ( src , QImode , out ) ; emit_cmp_and_jump_insns ( mem , const0_rtx , EQ , NULL , QImode , <NUM_LIT> , end_0_label ) ; emit_insn ( ix86_gen_add3 ( out , out , const1_rtx ) ) ; if ( align != <NUM_LIT> ) { emit_label ( align_2_label ) ; emit_cmp_and_jump_insns ( mem , const0_rtx , EQ , NULL , QImode , <NUM_LIT> , end_0_label ) ; emit_insn ( ix86_gen_add3 ( out , out , const1_rtx ) ) ; emit_label ( align_3_label ) ; } emit_cmp_and_jump_insns ( mem , const0_rtx , EQ , NULL , QImode , <NUM_LIT> , end_0_label ) ; emit_insn ( ix86_gen_add3 ( out , out , const1_rtx ) ) ; } emit_label ( align_4_label ) ; mem = change_address ( src , SImode , out ) ; emit_move_insn ( scratch , mem ) ; emit_insn ( ix86_gen_add3 ( out , out , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_addsi3 ( tmpreg , scratch , GEN_INT ( - <NUM_LIT> ) ) ) ; emit_insn ( gen_one_cmplsi2 ( scratch , scratch ) ) ; emit_insn ( gen_andsi3 ( tmpreg , tmpreg , scratch ) ) ; emit_insn ( gen_andsi3 ( tmpreg , tmpreg , gen_int_mode ( <NUM_LIT> , SImode ) ) ) ; emit_cmp_and_jump_insns ( tmpreg , const0_rtx , EQ , <NUM_LIT> , SImode , <NUM_LIT> , align_4_label ) ; if ( TARGET_CMOVE ) {


<s> case MULT : op2_l = gen_reg_rtx ( qimode ) ; op2_h = gen_reg_rtx ( qimode ) ; emit_insn ( gen_il ( op2_l , op2 , op2 ) ) ; emit_insn ( gen_ih ( op2_h , op2 , op2 ) ) ; op1_l = gen_reg_rtx ( qimode ) ; op1_h = gen_reg_rtx ( qimode ) ; emit_insn ( gen_il ( op1_l , op1 , op1 ) ) ; emit_insn ( gen_ih ( op1_h , op1 , op1 ) ) ; full_interleave = qimode == V16QImode ; break ; case ASHIFT : case LSHIFTRT : uns_p = true ; case ASHIFTRT : op1_l = gen_reg_rtx ( himode ) ; op1_h = gen_reg_rtx ( himode ) ; ix86_expand_sse_unpack ( op1_l , op1 , uns_p , false ) ; ix86_expand_sse_unpack ( op1_h , op1 , uns_p , true ) ; full_interleave = true ; break ; default : gcc_unreachable ( ) ; } res_l = expand_simple_binop ( himode , code , op1_l , op2_l , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; res_h = expand_simple_binop ( himode , code , op1_h , op2_h , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; gcc_assert ( res_l && res_h ) ; d . target = dest ; d . op0 = gen_lowpart ( qimode , res_l ) ; d . op1 = gen_lowpart ( qimode , res_h ) ; d . vmode = qimode ; d . nelt = GET_MODE_NUNITS ( qimode ) ; d . one_operand_p = false ; d . testing_p = false ;


<s> rtx x ; for ( i = <NUM_LIT> ; i < n_elts ; ++ i ) { x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( ! ( CONST_SCALAR_INT_P ( x ) || CONST_DOUBLE_P ( x ) || CONST_FIXED_P ( x ) ) ) n_var ++ , one_var = i ; else if ( x != CONST0_RTX ( inner_mode ) ) all_const_zero = false ; if ( i > <NUM_LIT> && ! rtx_equal_p ( x , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ) all_same = false ;


<s> int i , j ; switch ( n ) { case <NUM_LIT> : switch ( mode ) { case V16SImode : cmode = V8SImode ; break ; case V16SFmode : cmode = V8SFmode ; break ; case V8DImode : cmode = V4DImode ; break ; case V8DFmode : cmode = V4DFmode ; break ; case V8SImode : cmode = V4SImode ; break ; case V8SFmode : cmode = V4SFmode ; break ; case V4DImode : cmode = V2DImode ; break ; case V4DFmode : cmode = V2DFmode ; break ; case V4SImode : cmode = V2SImode ; break ; case V4SFmode : cmode = V2SFmode ; break ; case V2DImode : cmode = DImode ; break ; case V2SImode : cmode = SImode ; break ; case V2DFmode : cmode = DFmode ; break ; case V2SFmode : cmode = SFmode ; break ; default : gcc_unreachable ( ) ; } if ( ! register_operand ( ops [ <NUM_LIT> ] , cmode ) ) ops [ <NUM_LIT> ] = force_reg ( cmode , ops [ <NUM_LIT> ] ) ; if ( ! register_operand ( ops [ <NUM_LIT> ] , cmode ) ) ops [ <NUM_LIT> ] = force_reg ( cmode , ops [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( target , gen_rtx_VEC_CONCAT ( mode , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] ) ) ) ; break ; case <NUM_LIT> : switch ( mode ) { case V4DImode : cmode = V2DImode ; break ; case V4DFmode : cmode = V2DFmode ; break ; case V4SImode : cmode = V2SImode ; break ; case V4SFmode : cmode = V2SFmode ; break ; default : gcc_unreachable ( ) ; }


<s> val = gen_lowpart ( SImode , val ) ; x = gen_rtx_TRUNCATE ( HImode , val ) ; x = gen_rtx_VEC_DUPLICATE ( mode , x ) ; emit_insn ( gen_rtx_SET ( target , x ) ) ; return true ; } goto widen ; case V8QImode : if ( ! mmx_ok ) return false ; goto widen ; case V8HImode : if ( TARGET_AVX2 ) return ix86_vector_duplicate_value ( mode , target , val ) ; if ( TARGET_SSE2 ) { struct expand_vec_perm_d dperm ; rtx tmp1 , tmp2 ; permute : memset ( & dperm , <NUM_LIT> , sizeof ( dperm ) ) ; dperm . target = target ; dperm . vmode = mode ; dperm . nelt = GET_MODE_NUNITS ( mode ) ; dperm . op0 = dperm . op1 = gen_reg_rtx ( mode ) ; dperm . one_operand_p = true ; tmp1 = gen_reg_rtx ( SImode ) ; emit_move_insn ( tmp1 , gen_lowpart ( SImode , val ) ) ; tmp2 = gen_reg_rtx ( V4SImode ) ; emit_insn ( gen_vec_setv4si_0 ( tmp2 , CONST0_RTX ( V4SImode ) , tmp1 ) ) ; emit_move_insn ( dperm . op0 , gen_lowpart ( mode , tmp2 ) ) ; ok = ( expand_vec_perm_1 ( & dperm ) || expand_vec_perm_broadcast_1 ( & dperm ) ) ; gcc_assert ( ok ) ; return ok ; } goto widen ; case V16QImode : if ( TARGET_AVX2 ) return ix86_vector_duplicate_value ( mode , target , val ) ; if ( TARGET_SSE2 ) goto permute ; goto widen ; widen : { machine_mode smode , wsmode , wvmode ; rtx x ; smode = GET_MODE_INNER ( mode ) ; wvmode = get_mode_wider_vector ( mode ) ;


<s> wsmode = GET_MODE_INNER ( wvmode ) ; val = convert_modes ( wsmode , smode , val , true ) ; x = expand_simple_binop ( wsmode , ASHIFT , val , GEN_INT ( GET_MODE_BITSIZE ( smode ) ) , NULL_RTX , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; val = expand_simple_binop ( wsmode , IOR , val , x , x , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; x = gen_reg_rtx ( wvmode ) ; ok = ix86_expand_vector_init_duplicate ( mmx_ok , wvmode , x , val ) ; gcc_assert ( ok ) ; emit_move_insn ( target , gen_lowpart ( GET_MODE ( target ) , x ) ) ; return ok ; } case V16HImode : case V32QImode : if ( TARGET_AVX2 ) return ix86_vector_duplicate_value ( mode , target , val ) ; else { machine_mode hvmode = ( mode == V16HImode ? V8HImode : V16QImode ) ; rtx x = gen_reg_rtx ( hvmode ) ; ok = ix86_expand_vector_init_duplicate ( false , hvmode , x , val ) ; gcc_assert ( ok ) ; x = gen_rtx_VEC_CONCAT ( mode , x , x ) ; emit_insn ( gen_rtx_SET ( target , x ) ) ; } return true ; case V64QImode : case V32HImode : if ( TARGET_AVX512BW ) return ix86_vector_duplicate_value ( mode , target , val ) ; else { machine_mode hvmode = ( mode == V32HImode ? V16HImode : V32QImode ) ; rtx x = gen_reg_rtx ( hvmode ) ; ok = ix86_expand_vector_init_duplicate ( false , hvmode , x , val ) ;


<s> op0 = gen_reg_rtx ( half_mode ) ; op1 = gen_reg_rtx ( half_mode ) ; ix86_expand_vector_init_interleave ( half_mode , op0 , ops , n >> <NUM_LIT> ) ; ix86_expand_vector_init_interleave ( half_mode , op1 , & ops [ n >> <NUM_LIT> ] , n >> <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( target , gen_rtx_VEC_CONCAT ( mode , op0 , op1 ) ) ) ; return ; case V64QImode : quarter_mode = V16QImode ; half_mode = V32QImode ; goto quarter ; case V32HImode : quarter_mode = V8HImode ; half_mode = V16HImode ; goto quarter ; quarter : n = GET_MODE_NUNITS ( mode ) ; for ( i = <NUM_LIT> ; i < n ; i ++ ) ops [ i ] = XVECEXP ( vals , <NUM_LIT> , i ) ; op0 = gen_reg_rtx ( quarter_mode ) ; op1 = gen_reg_rtx ( quarter_mode ) ; op2 = gen_reg_rtx ( quarter_mode ) ; op3 = gen_reg_rtx ( quarter_mode ) ; op4 = gen_reg_rtx ( half_mode ) ; op5 = gen_reg_rtx ( half_mode ) ; ix86_expand_vector_init_interleave ( quarter_mode , op0 , ops , n >> <NUM_LIT> ) ; ix86_expand_vector_init_interleave ( quarter_mode , op1 , & ops [ n >> <NUM_LIT> ] , n >> <NUM_LIT> ) ; ix86_expand_vector_init_interleave ( quarter_mode , op2 , & ops [ n >> <NUM_LIT> ] , n >> <NUM_LIT> ) ; ix86_expand_vector_init_interleave ( quarter_mode , op3 , & ops [ ( n >> <NUM_LIT> ) | ( n >> <NUM_LIT> ) ] , n >> <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( op4 , gen_rtx_VEC_CONCAT ( half_mode , op0 , op1 ) ) ) ; emit_insn ( gen_rtx_SET ( op5 , gen_rtx_VEC_CONCAT ( half_mode , op2 , op3 ) ) ) ; emit_insn ( gen_rtx_SET ( target , gen_rtx_VEC_CONCAT ( mode , op4 , op5 ) ) ) ; return ; case V16QImode : if ( ! TARGET_SSE4_1 ) break ;


<s> break ; default : gcc_unreachable ( ) ; } for ( i = <NUM_LIT> ; i < n ; i ++ ) { op0 = gen_reg_rtx ( SImode ) ; emit_move_insn ( op0 , gen_lowpart ( SImode , ops [ i + i ] ) ) ; op1 = gen_reg_rtx ( V4SImode ) ; op0 = gen_rtx_VEC_MERGE ( V4SImode , gen_rtx_VEC_DUPLICATE ( V4SImode , op0 ) , CONST0_RTX ( V4SImode ) , const1_rtx ) ; emit_insn ( gen_rtx_SET ( op1 , op0 ) ) ; op0 = gen_reg_rtx ( mode ) ; emit_move_insn ( op0 , gen_lowpart ( mode , op1 ) ) ; emit_insn ( gen_load_even ( op0 , force_reg ( inner_mode , ops [ i + i + <NUM_LIT> ] ) , const1_rtx ) ) ; ops [ i ] = gen_reg_rtx ( first_imode ) ; emit_move_insn ( ops [ i ] , gen_lowpart ( first_imode , op0 ) ) ; } for ( i = j = <NUM_LIT> ; i < n ; i += <NUM_LIT> , j ++ ) { op0 = gen_reg_rtx ( first_imode ) ; emit_insn ( gen_interleave_first_low ( op0 , ops [ i ] , ops [ i + <NUM_LIT> ] ) ) ; ops [ j ] = gen_reg_rtx ( second_imode ) ; emit_move_insn ( ops [ j ] , gen_lowpart ( second_imode , op0 ) ) ; } switch ( second_imode ) { case V4SImode : for ( i = j = <NUM_LIT> ; i < n / <NUM_LIT> ; i += <NUM_LIT> , j ++ ) { op0 = gen_reg_rtx ( second_imode ) ; emit_insn ( gen_interleave_second_low ( op0 , ops [ i ] , ops [ i + <NUM_LIT> ] ) ) ; ops [ j ] = gen_reg_rtx ( third_imode ) ; emit_move_insn ( ops [ j ] , gen_lowpart ( third_imode , op0 ) ) ; } second_imode = V2DImode ; gen_interleave_second_low = gen_vec_interleave_lowv2di ; case V2DImode : op0 = gen_reg_rtx ( second_imode ) ; emit_insn ( gen_interleave_second_low ( op0 , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] ) ) ;

emit_insn ( gen_rtx_SET ( target , gen_lowpart ( mode , op0 ) ) ) ;


<s> else if ( SUBREG_P ( operands [ <NUM_LIT> ] ) ) { op1 = operands [ <NUM_LIT> ] ; op2 = operands [ <NUM_LIT> ] ; } if ( op1 && ! TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL && ( SUBREG_P ( op2 ) || GET_CODE ( op2 ) == CONST_VECTOR ) && GET_MODE_CLASS ( GET_MODE ( SUBREG_REG ( op1 ) ) ) == MODE_VECTOR_FLOAT && GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( op1 ) ) ) == GET_MODE_SIZE ( mode ) && SUBREG_BYTE ( op1 ) == <NUM_LIT> && ( GET_CODE ( op2 ) == CONST_VECTOR || ( GET_MODE ( SUBREG_REG ( op1 ) ) == GET_MODE ( SUBREG_REG ( op2 ) ) && SUBREG_BYTE ( op2 ) == <NUM_LIT> ) ) && can_create_pseudo_p ( ) ) { rtx dst ; switch ( GET_MODE ( SUBREG_REG ( op1 ) ) ) { case V4SFmode : case V8SFmode : case V16SFmode :


<s> case V4SFmode : case V8SFmode : case V16SFmode : case V2DFmode : case V4DFmode : case V8DFmode : dst = gen_reg_rtx ( GET_MODE ( SUBREG_REG ( op1 ) ) ) ; if ( GET_CODE ( op2 ) == CONST_VECTOR ) { op2 = gen_lowpart ( GET_MODE ( dst ) , op2 ) ; op2 = force_reg ( GET_MODE ( dst ) , op2 ) ; } else { op1 = operands [ <NUM_LIT> ] ; op2 = SUBREG_REG ( operands [ <NUM_LIT> ] ) ; if ( ! vector_operand ( op2 , GET_MODE ( dst ) ) ) op2 = force_reg ( GET_MODE ( dst ) , op2 ) ; } op1 = SUBREG_REG ( op1 ) ; if ( ! vector_operand ( op1 , GET_MODE ( dst ) ) ) op1 = force_reg ( GET_MODE ( dst ) , op1 ) ; emit_insn ( gen_rtx_SET ( dst , gen_rtx_fmt_ee ( code , GET_MODE ( dst ) , op1 , op2 ) ) ) ; emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , dst ) ) ; return ; default : break ;


<s> rtx tmp [ <NUM_LIT> ] ; if ( CONSTANT_P ( op1 ) || ( SUBREG_P ( op1 ) && CONSTANT_P ( SUBREG_REG ( op1 ) ) ) ) op1 = validize_mem ( force_const_mem ( mode , op1 ) ) ; if ( ! register_operand ( op0 , mode ) && ! register_operand ( op1 , mode ) ) op1 = force_reg ( mode , op1 ) ; tmp [ <NUM_LIT> ] = op0 ; tmp [ <NUM_LIT> ] = op1 ; ix86_expand_vector_move_misalign ( mode , tmp ) ; return ; } if ( can_create_pseudo_p ( ) && ! register_operand ( op0 , mode ) && ! register_operand ( op1 , mode ) ) { emit_move_insn ( op0 , force_reg ( GET_MODE ( op0 ) , op1 ) ) ; return ;


<s> } if ( TARGET_AVX && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) { switch ( GET_MODE_CLASS ( mode ) ) { case MODE_VECTOR_INT : case MODE_INT : if ( GET_MODE ( op0 ) != V32QImode ) { if ( ! MEM_P ( op0 ) ) { orig_op0 = op0 ; op0 = gen_reg_rtx ( V32QImode ) ; } else op0 = gen_lowpart ( V32QImode , op0 ) ; } op1 = gen_lowpart ( V32QImode , op1 ) ; case MODE_VECTOR_FLOAT : ix86_avx256_split_vector_move_misalign ( op0 , op1 ) ; if ( orig_op0 ) emit_move_insn ( orig_op0 , gen_lowpart ( GET_MODE ( orig_op0 ) , op0 ) ) ; break ; default : gcc_unreachable ( ) ; } return ; } if ( MEM_P ( op1 ) ) { if ( TARGET_AVX && ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) && misaligned_operand ( op1 , GET_MODE ( op1 ) ) ) emit_insn ( gen_rtx_SET ( op0 , op1 ) ) ; else if ( TARGET_SSE2 && GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) { if ( GET_MODE ( op0 ) != V16QImode ) { orig_op0 = op0 ; op0 = gen_reg_rtx ( V16QImode ) ; } op1 = gen_lowpart ( V16QImode , op1 ) ; emit_insn ( gen_sse2_loaddquv16qi ( op0 , op1 ) ) ; if ( orig_op0 ) emit_move_insn ( orig_op0 , gen_lowpart ( GET_MODE ( orig_op0 ) , op0 ) ) ; } else if ( TARGET_SSE2 && mode == V2DFmode ) { rtx zero ; if ( TARGET_AVX || TARGET_SSE_UNALIGNED_LOAD_OPTIMAL || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL || optimize_insn_for_size_p ( ) ) { emit_insn ( gen_sse2_loadupd ( op0 , op1 ) ) ; return ; } if ( TARGET_SSE_SPLIT_REGS ) { emit_clobber ( op0 ) ; zero = op0 ; } else { zero = CONST0_RTX ( V2DFmode ) ; } m = adjust_address ( op1 , DFmode , <NUM_LIT> ) ; emit_insn ( gen_sse2_loadlpd ( op0 , zero , m ) ) ; m = adjust_address ( op1 , DFmode , <NUM_LIT> ) ; emit_insn ( gen_sse2_loadhpd ( op0 , op0 , m ) ) ; } else { rtx t ; if ( TARGET_AVX || TARGET_SSE_UNALIGNED_LOAD_OPTIMAL || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL || optimize_insn_for_size_p ( ) ) { if ( GET_MODE ( op0 ) != V4SFmode ) { orig_op0 = op0 ; op0 = gen_reg_rtx ( V4SFmode ) ; } op1 = gen_lowpart ( V4SFmode , op1 ) ; emit_insn ( gen_sse_loadups ( op0 , op1 ) ) ; if ( orig_op0 ) emit_move_insn ( orig_op0 , gen_lowpart ( GET_MODE ( orig_op0 ) , op0 ) ) ; return ; }

if ( mode != V4SFmode ) t = gen_reg_rtx ( V4SFmode ) ;


if ( canonicalize_vector_int_perm ( d , & nd ) && expand_vec_perm_1 ( & nd ) ) {


<s> CLEAR_HARD_REG_SET ( prologue_used ) ; CLEAR_HARD_REG_SET ( set_up_by_prologue ) ; add_to_hard_reg_set ( & set_up_by_prologue , Pmode , STACK_POINTER_REGNUM ) ; add_to_hard_reg_set ( & set_up_by_prologue , Pmode , ARG_POINTER_REGNUM ) ; add_to_hard_reg_set ( & set_up_by_prologue , Pmode , HARD_FRAME_POINTER_REGNUM ) ; 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 ; crtl -> stack_realign_finalized = true ; return ; } } if ( crtl -> drap_reg ) { basic_block bb = ENTRY_BLOCK_PTR_FOR_FN ( cfun ) -> next_bb ; if ( ! REGNO_REG_SET_P ( DF_LR_IN ( bb ) , REGNO ( crtl -> drap_reg ) ) ) { crtl -> drap_reg = NULL_RTX ; crtl -> need_drap = false ; } } else cfun -> machine -> no_drap_save_restore = true ; frame_pointer_needed = false ; stack_realign = false ; crtl -> max_used_stack_slot_alignment = incoming_stack_boundary ; crtl -> stack_alignment_needed = incoming_stack_boundary ; crtl -> stack_alignment_estimated = incoming_stack_boundary ; if ( crtl -> preferred_stack_boundary > incoming_stack_boundary ) crtl -> preferred_stack_boundary = incoming_stack_boundary ; df_finish_pass ( true ) ; df_scan_alloc ( NULL ) ; df_scan_blocks ( ) ; df_compute_regs_ever_live ( true ) ; df_analyze ( ) ; }


<s> if ( TARGET_64BIT ) { if ( GET_CODE ( x ) != CONST ) return x ; term = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( term ) == PLUS && CONST_INT_P ( XEXP ( term , <NUM_LIT> ) ) ) term = XEXP ( term , <NUM_LIT> ) ; if ( GET_CODE ( term ) != UNSPEC || ( XINT ( term , <NUM_LIT> ) != UNSPEC_GOTPCREL && XINT ( term , <NUM_LIT> ) != UNSPEC_PCREL ) ) return x ; return XVECEXP ( term , <NUM_LIT> , <NUM_LIT> ) ; }

return ix86_delegitimize_address ( x ) ;


<s> if ( GET_CODE ( x ) != CONST ) return x ; term = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( term ) == PLUS && CONST_INT_P ( XEXP ( term , <NUM_LIT> ) ) ) term = XEXP ( term , <NUM_LIT> ) ; if ( GET_CODE ( term ) != UNSPEC || ( XINT ( term , <NUM_LIT> ) != UNSPEC_GOTPCREL && XINT ( term , <NUM_LIT> ) != UNSPEC_PCREL ) ) return x ;

return XVECEXP ( term , <NUM_LIT> , <NUM_LIT> ) ;


<s> switch ( code ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case GT : return <NUM_LIT> ; case LE : return <NUM_LIT> ; case GE : return <NUM_LIT> ; case LT : return <NUM_LIT> ; default : gcc_unreachable ( ) ; }


<s> if ( SUBTARGET_FRAME_POINTER_REQUIRED ) return true ; if ( TARGET_32BIT_MS_ABI && cfun -> calls_setjmp ) return true ;

if ( TARGET_64BIT_MS_ABI && get_frame_size ( ) > SEH_MAX_FRAME_SIZE ) return true ;


<s> static enum calling_abi ix86_function_abi ( const_tree fndecl ) { return fndecl ? ix86_function_type_abi ( TREE_TYPE ( fndecl ) ) : ix86_abi ;


<s> if ( type && TREE_CODE ( type ) == VECTOR_TYPE ) mode = type_natural_mode ( type , cum , false ) ; if ( TARGET_64BIT ) { enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ; if ( call_abi == MS_ABI ) arg = function_arg_ms_64 ( cum , mode , omode , named , bytes ) ; else arg = function_arg_64 ( cum , mode , omode , type , named ) ; } else arg = function_arg_32 ( cum , mode , omode , type , bytes , words ) ; return arg ;


<s> static void ix86_function_arg_advance ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; HOST_WIDE_INT bytes , words ; int nregs ; if ( mode == BLKmode ) bytes = int_size_in_bytes ( type ) ; else bytes = GET_MODE_SIZE ( mode ) ; words = CEIL ( bytes , UNITS_PER_WORD ) ; if ( type ) mode = type_natural_mode ( type , NULL , false ) ; if ( ( type && POINTER_BOUNDS_TYPE_P ( type ) ) || POINTER_BOUNDS_MODE_P ( mode ) ) { if ( cum -> bnds_in_bt ) { cum -> bnds_in_bt -- ; return ; } if ( cum -> force_bnd_pass ) cum -> force_bnd_pass -- ; cum -> bnd_regno ++ ; return ; } cum -> bnds_in_bt = <NUM_LIT> ; if ( cum -> force_bnd_pass ) { cum -> bnd_regno += cum -> force_bnd_pass ; cum -> force_bnd_pass = <NUM_LIT> ; } if ( TARGET_64BIT ) { enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ; if ( call_abi == MS_ABI ) nregs = function_arg_advance_ms_64 ( cum , bytes , words ) ; else nregs = function_arg_advance_64 ( cum , mode , type , words , named ) ; }

else nregs = function_arg_advance_32 ( cum , mode , type , bytes , words ) ;


<s> words = CEIL ( bytes , UNITS_PER_WORD ) ; if ( type ) mode = type_natural_mode ( type , NULL , false ) ; if ( ( type && POINTER_BOUNDS_TYPE_P ( type ) ) || POINTER_BOUNDS_MODE_P ( mode ) ) { if ( cum -> bnds_in_bt ) { cum -> bnds_in_bt -- ; return ; } if ( cum -> force_bnd_pass ) cum -> force_bnd_pass -- ; cum -> bnd_regno ++ ; return ; } cum -> bnds_in_bt = <NUM_LIT> ; if ( cum -> force_bnd_pass ) { cum -> bnd_regno += cum -> force_bnd_pass ; cum -> force_bnd_pass = <NUM_LIT> ; } if ( TARGET_64BIT ) { enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ; if ( call_abi == MS_ABI ) nregs = function_arg_advance_ms_64 ( cum , bytes , words ) ; else nregs = function_arg_advance_64 ( cum , mode , type , words , named ) ; } else nregs = function_arg_advance_32 ( cum , mode , type , bytes , words ) ;

if ( cum -> stdarg ) cum -> force_bnd_pass = nregs ;


<s> int i ; enum calling_abi call_abi ; const int * parm_regs ; if ( TARGET_MPX && BND_REGNO_P ( regno ) ) return true ; if ( ! TARGET_64BIT ) { if ( TARGET_MACHO ) return ( regno < REGPARM_MAX || ( TARGET_SSE && SSE_REGNO_P ( regno ) && ! fixed_regs [ regno ] ) ) ; else return ( regno < REGPARM_MAX || ( TARGET_MMX && MMX_REGNO_P ( regno ) && ( regno < FIRST_MMX_REG + MMX_REGPARM_MAX ) ) || ( TARGET_SSE && SSE_REGNO_P ( regno ) && ( regno < FIRST_SSE_REG + SSE_REGPARM_MAX ) ) ) ; } if ( TARGET_SSE && SSE_REGNO_P ( regno ) && ( regno < FIRST_SSE_REG + SSE_REGPARM_MAX ) ) return true ; call_abi = ix86_cfun_abi ( ) ; if ( call_abi == SYSV_ABI && regno == AX_REG ) return true ; if ( call_abi == MS_ABI ) parm_regs = x86_64_ms_abi_int_parameter_registers ;


<s> type = TREE_TYPE ( type ) ; decl_or_type = type ; } a = ix86_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = ix86_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( STACK_REG_P ( a ) || STACK_REG_P ( b ) ) { if ( ! rtx_equal_p ( a , b ) ) return false ; } else if ( VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) ; else if ( ! rtx_equal_p ( a , b ) ) return false ; if ( TARGET_64BIT ) { if ( cfun -> machine -> call_abi == MS_ABI && ix86_function_type_abi ( type ) == SYSV_ABI ) return false ; } else {

if ( ! decl || ( bind_global && flag_pic && ! flag_plt ) || ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P ( decl ) ) ) {


<s> type = TREE_TYPE ( type ) ; type = TREE_TYPE ( type ) ; decl_or_type = type ; } a = ix86_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = ix86_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( STACK_REG_P ( a ) || STACK_REG_P ( b ) ) { if ( ! rtx_equal_p ( a , b ) ) return false ; } else if ( VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) ; else if ( ! rtx_equal_p ( a , b ) ) return false ; if ( TARGET_64BIT ) { if ( cfun -> machine -> call_abi == MS_ABI && ix86_function_type_abi ( type ) == SYSV_ABI ) return false ; } else { if ( ! decl || ( bind_global && flag_pic && ! flag_plt ) || ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P ( decl ) ) ) { if ( ix86_function_regparm ( type , NULL ) >= <NUM_LIT> && ! cfun -> machine -> arg_reg_available ) return false ; }


<s> if ( ! TARGET_SSE ) { if ( warn ) { if ( decl ) error ( <STR_LIT> <STR_LIT> , decl ) ; else error ( <STR_LIT> <STR_LIT> , type ) ; } return <NUM_LIT> ; } return <NUM_LIT> ; } if ( ! decl ) return <NUM_LIT> ; cgraph_node * target = cgraph_node :: get ( decl ) ; if ( target ) target = target -> function_symbol ( ) ; if ( target && ( target_opts_for_fn ( target -> decl ) -> x_ix86_fpmath & FPMATH_SSE ) && opt_for_fn ( target -> decl , optimize ) && ! ( profile_flag && ! flag_fentry ) ) { cgraph_local_info * i = & target -> local ; if ( i && i -> local && i -> can_change_signature ) { if ( ! TARGET_SSE && warn ) return - <NUM_LIT> ;

return TARGET_SSE2_P ( target_opts_for_fn ( target -> decl ) -> x_ix86_isa_flags ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( warn ) { if ( decl ) error ( <STR_LIT> <STR_LIT> , decl ) ; else error ( <STR_LIT> <STR_LIT> , type ) ; } return <NUM_LIT> ; } return <NUM_LIT> ; } if ( ! decl ) return <NUM_LIT> ; cgraph_node * target = cgraph_node :: get ( decl ) ; if ( target ) target = target -> function_symbol ( ) ; if ( target && ( target_opts_for_fn ( target -> decl ) -> x_ix86_fpmath & FPMATH_SSE ) && opt_for_fn ( target -> decl , optimize ) && ! ( profile_flag && ! flag_fentry ) ) { cgraph_local_info * i = & target -> local ; if ( i && i -> local && i -> can_change_signature ) { if ( ! TARGET_SSE && warn ) return - <NUM_LIT> ; return TARGET_SSE2_P ( target_opts_for_fn ( target -> decl ) -> x_ix86_isa_flags ) ? <NUM_LIT> : <NUM_LIT> ; } } return <NUM_LIT> ;


<s> abi = MS_ABI ; } else if ( abi == MS_ABI && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) abi = SYSV_ABI ;


<s> static bool ix86_function_value_regno_p ( const unsigned int regno ) { switch ( regno ) { case AX_REG : return true ; case DX_REG : return ( ! TARGET_64BIT || ix86_cfun_abi ( ) != MS_ABI ) ; case DI_REG : case SI_REG : return TARGET_64BIT && ix86_cfun_abi ( ) != MS_ABI ; case BND0_REG : case BND1_REG : return chkp_function_instrumented_p ( current_function_decl ) ; case ST0_REG :


<s> return true ; case DX_REG : return ( ! TARGET_64BIT || ix86_cfun_abi ( ) != MS_ABI ) ; case DI_REG : case SI_REG : return TARGET_64BIT && ix86_cfun_abi ( ) != MS_ABI ;


<s> if ( DECL_FUNCTION_VERSIONED ( fn1 ) || DECL_FUNCTION_VERSIONED ( fn2 ) ) { if ( attr2 != NULL_TREE ) { std :: swap ( fn1 , fn2 ) ; attr1 = attr2 ; } error_at ( DECL_SOURCE_LOCATION ( fn2 ) , <STR_LIT> , fn2 ) ; inform ( DECL_SOURCE_LOCATION ( fn1 ) , <STR_LIT> , fn1 ) ;


return mode_for_vector ( elem_mode , nunits ) ;


<s> unsigned elem_size = vector_size / nunits ; if ( ( TARGET_AVX512F && vector_size == <NUM_LIT> ) || ( TARGET_AVX512VL && ( vector_size == <NUM_LIT> || vector_size == <NUM_LIT> ) ) ) { if ( elem_size == <NUM_LIT> || elem_size == <NUM_LIT> || TARGET_AVX512BW ) return smallest_mode_for_size ( nunits , MODE_INT ) ; }


<s> * popno0 = <NUM_LIT> ; * popno1 = <NUM_LIT> ; } op0 = operands [ <NUM_LIT> ] ; op1 = operands [ <NUM_LIT> ] ; break ; case MODRM_CLASS_OP01 : gcc_assert ( noperands >= <NUM_LIT> ) ; if ( popno0 ) { * popno0 = <NUM_LIT> ; * popno1 = <NUM_LIT> ; } op0 = operands [ <NUM_LIT> ] ;


<s> case PROCESSOR_K8 : case PROCESSOR_AMDFAM10 : case PROCESSOR_GENERIC : case PROCESSOR_BTVER1 : return <NUM_LIT> ; case PROCESSOR_BDVER1 : case PROCESSOR_BDVER2 : case PROCESSOR_BDVER3 : case PROCESSOR_BDVER4 : case PROCESSOR_ZNVER1 : case PROCESSOR_CORE2 : case PROCESSOR_NEHALEM : case PROCESSOR_SANDYBRIDGE : case PROCESSOR_HASWELL : return <NUM_LIT> ; default : return <NUM_LIT> ; }


<s> base = parts . base ; index = parts . index ; disp = parts . disp ; scale = parts . scale ; seg = parts . seg ; if ( base ) { rtx reg = ix86_validate_address_register ( base ) ; if ( reg == NULL_RTX ) return false ; if ( ( strict && ! REG_OK_FOR_BASE_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_BASE_NONSTRICT_P ( reg ) ) ) return false ; } if ( index ) { rtx reg = ix86_validate_address_register ( index ) ; if ( reg == NULL_RTX ) return false ; if ( ( strict && ! REG_OK_FOR_INDEX_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P ( reg ) ) ) return false ; } if ( base && index && GET_MODE ( base ) != GET_MODE ( index ) ) return false ; if ( seg != ADDR_SPACE_GENERIC && ( ( base && GET_MODE ( base ) != word_mode ) || ( index && GET_MODE ( index ) != word_mode ) ) ) return false ; if ( scale != <NUM_LIT> ) { if ( ! index ) return false ; if ( scale != <NUM_LIT> && scale != <NUM_LIT> && scale != <NUM_LIT> ) return false ; } if ( disp ) { if ( GET_CODE ( disp ) == CONST && GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) != UNSPEC_MACHOPIC_OFFSET ) switch ( XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : gcc_assert ( flag_pic ) ; if ( ! TARGET_64BIT ) goto is_legitimate_pic ; return false ; case UNSPEC_GOTPCREL : case UNSPEC_PCREL : gcc_assert ( flag_pic ) ;


<s> struct ix86_address parts ; rtx base , index , disp ; HOST_WIDE_INT scale ; addr_space_t seg ; if ( ix86_decompose_address ( addr , & parts ) <= <NUM_LIT> ) return false ; base = parts . base ; index = parts . index ; disp = parts . disp ; scale = parts . scale ; seg = parts . seg ; if ( base ) { rtx reg = ix86_validate_address_register ( base ) ; if ( reg == NULL_RTX ) return false ; if ( ( strict && ! REG_OK_FOR_BASE_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_BASE_NONSTRICT_P ( reg ) ) ) return false ; } if ( index ) { rtx reg = ix86_validate_address_register ( index ) ; if ( reg == NULL_RTX ) return false ; if ( ( strict && ! REG_OK_FOR_INDEX_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P ( reg ) ) ) return false ; } if ( base && index && GET_MODE ( base ) != GET_MODE ( index ) ) return false ; if ( seg != ADDR_SPACE_GENERIC && ( ( base && GET_MODE ( base ) != word_mode ) || ( index && GET_MODE ( index ) != word_mode ) ) ) return false ; if ( scale != <NUM_LIT> ) { if ( ! index ) return false ; if ( scale != <NUM_LIT> && scale != <NUM_LIT> && scale != <NUM_LIT> ) return false ; } if ( disp ) { if ( GET_CODE ( disp ) == CONST && GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) != UNSPEC_MACHOPIC_OFFSET ) switch ( XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : gcc_assert ( flag_pic ) ; if ( ! TARGET_64BIT ) goto is_legitimate_pic ; return false ; case UNSPEC_GOTPCREL : case UNSPEC_PCREL : gcc_assert ( flag_pic ) ; goto is_legitimate_pic ; case UNSPEC_GOTTPOFF : case UNSPEC_GOTNTPOFF : case UNSPEC_INDNTPOFF : case UNSPEC_NTPOFF :


<s> bool win ; int j ; if ( ! TARGET_AVX && VECTOR_MODE_P ( mode ) && misaligned_operand ( op , mode ) ) { unsigned int min_align = get_attr_ssememalign ( insn ) ; if ( min_align == <NUM_LIT> || MEM_ALIGN ( op ) < min_align ) return false ; } if ( UNARY_P ( op ) ) op = XEXP ( op , <NUM_LIT> ) ; if ( SUBREG_P ( op ) ) { if ( REG_P ( SUBREG_REG ( op ) ) && REGNO ( SUBREG_REG ( op ) ) < FIRST_PSEUDO_REGISTER ) offset = subreg_regno_offset ( REGNO ( SUBREG_REG ( op ) ) , GET_MODE ( SUBREG_REG ( op ) ) , SUBREG_BYTE ( op ) , GET_MODE ( op ) ) ; op = SUBREG_REG ( op ) ; } if ( ! ( REG_P ( op ) && HARD_REGISTER_P ( op ) ) ) continue ; op_alt = recog_op_alt ; win = ! n_alternatives ; alternative_mask preferred = get_preferred_alternatives ( insn ) ; for ( j = <NUM_LIT> ; j < n_alternatives ; j ++ , op_alt += n_operands ) { if ( ! TEST_BIT ( preferred , j ) ) continue ; if ( op_alt [ i ] . anything_ok || ( op_alt [ i ] . matches != - <NUM_LIT> && operands_match_p ( recog_data . operand [ i ] , recog_data . operand [ op_alt [ i ] . matches ] ) ) || reg_fits_class_p ( op , op_alt [ i ] . cl , offset , mode ) ) { win = true ; break ;


<s> } if ( ! ( REG_P ( op ) && HARD_REGISTER_P ( op ) ) ) continue ; op_alt = recog_op_alt ; win = ! n_alternatives ; alternative_mask preferred = get_preferred_alternatives ( insn ) ; for ( j = <NUM_LIT> ; j < n_alternatives ; j ++ , op_alt += n_operands ) { if ( ! TEST_BIT ( preferred , j ) ) continue ; if ( op_alt [ i ] . anything_ok || ( op_alt [ i ] . matches != - <NUM_LIT> && operands_match_p ( recog_data . operand [ i ] , recog_data . operand [ op_alt [ i ] . matches ] ) ) || reg_fits_class_p ( op , op_alt [ i ] . cl , offset , mode ) ) { win = true ; break ; }


<s> if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : case UNSPEC_PLTOFF : return TARGET_64BIT ; case UNSPEC_TPOFF : case UNSPEC_NTPOFF : x = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_EXEC ) ; case UNSPEC_DTPOFF : x = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_DYNAMIC ) ; default : return false ; } if ( GET_CODE ( x ) == LABEL_REF ) return true ; if ( GET_CODE ( x ) != SYMBOL_REF ) return false ; case SYMBOL_REF : if ( SYMBOL_REF_TLS_MODEL ( x ) ) return false ; if ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P ( x ) ) return false ; if ( MACHO_DYNAMIC_NO_PIC_P ) return machopic_symbol_defined_p ( x ) ; break ;


<s> gcc_assert ( MEM_P ( slot ) ) ; ptr = copy_addr_to_reg ( slot ) ; } if ( ! register_operand ( ptr , Pmode ) ) ptr = ix86_zero_extend_to_Pmode ( ptr ) ; emit_insn ( BNDmode == BND64mode ? gen_bnd64_ldx ( reg , addr , ptr ) : gen_bnd32_ldx ( reg , addr , ptr ) ) ;


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


<s> decl = NULL ; } if ( ! TARGET_64BIT && align == <NUM_LIT> && ix86_preferred_stack_boundary < <NUM_LIT> && ( mode == DImode || ( type && TYPE_MODE ( type ) == DImode ) ) && ( ! type || ! TYPE_USER_ALIGN ( type ) ) && ( ! decl || ! DECL_USER_ALIGN ( decl ) ) ) align = <NUM_LIT> ; if ( ! type ) { if ( mode == XFmode && align < GET_MODE_ALIGNMENT ( DFmode ) ) align = GET_MODE_ALIGNMENT ( DFmode ) ; return align ; } if ( TARGET_IAMCU ) return align ; if ( TARGET_64BIT && optimize_function_for_speed_p ( cfun ) && TARGET_SSE ) { if ( AGGREGATE_TYPE_P ( type ) && ( va_list_type_node == NULL_TREE || ( TYPE_MAIN_VARIANT ( type ) != TYPE_MAIN_VARIANT ( va_list_type_node ) ) ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( TYPE_SIZE ( type ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; } 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> ;


<s> subrtx_iterator :: array_type array ; bbs = get_loop_body ( loop ) ; for ( i = <NUM_LIT> ; i < loop -> num_nodes ; i ++ ) FOR_BB_INSNS ( bbs [ i ] , insn ) if ( NONDEBUG_INSN_P ( insn ) ) FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( const_rtx x = * iter ) if ( MEM_P ( x ) ) { machine_mode mode = GET_MODE ( x ) ; unsigned int n_words = GET_MODE_SIZE ( mode ) / UNITS_PER_WORD ; if ( n_words > <NUM_LIT> ) mem_count += <NUM_LIT> ;


<s> subrtx_iterator :: array_type array ; bbs = get_loop_body ( loop ) ; for ( i = <NUM_LIT> ; i < loop -> num_nodes ; i ++ ) FOR_BB_INSNS ( bbs [ i ] , insn ) if ( NONDEBUG_INSN_P ( insn ) ) FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( const_rtx x = * iter ) if ( MEM_P ( x ) ) { machine_mode mode = GET_MODE ( x ) ; unsigned int n_words = GET_MODE_SIZE ( mode ) / UNITS_PER_WORD ; if ( n_words > <NUM_LIT> ) mem_count += <NUM_LIT> ; else mem_count += <NUM_LIT> ;


<s> if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , <NUM_LIT> ) != const0_rtx ) ) return false ; break ; case CCmode : if ( req_mode == CCGCmode ) return false ; case CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return false ; case CCGOCmode : if ( req_mode == CCZmode ) return false ; case CCZmode : break ; case CCAmode : case CCCmode :


<s> set = PATTERN ( insn ) ; if ( GET_CODE ( set ) == PARALLEL ) set = XVECEXP ( set , <NUM_LIT> , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; gcc_assert ( GET_CODE ( SET_SRC ( set ) ) == COMPARE ) ; set_mode = GET_MODE ( SET_DEST ( set ) ) ; switch ( set_mode ) { case CCNOmode : if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , <NUM_LIT> ) != const0_rtx ) ) return false ; break ; case CCmode : if ( req_mode == CCGCmode ) return false ; case CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return false ; case CCGOCmode : if ( req_mode == CCZmode ) return false ; case CCZmode : break ; case CCAmode :


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


<s> constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_SCRATCH ( SImode ) ; } rtx x = gen_rtx_REG ( mode , FLAGS_REG ) ; x = gen_rtx_fmt_ee ( code , QImode , x , const0_rtx ) ; machine_mode dest_mode = GET_MODE ( dest ) ; if ( ! SCALAR_INT_MODE_P ( dest_mode ) ) { error ( <STR_LIT> ) ; continue ; } if ( dest_mode == DImode && ! TARGET_64BIT ) dest_mode = SImode ; if ( dest_mode != QImode ) { rtx destqi = gen_reg_rtx ( QImode ) ; emit_insn ( gen_rtx_SET ( destqi , x ) ) ; if ( TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p ( cfun ) ) { x = force_reg ( dest_mode , const0_rtx ) ; emit_insn ( gen_movstrictqi ( gen_lowpart ( QImode , x ) , destqi ) ) ; } else x = gen_rtx_ZERO_EXTEND ( dest_mode , destqi ) ; } if ( dest_mode != GET_MODE ( dest ) ) { rtx tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_rtx_SET ( tmp , x ) ) ; emit_insn ( gen_zero_extendsidi2 ( dest , tmp ) ) ; } else emit_insn ( gen_rtx_SET ( dest , x ) ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; if ( saw_asm_flag ) return seq ; else { clobbers . safe_push ( gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; SET_HARD_REG_BIT ( clobbered_regs , FLAGS_REG ) ; return NULL ;


<s> return MEMMODEL_SEQ_CST ; } strong = ( is_mm_acq_rel ( model ) || is_mm_seq_cst ( model ) ) ; if ( val & IX86_HLE_ACQUIRE && ! ( is_mm_acquire ( model ) || strong ) ) { warning ( OPT_Winvalid_memory_model , <STR_LIT> ) ; return MEMMODEL_SEQ_CST | IX86_HLE_ACQUIRE ; } if ( val & IX86_HLE_RELEASE && ! ( is_mm_release ( model ) || strong ) ) {


<s> if ( val & IX86_HLE_ACQUIRE && ! ( is_mm_acquire ( model ) || strong ) ) { warning ( OPT_Winvalid_memory_model , <STR_LIT> ) ; return MEMMODEL_SEQ_CST | IX86_HLE_ACQUIRE ; } if ( val & IX86_HLE_RELEASE && ! ( is_mm_release ( model ) || strong ) ) { warning ( OPT_Winvalid_memory_model , <STR_LIT> ) ; return MEMMODEL_SEQ_CST | IX86_HLE_RELEASE ; }


<s> if ( incoming_stack_boundary < crtl -> parm_stack_boundary ) incoming_stack_boundary = crtl -> parm_stack_boundary ;


<s> df_note_add_problem ( ) ; df_insn_rescan_all ( ) ; df_analyze ( ) ; regrename_init ( true ) ; regrename_analyze ( NULL ) ; auto_vec < du_head_p > cands ; for ( rtx_insn * insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) continue ; extract_insn ( insn ) ; int opno0 , opno1 ; int modrm = ix86_get_modrm_for_rop ( insn , recog_data . operand , recog_data . n_operands , & opno0 , & opno1 ) ; if ( ! ix86_rop_should_change_byte_p ( modrm ) ) continue ; insn_rr_info * info = & insn_rr [ INSN_UID ( insn ) ] ; if ( ! info -> op_info ) continue ; if ( info -> op_info [ opno0 ] . n_chains != <NUM_LIT> ) { gcc_assert ( info -> op_info [ opno0 ] . n_chains == <NUM_LIT> ) ; du_head_p op0c ; op0c = regrename_chain_from_id ( info -> op_info [ opno0 ] . heads [ <NUM_LIT> ] -> id ) ; if ( op0c -> target_data_1 + op0c -> target_data_2 == <NUM_LIT> && ! op0c -> cannot_rename ) cands . safe_push ( op0c ) ; op0c -> target_data_1 ++ ; } if ( info -> op_info [ opno1 ] . n_chains != <NUM_LIT> ) { gcc_assert ( info -> op_info [ opno1 ] . n_chains == <NUM_LIT> ) ; du_head_p op1c ; op1c = regrename_chain_from_id ( info -> op_info [ opno1 ] . heads [ <NUM_LIT> ] -> id ) ; if ( op1c -> target_data_1 + op1c -> target_data_2 == <NUM_LIT> && ! op1c -> cannot_rename ) cands . safe_push ( op1c ) ; op1c -> target_data_2 ++ ; } } int i ; du_head_p head ; FOR_EACH_VEC_ELT ( cands , i , head ) { int old_reg , best_reg ; HARD_REG_SET unavailable ; CLEAR_HARD_REG_SET ( unavailable ) ; if ( head -> target_data_1 ) IOR_HARD_REG_SET ( unavailable , output_risky ) ; if ( head -> target_data_2 ) IOR_HARD_REG_SET ( unavailable , input_risky ) ; int n_uses ; reg_class superclass = regrename_find_superclass ( head , & n_uses , & unavailable ) ; old_reg = head -> regno ; best_reg = find_rename_reg ( head , superclass , & unavailable , old_reg , false ) ; bool ok = regrename_do_replace ( head , best_reg ) ; gcc_assert ( ok ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , head -> id , reg_names [ best_reg ] , reg_class_names [ superclass ] ) ; } regrename_finish ( ) ; df_analyze ( ) ; basic_block bb ; regset_head live ; INIT_REG_SET ( & live ) ; FOR_EACH_BB_FN ( bb , cfun ) { rtx_insn * insn ; COPY_REG_SET ( & live , DF_LR_OUT ( bb ) ) ; df_simulate_initialize_backwards ( bb , & live ) ;


<s> tree symbol_decl = SYMBOL_REF_DECL ( call_op ) ; if ( ! flag_plt || ( symbol_decl != NULL_TREE && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( symbol_decl ) ) ) ) return true ; return false ;


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


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


<s> if ( REGNO ( reg_1 ) != REGNO ( reg_2 ) ) return false ; if ( ! extract_base_offset_in_addr ( mem_1 , & base_1 , & offset_1 ) ) return false ; if ( ! extract_base_offset_in_addr ( mem_2 , & base_2 , & offset_2 ) ) return false ; if ( ! rtx_equal_p ( base_1 , base_2 ) ) return false ; offval_1 = INTVAL ( offset_1 ) ; offval_2 = INTVAL ( offset_2 ) ; msize = GET_MODE_SIZE ( mode ) ;

if ( offval_1 + msize != offval_2 ) return false ;


<s> else { mem_1 = operands [ <NUM_LIT> ] ; mem_2 = operands [ <NUM_LIT> ] ; reg_1 = operands [ <NUM_LIT> ] ; reg_2 = operands [ <NUM_LIT> ] ; } gcc_assert ( REG_P ( reg_1 ) && REG_P ( reg_2 ) ) ; if ( REGNO ( reg_1 ) != REGNO ( reg_2 ) ) return false ; if ( ! extract_base_offset_in_addr ( mem_1 , & base_1 , & offset_1 ) ) return false ; if ( ! extract_base_offset_in_addr ( mem_2 , & base_2 , & offset_2 ) ) return false ; if ( ! rtx_equal_p ( base_1 , base_2 ) ) return false ;


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


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


opt_pass * pass_stv = make_pass_stv ( g ) ;


<s> ix86_default_align ( & global_options ) ;


<s> char * curr_range_str , * next_range_str ; int i = <NUM_LIT> , n = <NUM_LIT> ; if ( is_memset ) default_algs = & ix86_cost -> memset [ TARGET_64BIT != <NUM_LIT> ] ; else default_algs = & ix86_cost -> memcpy [ TARGET_64BIT != <NUM_LIT> ] ; curr_range_str = strategy_str ; do { int maxs ; char alg_name [ <NUM_LIT> ] ; char align [ <NUM_LIT> ] ; next_range_str = strchr ( curr_range_str , ',' ) ; if ( next_range_str ) * next_range_str ++ = '\0' ; if ( <NUM_LIT> != sscanf ( curr_range_str , <STR_LIT> , alg_name , & maxs , align ) ) { error ( <STR_LIT> , curr_range_str , is_memset ? <STR_LIT> : <STR_LIT> ) ; return ; } if ( n > <NUM_LIT> && ( maxs < ( input_ranges [ n - <NUM_LIT> ] . max + <NUM_LIT> ) && maxs != - <NUM_LIT> ) ) {


<s> enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ; if ( call_abi == MS_ABI ) { HOST_WIDE_INT msize = GET_MODE_SIZE ( mode ) ; if ( type ) { if ( TREE_CODE ( type ) == ARRAY_TYPE ) return true ; if ( RECORD_OR_UNION_TYPE_P ( type ) ) { msize = int_size_in_bytes ( type ) ; } } return msize != <NUM_LIT> && msize != <NUM_LIT> && msize != <NUM_LIT> && msize != <NUM_LIT> ; } else if ( type && int_size_in_bytes ( type ) == - <NUM_LIT> ) return true ; } return false ;


<s> if ( x == CONST0_RTX ( mode ) ) return regclass ; if ( CONSTANT_P ( x ) && ( MAYBE_MMX_CLASS_P ( regclass ) || MAYBE_SSE_CLASS_P ( regclass ) || MAYBE_MASK_CLASS_P ( regclass ) ) ) return NO_REGS ; if ( TARGET_SSE_MATH && ! TARGET_MIX_SSE_I387 && SSE_FLOAT_MODE_P ( mode ) ) return SSE_CLASS_P ( regclass ) ? regclass : NO_REGS ; if ( CONST_DOUBLE_P ( x ) ) { if ( reg_class_subset_p ( regclass , GENERAL_REGS ) ) return regclass ; if ( TARGET_80387 && standard_80387_constant_p ( x ) > <NUM_LIT> ) { if ( regclass == FLOAT_SSE_REGS ) return FLOAT_REGS ; if ( regclass == FP_TOP_SSE_REGS ) return FP_TOP_REG ; if ( regclass == FP_SECOND_SSE_REGS ) return FP_SECOND_REG ; if ( regclass == FLOAT_INT_REGS || regclass == FLOAT_REGS ) return regclass ; }


<s> parts . index = XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ; addr = XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ; } else ok = ix86_decompose_address ( addr , & parts ) ; gcc_assert ( ok ) ; base = parts . base ; index = parts . index ; disp = parts . disp ; scale = parts . scale ; if ( ADDR_SPACE_GENERIC_P ( as ) ) as = parts . seg ; else gcc_assert ( ADDR_SPACE_GENERIC_P ( parts . seg ) ) ; if ( ! ADDR_SPACE_GENERIC_P ( as ) ) { const char * string ; if ( as == ADDR_SPACE_SEG_FS ) string = ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> ) ; else if ( as == ADDR_SPACE_SEG_GS ) string = ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> ) ; else gcc_unreachable ( ) ; fputs ( string , file ) ; } if ( TARGET_64BIT && ! base && ! index && ! no_rip ) { rtx symbol = disp ; if ( GET_CODE ( disp ) == CONST && GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) == PLUS && CONST_INT_P ( XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) ) symbol = XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( symbol ) == LABEL_REF || ( GET_CODE ( symbol ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( symbol ) == <NUM_LIT> ) ) base = pc_rtx ; } if ( ! base && ! index ) { if ( CONST_INT_P ( disp ) ) { if ( ASSEMBLER_DIALECT == ASM_INTEL && parts . seg == ADDR_SPACE_GENERIC ) fputs ( <STR_LIT> , file ) ; fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( disp ) ) ; } else if ( flag_pic ) output_pic_addr_const ( file , disp , <NUM_LIT> ) ; else output_addr_const ( file , disp ) ; } else { if ( SImode_address_operand ( addr , VOIDmode ) ) { if ( flag_checking ) { gcc_assert ( TARGET_64BIT ) ; switch ( GET_CODE ( addr ) ) { case SUBREG : gcc_assert ( GET_MODE ( addr ) == SImode ) ; gcc_assert ( GET_MODE ( SUBREG_REG ( addr ) ) == DImode ) ; break ; case ZERO_EXTEND : case AND : gcc_assert ( GET_MODE ( addr ) == DImode ) ; break ; default : gcc_unreachable ( ) ; } } gcc_assert ( ! code ) ; code = 'k' ;


<s> if ( TARGET_VECTOR_PARALLEL_EXECUTION ) return <NUM_LIT> ; else return <NUM_LIT> ; } if ( INTEGRAL_MODE_P ( mode ) && TARGET_REASSOC_INT_TO_PARALLEL ) return <NUM_LIT> ; else if ( FLOAT_MODE_P ( mode ) && TARGET_REASSOC_FP_TO_PARALLEL ) return ( ( TARGET_64BIT && ix86_tune == PROCESSOR_HASWELL ) ? <NUM_LIT> : <NUM_LIT> ) ;


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

else if ( TARGET_PAD_RETURNS ) ix86_pad_returns ( ) ;


<s> size = int_size_in_bytes ( type ) ; if ( ( ! type || VECTOR_INTEGER_TYPE_P ( type ) || INTEGRAL_TYPE_P ( type ) || VECTOR_FLOAT_TYPE_P ( type ) ) && ( SCALAR_INT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) && ! COMPLEX_MODE_P ( mode ) && ( GET_MODE_SIZE ( mode ) == <NUM_LIT> || size == <NUM_LIT> ) ) return false ; return size != <NUM_LIT> && size != <NUM_LIT> && size != <NUM_LIT> && size != <NUM_LIT> ; } else { int needed_intregs , needed_sseregs ; return examine_argument ( mode , type , <NUM_LIT> , & needed_intregs , & needed_sseregs ) ; } } else { size = int_size_in_bytes ( type ) ; if ( TARGET_IAMCU ) return VECTOR_MODE_P ( mode ) || size < <NUM_LIT> || size > <NUM_LIT> ;


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


<s> static reg_class_t ix86_secondary_reload ( bool in_p , rtx x , reg_class_t rclass , machine_mode mode , secondary_reload_info * sri ) { if ( TARGET_64BIT && MEM_P ( x ) && GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && INTEGER_CLASS_P ( rclass ) && ! offsettable_memref_p ( x ) ) { sri -> icode = ( in_p ? CODE_FOR_reload_noff_load : CODE_FOR_reload_noff_store ) ; sri -> extra_cost = <NUM_LIT> ; return NO_REGS ;


<s> if ( ! TARGET_64BIT || cum -> call_abi == MS_ABI ) return ; fntype = TREE_TYPE ( current_function_decl ) ; next_cum = * cum ; if ( stdarg_p ( fntype ) ) ix86_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , true ) ; save_area = frame_pointer_rtx ; max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( max > X86_64_REGPARM_MAX ) max = X86_64_REGPARM_MAX ; bnd_reg = cum -> bnd_regno + cum -> force_bnd_pass ; if ( chkp_function_instrumented_p ( current_function_decl ) ) for ( i = cum -> regno ; i < max ; i ++ ) { rtx addr = plus_constant ( Pmode , save_area , i * UNITS_PER_WORD ) ; rtx ptr = gen_rtx_REG ( Pmode , x86_64_int_parameter_registers [ i ] ) ; rtx bounds ; if ( bnd_reg <= LAST_BND_REG ) bounds = gen_rtx_REG ( BNDmode , bnd_reg ) ; else { rtx ldx_addr = plus_constant ( Pmode , arg_pointer_rtx , ( LAST_BND_REG - bnd_reg ) * GET_MODE_SIZE ( Pmode ) ) ; bounds = gen_reg_rtx ( BNDmode ) ; emit_insn ( BNDmode == BND64mode ? gen_bnd64_ldx ( bounds , ldx_addr , ptr ) : gen_bnd32_ldx ( bounds , ldx_addr , ptr ) ) ; }

emit_insn ( BNDmode == BND64mode ? gen_bnd64_stx ( addr , ptr , bounds ) : gen_bnd32_stx ( addr , ptr , bounds ) ) ;


<s> else old_tree = target_option_default_node ; if ( fndecl == NULL_TREE ) { if ( old_tree != target_option_current_node ) ix86_reset_previous_fndecl ( ) ; return ; } tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( new_tree == NULL_TREE ) new_tree = target_option_default_node ; if ( old_tree != new_tree ) {


<s> else if ( DECL_FUNCTION_SPECIFIC_TARGET ( ix86_previous_fndecl ) ) old_tree = DECL_FUNCTION_SPECIFIC_TARGET ( ix86_previous_fndecl ) ; else old_tree = target_option_default_node ; if ( fndecl == NULL_TREE ) { if ( old_tree != target_option_current_node ) ix86_reset_previous_fndecl ( ) ; return ; } tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( new_tree == NULL_TREE ) new_tree = target_option_default_node ; if ( old_tree != new_tree ) { cl_target_option_restore ( & global_options , TREE_TARGET_OPTION ( new_tree ) ) ; if ( TREE_TARGET_GLOBALS ( new_tree ) ) restore_target_globals ( TREE_TARGET_GLOBALS ( new_tree ) ) ; else if ( new_tree == target_option_default_node ) restore_target_globals ( & default_target_globals ) ; else TREE_TARGET_GLOBALS ( new_tree ) = save_target_globals_default_opts ( ) ; } ix86_previous_fndecl = fndecl ; if ( TARGET_64BIT && ( call_used_regs [ SI_REG ] == ( cfun -> machine -> call_abi == MS_ABI ) ) ) reinit_regs ( ) ;


<s> case MODE_VECTOR_FLOAT : if ( ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) || ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) || ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) || ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) || ( TARGET_MMX && VALID_MMX_REG_MODE ( mode ) ) ) units = GET_MODE_SIZE ( mode ) ; }

return COSTS_N_INSNS ( CEIL ( GET_MODE_SIZE ( mode ) , units ) ) ;


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


<s> gcc_assert ( node -> decl == cfun -> decl ) ; switch ( node -> simdclone -> vecsize_mangle ) { case 'b' : if ( ! TARGET_SSE2 ) str = <STR_LIT> ; break ; case 'c' : if ( ! TARGET_AVX ) str = <STR_LIT> ; break ; case 'd' : if ( ! TARGET_AVX2 ) str = <STR_LIT> ; break ; case 'e' : if ( ! TARGET_AVX512F ) str = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( str == NULL ) return ; push_cfun ( NULL ) ; tree args = build_tree_list ( NULL_TREE , build_string ( strlen ( str ) , str ) ) ; bool ok = ix86_valid_target_attribute_p ( node -> decl , NULL , args , <NUM_LIT> ) ; gcc_assert ( ok ) ;


<s> ret = <NUM_LIT> ; } else { clonei -> vecsize_mangle = <STR_LIT> [ num ] ; ret = <NUM_LIT> ; } clonei -> mask_mode = VOIDmode ; switch ( clonei -> vecsize_mangle ) { case 'b' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'c' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'd' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'e' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; if ( TYPE_MODE ( base_type ) == QImode ) clonei -> mask_mode = DImode ; else clonei -> mask_mode = SImode ; break ; } if ( clonei -> simdlen == <NUM_LIT> ) { if ( SCALAR_INT_MODE_P ( TYPE_MODE ( base_type ) ) ) clonei -> simdlen = clonei -> vecsize_int ; else clonei -> simdlen = clonei -> vecsize_float ; clonei -> simdlen /= GET_MODE_BITSIZE ( TYPE_MODE ( base_type ) ) ; }

else if ( clonei -> simdlen > <NUM_LIT> ) {


<s> clonei -> vecsize_float = <NUM_LIT> ; if ( TYPE_MODE ( base_type ) == QImode ) clonei -> mask_mode = DImode ; else clonei -> mask_mode = SImode ; break ; } if ( clonei -> simdlen == <NUM_LIT> ) { if ( SCALAR_INT_MODE_P ( TYPE_MODE ( base_type ) ) ) clonei -> simdlen = clonei -> vecsize_int ; else clonei -> simdlen = clonei -> vecsize_float ; clonei -> simdlen /= GET_MODE_BITSIZE ( TYPE_MODE ( base_type ) ) ; } else if ( clonei -> simdlen > <NUM_LIT> ) { tree ctype = ret_type ; if ( TREE_CODE ( ret_type ) == VOID_TYPE ) ctype = base_type ; int cnt = GET_MODE_BITSIZE ( TYPE_MODE ( ctype ) ) * clonei -> simdlen ; if ( SCALAR_INT_MODE_P ( TYPE_MODE ( ctype ) ) ) cnt /= clonei -> vecsize_int ; else cnt /= clonei -> vecsize_float ; if ( cnt > ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ) { warning_at ( DECL_SOURCE_LOCATION ( node -> decl ) , <NUM_LIT> , <STR_LIT> , clonei -> simdlen ) ; return <NUM_LIT> ; }


<s> switch ( node -> simdclone -> vecsize_mangle ) { case 'b' : if ( ! TARGET_SSE2 ) return - <NUM_LIT> ; if ( ! TARGET_AVX ) return <NUM_LIT> ; return TARGET_AVX2 ? <NUM_LIT> : <NUM_LIT> ; case 'c' : if ( ! TARGET_AVX ) return - <NUM_LIT> ; return TARGET_AVX2 ? <NUM_LIT> : <NUM_LIT> ; break ; case 'd' : if ( ! TARGET_AVX2 ) return - <NUM_LIT> ; return <NUM_LIT> ; case 'e' : if ( ! TARGET_AVX512F ) return - <NUM_LIT> ;


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


<s> else x = gen_lowpart ( half_mode , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( high [ <NUM_LIT> ] , x ) ) ; emit_insn ( gen_lshr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( bits ) ) ) ; emit_insn ( gen_and3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , const1_rtx ) ) ; emit_move_insn ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] ) ; emit_insn ( gen_xor3 ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , const1_rtx ) ) ; } emit_insn ( gen_ashl3 ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_ashl3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return ; } if ( operands [ <NUM_LIT> ] == constm1_rtx ) { emit_move_insn ( low [ <NUM_LIT> ] , constm1_rtx ) ; if ( optimize_insn_for_size_p ( ) ) emit_move_insn ( high [ <NUM_LIT> ] , low [ <NUM_LIT> ] ) ; else emit_move_insn ( high [ <NUM_LIT> ] , constm1_rtx ) ; } else { gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; emit_insn ( gen_shld ( high [ <NUM_LIT> ] , low [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; } emit_insn ( gen_ashl3 ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; if ( TARGET_CMOVE && scratch ) { rtx ( * gen_x86_shift_adj_1 ) ( rtx , rtx , rtx , rtx ) = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1 ;


<s> emit_move_insn ( low [ <NUM_LIT> ] , const0_rtx ) ; if ( count > half_width ) ix86_expand_ashl_const ( high [ <NUM_LIT> ] , count - half_width , mode ) ; } else { gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_shld ( high [ <NUM_LIT> ] , low [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; ix86_expand_ashl_const ( low [ <NUM_LIT> ] , count , mode ) ; } return ; } split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; gen_ashl3 = mode == DImode ? gen_ashlsi3 : gen_ashldi3 ; if ( operands [ <NUM_LIT> ] == const1_rtx ) { if ( ANY_QI_REG_P ( low [ <NUM_LIT> ] ) && ANY_QI_REG_P ( high [ <NUM_LIT> ] ) ) { rtx s , d , flags = gen_rtx_REG ( CCZmode , FLAGS_REG ) ; ix86_expand_clear ( low [ <NUM_LIT> ] ) ; ix86_expand_clear ( high [ <NUM_LIT> ] ) ; emit_insn ( gen_testqi_ccz_1 ( operands [ <NUM_LIT> ] , GEN_INT ( half_width ) ) ) ; d = gen_lowpart ( QImode , low [ <NUM_LIT> ] ) ; d = gen_rtx_STRICT_LOW_PART ( VOIDmode , d ) ; s = gen_rtx_EQ ( QImode , flags , const0_rtx ) ; emit_insn ( gen_rtx_SET ( d , s ) ) ; d = gen_lowpart ( QImode , high [ <NUM_LIT> ] ) ; d = gen_rtx_STRICT_LOW_PART ( VOIDmode , d ) ; s = gen_rtx_NE ( QImode , flags , const0_rtx ) ; emit_insn ( gen_rtx_SET ( d , s ) ) ; } else { machine_mode half_mode ; rtx ( * gen_lshr3 ) ( rtx , rtx , rtx ) ; rtx ( * gen_and3 ) ( rtx , rtx , rtx ) ; rtx ( * gen_xor3 ) ( rtx , rtx , rtx ) ; HOST_WIDE_INT bits ; rtx x ; if ( mode == DImode ) { half_mode = SImode ; gen_lshr3 = gen_lshrsi3 ; gen_and3 = gen_andsi3 ; gen_xor3 = gen_xorsi3 ; bits = <NUM_LIT> ; } else { half_mode = DImode ; gen_lshr3 = gen_lshrdi3 ; gen_and3 = gen_anddi3 ; gen_xor3 = gen_xordi3 ; bits = <NUM_LIT> ; } if ( TARGET_PARTIAL_REG_STALL && ! optimize_insn_for_size_p ( ) ) x = gen_rtx_ZERO_EXTEND ( half_mode , operands [ <NUM_LIT> ] ) ; else x = gen_lowpart ( half_mode , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( high [ <NUM_LIT> ] , x ) ) ;

emit_insn ( gen_lshr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( bits ) ) ) ;


<s> x = gen_rtx_AND ( vmode , dest , mask ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; if ( op0 != CONST0_RTX ( vmode ) ) { x = gen_rtx_IOR ( vmode , dest , op0 ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; }


<s> condition = ix86_expand_fp_compare ( code , op1 , op2 , tmp ) ; i = emit_jump_insn ( gen_rtx_SET ( pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , condition , target1 , target2 ) ) ) ;

if ( split_branch_probability >= <NUM_LIT> ) add_int_reg_note ( i , REG_BR_PROB , split_branch_probability ) ;


<s> gen_test_ccno_1 = gen_testdi_ccno_1 ; gen_zero_extend = gen_zero_extendqidi2 ; break ; default : gcc_unreachable ( ) ; } end_label = gen_label_rtx ( ) ; qimode_label = gen_label_rtx ( ) ; scratch = gen_reg_rtx ( mode ) ; emit_move_insn ( scratch , operands [ <NUM_LIT> ] ) ; scratch = expand_simple_binop ( mode , IOR , scratch , operands [ <NUM_LIT> ] , scratch , <NUM_LIT> , OPTAB_DIRECT ) ; emit_insn ( gen_test_ccno_1 ( scratch , GEN_INT ( - <NUM_LIT> ) ) ) ; tmp0 = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ; tmp0 = gen_rtx_EQ ( VOIDmode , tmp0 , const0_rtx ) ; tmp0 = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp0 , gen_rtx_LABEL_REF ( VOIDmode , qimode_label ) , pc_rtx ) ; insn = emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp0 ) ) ; predict_jump ( REG_BR_PROB_BASE * <NUM_LIT> / <NUM_LIT> ) ; JUMP_LABEL ( insn ) = qimode_label ; div = gen_divmod4_1 ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( div ) ; emit_jump_insn ( gen_jump ( end_label ) ) ; emit_barrier ( ) ; emit_label ( qimode_label ) ; tmp0 = simplify_gen_subreg ( HImode , scratch , mode , <NUM_LIT> ) ; tmp1 = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; tmp2 = simplify_gen_subreg ( QImode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; emit_insn ( gen_udivmodhiqi3 ( tmp0 , tmp1 , tmp2 ) ) ; if ( signed_p ) { div = gen_rtx_DIV ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; mod = gen_rtx_MOD ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { div = gen_rtx_UDIV ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; mod = gen_rtx_UMOD ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } tmp1 = gen_rtx_ZERO_EXTRACT ( mode , tmp0 , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; if ( REG_P ( operands [ <NUM_LIT> ] ) ) insn = emit_move_insn ( operands [ <NUM_LIT> ] , tmp1 ) ; else { scratch = gen_reg_rtx ( mode ) ; emit_move_insn ( scratch , tmp1 ) ; insn = emit_move_insn ( operands [ <NUM_LIT> ] , scratch ) ; } set_unique_reg_note ( insn , REG_EQUAL , mod ) ; tmp1 = gen_lowpart ( QImode , tmp0 ) ; insn = emit_insn ( gen_zero_extend ( operands [ <NUM_LIT> ] , tmp1 ) ) ; set_unique_reg_note ( insn , REG_EQUAL , div ) ; emit_label ( end_label ) ;


<s> gen_zero_extend = gen_zero_extendqisi2 ; break ; case DImode : gen_divmod4_1 = signed_p ? gen_divmoddi4_1 : gen_udivmoddi4_1 ; gen_test_ccno_1 = gen_testdi_ccno_1 ; gen_zero_extend = gen_zero_extendqidi2 ; break ; default : gcc_unreachable ( ) ; } end_label = gen_label_rtx ( ) ; qimode_label = gen_label_rtx ( ) ; scratch = gen_reg_rtx ( mode ) ; emit_move_insn ( scratch , operands [ <NUM_LIT> ] ) ; scratch = expand_simple_binop ( mode , IOR , scratch , operands [ <NUM_LIT> ] , scratch , <NUM_LIT> , OPTAB_DIRECT ) ; emit_insn ( gen_test_ccno_1 ( scratch , GEN_INT ( - <NUM_LIT> ) ) ) ; tmp0 = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ; tmp0 = gen_rtx_EQ ( VOIDmode , tmp0 , const0_rtx ) ; tmp0 = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp0 , gen_rtx_LABEL_REF ( VOIDmode , qimode_label ) , pc_rtx ) ; insn = emit_jump_insn ( gen_rtx_SET ( pc_rtx , tmp0 ) ) ; predict_jump ( REG_BR_PROB_BASE * <NUM_LIT> / <NUM_LIT> ) ; JUMP_LABEL ( insn ) = qimode_label ; div = gen_divmod4_1 ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( div ) ; emit_jump_insn ( gen_jump ( end_label ) ) ; emit_barrier ( ) ; emit_label ( qimode_label ) ; tmp0 = simplify_gen_subreg ( HImode , scratch , mode , <NUM_LIT> ) ; tmp1 = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; tmp2 = simplify_gen_subreg ( QImode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; emit_insn ( gen_udivmodhiqi3 ( tmp0 , tmp1 , tmp2 ) ) ; if ( signed_p ) { div = gen_rtx_DIV ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; mod = gen_rtx_MOD ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { div = gen_rtx_UDIV ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; mod = gen_rtx_UMOD ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } tmp1 = gen_rtx_ZERO_EXTRACT ( mode , tmp0 , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; if ( REG_P ( operands [ <NUM_LIT> ] ) ) insn = emit_move_insn ( operands [ <NUM_LIT> ] , tmp1 ) ; else { scratch = gen_reg_rtx ( mode ) ; emit_move_insn ( scratch , tmp1 ) ; insn = emit_move_insn ( operands [ <NUM_LIT> ] , scratch ) ; }

set_unique_reg_note ( insn , REG_EQUAL , mod ) ;


<s> parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; break ; case XFmode : real_to_target ( l , r , mode ) ; parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; break ; case DFmode : REAL_VALUE_TO_TARGET_DOUBLE ( * r , l ) ; break ; default : gcc_unreachable ( ) ; } parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; } else gcc_unreachable ( ) ; } } else { if ( mode == TImode ) split_double_mode ( mode , & operand , <NUM_LIT> , & parts [ <NUM_LIT> ] , & parts [ <NUM_LIT> ] ) ; if ( mode == XFmode || mode == TFmode ) { machine_mode upper_mode = mode == XFmode ? SImode : DImode ; if ( REG_P ( operand ) ) { gcc_assert ( reload_completed ) ; parts [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( operand ) + <NUM_LIT> ) ; parts [ <NUM_LIT> ] = gen_rtx_REG ( upper_mode , REGNO ( operand ) + <NUM_LIT> ) ; } else if ( offsettable_memref_p ( operand ) ) { operand = adjust_address ( operand , DImode , <NUM_LIT> ) ; parts [ <NUM_LIT> ] = operand ; parts [ <NUM_LIT> ] = adjust_address ( operand , upper_mode , <NUM_LIT> ) ; } else if ( CONST_DOUBLE_P ( operand ) ) { long l [ <NUM_LIT> ] ; real_to_target ( l , CONST_DOUBLE_REAL_VALUE ( operand ) , mode ) ; parts [ <NUM_LIT> ] = gen_int_mode ( ( l [ <NUM_LIT> ] & ( HOST_WIDE_INT ) <NUM_LIT> ) | ( ( l [ <NUM_LIT> ] & ( HOST_WIDE_INT ) <NUM_LIT> ) << <NUM_LIT> ) , DImode ) ; if ( upper_mode == SImode ) parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; else parts [ <NUM_LIT> ] = gen_int_mode ( ( l [ <NUM_LIT> ] & ( HOST_WIDE_INT ) <NUM_LIT> ) | ( ( l [ <NUM_LIT> ] & ( HOST_WIDE_INT ) <NUM_LIT> ) << <NUM_LIT> ) , DImode ) ; } else gcc_unreachable ( ) ;


<s> gcc_assert ( POINTER_BOUNDS_MODE_P ( GET_MODE ( bounds ) ) ) ; if ( ! register_operand ( bounds , BNDmode ) ) bounds = copy_to_mode_reg ( BNDmode , bounds ) ;


<s> rtx addr ; addr = ix86_get_arg_address_for_bt ( slot , slot_no , stack_pointer_rtx ) ; if ( ! ptr ) { gcc_assert ( MEM_P ( slot ) ) ; ptr = copy_addr_to_reg ( slot ) ; } if ( ! register_operand ( ptr , Pmode ) ) ptr = ix86_zero_extend_to_Pmode ( ptr ) ; gcc_assert ( POINTER_BOUNDS_MODE_P ( GET_MODE ( bounds ) ) ) ; if ( ! register_operand ( bounds , BNDmode ) ) bounds = copy_to_mode_reg ( BNDmode , bounds ) ; emit_insn ( BNDmode == BND64mode ? gen_bnd64_stx ( addr , ptr , bounds ) : gen_bnd32_stx ( addr , ptr , bounds ) ) ;


return TARGET_RED_ZONE && ! TARGET_64BIT_MS_ABI ;


<s> return TARGET_RED_ZONE && ! TARGET_64BIT_MS_ABI ;


<s> tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) ; if ( ! func_optimize ) func_optimize = old_optimize ; memset ( & func_options , <NUM_LIT> , sizeof ( func_options ) ) ; init_options_struct ( & func_options , NULL ) ; lang_hooks . init_options_struct ( & func_options ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ;


<s> lang_hooks . init_options_struct ( & func_options ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ; cl_target_option_restore ( & func_options , TREE_TARGET_OPTION ( target_option_default_node ) ) ; new_target = ix86_valid_target_attribute_tree ( args , & func_options , & global_options_set ) ; new_optimize = build_optimization_node ( & func_options ) ; if ( new_target == error_mark_node ) ret = false ; else if ( fndecl && new_target ) {

DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) = new_target ;


<s> else if ( orig_tune_defaulted ) opts -> x_ix86_tune_string = NULL ; if ( enum_opts_set . x_ix86_fpmath ) opts_set -> x_ix86_fpmath = ( enum fpmath_unit ) <NUM_LIT> ; else if ( ! TARGET_64BIT_P ( opts -> x_ix86_isa_flags ) && TARGET_SSE_P ( opts -> x_ix86_isa_flags ) ) { if ( TARGET_80387_P ( opts -> x_target_flags ) ) opts -> x_ix86_fpmath = ( enum fpmath_unit ) ( FPMATH_SSE | FPMATH_387 ) ; else opts -> x_ix86_fpmath = ( enum fpmath_unit ) FPMATH_SSE ; opts_set -> x_ix86_fpmath = ( enum fpmath_unit ) <NUM_LIT> ; } ix86_option_override_internal ( false , opts , opts_set ) ; ix86_add_new_builtins ( opts -> x_ix86_isa_flags ) ;


<s> end_sequence ( ) ; push_topmost_sequence ( ) ; emit_insn_after ( seq , entry_of_function ( ) ) ; pop_topmost_sequence ( ) ; } } if ( is_va_list_char_pointer ( TREE_TYPE ( valist ) ) ) { if ( cfun -> machine -> split_stack_varargs_pointer == NULL_RTX ) std_expand_builtin_va_start ( valist , nextarg ) ; else { rtx va_r , next ; va_r = expand_expr ( valist , NULL_RTX , VOIDmode , EXPAND_WRITE ) ; next = expand_binop ( ptr_mode , add_optab , cfun -> machine -> split_stack_varargs_pointer , crtl -> args . arg_offset_rtx , NULL_RTX , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; convert_move ( va_r , next , <NUM_LIT> ) ; if ( chkp_function_instrumented_p ( current_function_decl ) ) chkp_expand_bounds_reset_for_mem ( valist , make_tree ( TREE_TYPE ( valist ) , next ) ) ; } return ; } f_gpr = TYPE_FIELDS ( TREE_TYPE ( sysv_va_list_type_node ) ) ; f_fpr = DECL_CHAIN ( f_gpr ) ; f_ovf = DECL_CHAIN ( f_fpr ) ; f_sav = DECL_CHAIN ( f_ovf ) ; valist = build_simple_mem_ref ( valist ) ; TREE_TYPE ( valist ) = TREE_TYPE ( sysv_va_list_type_node ) ; gpr = build3 ( COMPONENT_REF , TREE_TYPE ( f_gpr ) , unshare_expr ( valist ) , f_gpr , NULL_TREE ) ; fpr = build3 ( COMPONENT_REF , TREE_TYPE ( f_fpr ) , unshare_expr ( valist ) , f_fpr , NULL_TREE ) ; ovf = build3 ( COMPONENT_REF , TREE_TYPE ( f_ovf ) , unshare_expr ( valist ) , f_ovf , NULL_TREE ) ; sav = build3 ( COMPONENT_REF , TREE_TYPE ( f_sav ) , unshare_expr ( valist ) , f_sav , NULL_TREE ) ; words = crtl -> args . info . words ; n_gpr = crtl -> args . info . regno ; n_fpr = crtl -> args . info . sse_regno ; if ( cfun -> va_list_gpr_size ) { type = TREE_TYPE ( gpr ) ; t = build2 ( MODIFY_EXPR , type , gpr , build_int_cst ( type , n_gpr * <NUM_LIT> ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ;


<s> sav = build3 ( COMPONENT_REF , TREE_TYPE ( f_sav ) , unshare_expr ( valist ) , f_sav , NULL_TREE ) ; words = crtl -> args . info . words ; n_gpr = crtl -> args . info . regno ; n_fpr = crtl -> args . info . sse_regno ; if ( cfun -> va_list_gpr_size ) { type = TREE_TYPE ( gpr ) ; t = build2 ( MODIFY_EXPR , type , gpr , build_int_cst ( type , n_gpr * <NUM_LIT> ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } if ( TARGET_SSE && cfun -> va_list_fpr_size ) { type = TREE_TYPE ( fpr ) ; t = build2 ( MODIFY_EXPR , type , fpr , build_int_cst ( type , n_fpr * <NUM_LIT> + <NUM_LIT> * X86_64_REGPARM_MAX ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } type = TREE_TYPE ( ovf ) ; if ( cfun -> machine -> split_stack_varargs_pointer == NULL_RTX ) ovf_rtx = crtl -> args . internal_arg_pointer ; else ovf_rtx = cfun -> machine -> split_stack_varargs_pointer ; t = make_tree ( type , ovf_rtx ) ; if ( words != <NUM_LIT> ) t = fold_build_pointer_plus_hwi ( t , words * UNITS_PER_WORD ) ; if ( chkp_function_instrumented_p ( current_function_decl ) ) chkp_expand_bounds_reset_for_mem ( ovf , t ) ; t = build2 ( MODIFY_EXPR , type , ovf , t ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ;

if ( ix86_varargs_gpr_size || ix86_varargs_fpr_size ) {


<s> CASE_CFN_LOG : CASE_CFN_LOG2 : CASE_CFN_LOG10 : if ( el_mode == DFmode && n == <NUM_LIT> ) { name [ <NUM_LIT> ] = 'd' ; name [ <NUM_LIT> ] = '2' ; } else if ( el_mode == SFmode && n == <NUM_LIT> ) { name [ <NUM_LIT> ] = 's' ; name [ <NUM_LIT> ] = '4' ; } else return NULL_TREE ; break ; default : return NULL_TREE ; } tree fndecl = mathfn_built_in ( TREE_TYPE ( type_in ) , fn ) ; bname = IDENTIFIER_POINTER ( DECL_NAME ( fndecl ) ) ; sprintf ( name + <NUM_LIT> , <STR_LIT> , bname + <NUM_LIT> ) ; arity = <NUM_LIT> ; for ( args = DECL_ARGUMENTS ( fndecl ) ; args ; args = TREE_CHAIN ( args ) ) arity ++ ; if ( arity == <NUM_LIT> ) fntype = build_function_type_list ( type_out , type_in , NULL ) ; else fntype = build_function_type_list ( type_out , type_in , type_in , NULL ) ; new_fndecl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , get_identifier ( name ) , fntype ) ; TREE_PUBLIC ( new_fndecl ) = <NUM_LIT> ; DECL_EXTERNAL ( new_fndecl ) = <NUM_LIT> ; DECL_IS_NOVOPS ( new_fndecl ) = <NUM_LIT> ; TREE_READONLY ( new_fndecl ) = <NUM_LIT> ; return new_fndecl ;


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


<s> if ( ( TREE_CODE ( index_type ) != INTEGER_TYPE && ! POINTER_TYPE_P ( index_type ) ) || ( TYPE_MODE ( index_type ) != SImode && TYPE_MODE ( index_type ) != DImode ) ) return NULL_TREE ; if ( TYPE_PRECISION ( index_type ) > POINTER_SIZE ) return NULL_TREE ; if ( TYPE_PRECISION ( index_type ) < POINTER_SIZE && TYPE_UNSIGNED ( index_type ) ) return NULL_TREE ; if ( scale <= <NUM_LIT> || scale > <NUM_LIT> || ( scale & ( scale - <NUM_LIT> ) ) != <NUM_LIT> ) return NULL_TREE ; si = TYPE_MODE ( index_type ) == SImode ; switch ( TYPE_MODE ( vectype ) ) { case V8DFmode : code = si ? IX86_BUILTIN_SCATTERALTSIV8DF : IX86_BUILTIN_SCATTERDIV8DF ;


<s> static bool ix86_vector_duplicate_value ( machine_mode mode , rtx target , rtx val ) { bool ok ; rtx_insn * insn ; rtx dup ; dup = gen_rtx_VEC_DUPLICATE ( mode , val ) ; insn = emit_insn ( gen_rtx_SET ( target , dup ) ) ; if ( recog_memoized ( insn ) < <NUM_LIT> ) {


<s> rtx tmp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_vec_interleave_lowv4si ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) ) ) ; } else { rtx tmp = assign_386_stack_local ( DImode , SLOT_TEMP ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( vreg , tmp ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; emit_conversion_insns ( seq , insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( vreg ) , DF_REF_INSN_UID ( ref ) ) ; } for ( ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { replace_with_subreg_in_insn ( DF_REF_INSN ( ref ) , reg , vreg ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( vreg ) , DF_REF_INSN_UID ( ref ) ) ; }


<s> if ( TARGET_SSE4_1 ) { emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse4_1_pinsrd ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ; } else if ( TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx tmp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_vec_interleave_lowv4si ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) ) ) ; } else { rtx tmp = assign_386_stack_local ( DImode , SLOT_TEMP ) ;

emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ;


<s> if ( bitmap_bit_p ( defs_conv , DF_REF_REGNO ( def ) ) ) return ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , DF_REF_REGNO ( def ) , DF_REF_INSN_UID ( def ) , chain_id ) ; bitmap_set_bit ( defs_conv , DF_REF_REGNO ( def ) ) ;


<s> gcc_assert ( DF_REF_REG_DEF_P ( def ) ) ; if ( bitmap_bit_p ( defs_conv , DF_REF_REGNO ( def ) ) ) return ;

if ( dump_file ) fprintf ( dump_file , <STR_LIT> , DF_REF_REGNO ( def ) , DF_REF_INSN_UID ( def ) , chain_id ) ;


<s> struct ix86_address parts ; rtx base , index , disp ; int len ; int ok ; if ( GET_CODE ( addr ) == PRE_DEC || GET_CODE ( addr ) == POST_INC || GET_CODE ( addr ) == PRE_MODIFY || GET_CODE ( addr ) == POST_MODIFY ) return <NUM_LIT> ; ok = ix86_decompose_address ( addr , & parts ) ; gcc_assert ( ok ) ; len = ( parts . seg == ADDR_SPACE_GENERIC ) ? <NUM_LIT> : <NUM_LIT> ; if ( TARGET_64BIT && ! lea && ( SImode_address_operand ( addr , VOIDmode ) || ( parts . base && GET_MODE ( parts . base ) == SImode ) || ( parts . index && GET_MODE ( parts . index ) == SImode ) ) ) len ++ ; base = parts . base ; index = parts . index ; disp = parts . disp ;

if ( base && SUBREG_P ( base ) ) base = SUBREG_REG ( base ) ;


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


<s> const char * output_adjust_stack_and_probe ( rtx reg ) { static int labelno = <NUM_LIT> ; char loop_lab [ <NUM_LIT> ] ; rtx xops [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = stack_pointer_rtx ; xops [ <NUM_LIT> ] = GEN_INT ( PROBE_INTERVAL ) ; output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = const0_rtx ; output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = stack_pointer_rtx ; xops [ <NUM_LIT> ] = reg ; output_asm_insn ( <STR_LIT> , xops ) ;


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


<s> xops [ <NUM_LIT> ] = stack_pointer_rtx ; xops [ <NUM_LIT> ] = reg ; xops [ <NUM_LIT> ] = const0_rtx ; output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = reg ; xops [ <NUM_LIT> ] = end ;


<s> pass_stv ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_stv , ctxt ) {


<s> if ( x == pc_rtx ) { gcc_assert ( TARGET_64BIT ) ; fputs ( <STR_LIT> , file ) ; return ; } if ( code == 'y' && STACK_TOP_P ( x ) ) { fputs ( <STR_LIT> , file ) ; return ; } if ( code == 'w' ) msize = <NUM_LIT> ; else if ( code == 'b' ) msize = <NUM_LIT> ; else if ( code == 'k' ) msize = <NUM_LIT> ; else if ( code == 'q' ) msize = <NUM_LIT> ; else if ( code == 'h' ) msize = <NUM_LIT> ; else if ( code == 'x' ) msize = <NUM_LIT> ; else if ( code == 't' ) msize = <NUM_LIT> ; else if ( code == 'g' ) msize = <NUM_LIT> ; else msize = GET_MODE_SIZE ( GET_MODE ( x ) ) ; regno = true_regnum ( x ) ; gcc_assert ( regno != ARG_POINTER_REGNUM && regno != FRAME_POINTER_REGNUM && regno != FLAGS_REG && regno != FPSR_REG && regno != FPCR_REG ) ; duplicated = code == 'd' && TARGET_AVX ; switch ( msize ) { case <NUM_LIT> : case <NUM_LIT> : if ( LEGACY_INT_REGNO_P ( regno ) ) putc ( msize == <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : normal : reg = hi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; reg = qi_reg_name [ regno ] ;


<s> if ( Pmode == SImode ) insn = gen_pro_epilogue_adjust_stack_si_add ( dest , src , offset ) ; else if ( x86_64_immediate_operand ( offset , DImode ) ) insn = gen_pro_epilogue_adjust_stack_di_add ( dest , src , offset ) ; else { rtx tmp ; if ( style ) tmp = gen_rtx_REG ( DImode , R11_REG ) ; else { gcc_assert ( src != hard_frame_pointer_rtx && dest != hard_frame_pointer_rtx ) ; tmp = hard_frame_pointer_rtx ; } insn = emit_insn ( gen_rtx_SET ( tmp , offset ) ) ; if ( style < <NUM_LIT> ) add_frame_related_expr = true ; insn = gen_pro_epilogue_adjust_stack_di_add ( dest , src , tmp ) ; } insn = emit_insn ( insn ) ; if ( style >= <NUM_LIT> ) ix86_add_queued_cfa_restore_notes ( insn ) ; if ( set_cfa ) { rtx r ; gcc_assert ( m -> fs . cfa_reg == src ) ; m -> fs . cfa_offset += INTVAL ( offset ) ;


<s> if ( style >= <NUM_LIT> ) ix86_add_queued_cfa_restore_notes ( insn ) ; if ( set_cfa ) { rtx r ; gcc_assert ( m -> fs . cfa_reg == src ) ; m -> fs . cfa_offset += INTVAL ( offset ) ; m -> fs . cfa_reg = dest ; r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( dest , r ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , r ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( style < <NUM_LIT> ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( add_frame_related_expr ) { rtx r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( dest , r ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , r ) ; } } if ( dest == stack_pointer_rtx ) { HOST_WIDE_INT ooffset = m -> fs . sp_offset ; bool valid = m -> fs . sp_valid ; if ( src == hard_frame_pointer_rtx ) { valid = m -> fs . fp_valid ; ooffset = m -> fs . fp_offset ; }


<s> switch ( mode ) { case CCNOmode : case CCGOCmode : suffix = <STR_LIT> ; break ; case CCmode : case CCGCmode : suffix = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case LTU : if ( mode == CCmode ) suffix = <STR_LIT> ; else if ( mode == CCCmode ) suffix = fp ? <STR_LIT> : <STR_LIT> ; else gcc_unreachable ( ) ; 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 : if ( mode == CCmode ) suffix = <STR_LIT> ; else if ( mode == CCCmode ) suffix = fp ? <STR_LIT> : <STR_LIT> ; else gcc_unreachable ( ) ;


<s> return <NUM_LIT> ; case SP_REG : return <NUM_LIT> ; case BP_REG : return <NUM_LIT> ; case SI_REG : return <NUM_LIT> ; case DI_REG : return <NUM_LIT> ; default : break ; } if ( IN_RANGE ( regno , FIRST_STACK_REG , LAST_STACK_REG ) ) return regno - FIRST_STACK_REG ; if ( IN_RANGE ( regno , FIRST_SSE_REG , LAST_SSE_REG ) ) return regno - FIRST_SSE_REG ; if ( IN_RANGE ( regno , FIRST_MMX_REG , LAST_MMX_REG ) ) return regno - FIRST_MMX_REG ; if ( IN_RANGE ( regno , FIRST_REX_SSE_REG , LAST_REX_SSE_REG ) ) return regno - FIRST_REX_SSE_REG ;

if ( IN_RANGE ( regno , FIRST_REX_INT_REG , LAST_REX_INT_REG ) ) return regno - FIRST_REX_INT_REG ;


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


<s> break ; } } } EXECUTE_IF_SET_IN_BITMAP ( regs , <NUM_LIT> , id , bi ) { for ( df_ref def = DF_REG_DEF_CHAIN ( id ) ; def ; def = DF_REF_NEXT_REG ( def ) ) if ( bitmap_bit_p ( candidates , DF_REF_INSN_UID ( def ) ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , DF_REF_INSN_UID ( def ) ) ; bitmap_clear_bit ( candidates , DF_REF_INSN_UID ( def ) ) ; } } BITMAP_FREE ( regs ) ;


<s> if ( fmt [ i ] == 'e' ) XEXP ( x , i ) = replace_with_subreg ( XEXP ( x , i ) , reg , new_reg ) ; else if ( fmt [ i ] == 'E' ) for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) XVECEXP ( x , i , j ) = replace_with_subreg ( XVECEXP ( x , i , j ) , reg , new_reg ) ; } return x ;


<s> replace_with_subreg ( single_set ( insn ) , reg , new_reg ) ;


<s> chain_id = ++ max_id ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain_id ) ; bitmap_obstack_initialize ( NULL ) ; insns = BITMAP_ALLOC ( NULL ) ; defs = BITMAP_ALLOC ( NULL ) ; defs_conv = BITMAP_ALLOC ( NULL ) ; queue = NULL ;


<s> case MEM : return REG_P ( dst ) ; default : return false ; } if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ( GET_CODE ( src ) != AND || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != NOT || ! REG_P ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) return false ; if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode || GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode ) return false ;


<s> if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ( GET_CODE ( src ) != AND || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != NOT || ! REG_P ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) return false ; if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode || GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode ) return false ; return true ;


<s> SET_HARD_REG_BIT ( in , base + <NUM_LIT> ) ; SET_HARD_REG_BIT ( in , base + <NUM_LIT> ) ;


<s> case V8HImode : case V4SImode : case V2DImode : if ( TARGET_SSE2 ) return <NUM_LIT> ; case V32QImode : case V16HImode : case V8SImode : case V4DImode : if ( TARGET_AVX2 ) return <NUM_LIT> ;


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

if ( cum && cum -> warn_mmx && ! warnedmmx ) {


<s> return ( TARGET_SSE_MATH && flag_finite_math_only && ! flag_trapping_math && flag_unsafe_math_optimizations ) ;


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


<s> if ( TARGET_64BIT || TARGET_ALIGN_DOUBLE ) return computed ; if ( TARGET_IAMCU ) return iamcu_alignment ( type , computed ) ;

mode = TYPE_MODE ( strip_array_types ( type ) ) ;


<s> else if ( REG_P ( src ) && MEM_P ( dst ) ) gain += <NUM_LIT> * ix86_cost -> int_store [ <NUM_LIT> ] - ix86_cost -> sse_store [ <NUM_LIT> ] ; else if ( MEM_P ( src ) && REG_P ( dst ) ) gain += <NUM_LIT> * ix86_cost -> int_load [ <NUM_LIT> ] - ix86_cost -> sse_load [ <NUM_LIT> ] ; else if ( GET_CODE ( src ) == ASHIFT || GET_CODE ( src ) == LSHIFTRT ) { gain += ix86_cost -> shift_const ; if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) gain -= vector_const_cost ( XEXP ( src , <NUM_LIT> ) ) ; if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) && INTVAL ( XEXP ( src , <NUM_LIT> ) ) >= <NUM_LIT> ) gain -= COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( GET_CODE ( src ) == PLUS || GET_CODE ( src ) == MINUS || GET_CODE ( src ) == IOR || GET_CODE ( src ) == XOR || GET_CODE ( src ) == AND ) {


<s> emit_insn_before ( gen_move_insn ( subreg , CONSTM1_RTX ( V2DImode ) ) , insn ) ; src = gen_rtx_XOR ( V2DImode , src , subreg ) ; break ; case MEM : if ( ! REG_P ( dst ) ) convert_op ( & src , insn ) ; break ; case REG : if ( ! MEM_P ( dst ) ) convert_op ( & src , insn ) ; break ; case SUBREG : gcc_assert ( GET_MODE ( src ) == V2DImode ) ; break ; case COMPARE : src = SUBREG_REG ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ; gcc_assert ( ( REG_P ( src ) && GET_MODE ( src ) == DImode ) || ( SUBREG_P ( src ) && GET_MODE ( src ) == V2DImode ) ) ; if ( REG_P ( src ) ) subreg = gen_rtx_SUBREG ( V2DImode , src , <NUM_LIT> ) ; else subreg = copy_rtx_if_shared ( src ) ; emit_insn_before ( gen_vec_interleave_lowv2di ( copy_rtx_if_shared ( subreg ) , copy_rtx_if_shared ( subreg ) , copy_rtx_if_shared ( subreg ) ) , insn ) ; dst = gen_rtx_REG ( CCmode , FLAGS_REG ) ; src = gen_rtx_UNSPEC ( CCmode , gen_rtvec ( <NUM_LIT> , copy_rtx_if_shared ( src ) , copy_rtx_if_shared ( src ) ) , UNSPEC_PTEST ) ; break ; case CONST_INT : convert_op ( & src , insn ) ; break ; default :