<s> d . one_operand_p = false ; d . testing_p = false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] = i * <NUM_LIT> + odd ; if ( expand_vec_perm_1 ( & d ) ) return ;

expand_vec_perm_even_odd_1 ( & d , odd ) ;


<s> d . op1 = op1 ; d . vmode = GET_MODE ( targ ) ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . one_operand_p = false ; d . testing_p = false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] = i * <NUM_LIT> + odd ; if ( expand_vec_perm_1 ( & d ) ) return ; expand_vec_perm_even_odd_1 ( & d , odd ) ;


<s> mode0 = TYPE_MODE ( TREE_TYPE ( arg0 ) ) ; gcc_assert ( VECTOR_MODE_P ( mode0 ) ) ; op0 = force_reg ( mode0 , op0 ) ; if ( optimize || ! target || ! register_operand ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; ix86_expand_vector_extract ( true , target , op0 , elt ) ;


<s> for ( i = <NUM_LIT> ; i < n_elt ; ++ i ) { rtx x = expand_normal ( CALL_EXPR_ARG ( exp , i ) ) ; RTVEC_ELT ( v , i ) = gen_lowpart ( inner_mode , x ) ; } if ( ! target || ! register_operand ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; ix86_expand_vector_init ( true , target , gen_rtx_PARALLEL ( tmode , v ) ) ;


<s> case E_V16QImode : gen = gen_avx512vl_permvarv16qi ; break ; default : return false ; } if ( d -> testing_p ) return true ; target = d -> target ; op0 = d -> op0 ; for ( int i = <NUM_LIT> ; i < d -> nelt ; ++ i ) vec [ i ] = GEN_INT ( d -> perm [ i ] ) ; mask = gen_rtx_CONST_VECTOR ( maskmode , gen_rtvec_v ( d -> nelt , vec ) ) ; emit_insn ( gen ( target , op0 , force_reg ( maskmode , mask ) ) ) ; return true ;


<s> case E_V4SFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv4sf3 ; maskmode = V4SImode ; } break ; case E_V8SFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv8sf3 ; maskmode = V8SImode ; } break ; case E_V16SFmode : if ( TARGET_AVX512F ) { gen = gen_avx512f_vpermt2varv16sf3 ; maskmode = V16SImode ; } break ; case E_V2DImode : if ( TARGET_AVX512VL ) gen = gen_avx512vl_vpermt2varv2di3 ; break ; case E_V4DImode : if ( TARGET_AVX512VL ) gen = gen_avx512vl_vpermt2varv4di3 ; break ; case E_V8DImode : if ( TARGET_AVX512F ) gen = gen_avx512f_vpermt2varv8di3 ; break ; case E_V2DFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv2df3 ; maskmode = V2DImode ; } break ; case E_V4DFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv4df3 ; maskmode = V4DImode ; } break ; case E_V8DFmode : if ( TARGET_AVX512F ) { gen = gen_avx512f_vpermt2varv8df3 ; maskmode = V8DImode ; }


<s> static bool ix86_expand_vec_perm_vpermt2 ( rtx target , rtx mask , rtx op0 , rtx op1 , struct expand_vec_perm_d * d ) { machine_mode mode = GET_MODE ( d ? d -> op0 : op0 ) ; machine_mode maskmode = mode ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) = NULL ; switch ( mode ) { case E_V16QImode : if ( TARGET_AVX512VL && TARGET_AVX512VBMI ) gen = gen_avx512vl_vpermt2varv16qi3 ; break ; case E_V32QImode : if ( TARGET_AVX512VL && TARGET_AVX512VBMI ) gen = gen_avx512vl_vpermt2varv32qi3 ; break ; case E_V64QImode : if ( TARGET_AVX512VBMI ) gen = gen_avx512bw_vpermt2varv64qi3 ; break ; case E_V8HImode : if ( TARGET_AVX512VL && TARGET_AVX512BW ) gen = gen_avx512vl_vpermt2varv8hi3 ; break ; case E_V16HImode : if ( TARGET_AVX512VL && TARGET_AVX512BW ) gen = gen_avx512vl_vpermt2varv16hi3 ; break ; case E_V32HImode : if ( TARGET_AVX512BW ) gen = gen_avx512bw_vpermt2varv32hi3 ; break ; case E_V4SImode : if ( TARGET_AVX512VL ) gen = gen_avx512vl_vpermt2varv4si3 ; break ; case E_V8SImode : if ( TARGET_AVX512VL ) gen = gen_avx512vl_vpermt2varv8si3 ; break ; case E_V16SImode : if ( TARGET_AVX512F ) gen = gen_avx512f_vpermt2varv16si3 ; break ; case E_V4SFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv4sf3 ; maskmode = V4SImode ; } break ; case E_V8SFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv8sf3 ; maskmode = V8SImode ; } break ; case E_V16SFmode : if ( TARGET_AVX512F ) { gen = gen_avx512f_vpermt2varv16sf3 ; maskmode = V16SImode ; } break ; case E_V2DImode : if ( TARGET_AVX512VL ) gen = gen_avx512vl_vpermt2varv2di3 ; break ; case E_V4DImode : if ( TARGET_AVX512VL ) gen = gen_avx512vl_vpermt2varv4di3 ; break ; case E_V8DImode : if ( TARGET_AVX512F ) gen = gen_avx512f_vpermt2varv8di3 ; break ; case E_V2DFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv2df3 ; maskmode = V2DImode ; } break ; case E_V4DFmode : if ( TARGET_AVX512VL ) { gen = gen_avx512vl_vpermt2varv4df3 ; maskmode = V4DImode ; } break ; case E_V8DFmode : if ( TARGET_AVX512F ) { gen = gen_avx512f_vpermt2varv8df3 ; maskmode = V8DImode ; } break ; default : break ; } if ( gen == NULL ) return false ; if ( d ) { rtx vec [ <NUM_LIT> ] ;


<s> machine_mode tmode , mode1 ; tree arg0 , arg1 , arg2 ; int elt ; rtx op0 , op1 , target ; arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; arg1 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; arg2 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; tmode = TYPE_MODE ( TREE_TYPE ( arg0 ) ) ; mode1 = TYPE_MODE ( TREE_TYPE ( TREE_TYPE ( arg0 ) ) ) ; gcc_assert ( VECTOR_MODE_P ( tmode ) ) ; op0 = expand_expr ( arg0 , NULL_RTX , tmode , EXPAND_NORMAL ) ; op1 = expand_expr ( arg1 , NULL_RTX , mode1 , EXPAND_NORMAL ) ; elt = get_element_number ( TREE_TYPE ( arg0 ) , arg2 ) ; if ( GET_MODE ( op1 ) != mode1 && GET_MODE ( op1 ) != VOIDmode ) op1 = convert_modes ( mode1 , GET_MODE ( op1 ) , op1 , true ) ; op0 = force_reg ( tmode , op0 ) ; op1 = force_reg ( mode1 , op1 ) ; target = gen_reg_rtx ( tmode ) ; emit_move_insn ( target , op0 ) ; ix86_expand_vector_set ( true , target , op1 , elt ) ; return target ;


<s> tree arg0 , arg1 , arg2 ; int elt ; rtx op0 , op1 , target ; arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; arg1 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; arg2 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; tmode = TYPE_MODE ( TREE_TYPE ( arg0 ) ) ;


<s> rtx ( * gen_shift ) ( rtx , rtx , rtx ) ; rtx ( * gen_and ) ( rtx , rtx , rtx ) ; rtx ( * gen_xor ) ( rtx , rtx , rtx ) ; rtx ( * gen_sub ) ( rtx , rtx , rtx ) ; if ( ! CONST_INT_P ( op2 ) ) return false ; qimode = GET_MODE ( dest ) ; shift_amount = INTVAL ( op2 ) ; if ( shift_amount > <NUM_LIT> ) return false ; gcc_assert ( code == ASHIFT || code == ASHIFTRT || code == LSHIFTRT ) ; xor_constant = <NUM_LIT> << ( <NUM_LIT> - shift_amount - <NUM_LIT> ) ; and_constant = ( code == ASHIFT ? <NUM_LIT> - ( <NUM_LIT> << shift_amount ) : ( <NUM_LIT> << ( <NUM_LIT> - shift_amount ) ) - <NUM_LIT> ) ; switch ( qimode ) { case V16QImode : himode = V8HImode ; gen_shift = ( ( code == ASHIFT ) ? gen_ashlv8hi3 : ( code == ASHIFTRT ) ? gen_ashrv8hi3 : gen_lshrv8hi3 ) ; gen_and = gen_andv16qi3 ; gen_xor = gen_xorv16qi3 ; gen_sub = gen_subv16qi3 ; break ; case V32QImode : himode = V16HImode ; gen_shift = ( ( code == ASHIFT ) ? gen_ashlv16hi3 : ( code == ASHIFTRT ) ? gen_ashrv16hi3 : gen_lshrv16hi3 ) ; gen_and = gen_andv32qi3 ; gen_xor = gen_xorv32qi3 ; gen_sub = gen_subv32qi3 ; break ; case V64QImode :


<s> mode = GET_MODE ( dest ) ; if ( mode == HFmode ) vmode = V8HFmode ; else if ( mode == SFmode ) vmode = V4SFmode ; else if ( mode == DFmode ) vmode = V2DFmode ; else gcc_unreachable ( ) ; temp = gen_reg_rtx ( vmode ) ; mask = ix86_build_signbit_mask ( vmode , <NUM_LIT> , <NUM_LIT> ) ; op1 = lowpart_subreg ( vmode , force_reg ( mode , op1 ) , mode ) ; x = gen_rtx_AND ( vmode , op1 , mask ) ; emit_insn ( gen_rtx_SET ( temp , x ) ) ; op0 = lowpart_subreg ( vmode , force_reg ( mode , op0 ) , mode ) ; x = gen_rtx_XOR ( vmode , temp , op0 ) ; vdest = lowpart_subreg ( vmode , dest , mode ) ;

if ( vdest == NULL_RTX ) vdest = gen_reg_rtx ( vmode ) ;


<s> op1 = operands [ <NUM_LIT> ] ; mode = GET_MODE ( dest ) ; if ( mode == HFmode ) vmode = V8HFmode ; else if ( mode == SFmode ) vmode = V4SFmode ; else if ( mode == DFmode ) vmode = V2DFmode ; else gcc_unreachable ( ) ; temp = gen_reg_rtx ( vmode ) ; mask = ix86_build_signbit_mask ( vmode , <NUM_LIT> , <NUM_LIT> ) ;

op1 = lowpart_subreg ( vmode , force_reg ( mode , op1 ) , mode ) ;


<s> rtx constant = get_pool_constant ( XEXP ( mem , <NUM_LIT> ) ) ; if ( GET_CODE ( constant ) != CONST_VECTOR ) return false ; if ( GET_MODE ( constant ) != mode ) { constant = simplify_subreg ( mode , constant , GET_MODE ( constant ) , <NUM_LIT> ) ; if ( constant == nullptr || GET_CODE ( constant ) != CONST_VECTOR ) return false ; } for ( int i = <NUM_LIT> ; i != nelt ; i ++ ) perm [ i ] = UINTVAL ( XVECEXP ( constant , <NUM_LIT> , i ) ) ; return true ;


<s> int nelt = GET_MODE_NUNITS ( mode ) ; if ( ! INTEGRAL_MODE_P ( mode ) ) return false ; if ( ! ( MEM_P ( mem ) ) || ! SYMBOL_REF_P ( XEXP ( mem , <NUM_LIT> ) ) || ! CONSTANT_POOL_ADDRESS_P ( XEXP ( mem , <NUM_LIT> ) ) ) return false ; rtx constant = get_pool_constant ( XEXP ( mem , <NUM_LIT> ) ) ; if ( GET_CODE ( constant ) != CONST_VECTOR ) return false ; if ( GET_MODE ( constant ) != mode ) { constant = simplify_subreg ( mode , constant , GET_MODE ( constant ) , <NUM_LIT> ) ; if ( constant == nullptr || GET_CODE ( constant ) != CONST_VECTOR ) return false ; }

for ( int i = <NUM_LIT> ; i != nelt ; i ++ ) perm [ i ] = UINTVAL ( XVECEXP ( constant , <NUM_LIT> , i ) ) ;


<s> else if ( rtx_equal_p ( dst , src1 ) ) src2 = force_reg ( mode , src2 ) ; else src1 = force_reg ( mode , src1 ) ; } if ( MEM_P ( dst ) && ! rtx_equal_p ( dst , src1 ) ) dst = gen_reg_rtx ( mode ) ; if ( CONSTANT_P ( src1 ) ) src1 = force_reg ( mode , src1 ) ; if ( MEM_P ( src1 ) && ! rtx_equal_p ( dst , src1 ) ) src1 = force_reg ( mode , src1 ) ; if ( code == PLUS && GET_MODE_CLASS ( mode ) == MODE_INT && MEM_P ( src2 ) ) src2 = force_reg ( mode , src2 ) ; operands [ <NUM_LIT> ] = src1 ; operands [ <NUM_LIT> ] = src2 ; return dst ;


<s> rtx dst = ix86_fixup_binary_operands ( code , mode , operands ) ; gcc_assert ( dst == operands [ <NUM_LIT> ] ) ;


<s> void ix86_fixup_binary_operands_no_copy ( enum rtx_code code , machine_mode mode , rtx operands [ ] ) { rtx dst = ix86_fixup_binary_operands ( code , mode , operands ) ; gcc_assert ( dst == operands [ <NUM_LIT> ] ) ;


<s> case UNLE : return <NUM_LIT> ; case UNLT : return <NUM_LIT> ; case UNGE : return <NUM_LIT> ; case UNGT : return <NUM_LIT> ; case UNEQ : return <NUM_LIT> ; case LTGT : return <NUM_LIT> ; case ORDERED : return <NUM_LIT> ; case UNORDERED : return <NUM_LIT> ; default : gcc_unreachable ( ) ; }


<s> case UNLE : case UNLT : case LTGT : case GT : case GE : case UNORDERED : case ORDERED : case UNEQ : arith_cost = <NUM_LIT> ; break ; case LT : case NE : case EQ : case UNGE : arith_cost = TARGET_IEEE_FP ? <NUM_LIT> : <NUM_LIT> ; break ; case LE : case UNGT : arith_cost = TARGET_IEEE_FP ? <NUM_LIT> : <NUM_LIT> ; break ; default : gcc_unreachable ( ) ;


<s> rtx TWO52 ; fmt = REAL_MODE_FORMAT ( mode ) ; real_2expN ( & TWO52r , fmt -> p - <NUM_LIT> , mode ) ; TWO52 = const_double_from_real_value ( TWO52r , mode ) ;


<s> real_2expN ( & TWO52r , fmt -> p - <NUM_LIT> , mode ) ; TWO52 = const_double_from_real_value ( TWO52r , mode ) ;


<s> return <NUM_LIT> ; case NE : return <NUM_LIT> ; case GE : case GEU : return <NUM_LIT> ; case GT :


<s> rtx dest = lowpart_subreg ( V4SImode , op , GET_MODE ( op ) ) ; op = gen_rtx_VEC_SELECT ( V4SImode , dest , mask ) ; rtx insn = gen_rtx_SET ( dest , op ) ;


<s> if ( JUMP_P ( insn ) && ! flag_cet_switch ) { rtx target = JUMP_LABEL ( insn ) ; if ( target == NULL_RTX || ANY_RETURN_P ( target ) ) return false ; rtx_insn * label = as_a < rtx_insn * > ( target ) ; rtx_insn * table = next_insn ( label ) ; if ( table == NULL_RTX || ! JUMP_TABLE_DATA_P ( table ) ) return false ; else return true ; }


<s> rtx addr = XEXP ( call , <NUM_LIT> ) ; if ( MEM_P ( addr ) && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == SYMBOL_REF ) return false ; else return find_reg_note ( insn , REG_CALL_NOCF_CHECK , <NUM_LIT> ) ; } if ( JUMP_P ( insn ) && ! flag_cet_switch ) { rtx target = JUMP_LABEL ( insn ) ; if ( target == NULL_RTX || ANY_RETURN_P ( target ) ) return false ; rtx_insn * label = as_a < rtx_insn * > ( target ) ; rtx_insn * table = next_insn ( label ) ; if ( table == NULL_RTX || ! JUMP_TABLE_DATA_P ( table ) ) return false ; else return true ;


<s> if ( tmp == <NUM_LIT> ) op1 = validize_mem ( force_const_mem ( op_mode , op1 ) ) ; else if ( tmp == <NUM_LIT> ) { if ( TARGET_CMOVE ) op1 = force_reg ( op_mode , op1 ) ; } else op1 = force_reg ( op_mode , op1 ) ; } } if ( ix86_fp_comparison_cost ( code ) > ix86_fp_comparison_cost ( swap_condition ( code ) ) && ( REG_P ( op1 ) || can_create_pseudo_p ( ) ) ) { std :: swap ( op0 , op1 ) ; code = swap_condition ( code ) ; if ( ! REG_P ( op0 ) ) op0 = force_reg ( op_mode , op0 ) ; } * pop0 = op0 ; * pop1 = op1 ;


<s> case LT : case LE : case UNGT : case UNGE : break ; case EQ : case NE : case UNORDERED : case ORDERED : if ( TARGET_AVX ) break ; if ( ! dest || ! rtx_equal_p ( dest , * pop1 ) ) break ;


<s> case UNGT : case UNGE : break ; case EQ : case NE : case UNORDERED : case ORDERED : if ( TARGET_AVX ) break ; if ( ! dest || ! rtx_equal_p ( dest , * pop1 ) ) break ; case GE : case GT : case UNLE : case UNLT : std :: swap ( * pop0 , * pop1 ) ; code = swap_condition ( code ) ; break ; default :


<s> 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 ) { ix86_expand_clear ( scratch ) ; emit_insn ( gen_x86_shift_adj_1 ( half_mode , high [ <NUM_LIT> ] , low [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , scratch ) ) ; }

else emit_insn ( gen_x86_shift_adj_2 ( half_mode , high [ <NUM_LIT> ] , low [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> 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 { 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 ) { gen_lshr3 = gen_lshrsi3 ; gen_and3 = gen_andsi3 ; gen_xor3 = gen_xorsi3 ; bits = <NUM_LIT> ; } else { 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 ) ) ) ; 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> ] ) ) ;


<s> emit_insn ( gen_ashr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( half_width - <NUM_LIT> ) ) ) ; if ( count > half_width ) emit_insn ( gen_ashr3 ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , GEN_INT ( count - half_width ) ) ) ; } else { gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_shrd ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; emit_insn ( gen_ashr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; } } else { machine_mode half_mode ; gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; 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 ) ;


<s> } emit_move_insn ( large , two31 ) ; emit_move_insn ( zero_or_two31 , MEM_P ( two31 ) ? large : two31 ) ; x = gen_rtx_fmt_ee ( LE , vecmode , large , value ) ; emit_insn ( gen_rtx_SET ( large , x ) ) ; x = gen_rtx_AND ( vecmode , zero_or_two31 , large ) ; emit_insn ( gen_rtx_SET ( zero_or_two31 , x ) ) ; x = gen_rtx_MINUS ( vecmode , value , zero_or_two31 ) ; emit_insn ( gen_rtx_SET ( value , x ) ) ; large = gen_rtx_REG ( V4SImode , REGNO ( large ) ) ; emit_insn ( gen_ashlv4si3 ( large , large , GEN_INT ( <NUM_LIT> ) ) ) ; x = gen_rtx_REG ( V4SImode , REGNO ( value ) ) ; if ( vecmode == V4SFmode ) emit_insn ( gen_fix_truncv4sfv4si2 ( x , value ) ) ;

else emit_insn ( gen_sse2_cvttpd2dq ( x , value ) ) ;


<s> input = gen_rtx_REG ( vecmode , REGNO ( input ) ) ; emit_move_insn ( value , CONST0_RTX ( vecmode ) ) ; if ( vecmode == V4SFmode ) emit_insn ( gen_sse_movss ( value , value , input ) ) ; else emit_insn ( gen_sse2_movsd ( value , value , input ) ) ; } emit_move_insn ( large , two31 ) ; emit_move_insn ( zero_or_two31 , MEM_P ( two31 ) ? large : two31 ) ; x = gen_rtx_fmt_ee ( LE , vecmode , large , value ) ; emit_insn ( gen_rtx_SET ( large , x ) ) ; x = gen_rtx_AND ( vecmode , zero_or_two31 , large ) ;

emit_insn ( gen_rtx_SET ( zero_or_two31 , x ) ) ;


<s> mode = GET_MODE ( dest ) ; vmode = GET_MODE ( mask ) ; dest = lowpart_subreg ( vmode , dest , mode ) ; 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> x = gen_rtx_AND ( vmode , scratch , mask ) ; emit_insn ( gen_rtx_SET ( scratch , x ) ) ; dest = mask ; op0 = lowpart_subreg ( vmode , op0 , mode ) ; x = gen_rtx_NOT ( vmode , dest ) ; x = gen_rtx_AND ( vmode , x , op0 ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; } else { if ( REGNO ( op1 ) == REGNO ( scratch ) ) { x = gen_rtx_AND ( vmode , scratch , mask ) ; } else { gcc_assert ( REGNO ( mask ) == REGNO ( scratch ) ) ; op1 = lowpart_subreg ( vmode , op1 , mode ) ; x = gen_rtx_AND ( vmode , scratch , op1 ) ; } emit_insn ( gen_rtx_SET ( scratch , x ) ) ; if ( REGNO ( op0 ) == REGNO ( dest ) ) { dest = lowpart_subreg ( vmode , op0 , mode ) ; x = gen_rtx_AND ( vmode , dest , nmask ) ; }


<s> regno0 = true_regnum ( target ) ; regno1 = INVALID_REGNUM ; regno2 = INVALID_REGNUM ; if ( parts . base ) { parts . base = gen_lowpart ( mode , parts . base ) ; regno1 = true_regnum ( parts . base ) ; } if ( parts . index ) { parts . index = gen_lowpart ( mode , parts . index ) ; regno2 = true_regnum ( parts . index ) ; } if ( parts . disp ) parts . disp = gen_lowpart ( mode , parts . disp ) ; if ( parts . scale > <NUM_LIT> ) { if ( regno1 == regno0 ) { gcc_assert ( regno2 != regno0 ) ; for ( adds = parts . scale ; adds > <NUM_LIT> ; adds -- ) ix86_emit_binop ( PLUS , mode , target , parts . index ) ; } else { if ( regno0 != regno2 ) emit_insn ( gen_rtx_SET ( target , parts . index ) ) ; ix86_emit_binop ( MULT , mode , target , GEN_INT ( parts . scale ) ) ; if ( parts . base ) ix86_emit_binop ( PLUS , mode , target , parts . base ) ; if ( parts . disp && parts . disp != const0_rtx ) ix86_emit_binop ( PLUS , mode , target , parts . disp ) ; } } else if ( ! parts . base && ! parts . index ) { gcc_assert ( parts . disp ) ; emit_insn ( gen_rtx_SET ( target , parts . disp ) ) ; } else { if ( ! parts . base ) { if ( regno0 != regno2 ) emit_insn ( gen_rtx_SET ( target , parts . index ) ) ; } else if ( ! parts . index ) { if ( regno0 != regno1 ) emit_insn ( gen_rtx_SET ( target , parts . base ) ) ; } else { if ( regno0 == regno1 ) tmp = parts . index ; else if ( regno0 == regno2 ) tmp = parts . base ; else { rtx tmp1 ; if ( find_nearest_reg_def ( insn , regno1 , regno2 ) ) tmp = parts . index , tmp1 = parts . base ; else tmp = parts . base , tmp1 = parts . index ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; if ( parts . disp && parts . disp != const0_rtx ) ix86_emit_binop ( PLUS , mode , target , parts . disp ) ; ix86_emit_binop ( PLUS , mode , target , tmp1 ) ; return ;


<s> else { machine_mode half_mode ; gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; 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 ) ; half_mode = mode == DImode ? SImode : DImode ; emit_insn ( gen_shrd ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_lshr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; if ( TARGET_CMOVE && scratch ) { ix86_expand_clear ( scratch ) ;

emit_insn ( gen_x86_shift_adj_1 ( half_mode , low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , scratch ) ) ;


<s> if ( CONST_INT_P ( operands [ <NUM_LIT> ] ) ) { split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; count = INTVAL ( operands [ <NUM_LIT> ] ) & ( GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ; if ( count >= half_width ) { emit_move_insn ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] ) ; ix86_expand_clear ( high [ <NUM_LIT> ] ) ; if ( count > half_width ) emit_insn ( gen_lshr3 ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , GEN_INT ( count - half_width ) ) ) ; } else { gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_shrd ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; emit_insn ( gen_lshr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; } } else { machine_mode half_mode ; gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> machine_mode inner_dmode = GET_MODE_INNER ( dmode ) ; machine_mode inner_smode = GET_MODE_INNER ( smode ) ; int nunits = <NUM_LIT> / GET_MODE_SIZE ( inner_dmode ) ; machine_mode sse_dmode = mode_for_vector ( GET_MODE_INNER ( dmode ) , nunits ) . require ( ) ; machine_mode sse_half_dmode = mode_for_vector ( GET_MODE_INNER ( dmode ) , nunits / <NUM_LIT> ) . require ( ) ; nunits = <NUM_LIT> / GET_MODE_SIZE ( inner_smode ) ; machine_mode sse_smode = mode_for_vector ( GET_MODE_INNER ( smode ) , nunits ) . require ( ) ;

rtx dest = lowpart_subreg ( sse_dmode , op0 , GET_MODE ( op0 ) ) ;


<s> machine_mode dmode = GET_MODE ( op0 ) ; machine_mode smode = GET_MODE ( op1 ) ; machine_mode inner_dmode = GET_MODE_INNER ( dmode ) ; machine_mode inner_smode = GET_MODE_INNER ( smode ) ; int nunits = <NUM_LIT> / GET_MODE_SIZE ( inner_dmode ) ; machine_mode sse_dmode = mode_for_vector ( GET_MODE_INNER ( dmode ) , nunits ) . require ( ) ; machine_mode sse_half_dmode = mode_for_vector ( GET_MODE_INNER ( dmode ) , nunits / <NUM_LIT> ) . require ( ) ; nunits = <NUM_LIT> / GET_MODE_SIZE ( inner_smode ) ; machine_mode sse_smode = mode_for_vector ( GET_MODE_INNER ( smode ) , nunits ) . require ( ) ; rtx dest = lowpart_subreg ( sse_dmode , op0 , GET_MODE ( op0 ) ) ; op1 = lowpart_subreg ( sse_smode , op1 , GET_MODE ( op1 ) ) ;


<s> default : gcc_unreachable ( ) ; } rtx dest = lowpart_subreg ( sse_mode , op0 , GET_MODE ( op0 ) ) ; op1 = lowpart_subreg ( sse_mode , op1 , GET_MODE ( op1 ) ) ; op2 = lowpart_subreg ( sse_mode , op2 , GET_MODE ( op2 ) ) ; op1 = gen_rtx_VEC_CONCAT ( double_sse_mode , op1 , op2 ) ; op2 = gen_rtx_VEC_SELECT ( sse_mode , op1 , mask ) ; rtx insn = gen_rtx_SET ( dest , op2 ) ; emit_insn ( insn ) ; if ( high_p ) { if ( sse_mode == V4SFmode ) { mask = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ; op2 = gen_rtx_VEC_CONCAT ( V8SFmode , dest , dest ) ; op1 = gen_rtx_VEC_SELECT ( V4SFmode , op2 , mask ) ; } else { int sz = GET_MODE_SIZE ( mode ) ;

if ( sz == <NUM_LIT> ) mask = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ;


<s> case E_V16SImode : case E_V8SImode : return V4SImode ; case E_V32HImode : case E_V16HImode : return V8HImode ; case E_V64QImode : case E_V32QImode : return V16QImode ;


<s> x = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , popc ) ; x = gen_rtx_SET ( stack_pointer_rtx , x ) ; insn = emit_insn ( x ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , x ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

emit_jump_insn ( gen_simple_return_indirect_internal ( ecx ) ) ;


<s> else if ( offsettable_memref_p ( operand ) ) { operand = adjust_address ( operand , SImode , <NUM_LIT> ) ; parts [ <NUM_LIT> ] = operand ; for ( i = <NUM_LIT> ; i < size ; i ++ ) parts [ i ] = adjust_address ( operand , SImode , <NUM_LIT> * i ) ; } else if ( CONST_DOUBLE_P ( operand ) ) { const REAL_VALUE_TYPE * r ; long l [ <NUM_LIT> ] ; r = CONST_DOUBLE_REAL_VALUE ( operand ) ; switch ( mode ) { case E_TFmode : real_to_target ( l , r , mode ) ; parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; break ; case E_XFmode : real_to_target ( l , r , mode ) ; parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; break ; case E_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_C ( <NUM_LIT> ) ) | ( ( l [ <NUM_LIT> ] & HOST_WIDE_INT_C ( <NUM_LIT> ) ) << <NUM_LIT> ) , DImode ) ;


<s> void ix86_split_xorsign ( rtx operands [ ] ) { machine_mode mode , vmode ; rtx dest , op0 , mask , x ; dest = operands [ <NUM_LIT> ] ;


<s> if ( mode == SFmode ) vmode = V4SFmode ; else if ( mode == DFmode ) vmode = V2DFmode ; else vmode = mode ; mask = ix86_build_signbit_mask ( vmode , VECTOR_MODE_P ( mode ) , false ) ; if ( ! VECTOR_MODE_P ( mode ) ) { rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) ) ; tmp = gen_rtx_VEC_SELECT ( mode , mask , tmp ) ;


<s> if ( rtx_equal_p ( dst , src1 ) ) return false ; if ( rtx_equal_p ( dst , src2 ) ) return true ; if ( immediate_operand ( src2 , mode ) ) return false ; if ( immediate_operand ( src1 , mode ) ) return true ; if ( MEM_P ( src2 ) ) return false ;


<s> case LT : case LE : case GT : case GE : case LTGT : return false ; case EQ : case NE : case UNORDERED : case ORDERED : case UNLT : case UNLE : case UNGT : case UNGE : case UNEQ : return true ; default :


<s> if ( op_false == CONST0_RTX ( mode ) || op_true == CONST0_RTX ( mode ) || ( INTEGRAL_MODE_P ( mode ) && ( op_true == CONSTM1_RTX ( mode ) || op_false == CONSTM1_RTX ( mode ) ) ) ) return false ;


<s> static bool ix86_use_mask_cmp_p ( machine_mode mode , machine_mode cmp_mode , rtx op_true , rtx op_false ) { int vector_size = GET_MODE_SIZE ( mode ) ; if ( cmp_mode == HFmode ) return true ; else if ( vector_size < <NUM_LIT> ) return false ; else if ( vector_size == <NUM_LIT> ) return true ; else if ( GET_MODE_INNER ( cmp_mode ) == HFmode ) return true ; gcc_assert ( ! op_true == ! op_false ) ; if ( ! op_true || ! ix86_valid_mask_cmp_mode ( cmp_mode ) ) return false ; if ( op_false == CONST0_RTX ( mode ) || op_true == CONST0_RTX ( mode ) || ( INTEGRAL_MODE_P ( mode ) && ( op_true == CONSTM1_RTX ( mode ) || op_false == CONSTM1_RTX ( mode ) ) ) ) return false ; return true ;


<s> static bool ix86_valid_mask_cmp_mode ( machine_mode mode ) { if ( TARGET_XOP && ! TARGET_AVX512F ) return false ;

if ( TARGET_AVX512FP16 && mode == HFmode ) return true ;


<s> if ( TARGET_64BIT && ( size_needed > <NUM_LIT> || ( desired_align > align && desired_align > <NUM_LIT> ) ) ) promoted_val = promote_duplicated_reg ( DImode , val ) ; else if ( size_needed > <NUM_LIT> || ( desired_align > align && desired_align > <NUM_LIT> ) ) promoted_val = promote_duplicated_reg ( SImode , val ) ; else if ( size_needed > <NUM_LIT> || ( desired_align > align && desired_align > <NUM_LIT> ) ) promoted_val = promote_duplicated_reg ( HImode , val ) ; else promoted_val = val ; return promoted_val ;


<s> static rtx safe_vector_operand ( rtx x , machine_mode mode ) { if ( x == const0_rtx ) x = CONST0_RTX ( mode ) ;


<s> if ( x == const0_rtx ) x = CONST0_RTX ( mode ) ; return x ;


sc = expand_simple_binop ( GET_MODE ( countreg ) , LSHIFTRT , countreg , GEN_INT ( exact_log2 ( scale ) ) , NULL , <NUM_LIT> , OPTAB_DIRECT ) ;


<s> half_mode = HImode ; break ; case E_P2QImode : half_mode = QImode ; break ; default : gcc_unreachable ( ) ; } byte = GET_MODE_SIZE ( half_mode ) ; while ( num -- ) { rtx op = operands [ num ] ; if ( MEM_P ( op ) ) { if ( mem_op && rtx_equal_p ( op , mem_op ) ) { lo_half [ num ] = lo_half [ mem_num ] ; hi_half [ num ] = hi_half [ mem_num ] ; } else { mem_op = op ; mem_num = num ; lo_half [ num ] = adjust_address ( op , half_mode , <NUM_LIT> ) ;

hi_half [ num ] = adjust_address ( op , half_mode , byte ) ;


<s> if ( GET_MODE_CLASS ( vmode ) != MODE_VECTOR_INT || GET_MODE_CLASS ( d -> vmode ) != MODE_VECTOR_INT || GET_MODE_SIZE ( vmode ) != GET_MODE_SIZE ( d -> vmode ) ) return false ; if ( GET_MODE_NUNITS ( vmode ) >= d -> nelt ) return true ; chunk = d -> nelt / GET_MODE_NUNITS ( vmode ) ; for ( i = <NUM_LIT> ; i < d -> nelt ; i += chunk ) if ( d -> perm [ i ] & ( chunk - <NUM_LIT> ) ) return false ; else for ( j = <NUM_LIT> ; j < chunk ; ++ j ) if ( d -> perm [ i ] + j != d -> perm [ i + j ] ) return false ;


<s> rtx def_set = single_set ( insn ) ; if ( def_set && REG_P ( SET_DEST ( def_set ) ) && ! HARD_REGISTER_P ( SET_DEST ( def_set ) ) ) bitmap_set_bit ( defs , REGNO ( SET_DEST ( def_set ) ) ) ; df_ref ref ; for ( ref = DF_INSN_UID_DEFS ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! HARD_REGISTER_P ( DF_REF_REG ( ref ) ) ) if ( ! analyze_register_chain ( candidates , ref , disallowed ) ) return false ; if ( def_set && GET_CODE ( SET_SRC ( def_set ) ) == VEC_SELECT ) return true ; for ( ref = DF_INSN_UID_USES ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! DF_REF_REG_MEM_P ( ref ) ) if ( ! analyze_register_chain ( candidates , ref , disallowed ) ) return false ;


<s> void scalar_chain :: add_to_queue ( unsigned insn_uid ) {

if ( ! bitmap_set_bit ( queue , insn_uid ) ) return ;


<s> bitmap_clear_bit ( candidates , insn_uid ) ; if ( ! add_insn ( candidates , insn_uid , disallowed ) ) { bitmap_ior_into ( disallowed , insns ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain_id ) ; BITMAP_FREE ( queue ) ; return false ; } } if ( dump_file ) { fprintf ( dump_file , <STR_LIT> , chain_id ) ;


<s> opt_pass * clone ( ) final override {


<s> if ( MEM_P ( dst ) ) igain = - COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case AND : case XOR : case IOR : if ( ! MEM_P ( dst ) ) igain = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ASHIFT : case LSHIFTRT : op1val = INTVAL ( XEXP ( src , <NUM_LIT> ) ) ; if ( optimize_insn_for_size_p ( ) ) { if ( op1val == <NUM_LIT> || op1val == <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val >= <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val == <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else scost = COSTS_N_BYTES ( <NUM_LIT> ) ; if ( ( op1val & <NUM_LIT> ) == <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val > <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ; else vcost = TARGET_AVX ? COSTS_N_BYTES ( <NUM_LIT> ) : COSTS_N_BYTES ( <NUM_LIT> ) ; } else { scost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( ( op1val & <NUM_LIT> ) == <NUM_LIT> ) vcost = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( op1val > <NUM_LIT> ) vcost = COSTS_N_INSNS ( <NUM_LIT> ) ; else vcost = TARGET_AVX ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; } igain = scost - vcost ; break ; case ASHIFTRT : op1val = INTVAL ( XEXP ( src , <NUM_LIT> ) ) ; if ( optimize_insn_for_size_p ( ) ) { if ( op1val == <NUM_LIT> || op1val == <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val == <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val == <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val >= <NUM_LIT> ) scost = COSTS_N_BYTES ( <NUM_LIT> ) ; else scost = COSTS_N_BYTES ( <NUM_LIT> ) ; if ( op1val == <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val == <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val == <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( op1val >= <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ; else if ( TARGET_AVX2 && op1val == <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ;

else if ( TARGET_SSE4_1 && op1val == <NUM_LIT> ) vcost = COSTS_N_BYTES ( <NUM_LIT> ) ;


<s> if ( INSN_P ( insn ) ) replace_constant_pool_with_broadcast ( insn ) ; }


<s> timevar_push ( TV_MACH_DEP ) ; rtx_insn * insn ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) {

if ( INSN_P ( insn ) ) replace_constant_pool_with_broadcast ( insn ) ;


<s> if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain_id ) ; convert_registers ( ) ; EXECUTE_IF_SET_IN_BITMAP ( insns , <NUM_LIT> , id , bi ) { rtx_insn * insn = DF_INSN_UID_GET ( id ) -> insn ;


<s> EXECUTE_IF_SET_IN_BITMAP ( insns , <NUM_LIT> , id , bi ) { rtx_insn * insn = DF_INSN_UID_GET ( id ) -> insn ; convert_insn_common ( insn ) ; convert_insn ( insn ) ; converted_insns ++ ;


<s> gcc_assert ( GET_CODE ( src ) == COMPARE ) ; if ( GET_CODE ( dst ) != REG || REGNO ( dst ) != FLAGS_REG || GET_MODE ( dst ) != CCZmode ) return false ; rtx op1 = XEXP ( src , <NUM_LIT> ) ; rtx op2 = XEXP ( src , <NUM_LIT> ) ; if ( ( CONST_SCALAR_INT_P ( op1 ) || ( ( REG_P ( op1 ) || MEM_P ( op1 ) ) && GET_MODE ( op1 ) == mode ) ) && ( CONST_SCALAR_INT_P ( op2 ) || ( ( REG_P ( op2 ) || MEM_P ( op2 ) ) && GET_MODE ( op2 ) == mode ) ) ) return true ; if ( op2 == const0_rtx && GET_CODE ( op1 ) == AND && REG_P ( XEXP ( op1 , <NUM_LIT> ) ) ) { rtx op12 = XEXP ( op1 , <NUM_LIT> ) ; return GET_MODE ( XEXP ( op1 , <NUM_LIT> ) ) == TImode && ( CONST_SCALAR_INT_P ( op12 ) || ( ( REG_P ( op12 ) || MEM_P ( op12 ) ) && GET_MODE ( op12 ) == TImode ) ) ; } if ( op2 == const0_rtx && GET_CODE ( op1 ) == AND && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == NOT ) { rtx op11 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; rtx op12 = XEXP ( op1 , <NUM_LIT> ) ; return ( REG_P ( op11 ) || MEM_P ( op11 ) ) && ( REG_P ( op12 ) || MEM_P ( op12 ) ) && GET_MODE ( op11 ) == mode && GET_MODE ( op12 ) == mode ;


<s> if ( ( CONST_SCALAR_INT_P ( op1 ) || ( ( REG_P ( op1 ) || MEM_P ( op1 ) ) && GET_MODE ( op1 ) == mode ) ) && ( CONST_SCALAR_INT_P ( op2 ) || ( ( REG_P ( op2 ) || MEM_P ( op2 ) ) && GET_MODE ( op2 ) == mode ) ) ) return true ; if ( op2 == const0_rtx && GET_CODE ( op1 ) == AND && REG_P ( XEXP ( op1 , <NUM_LIT> ) ) ) { rtx op12 = XEXP ( op1 , <NUM_LIT> ) ; return GET_MODE ( XEXP ( op1 , <NUM_LIT> ) ) == TImode && ( CONST_SCALAR_INT_P ( op12 ) || ( ( REG_P ( op12 ) || MEM_P ( op12 ) ) && GET_MODE ( op12 ) == TImode ) ) ; } if ( op2 == const0_rtx && GET_CODE ( op1 ) == AND && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == NOT ) { rtx op11 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; rtx op12 = XEXP ( op1 , <NUM_LIT> ) ; return ( REG_P ( op11 ) || MEM_P ( op11 ) ) && ( REG_P ( op12 ) || MEM_P ( op12 ) ) && GET_MODE ( op11 ) == mode && GET_MODE ( op12 ) == mode ; } return false ;


<s> convert_op ( & op11 , insn ) ; convert_op ( & op12 , insn ) ; if ( ! REG_P ( op11 ) ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( tmp , op11 ) , insn ) ; op11 = tmp ; } return gen_rtx_UNSPEC ( CCmode , gen_rtvec ( <NUM_LIT> , op11 , op12 ) , UNSPEC_PTEST ) ; } else { convert_op ( & op1 , insn ) ; src = op1 ; } if ( ! REG_P ( src ) ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( tmp , src ) , insn ) ; src = tmp ; } if ( vmode == V2DImode ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_vec_interleave_lowv2di ( tmp , src , src ) , insn ) ; src = tmp ; } else if ( vmode == V4SImode ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_sse2_pshufd ( tmp , src , const0_rtx ) , insn ) ; src = tmp ; }

return gen_rtx_UNSPEC ( CCmode , gen_rtvec ( <NUM_LIT> , src , src ) , UNSPEC_PTEST ) ;


<s> rtx src , tmp ; if ( op2 != const0_rtx ) { convert_op ( & op1 , insn ) ; convert_op ( & op2 , insn ) ; if ( MEM_P ( op1 ) && MEM_P ( op2 ) ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( tmp , op1 ) , insn ) ; src = tmp ; } else src = op1 ; src = gen_rtx_XOR ( vmode , src , op2 ) ; } else if ( GET_CODE ( op1 ) == AND && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == NOT ) { rtx op11 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; rtx op12 = XEXP ( op1 , <NUM_LIT> ) ; convert_op ( & op11 , insn ) ; convert_op ( & op12 , insn ) ; if ( ! REG_P ( op11 ) ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( tmp , op11 ) , insn ) ; op11 = tmp ; } src = gen_rtx_AND ( vmode , gen_rtx_NOT ( vmode , op11 ) , op12 ) ; } else if ( GET_CODE ( op1 ) == AND ) { rtx op11 = XEXP ( op1 , <NUM_LIT> ) ; rtx op12 = XEXP ( op1 , <NUM_LIT> ) ; convert_op ( & op11 , insn ) ; convert_op ( & op12 , insn ) ; if ( ! REG_P ( op11 ) ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( tmp , op11 ) , insn ) ; op11 = tmp ; } return gen_rtx_UNSPEC ( CCmode , gen_rtvec ( <NUM_LIT> , op11 , op12 ) , UNSPEC_PTEST ) ; } else { convert_op ( & op1 , insn ) ; src = op1 ; } if ( ! REG_P ( src ) ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( tmp , src ) , insn ) ; src = tmp ; } if ( vmode == V2DImode ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_vec_interleave_lowv2di ( tmp , src , src ) , insn ) ; src = tmp ; } else if ( vmode == V4SImode ) { tmp = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_sse2_pshufd ( tmp , src , const0_rtx ) , insn ) ;


<s> src = tmp ; } } break ; case CONST_INT : switch ( standard_sse_constant_p ( src , TImode ) ) { case <NUM_LIT> : src = CONST0_RTX ( GET_MODE ( dst ) ) ; break ; case <NUM_LIT> : src = CONSTM1_RTX ( GET_MODE ( dst ) ) ; break ; default : gcc_unreachable ( ) ; } if ( MEM_P ( dst ) ) { tmp = gen_reg_rtx ( V1TImode ) ; emit_insn_before ( gen_rtx_SET ( tmp , src ) , insn ) ; src = tmp ; } break ; case AND : if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == NOT ) { convert_op ( & XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , insn ) ; convert_op ( & XEXP ( src , <NUM_LIT> ) , insn ) ; PUT_MODE ( XEXP ( src , <NUM_LIT> ) , V1TImode ) ; PUT_MODE ( src , V1TImode ) ; break ; } case XOR : case IOR : convert_op ( & XEXP ( src , <NUM_LIT> ) , insn ) ; convert_op ( & XEXP ( src , <NUM_LIT> ) , insn ) ; PUT_MODE ( src , V1TImode ) ; if ( MEM_P ( dst ) ) { tmp = gen_reg_rtx ( V1TImode ) ; emit_insn_before ( gen_rtx_SET ( tmp , src ) , insn ) ; src = tmp ; } break ; case NOT : src = XEXP ( src , <NUM_LIT> ) ; convert_op ( & src , insn ) ; tmp = gen_reg_rtx ( V1TImode ) ; emit_insn_before ( gen_move_insn ( tmp , CONSTM1_RTX ( V1TImode ) ) , insn ) ; src = gen_rtx_XOR ( V1TImode , src , tmp ) ; if ( MEM_P ( dst ) ) { tmp = gen_reg_rtx ( V1TImode ) ; emit_insn_before ( gen_rtx_SET ( tmp , src ) , insn ) ; src = tmp ; } break ; case COMPARE : dst = gen_rtx_REG ( CCmode , FLAGS_REG ) ; src = convert_compare ( XEXP ( src , <NUM_LIT> ) , XEXP ( src , <NUM_LIT> ) , insn ) ; break ; case ASHIFT :


<s> for ( df_ref ref = DF_INSN_DEFS ( insn ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( bitmap_bit_p ( defs_conv , DF_REF_REGNO ( ref ) ) ) { df_link * use ; for ( use = DF_REF_CHAIN ( ref ) ; use ; use = use -> next ) if ( NONDEBUG_INSN_P ( DF_REF_INSN ( use -> ref ) ) && ( DF_REF_REG_MEM_P ( use -> ref ) || ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( use -> ref ) ) ) ) break ; if ( use ) convert_reg ( insn , DF_REF_REG ( ref ) , * defs_map . get ( regno_reg_rtx [ DF_REF_REGNO ( ref ) ] ) ) ; else if ( MAY_HAVE_DEBUG_BIND_INSNS ) { auto_vec < rtx_insn * , <NUM_LIT> > to_reset_debug_insns ; for ( use = DF_REF_CHAIN ( ref ) ; use ; use = use -> next ) if ( DEBUG_INSN_P ( DF_REF_INSN ( use -> ref ) ) ) { rtx_insn * debug_insn = DF_REF_INSN ( use -> ref ) ; df_link * def ; for ( def = DF_REF_CHAIN ( use -> ref ) ; def ; def = def -> next ) if ( ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( def -> ref ) ) ) break ; if ( def ) to_reset_debug_insns . safe_push ( debug_insn ) ; else { * DF_REF_REAL_LOC ( use -> ref ) = * defs_map . get ( regno_reg_rtx [ DF_REF_REGNO ( ref ) ] ) ; df_insn_rescan ( debug_insn ) ; } } while ( ! to_reset_debug_insns . is_empty ( ) ) { rtx_insn * debug_insn = to_reset_debug_insns . pop ( ) ; INSN_VAR_LOCATION_LOC ( debug_insn ) = gen_rtx_UNKNOWN_VAR_LOC ( ) ; df_insn_rescan_debug_internal ( debug_insn ) ; } } }

for ( df_ref ref = DF_INSN_USES ( insn ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! DF_REF_REG_MEM_P ( ref ) ) if ( rtx * vreg = defs_map . get ( regno_reg_rtx [ DF_REF_REGNO ( ref ) ] ) ) {


<s> void scalar_chain :: convert_insn_common ( rtx_insn * insn ) { for ( df_ref ref = DF_INSN_DEFS ( insn ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( bitmap_bit_p ( defs_conv , DF_REF_REGNO ( ref ) ) ) { df_link * use ; for ( use = DF_REF_CHAIN ( ref ) ; use ; use = use -> next ) if ( NONDEBUG_INSN_P ( DF_REF_INSN ( use -> ref ) ) && ( DF_REF_REG_MEM_P ( use -> ref ) || ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( use -> ref ) ) ) ) break ; if ( use ) convert_reg ( insn , DF_REF_REG ( ref ) , * defs_map . get ( regno_reg_rtx [ DF_REF_REGNO ( ref ) ] ) ) ; else if ( MAY_HAVE_DEBUG_BIND_INSNS ) { auto_vec < rtx_insn * , <NUM_LIT> > to_reset_debug_insns ; for ( use = DF_REF_CHAIN ( ref ) ; use ; use = use -> next ) if ( DEBUG_INSN_P ( DF_REF_INSN ( use -> ref ) ) ) { rtx_insn * debug_insn = DF_REF_INSN ( use -> ref ) ; df_link * def ; for ( def = DF_REF_CHAIN ( use -> ref ) ; def ; def = def -> next ) if ( ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( def -> ref ) ) ) break ; if ( def ) to_reset_debug_insns . safe_push ( debug_insn ) ; else { * DF_REF_REAL_LOC ( use -> ref ) = * defs_map . get ( regno_reg_rtx [ DF_REF_REGNO ( ref ) ] ) ; df_insn_rescan ( debug_insn ) ;


<s> v [ <NUM_LIT> ] = * op ; vec_cst = gen_rtx_CONST_VECTOR ( V1TImode , gen_rtvec_v ( <NUM_LIT> , v ) ) ; } if ( ! standard_sse_constant_p ( vec_cst , V1TImode ) ) { start_sequence ( ) ; vec_cst = validize_mem ( force_const_mem ( V1TImode , vec_cst ) ) ; rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; emit_insn_before ( seq , insn ) ; } emit_insn_before ( gen_move_insn ( tmp , vec_cst ) , insn ) ; * op = tmp ; } else {


<s> void scalar_chain :: convert_reg ( rtx_insn * insn , rtx dst , rtx src ) { start_sequence ( ) ; if ( ! TARGET_INTER_UNIT_MOVES_FROM_VEC ) { rtx tmp = assign_386_stack_local ( smode , SLOT_STV_TEMP ) ; emit_move_insn ( tmp , src ) ; if ( ! TARGET_64BIT && smode == DImode ) { emit_move_insn ( gen_rtx_SUBREG ( SImode , dst , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , dst , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; } else emit_move_insn ( dst , copy_rtx ( tmp ) ) ; } else if ( ! TARGET_64BIT && smode == DImode ) { if ( TARGET_SSE4_1 ) {

rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) ) ;


<s> emit_move_insn ( gen_rtx_SUBREG ( SImode , dst , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; } else emit_move_insn ( dst , copy_rtx ( tmp ) ) ; } else if ( ! TARGET_64BIT && smode == DImode ) { if ( TARGET_SSE4_1 ) { rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( SImode , dst , <NUM_LIT> ) , gen_rtx_VEC_SELECT ( SImode , gen_rtx_SUBREG ( V4SImode , src , <NUM_LIT> ) , tmp ) ) ) ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( SImode , dst , <NUM_LIT> ) , gen_rtx_VEC_SELECT ( SImode , gen_rtx_SUBREG ( V4SImode , src , <NUM_LIT> ) , tmp ) ) ) ; } else { rtx vcopy = gen_reg_rtx ( V2DImode ) ;

emit_move_insn ( vcopy , gen_rtx_SUBREG ( V2DImode , src , <NUM_LIT> ) ) ;


<s> return remove_partial_avx_dependency ( ) ;


<s> unsigned int execute ( function * ) final override { return remove_partial_avx_dependency ( ) ;


<s> zero = v4sf_const0 ; } else { dest_vecmode = V2DFmode ; zero = gen_rtx_SUBREG ( V2DFmode , v4sf_const0 , <NUM_LIT> ) ; } src = gen_rtx_VEC_DUPLICATE ( dest_vecmode , src ) ; src = gen_rtx_VEC_MERGE ( dest_vecmode , src , zero , GEN_INT ( HOST_WIDE_INT_1U ) ) ; rtx vec = gen_reg_rtx ( dest_vecmode ) ; set = gen_rtx_SET ( vec , src ) ; set_insn = emit_insn_before ( set , insn ) ; df_insn_rescan ( set_insn ) ; if ( cfun -> can_throw_non_call_exceptions ) { rtx note = find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ; if ( note ) { control_flow_insns . safe_push ( set_insn ) ; add_reg_note ( set_insn , REG_EH_REGION , XEXP ( note , <NUM_LIT> ) ) ; } } src = gen_rtx_SUBREG ( dest_mode , vec , <NUM_LIT> ) ;


<s> zero = v4sf_const0 ; } else { dest_vecmode = V2DFmode ; zero = gen_rtx_SUBREG ( V2DFmode , v4sf_const0 , <NUM_LIT> ) ; } src = gen_rtx_VEC_DUPLICATE ( dest_vecmode , src ) ; src = gen_rtx_VEC_MERGE ( dest_vecmode , src , zero , GEN_INT ( HOST_WIDE_INT_1U ) ) ; rtx vec = gen_reg_rtx ( dest_vecmode ) ; set = gen_rtx_SET ( vec , src ) ; set_insn = emit_insn_before ( set , insn ) ; df_insn_rescan ( set_insn ) ; if ( cfun -> can_throw_non_call_exceptions ) { rtx note = find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ; if ( note ) { control_flow_insns . safe_push ( set_insn ) ; add_reg_note ( set_insn , REG_EH_REGION , XEXP ( note , <NUM_LIT> ) ) ;


<s> bool gate ( function * ) final override {

return ( TARGET_AVX && TARGET_SSE_PARTIAL_REG_DEPENDENCY && TARGET_SSE_MATH && optimize && optimize_function_for_speed_p ( cfun ) ) ;


<s> case MEM : case CONST_INT : return REG_P ( dst ) ; case VEC_SELECT : return REG_P ( dst ) && REG_P ( XEXP ( src , <NUM_LIT> ) ) && GET_MODE ( XEXP ( src , <NUM_LIT> ) ) == ( mode == DImode ? V2DImode : V4SImode ) && GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == PARALLEL && XVECLEN ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) == <NUM_LIT> && CONST_INT_P ( XVECEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ) ; default : return false ; } if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != mode && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; return true ;


<s> static rtx gen_gpr_to_xmm_move_src ( enum machine_mode vmode , rtx gpr ) { switch ( GET_MODE_NUNITS ( vmode ) ) { case <NUM_LIT> : return gen_rtx_SUBREG ( vmode , gpr , <NUM_LIT> ) ; case <NUM_LIT> : return gen_rtx_VEC_CONCAT ( vmode , gpr , CONST0_RTX ( GET_MODE_INNER ( vmode ) ) ) ; default : return gen_rtx_VEC_MERGE ( vmode , gen_rtx_VEC_DUPLICATE ( vmode , gpr ) , CONST0_RTX ( vmode ) , GEN_INT ( HOST_WIDE_INT_1U ) ) ; }


<s> static rtx gen_gpr_to_xmm_move_src ( enum machine_mode vmode , rtx gpr ) { switch ( GET_MODE_NUNITS ( vmode ) ) { case <NUM_LIT> : return gen_rtx_SUBREG ( vmode , gpr , <NUM_LIT> ) ; case <NUM_LIT> :

return gen_rtx_VEC_CONCAT ( vmode , gpr , CONST0_RTX ( GET_MODE_INNER ( vmode ) ) ) ;


<s> gcc_assert ( fn != NULL && DECL_FUNCTION_VERSIONED ( fn ) ) ; node = cgraph_node :: get ( fn ) ; gcc_assert ( node != NULL ) ; node_v = node -> function_version ( ) ; gcc_assert ( node_v != NULL ) ; if ( node_v -> dispatcher_resolver != NULL ) return node_v -> dispatcher_resolver ; first_v = node_v ; while ( first_v -> prev != NULL ) first_v = first_v -> prev ; default_version_info = first_v ; while ( default_version_info != NULL ) { if ( is_function_default_version ( default_version_info -> this_node -> decl ) ) break ; default_version_info = default_version_info -> next ; } if ( default_version_info == NULL ) return NULL ; if ( first_v != default_version_info ) { default_version_info -> prev -> next = default_version_info -> next ; if ( default_version_info -> next ) default_version_info -> next -> prev = default_version_info -> prev ; first_v -> prev = default_version_info ; default_version_info -> next = first_v ; default_version_info -> prev = NULL ; } default_node = default_version_info -> this_node ; if ( targetm . has_ifunc_p ( ) ) { struct cgraph_function_version_info * it_v = NULL ; struct cgraph_node * dispatcher_node = NULL ; struct cgraph_function_version_info * dispatcher_version_info = NULL ; dispatch_decl = make_dispatcher_decl ( default_node -> decl ) ; TREE_NOTHROW ( dispatch_decl ) = TREE_NOTHROW ( fn ) ; dispatcher_node = cgraph_node :: get_create ( dispatch_decl ) ; gcc_assert ( dispatcher_node != NULL ) ; dispatcher_node -> dispatcher_function = <NUM_LIT> ; dispatcher_version_info = dispatcher_node -> insert_new_function_version ( ) ; dispatcher_version_info -> next = default_version_info ; dispatcher_node -> definition = <NUM_LIT> ; it_v = default_version_info ; while ( it_v != NULL ) { it_v -> dispatcher_resolver = dispatch_decl ; it_v = it_v -> next ;


<s> rtl_opt_pass * make_pass_constant_pool_broadcast ( gcc :: context * ctxt ) {

return new pass_constant_pool_broadcast ( ctxt ) ;


<s> 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 emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( vmode , vreg , <NUM_LIT> ) , gen_gpr_to_xmm_move_src ( vmode , reg ) ) ) ; rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ;


<s> if ( ! bitmap_set_bit ( insns_conv , DF_REF_INSN_UID ( def ) ) && ! reg_new ) return ; n_integer_to_sse ++ ; } else { if ( ! reg_new ) return ; n_sse_to_integer ++ ;


<s> pass_constant_pool_broadcast ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_constant_pool_broadcast , ctxt ) {


<s> src = gen_rtx_VEC_DUPLICATE ( dest_vecmode , src ) ; src = gen_rtx_VEC_MERGE ( dest_vecmode , src , zero , GEN_INT ( HOST_WIDE_INT_1U ) ) ; rtx vec = gen_reg_rtx ( dest_vecmode ) ; set = gen_rtx_SET ( vec , src ) ; set_insn = emit_insn_before ( set , insn ) ; df_insn_rescan ( set_insn ) ; if ( cfun -> can_throw_non_call_exceptions ) { rtx note = find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ; if ( note ) { control_flow_insns . safe_push ( set_insn ) ; add_reg_note ( set_insn , REG_EH_REGION , XEXP ( note , <NUM_LIT> ) ) ; } } src = gen_rtx_SUBREG ( dest_mode , vec , <NUM_LIT> ) ; set = gen_rtx_SET ( dest , src ) ; PATTERN ( insn ) = set ; INSN_CODE ( insn ) = - <NUM_LIT> ; recog_memoized ( insn ) ; df_insn_rescan ( insn ) ; bitmap_set_bit ( convert_bbs , bb -> index ) ; } } if ( v4sf_const0 ) { calculate_dominance_info ( CDI_DOMINATORS ) ; loop_optimizer_init ( AVOID_CFG_MODIFICATIONS ) ;

bb = nearest_common_dominator_for_set ( CDI_DOMINATORS , convert_bbs ) ;


<s> auto_vec < rtx_insn * > control_flow_insns ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; FOR_EACH_BB_FN ( bb , cfun ) { FOR_BB_INSNS ( bb , insn ) { if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( TARGET_AVX512F ) replace_constant_pool_with_broadcast ( insn ) ; set = single_set ( insn ) ; if ( ! set ) continue ; if ( get_attr_avx_partial_xmm_update ( insn ) != AVX_PARTIAL_XMM_UPDATE_TRUE ) continue ; if ( ! v4sf_const0 ) v4sf_const0 = gen_reg_rtx ( V4SFmode ) ; rtx src = SET_SRC ( set ) ; rtx dest = SET_DEST ( set ) ; machine_mode dest_mode = GET_MODE ( dest ) ; rtx zero ; machine_mode dest_vecmode ; if ( dest_mode == E_SFmode ) { dest_vecmode = V4SFmode ; zero = v4sf_const0 ; } else { dest_vecmode = V2DFmode ; zero = gen_rtx_SUBREG ( V2DFmode , v4sf_const0 , <NUM_LIT> ) ; } src = gen_rtx_VEC_DUPLICATE ( dest_vecmode , src ) ; src = gen_rtx_VEC_MERGE ( dest_vecmode , src , zero , GEN_INT ( HOST_WIDE_INT_1U ) ) ; rtx vec = gen_reg_rtx ( dest_vecmode ) ; set = gen_rtx_SET ( vec , src ) ; set_insn = emit_insn_before ( set , insn ) ; df_insn_rescan ( set_insn ) ; if ( cfun -> can_throw_non_call_exceptions ) { rtx note = find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ; if ( note ) { control_flow_insns . safe_push ( set_insn ) ; add_reg_note ( set_insn , REG_EH_REGION , XEXP ( note , <NUM_LIT> ) ) ; } } src = gen_rtx_SUBREG ( dest_mode , vec , <NUM_LIT> ) ; set = gen_rtx_SET ( dest , src ) ; PATTERN ( insn ) = set ; INSN_CODE ( insn ) = - <NUM_LIT> ; recog_memoized ( insn ) ; df_insn_rescan ( insn ) ; bitmap_set_bit ( convert_bbs , bb -> index ) ; } } if ( v4sf_const0 ) { calculate_dominance_info ( CDI_DOMINATORS ) ; loop_optimizer_init ( AVOID_CFG_MODIFICATIONS ) ; bb = nearest_common_dominator_for_set ( CDI_DOMINATORS , convert_bbs ) ; while ( bb -> loop_father -> latch != EXIT_BLOCK_PTR_FOR_FN ( cfun ) ) bb = get_immediate_dominator ( CDI_DOMINATORS , bb -> loop_father -> header ) ; set = gen_rtx_SET ( v4sf_const0 , CONST0_RTX ( V4SFmode ) ) ; insn = BB_HEAD ( bb ) ; while ( insn && ! NONDEBUG_INSN_P ( insn ) ) { if ( insn == BB_END ( bb ) ) { insn = NULL ; break ; } insn = NEXT_INSN ( insn ) ; } if ( insn == BB_HEAD ( bb ) ) set_insn = emit_insn_before ( set , insn ) ; else set_insn = emit_insn_after ( set , insn ? PREV_INSN ( insn ) : BB_END ( bb ) ) ; df_insn_rescan ( set_insn ) ; loop_optimizer_finalize ( ) ; if ( ! control_flow_insns . is_empty ( ) ) { free_dominance_info ( CDI_DOMINATORS ) ; unsigned int i ; FOR_EACH_VEC_ELT ( control_flow_insns , i , insn ) if ( control_flow_insn_p ( insn ) ) { bb = BLOCK_FOR_INSN ( insn ) ;


<s> if ( ! MEM_P ( x ) || ! SYMBOL_REF_P ( XEXP ( x , <NUM_LIT> ) ) || ! CONSTANT_POOL_ADDRESS_P ( XEXP ( x , <NUM_LIT> ) ) ) continue ; mode = GET_MODE ( x ) ; if ( ! VECTOR_MODE_P ( mode ) ) return ; constant = get_pool_constant ( XEXP ( x , <NUM_LIT> ) ) ; if ( GET_CODE ( constant ) != CONST_VECTOR ) return ; if ( GET_MODE ( constant ) != mode ) { constant = simplify_subreg ( mode , constant , GET_MODE ( constant ) , <NUM_LIT> ) ; if ( constant == NULL_RTX || GET_CODE ( constant ) != CONST_VECTOR ) return ; } first = XVECEXP ( constant , <NUM_LIT> , <NUM_LIT> ) ; for ( int i = <NUM_LIT> ; i < GET_MODE_NUNITS ( mode ) ; ++ i ) { rtx tmp = XVECEXP ( constant , <NUM_LIT> , i ) ; if ( ! rtx_equal_p ( tmp , first ) ) return ; } broadcast_mem = force_const_mem ( GET_MODE_INNER ( mode ) , first ) ; vec_dup = gen_rtx_VEC_DUPLICATE ( mode , broadcast_mem ) ;

validate_change ( insn , loc , vec_dup , <NUM_LIT> ) ;


<s> static unsigned int rest_of_handle_insert_vzeroupper ( void ) { if ( TARGET_VZEROUPPER && flag_expensive_optimizations && ! optimize_size ) { for ( int i = <NUM_LIT> ; i < MAX_386_ENTITIES ; i ++ ) ix86_optimize_mode_switching [ i ] = <NUM_LIT> ; ix86_optimize_mode_switching [ AVX_U128 ] = <NUM_LIT> ; g -> get_passes ( ) -> execute_pass_mode_switching ( ) ; } ix86_add_reg_usage_to_vzerouppers ( ) ;


<s> static unsigned int rest_of_handle_insert_vzeroupper ( void ) { if ( TARGET_VZEROUPPER && flag_expensive_optimizations && ! optimize_size ) { for ( int i = <NUM_LIT> ; i < MAX_386_ENTITIES ; i ++ ) ix86_optimize_mode_switching [ i ] = <NUM_LIT> ; ix86_optimize_mode_switching [ AVX_U128 ] = <NUM_LIT> ; g -> get_passes ( ) -> execute_pass_mode_switching ( ) ; }


<s> vmode = vmode_ ; chain_id = ++ max_id ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain_id ) ; bitmap_obstack_initialize ( NULL ) ; insns = BITMAP_ALLOC ( NULL ) ;


<s> 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 ) ; insns_conv = BITMAP_ALLOC ( NULL ) ; queue = NULL ; n_sse_to_integer = <NUM_LIT> ; n_integer_to_sse = <NUM_LIT> ; max_visits = x86_stv_max_visits ;


<s> if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , DF_REF_INSN_UID ( def ) ) ; bitmap_set_bit ( regs , regno ) ; break ; } } for ( df_ref ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) { if ( NONDEBUG_INSN_P ( DF_REF_INSN ( ref ) ) && ! bitmap_bit_p ( candidates , DF_REF_INSN_UID ( ref ) ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , DF_REF_INSN_UID ( ref ) ) ; bitmap_set_bit ( regs , regno ) ; break ;


<s> static bool timode_mem_p ( rtx x ) {

return MEM_P ( x ) && ( TARGET_SSE_UNALIGNED_LOAD_OPTIMAL || ! misaligned_operand ( x , TImode ) ) ;


<s> rtx_insn * insn = DF_INSN_UID_GET ( id ) -> insn ; df_ref ref ; FOR_EACH_INSN_DEF ( ref , insn ) if ( ! DF_REF_REG_MEM_P ( ref ) && GET_MODE ( DF_REF_REG ( ref ) ) == TImode ) timode_check_non_convertible_regs ( candidates , regs , DF_REF_REGNO ( ref ) ) ; FOR_EACH_INSN_USE ( ref , insn ) if ( ! DF_REF_REG_MEM_P ( ref ) && GET_MODE ( DF_REF_REG ( ref ) ) == TImode ) timode_check_non_convertible_regs ( candidates , regs , DF_REF_REGNO ( ref ) ) ; } 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 ) ) ;


<s> return standard_sse_constant_p ( src , TImode ) ; case MEM : return ( REG_P ( dst ) && ( ! misaligned_operand ( src , TImode ) || TARGET_SSE_UNALIGNED_LOAD_OPTIMAL ) ) ; case AND : if ( ! MEM_P ( dst ) && GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == NOT && REG_P ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) && ( REG_P ( XEXP ( src , <NUM_LIT> ) ) || CONST_SCALAR_INT_P ( XEXP ( src , <NUM_LIT> ) ) || timode_mem_p ( XEXP ( src , <NUM_LIT> ) ) ) ) return true ; return REG_P ( XEXP ( src , <NUM_LIT> ) ) && ( REG_P ( XEXP ( src , <NUM_LIT> ) ) || CONST_SCALAR_INT_P ( XEXP ( src , <NUM_LIT> ) ) || timode_mem_p ( XEXP ( src , <NUM_LIT> ) ) ) ; case IOR : case XOR : return REG_P ( XEXP ( src , <NUM_LIT> ) ) && ( REG_P ( XEXP ( src , <NUM_LIT> ) ) || CONST_SCALAR_INT_P ( XEXP ( src , <NUM_LIT> ) ) || timode_mem_p ( XEXP ( src , <NUM_LIT> ) ) ) ; case NOT : return REG_P ( XEXP ( src , <NUM_LIT> ) ) || timode_mem_p ( XEXP ( src , <NUM_LIT> ) ) ; case ASHIFT : case LSHIFTRT : case ASHIFTRT : case ROTATERT : case ROTATE : return REG_P ( XEXP ( src , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) & ~ <NUM_LIT> ) == <NUM_LIT> ; default : return false ;


<s> BITMAP_FREE ( defs ) ; BITMAP_FREE ( defs_conv ) ;


gimple_seq_add_stmt ( & gseq , convert_stmt ) ;


<s> for ( ref = DF_INSN_UID_DEFS ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! HARD_REGISTER_P ( DF_REF_REG ( ref ) ) ) analyze_register_chain ( candidates , ref ) ; for ( ref = DF_INSN_UID_USES ( insn_uid ) ; ref ; ref = DF_REF_NEXT_LOC ( ref ) ) if ( ! DF_REF_REG_MEM_P ( ref ) ) analyze_register_chain ( candidates , ref ) ;


<s> if ( bitmap_bit_p ( insns , insn_uid ) || bitmap_bit_p ( queue , insn_uid ) ) return ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , insn_uid , chain_id ) ; bitmap_set_bit ( queue , insn_uid ) ;


<s> add_to_queue ( DF_REF_INSN_UID ( ref ) ) ; for ( chain = DF_REF_CHAIN ( ref ) ; chain ; chain = chain -> next ) { unsigned uid = DF_REF_INSN_UID ( chain -> ref ) ; if ( ! NONDEBUG_INSN_P ( DF_REF_INSN ( chain -> ref ) ) ) continue ; if ( ! DF_REF_REG_MEM_P ( chain -> ref ) ) { if ( bitmap_bit_p ( insns , uid ) ) continue ; if ( bitmap_bit_p ( candidates , uid ) ) { add_to_queue ( uid ) ; continue ; } } if ( DF_REF_REG_DEF_P ( chain -> ref ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , DF_REF_REGNO ( chain -> ref ) , uid ) ;


<s> bitmap_clear_bit ( queue , insn_uid ) ; bitmap_clear_bit ( candidates , insn_uid ) ; add_insn ( candidates , insn_uid ) ; } if ( dump_file ) { fprintf ( dump_file , <STR_LIT> , chain_id ) ; fprintf ( dump_file , <STR_LIT> ) ; dump_bitmap ( dump_file , insns ) ; if ( ! bitmap_empty_p ( defs_conv ) ) { bitmap_iterator bi ; unsigned id ; const char * comma = <STR_LIT> ; fprintf ( dump_file , <STR_LIT> ) ; EXECUTE_IF_SET_IN_BITMAP ( defs_conv , <NUM_LIT> , id , bi ) { fprintf ( dump_file , <STR_LIT> , comma , id ) ; comma = <STR_LIT> ; }


<s> opt_pass * clone ( ) { return new pass_stv ( m_ctxt ) ;


<s> EXECUTE_IF_SET_IN_BITMAP ( insns , <NUM_LIT> , id , bi ) { convert_insn ( DF_INSN_UID_GET ( id ) -> insn ) ;


<s> bitmap_iterator bi ; unsigned id ; int converted_insns = <NUM_LIT> ; if ( ! dbg_cnt ( stv_conversion ) ) return <NUM_LIT> ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain_id ) ; convert_registers ( ) ; EXECUTE_IF_SET_IN_BITMAP ( insns , <NUM_LIT> , id , bi ) { convert_insn ( DF_INSN_UID_GET ( id ) -> insn ) ; converted_insns ++ ;


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

if ( op1 != op2 || ! REG_P ( op1 ) || GET_MODE ( op1 ) != DImode ) return false ;


<s> if ( ! TARGET_SSE4_1 ) return false ; rtx def_set = single_set ( insn ) ; gcc_assert ( def_set ) ; rtx src = SET_SRC ( def_set ) ; rtx dst = SET_DEST ( def_set ) ; gcc_assert ( GET_CODE ( src ) == COMPARE ) ; if ( GET_CODE ( dst ) != REG || REGNO ( dst ) != FLAGS_REG || GET_MODE ( dst ) != CCZmode ) return false ; rtx op1 = XEXP ( src , <NUM_LIT> ) ; rtx op2 = XEXP ( src , <NUM_LIT> ) ; if ( op2 != CONST0_RTX ( GET_MODE ( op2 ) ) ) return false ; if ( GET_CODE ( op1 ) != IOR ) return false ; op2 = XEXP ( op1 , <NUM_LIT> ) ; op1 = XEXP ( op1 , <NUM_LIT> ) ;

if ( ! SUBREG_P ( op1 ) || ! SUBREG_P ( op2 ) || GET_MODE ( op1 ) != SImode || GET_MODE ( op2 ) != SImode || ( ( SUBREG_BYTE ( op1 ) != <NUM_LIT> || SUBREG_BYTE ( op2 ) != GET_MODE_SIZE ( SImode ) ) && ( SUBREG_BYTE ( op2 ) != <NUM_LIT> || SUBREG_BYTE ( op1 ) != GET_MODE_SIZE ( SImode ) ) ) ) return false ;


<s> subreg = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_rtx_SET ( subreg , gen_rtx_ABS ( vmode , src ) ) , insn ) ; src = subreg ; } else convert_op ( & src , insn ) ; subreg = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_move_insn ( subreg , CONST0_RTX ( vmode ) ) , insn ) ; src = gen_rtx_MINUS ( vmode , subreg , src ) ; break ; case NOT : src = XEXP ( src , <NUM_LIT> ) ; convert_op ( & src , insn ) ; subreg = gen_reg_rtx ( vmode ) ; emit_insn_before ( gen_move_insn ( subreg , CONSTM1_RTX ( vmode ) ) , insn ) ; src = gen_rtx_XOR ( vmode , 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 ) == vmode ) ; break ; case COMPARE : src = SUBREG_REG ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ; gcc_assert ( REG_P ( src ) && GET_MODE ( src ) == DImode ) ; subreg = gen_rtx_SUBREG ( V2DImode , src , <NUM_LIT> ) ; 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 ( subreg ) , copy_rtx_if_shared ( subreg ) ) , UNSPEC_PTEST ) ; break ; case CONST_INT : convert_op ( & src , insn ) ; break ; default : gcc_unreachable ( ) ; } SET_SRC ( def_set ) = src ; SET_DEST ( def_set ) = dst ; PATTERN ( insn ) = def_set ; INSN_CODE ( insn ) = - <NUM_LIT> ;


<s> } else if ( CONST_INT_P ( * op ) ) { rtx vec_cst ; rtx tmp = gen_rtx_SUBREG ( vmode , gen_reg_rtx ( smode ) , <NUM_LIT> ) ; if ( constm1_operand ( * op , GET_MODE ( * op ) ) ) vec_cst = CONSTM1_RTX ( vmode ) ; else { unsigned n = GET_MODE_NUNITS ( vmode ) ; rtx * v = XALLOCAVEC ( rtx , n ) ; v [ <NUM_LIT> ] = * op ; for ( unsigned i = <NUM_LIT> ; i < n ; ++ i ) v [ i ] = const0_rtx ; vec_cst = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( n , v ) ) ; } if ( ! standard_sse_constant_p ( vec_cst , vmode ) ) { start_sequence ( ) ;

vec_cst = validize_mem ( force_const_mem ( vmode , vec_cst ) ) ;


<s> * op = gen_rtx_SUBREG ( vmode , * op , <NUM_LIT> ) ; } else if ( CONST_INT_P ( * op ) ) { rtx vec_cst ; rtx tmp = gen_rtx_SUBREG ( vmode , gen_reg_rtx ( smode ) , <NUM_LIT> ) ; if ( constm1_operand ( * op , GET_MODE ( * op ) ) ) vec_cst = CONSTM1_RTX ( vmode ) ; else { unsigned n = GET_MODE_NUNITS ( vmode ) ; rtx * v = XALLOCAVEC ( rtx , n ) ; v [ <NUM_LIT> ] = * op ; for ( unsigned i = <NUM_LIT> ; i < n ; ++ i ) v [ i ] = const0_rtx ; vec_cst = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( n , v ) ) ; } if ( ! standard_sse_constant_p ( vec_cst , vmode ) ) { start_sequence ( ) ; vec_cst = validize_mem ( force_const_mem ( vmode , vec_cst ) ) ; rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; emit_insn_before ( seq , insn ) ; }

emit_insn_before ( gen_move_insn ( copy_rtx ( tmp ) , vec_cst ) , insn ) ;


<s> else if ( ! timode_p ) { for ( unsigned i = <NUM_LIT> ; i <= <NUM_LIT> ; ++ i ) if ( general_scalar_to_vector_candidate_p ( insn , cand_mode [ i ] ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) , i == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; bitmap_set_bit ( & candidates [ i ] , INSN_UID ( insn ) ) ; break ; } } } if ( timode_p ) timode_remove_non_convertible_regs ( & candidates [ <NUM_LIT> ] ) ; for ( unsigned i = <NUM_LIT> ; i <= <NUM_LIT> ; ++ i ) if ( ! bitmap_empty_p ( & candidates [ i ] ) ) break ; else if ( i == <NUM_LIT> && dump_file ) fprintf ( dump_file , <STR_LIT> ) ; for ( unsigned i = <NUM_LIT> ; i <= <NUM_LIT> ; ++ i ) while ( ! bitmap_empty_p ( & candidates [ i ] ) ) { unsigned uid = bitmap_first_set_bit ( & candidates [ i ] ) ; scalar_chain * chain ; if ( cand_mode [ i ] == TImode ) chain = new timode_scalar_chain ; else chain = new general_scalar_chain ( cand_mode [ i ] , cand_vmode [ i ] ) ; chain -> build ( & candidates [ i ] , uid ) ; if ( chain -> compute_convert_gain ( ) > <NUM_LIT> ) converted_insns += chain -> convert ( ) ; else if ( dump_file ) fprintf ( dump_file , <STR_LIT> , chain -> chain_id ) ; delete chain ; } if ( dump_file ) fprintf ( dump_file , <STR_LIT> , converted_insns ) ; for ( unsigned i = <NUM_LIT> ; i <= <NUM_LIT> ; ++ i ) bitmap_release ( & candidates [ i ] ) ; bitmap_obstack_release ( NULL ) ; df_process_deferred_rescans ( ) ; if ( converted_insns ) { if ( crtl -> stack_alignment_needed < <NUM_LIT> ) crtl -> stack_alignment_needed = <NUM_LIT> ; if ( crtl -> stack_alignment_estimated < <NUM_LIT> ) crtl -> stack_alignment_estimated = <NUM_LIT> ; crtl -> stack_realign_needed = INCOMING_STACK_BOUNDARY < crtl -> stack_alignment_estimated ; crtl -> stack_realign_tried = crtl -> stack_realign_needed ; crtl -> stack_realign_processed = true ; if ( ! crtl -> drap_reg ) { rtx drap_rtx = targetm . calls . get_drap_rtx ( ) ; gcc_assert ( ( stack_realign_drap != <NUM_LIT> ) == ( drap_rtx != NULL ) ) ; if ( drap_rtx != NULL ) { crtl -> args . internal_arg_pointer = drap_rtx ; fixup_tail_calls ( ) ; } }

if ( TARGET_64BIT ) for ( tree parm = DECL_ARGUMENTS ( current_function_decl ) ;


<s> for ( count = i = MIN_REGS ; i < MAX_REGS ; ++ i ) { regno = REG_ORDER [ i ] ; if ( regno == BP_REG && hfp ) continue ; if ( ! ix86_save_reg ( regno , false , false ) ) break ; ++ count ;


<s> bool hfp = frame_pointer_needed || stack_realign_fp ; unsigned i , count ; unsigned regno ; for ( count = i = MIN_REGS ; i < MAX_REGS ; ++ i ) { regno = REG_ORDER [ i ] ; if ( regno == BP_REG && hfp ) continue ; if ( ! ix86_save_reg ( regno , false , false ) ) break ; ++ count ; } return count ;


<s> gseq = bb_seq ( * empty_bb ) ; ifunc_cpu_init_stmt = gimple_build_call_vec ( get_ix86_builtin ( IX86_BUILTIN_CPU_INIT ) , vNULL ) ; gimple_seq_add_stmt ( & gseq , ifunc_cpu_init_stmt ) ; gimple_set_bb ( ifunc_cpu_init_stmt , * empty_bb ) ; set_bb_seq ( * empty_bb , gseq ) ; pop_cfun ( ) ; for ( ix = <NUM_LIT> ; fndecls -> iterate ( ix , & ele ) ; ++ ix ) { tree version_decl = ele ; tree predicate_chain = NULL_TREE ; unsigned int priority ; priority = get_builtin_code_for_version ( version_decl , & predicate_chain ) ; if ( predicate_chain == NULL_TREE ) continue ; function_version_info [ actual_versions ] . version_decl = version_decl ; function_version_info [ actual_versions ] . predicate_chain = predicate_chain ;

function_version_info [ actual_versions ] . dispatch_priority = priority ;


<s> basic_block bb = BLOCK_FOR_INSN ( after ) ; edge e = find_fallthru_edge ( bb -> succs ) ; gcc_assert ( e ) ; basic_block new_bb = split_edge ( e ) ; emit_insn_after ( insns , BB_HEAD ( new_bb ) ) ;


<s> edge e = find_fallthru_edge ( bb -> succs ) ; gcc_assert ( e ) ; basic_block new_bb = split_edge ( e ) ; emit_insn_after ( insns , BB_HEAD ( new_bb ) ) ;


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


<s> const function_version_info c1 = * ( const function_version_info * ) v1 ; const function_version_info c2 = * ( const function_version_info * ) v2 ;


<s> static int feature_compare ( const void * v1 , const void * v2 ) { typedef struct _function_version_info { tree version_decl ;


<s> rtx * loc = DF_REF_LOC ( ref ) ; if ( REG_P ( * loc ) && GET_MODE ( * loc ) == V1TImode ) { * loc = gen_rtx_SUBREG ( TImode , * loc , <NUM_LIT> ) ; changed = true ; } } if ( changed ) df_insn_rescan ( insn ) ; }


<s> rtx vec = gen_reg_rtx ( dest_vecmode ) ; set = gen_rtx_SET ( vec , src ) ; set_insn = emit_insn_before ( set , insn ) ; df_insn_rescan ( set_insn ) ; if ( cfun -> can_throw_non_call_exceptions ) { rtx note = find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ; if ( note ) { control_flow_insns . safe_push ( set_insn ) ; add_reg_note ( set_insn , REG_EH_REGION , XEXP ( note , <NUM_LIT> ) ) ; } } src = gen_rtx_SUBREG ( dest_mode , vec , <NUM_LIT> ) ; set = gen_rtx_SET ( dest , src ) ; PATTERN ( insn ) = set ; INSN_CODE ( insn ) = - <NUM_LIT> ; recog_memoized ( insn ) ; df_insn_rescan ( insn ) ; bitmap_set_bit ( convert_bbs , bb -> index ) ;


<s> FOR_BB_INSNS_REVERSE ( bb , insn ) {

if ( ! NONDEBUG_INSN_P ( insn ) ) continue ;


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

if ( vzeroupper_pattern ( PATTERN ( insn ) , VOIDmode ) ) ix86_add_reg_usage_to_vzeroupper ( insn , live_regs ) ;


<s> break ; case E_VOIDmode : gcc_assert ( ! convert_p ) ; break ; default : gcc_unreachable ( ) ; } if ( ! v4sf_const0 ) v4sf_const0 = gen_reg_rtx ( V4SFmode ) ; rtx zero ; machine_mode dest_vecmode ; switch ( dest_mode ) { case E_HFmode : dest_vecmode = V8HFmode ; zero = gen_rtx_SUBREG ( V8HFmode , v4sf_const0 , <NUM_LIT> ) ; break ; case E_SFmode : dest_vecmode = V4SFmode ; zero = v4sf_const0 ; break ; case E_DFmode : dest_vecmode = V2DFmode ; zero = gen_rtx_SUBREG ( V2DFmode , v4sf_const0 , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } src = gen_rtx_VEC_DUPLICATE ( dest_vecmode , src ) ; src = gen_rtx_VEC_MERGE ( dest_vecmode , src , zero , GEN_INT ( HOST_WIDE_INT_1U ) ) ;

rtx vec = gen_reg_rtx ( dest_vecmode ) ;


<s> case LSHIFTRT : if ( ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) || ! IN_RANGE ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) , <NUM_LIT> , GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ) return false ; break ; case SMAX : case SMIN : case UMAX : case UMIN : if ( ( mode == DImode && ! TARGET_AVX512VL ) || ( mode == SImode && ! TARGET_SSE4_1 ) ) return false ; case AND : case IOR : case XOR : case PLUS : case MINUS : if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != mode && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_CODE ( src ) != AND || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != NOT ) break ; src = XEXP ( src , <NUM_LIT> ) ;


<s> case ASHIFTRT : if ( ! TARGET_AVX512VL ) return false ; case ASHIFT : case LSHIFTRT : if ( ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) || ! IN_RANGE ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) , <NUM_LIT> , GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ) return false ; break ; case SMAX : case SMIN : case UMAX : case UMIN : if ( ( mode == DImode && ! TARGET_AVX512VL ) || ( mode == SImode && ! TARGET_SSE4_1 ) ) return false ; case AND : case IOR : case XOR : case PLUS : case MINUS : if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != mode && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_CODE ( src ) != AND || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != NOT ) break ; src = XEXP ( src , <NUM_LIT> ) ;


<s> static rtx gen_gpr_to_xmm_move_src ( enum machine_mode vmode , rtx gpr ) { switch ( GET_MODE_NUNITS ( vmode ) ) { case <NUM_LIT> : gcc_unreachable ( ) ; case <NUM_LIT> : return gen_rtx_VEC_CONCAT ( vmode , gpr , CONST0_RTX ( GET_MODE_INNER ( vmode ) ) ) ; default :

return gen_rtx_VEC_MERGE ( vmode , gen_rtx_VEC_DUPLICATE ( vmode , gpr ) , CONST0_RTX ( vmode ) , GEN_INT ( HOST_WIDE_INT_1U ) ) ;


<s> const class xlogue_layout & xlogue_layout :: get_instance ( ) { enum xlogue_stub_sets stub_set ;

bool aligned_plus_8 = cfun -> machine -> call_ms2sysv_pad_in ;


<s> if ( stack_realign_fp ) stub_set = XLOGUE_SET_HFP_ALIGNED_OR_REALIGN ;


<s> unsigned get_nregs ( ) const { return m_nregs ;


<s> gcc_assert ( reg < m_nregs ) ; return m_regs [ reg ] ;


<s> const struct machine_function * m = cfun -> machine ; unsigned last_reg = m -> call_ms2sysv_extra_regs + MIN_REGS - <NUM_LIT> ; gcc_assert ( m -> call_ms2sysv_extra_regs <= MAX_EXTRA_REGS ) ;

return m_regs [ last_reg ] . offset + STUB_INDEX_OFFSET ;


<s> const struct machine_function * m = cfun -> machine ; unsigned last_reg = m -> call_ms2sysv_extra_regs + MIN_REGS - <NUM_LIT> ; gcc_assert ( m -> call_ms2sysv_extra_regs <= MAX_EXTRA_REGS ) ; return m_regs [ last_reg ] . offset + STUB_INDEX_OFFSET ;


int res = snprintf ( name , STUB_NAME_MAX_LEN , <STR_LIT> , ( have_avx ? <STR_LIT> : <STR_LIT> ) , STUB_BASE_NAMES [ stub ] , MIN_REGS + n_extra_regs ) ;


<s> HOST_WIDE_INT get_stub_ptr_offset ( ) const { return STUB_INDEX_OFFSET + m_stack_align_off_in ;


<s> return STUB_INDEX_OFFSET + m_stack_align_off_in ;


<s> gcc_checking_assert ( n_extra_regs <= MAX_EXTRA_REGS ) ; gcc_assert ( stub < XLOGUE_STUB_COUNT ) ; gcc_assert ( crtl -> stack_realign_finalized ) ; return gen_rtx_SYMBOL_REF ( Pmode , get_stub_name ( stub , n_extra_regs ) ) ;


<s> gcc_checking_assert ( n_extra_regs <= MAX_EXTRA_REGS ) ; gcc_assert ( stub < XLOGUE_STUB_COUNT ) ; gcc_assert ( crtl -> stack_realign_finalized ) ;

return gen_rtx_SYMBOL_REF ( Pmode , get_stub_name ( stub , n_extra_regs ) ) ;


<s> FOR_EACH_INSN_DEF ( ref , insn ) if ( HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) && ! DF_REF_FLAGS_IS_SET ( ref , DF_REF_MUST_CLOBBER ) && DF_REF_REGNO ( ref ) != FLAGS_REG ) return true ; FOR_EACH_INSN_USE ( ref , insn ) if ( ! DF_REF_REG_MEM_P ( ref ) && HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) ) return true ; return false ;


<s> FOR_EACH_INSN_DEF ( ref , insn ) if ( HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) && ! DF_REF_FLAGS_IS_SET ( ref , DF_REF_MUST_CLOBBER ) && DF_REF_REGNO ( ref ) != FLAGS_REG ) return true ; FOR_EACH_INSN_USE ( ref , insn ) if ( ! DF_REF_REG_MEM_P ( ref ) && HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) ) return true ;


<s> unsigned i ; for ( i = <NUM_LIT> ; i < count ; ++ i ) { gcc_assert ( i < MAX_REGS ) ;

if ( REG_ORDER [ i ] == BP_REG && hfp ) ++ count ;


<s> bool hfp = frame_pointer_needed || stack_realign_fp ; unsigned i ; for ( i = <NUM_LIT> ; i < count ; ++ i ) { gcc_assert ( i < MAX_REGS ) ; if ( REG_ORDER [ i ] == BP_REG && hfp ) ++ count ; else if ( REG_ORDER [ i ] == regno ) return true ; }


<s> FOR_EACH_BB_FN ( bb , cfun ) { bitmap_copy ( live_regs , df_get_live_out ( bb ) ) ; df_simulate_initialize_backwards ( bb , live_regs ) ; FOR_BB_INSNS_REVERSE ( bb , insn ) { if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( vzeroupper_pattern ( PATTERN ( insn ) , VOIDmode ) ) ix86_add_reg_usage_to_vzeroupper ( insn , live_regs ) ; df_simulate_one_insn_backwards ( bb , insn , live_regs ) ; } }


<s> FOR_EACH_BB_FN ( bb , cfun ) { bitmap_copy ( live_regs , df_get_live_out ( bb ) ) ; df_simulate_initialize_backwards ( bb , live_regs ) ; FOR_BB_INSNS_REVERSE ( bb , insn ) { if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( vzeroupper_pattern ( PATTERN ( insn ) , VOIDmode ) ) ix86_add_reg_usage_to_vzeroupper ( insn , live_regs ) ; df_simulate_one_insn_backwards ( bb , insn , live_regs ) ;


<s> int ix86_compare_version_priority ( tree decl1 , tree decl2 ) { unsigned int priority1 = get_builtin_code_for_version ( decl1 , NULL ) ; unsigned int priority2 = get_builtin_code_for_version ( decl2 , NULL ) ; return ( int ) priority1 - ( int ) priority2 ;


<s> struct cgraph_node * node ; struct cgraph_function_version_info * node_version_info = NULL ; struct cgraph_function_version_info * versn_info = NULL ; node = ( cgraph_node * ) node_p ; node_version_info = node -> function_version ( ) ; gcc_assert ( node -> dispatcher_function && node_version_info != NULL ) ; if ( node_version_info -> dispatcher_resolver ) return node_version_info -> dispatcher_resolver ; default_ver_decl = node_version_info -> next -> this_node -> decl ; node -> definition = false ; resolver_decl = make_resolver_func ( default_ver_decl , node -> decl , & empty_bb ) ; node_version_info -> dispatcher_resolver = resolver_decl ; push_cfun ( DECL_STRUCT_FUNCTION ( resolver_decl ) ) ; auto_vec < tree , <NUM_LIT> > fn_ver_vec ; for ( versn_info = node_version_info -> next ; versn_info ; versn_info = versn_info -> next ) { versn = versn_info -> this_node ; if ( DECL_VINDEX ( versn -> decl ) ) sorry ( <STR_LIT> ) ; fn_ver_vec . safe_push ( versn -> decl ) ; } dispatch_function_versions ( resolver_decl , & fn_ver_vec , & empty_bb ) ; cgraph_edge :: rebuild_edges ( ) ; pop_cfun ( ) ; return resolver_decl ;


<s> node = cgraph_node :: get ( fn ) ; gcc_assert ( node != NULL ) ; node_v = node -> function_version ( ) ; gcc_assert ( node_v != NULL ) ; if ( node_v -> dispatcher_resolver != NULL ) return node_v -> dispatcher_resolver ; first_v = node_v ; while ( first_v -> prev != NULL ) first_v = first_v -> prev ; default_version_info = first_v ; while ( default_version_info != NULL ) { if ( is_function_default_version ( default_version_info -> this_node -> decl ) ) break ; default_version_info = default_version_info -> next ; } if ( default_version_info == NULL ) return NULL ; if ( first_v != default_version_info ) { default_version_info -> prev -> next = default_version_info -> next ; if ( default_version_info -> next ) default_version_info -> next -> prev = default_version_info -> prev ; first_v -> prev = default_version_info ; default_version_info -> next = first_v ; default_version_info -> prev = NULL ; } default_node = default_version_info -> this_node ; if ( targetm . has_ifunc_p ( ) ) { struct cgraph_function_version_info * it_v = NULL ; struct cgraph_node * dispatcher_node = NULL ; struct cgraph_function_version_info * dispatcher_version_info = NULL ; dispatch_decl = make_dispatcher_decl ( default_node -> decl ) ; dispatcher_node = cgraph_node :: get_create ( dispatch_decl ) ; gcc_assert ( dispatcher_node != NULL ) ; dispatcher_node -> dispatcher_function = <NUM_LIT> ; dispatcher_version_info = dispatcher_node -> insert_new_function_version ( ) ; dispatcher_version_info -> next = default_version_info ; dispatcher_node -> definition = <NUM_LIT> ; it_v = default_version_info ; while ( it_v != NULL ) {


<s> first_v = node_v ; while ( first_v -> prev != NULL ) first_v = first_v -> prev ; default_version_info = first_v ; while ( default_version_info != NULL ) { if ( is_function_default_version ( default_version_info -> this_node -> decl ) ) break ; default_version_info = default_version_info -> next ; } if ( default_version_info == NULL ) return NULL ; if ( first_v != default_version_info ) { default_version_info -> prev -> next = default_version_info -> next ; if ( default_version_info -> next ) default_version_info -> next -> prev = default_version_info -> prev ; first_v -> prev = default_version_info ; default_version_info -> next = first_v ; default_version_info -> prev = NULL ; } default_node = default_version_info -> this_node ; if ( targetm . has_ifunc_p ( ) ) { struct cgraph_function_version_info * it_v = NULL ; struct cgraph_node * dispatcher_node = NULL ; struct cgraph_function_version_info * dispatcher_version_info = NULL ; dispatch_decl = make_dispatcher_decl ( default_node -> decl ) ; dispatcher_node = cgraph_node :: get_create ( dispatch_decl ) ; gcc_assert ( dispatcher_node != NULL ) ; dispatcher_node -> dispatcher_function = <NUM_LIT> ; dispatcher_version_info = dispatcher_node -> insert_new_function_version ( ) ;

dispatcher_version_info -> next = default_version_info ;


<s> tree ix86_mangle_decl_assembler_name ( tree decl , tree id ) {


<s> char * attr_str , * assembler_name ; if ( DECL_DECLARED_INLINE_P ( decl ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> <STR_LIT> ) ; if ( DECL_VIRTUAL_P ( decl ) || DECL_VINDEX ( decl ) ) sorry ( <STR_LIT> ) ; version_attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; gcc_assert ( version_attr != NULL_TREE ) ; orig_name = IDENTIFIER_POINTER ( id ) ; version_string = TREE_STRING_POINTER ( TREE_VALUE ( TREE_VALUE ( version_attr ) ) ) ; if ( strcmp ( version_string , <STR_LIT> ) == <NUM_LIT> ) return id ; attr_str = sorted_attr_string ( TREE_VALUE ( version_attr ) ) ; assembler_name = XNEWVEC ( char , strlen ( orig_name ) + strlen ( attr_str ) + <NUM_LIT> ) ; sprintf ( assembler_name , <STR_LIT> , orig_name , attr_str ) ; if ( DECL_ASSEMBLER_NAME_SET_P ( decl ) ) SET_DECL_RTL ( decl , NULL ) ; tree ret = get_identifier ( assembler_name ) ;


<s> return new pass_insert_endbranch ( ctxt ) ;


<s> return new pass_insert_endbr_and_patchable_area ( ctxt ) ;


return new pass_insert_endbr_and_patchable_area ( ctxt ) ;


<s> return new pass_insert_vzeroupper ( ctxt ) ;


<s> rtl_opt_pass * make_pass_insert_vzeroupper ( gcc :: context * ctxt ) { return new pass_insert_vzeroupper ( ctxt ) ;


<s> return new pass_remove_partial_avx_dependency ( ctxt ) ;


<s> tree decl_name = clone_function_name ( default_decl , <STR_LIT> ) ; const char * resolver_name = IDENTIFIER_POINTER ( decl_name ) ; type = build_function_type_list ( ptr_type_node , NULL_TREE ) ; decl = build_fn_decl ( resolver_name , type ) ; SET_DECL_ASSEMBLER_NAME ( decl , decl_name ) ; DECL_NAME ( decl ) = decl_name ; TREE_USED ( decl ) = <NUM_LIT> ; DECL_ARTIFICIAL ( decl ) = <NUM_LIT> ; DECL_IGNORED_P ( decl ) = <NUM_LIT> ; TREE_PUBLIC ( decl ) = <NUM_LIT> ; DECL_UNINLINABLE ( decl ) = <NUM_LIT> ; DECL_EXTERNAL ( decl ) = <NUM_LIT> ; DECL_EXTERNAL ( ifunc_alias_decl ) = <NUM_LIT> ; DECL_CONTEXT ( decl ) = NULL_TREE ; DECL_INITIAL ( decl ) = make_node ( BLOCK ) ; DECL_STATIC_CONSTRUCTOR ( decl ) = <NUM_LIT> ; if ( DECL_COMDAT_GROUP ( default_decl ) || TREE_PUBLIC ( default_decl ) ) { DECL_COMDAT ( decl ) = <NUM_LIT> ; make_decl_one_only ( decl , DECL_ASSEMBLER_NAME ( decl ) ) ; } else TREE_PUBLIC ( ifunc_alias_decl ) = <NUM_LIT> ; t = build_decl ( UNKNOWN_LOCATION , RESULT_DECL , NULL_TREE , ptr_type_node ) ; DECL_CONTEXT ( t ) = decl ; DECL_ARTIFICIAL ( t ) = <NUM_LIT> ; DECL_IGNORED_P ( t ) = <NUM_LIT> ; DECL_RESULT ( decl ) = t ; gimplify_function_tree ( decl ) ; push_cfun ( DECL_STRUCT_FUNCTION ( decl ) ) ; * empty_bb = init_lowered_empty_function ( decl , false , profile_count :: uninitialized ( ) ) ;

cgraph_node :: add_new_function ( decl , true ) ;


<s> DECL_CONTEXT ( decl ) = NULL_TREE ; DECL_INITIAL ( decl ) = make_node ( BLOCK ) ; DECL_STATIC_CONSTRUCTOR ( decl ) = <NUM_LIT> ; if ( DECL_COMDAT_GROUP ( default_decl ) || TREE_PUBLIC ( default_decl ) ) { DECL_COMDAT ( decl ) = <NUM_LIT> ; make_decl_one_only ( decl , DECL_ASSEMBLER_NAME ( decl ) ) ; } else TREE_PUBLIC ( ifunc_alias_decl ) = <NUM_LIT> ; t = build_decl ( UNKNOWN_LOCATION , RESULT_DECL , NULL_TREE , ptr_type_node ) ; DECL_CONTEXT ( t ) = decl ; DECL_ARTIFICIAL ( t ) = <NUM_LIT> ; DECL_IGNORED_P ( t ) = <NUM_LIT> ; DECL_RESULT ( decl ) = t ; gimplify_function_tree ( decl ) ; push_cfun ( DECL_STRUCT_FUNCTION ( decl ) ) ; * empty_bb = init_lowered_empty_function ( decl , false , profile_count :: uninitialized ( ) ) ; cgraph_node :: add_new_function ( decl , true ) ; symtab -> call_cgraph_insertion_hooks ( cgraph_node :: get_create ( decl ) ) ; pop_cfun ( ) ; gcc_assert ( ifunc_alias_decl != NULL ) ;


<s> } else if ( ! TARGET_64BIT && smode == DImode ) { 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 { 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 emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( vmode , vreg , <NUM_LIT> ) , gen_gpr_to_xmm_move_src ( vmode , reg ) ) ) ;


<s> void timode_scalar_chain :: mark_dual_mode_def ( df_ref ) {


<s> void timode_scalar_chain :: mark_dual_mode_def ( df_ref ) { gcc_unreachable ( ) ;


<s> pass_insert_endbranch ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_insert_endbranch , ctxt ) {


<s> pass_insert_vzeroupper ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_insert_vzeroupper , ctxt ) {


<s> pass_remove_partial_avx_dependency ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_remove_partial_avx_dependency , ctxt ) {


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


<s> if ( REG_P ( SET_SRC ( set ) ) && ! HARD_REGISTER_P ( SET_SRC ( set ) ) && push_operand ( SET_DEST ( set ) , mode ) ) return set ; df_ref ref ; FOR_EACH_INSN_DEF ( ref , insn ) if ( HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) && ! DF_REF_FLAGS_IS_SET ( ref , DF_REF_MUST_CLOBBER ) && DF_REF_REGNO ( ref ) != FLAGS_REG ) return NULL ; FOR_EACH_INSN_USE ( ref , insn ) if ( ! DF_REF_REG_MEM_P ( ref ) && HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) ) return NULL ;


<s> if ( REG_P ( SET_SRC ( set ) ) && ! HARD_REGISTER_P ( SET_SRC ( set ) ) && push_operand ( SET_DEST ( set ) , mode ) ) return set ; df_ref ref ; FOR_EACH_INSN_DEF ( ref , insn ) if ( HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) && ! DF_REF_FLAGS_IS_SET ( ref , DF_REF_MUST_CLOBBER ) && DF_REF_REGNO ( ref ) != FLAGS_REG ) return NULL ; FOR_EACH_INSN_USE ( ref , insn ) if ( ! DF_REF_REG_MEM_P ( ref ) && HARD_REGISTER_P ( DF_REF_REAL_REG ( ref ) ) ) return NULL ; return set ;


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


<s> static unsigned int rest_of_handle_insert_vzeroupper ( void ) { for ( int i = <NUM_LIT> ; i < MAX_386_ENTITIES ; i ++ ) ix86_optimize_mode_switching [ i ] = <NUM_LIT> ; ix86_optimize_mode_switching [ AVX_U128 ] = <NUM_LIT> ; g -> get_passes ( ) -> execute_pass_mode_switching ( ) ; df_analyze ( ) ;


<s> rtx_insn * insn = BB_HEAD ( bb ) ; endbr_insn = emit_insn_before ( endbr , insn ) ; } } } if ( patchable_area_size ) { if ( crtl -> profile && flag_fentry ) { if ( ! cfun -> machine -> insn_queued_at_entrance ) cfun -> machine -> insn_queued_at_entrance = TYPE_PATCHABLE_AREA ; } else { rtx patchable_area = gen_patchable_area ( GEN_INT ( patchable_area_size ) , GEN_INT ( crtl -> patch_area_entry == <NUM_LIT> ) ) ; if ( endbr_insn ) emit_insn_after ( patchable_area , endbr_insn ) ; else { bb = ENTRY_BLOCK_PTR_FOR_FN ( cfun ) -> next_bb ; insn = BB_HEAD ( bb ) ; emit_insn_before ( patchable_area , insn ) ; } } } if ( ! need_endbr ) return ; bb = <NUM_LIT> ; FOR_EACH_BB_FN ( bb , cfun ) { for ( insn = BB_HEAD ( bb ) ; insn != NEXT_INSN ( BB_END ( bb ) ) ; insn = NEXT_INSN ( insn ) ) { if ( CALL_P ( insn ) ) { need_endbr = find_reg_note ( insn , REG_SETJMP , NULL ) != NULL ; if ( ! need_endbr && ! SIBLING_CALL_P ( insn ) ) { rtx call = get_call_rtx_from ( insn ) ; rtx fnaddr = XEXP ( call , <NUM_LIT> ) ; tree fndecl = NULL_TREE ; if ( GET_CODE ( XEXP ( fnaddr , <NUM_LIT> ) ) == SYMBOL_REF ) fndecl = SYMBOL_REF_DECL ( XEXP ( fnaddr , <NUM_LIT> ) ) ; if ( fndecl == NULL_TREE ) fndecl = MEM_EXPR ( fnaddr ) ; if ( fndecl && TREE_CODE ( TREE_TYPE ( fndecl ) ) != FUNCTION_TYPE && TREE_CODE ( TREE_TYPE ( fndecl ) ) != METHOD_TYPE ) fndecl = NULL_TREE ; if ( fndecl && TYPE_ARG_TYPES ( TREE_TYPE ( fndecl ) ) ) { tree fntype = TREE_TYPE ( fndecl ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) need_endbr = true ; } } if ( ! need_endbr ) continue ; endbr = gen_nop_endbr ( ) ; emit_insn_after_setloc ( endbr , insn , INSN_LOCATION ( insn ) ) ; continue ; } if ( JUMP_P ( insn ) && flag_cet_switch ) { rtx target = JUMP_LABEL ( insn ) ; if ( target == NULL_RTX || ANY_RETURN_P ( target ) ) continue ; rtx_insn * label = as_a < rtx_insn * > ( target ) ; rtx_insn * table = next_insn ( label ) ; if ( table == NULL_RTX || ! JUMP_TABLE_DATA_P ( table ) ) continue ; edge_iterator ei ; edge e ; basic_block dest_blk ; FOR_EACH_EDGE ( e , ei , bb -> succs ) { rtx_insn * insn ; dest_blk = e -> dest ; insn = BB_HEAD ( dest_blk ) ; gcc_assert ( LABEL_P ( insn ) ) ; endbr = gen_nop_endbr ( ) ; emit_insn_after ( endbr , insn ) ; }


<s> emit_insn_before ( patchable_area , insn ) ; } } } if ( ! need_endbr ) return ; bb = <NUM_LIT> ; FOR_EACH_BB_FN ( bb , cfun ) { for ( insn = BB_HEAD ( bb ) ; insn != NEXT_INSN ( BB_END ( bb ) ) ; insn = NEXT_INSN ( insn ) ) { if ( CALL_P ( insn ) ) { need_endbr = find_reg_note ( insn , REG_SETJMP , NULL ) != NULL ; if ( ! need_endbr && ! SIBLING_CALL_P ( insn ) ) { rtx call = get_call_rtx_from ( insn ) ; rtx fnaddr = XEXP ( call , <NUM_LIT> ) ; tree fndecl = NULL_TREE ; if ( GET_CODE ( XEXP ( fnaddr , <NUM_LIT> ) ) == SYMBOL_REF ) fndecl = SYMBOL_REF_DECL ( XEXP ( fnaddr , <NUM_LIT> ) ) ; if ( fndecl == NULL_TREE ) fndecl = MEM_EXPR ( fnaddr ) ; if ( fndecl && TREE_CODE ( TREE_TYPE ( fndecl ) ) != FUNCTION_TYPE && TREE_CODE ( TREE_TYPE ( fndecl ) ) != METHOD_TYPE ) fndecl = NULL_TREE ; if ( fndecl && TYPE_ARG_TYPES ( TREE_TYPE ( fndecl ) ) ) { tree fntype = TREE_TYPE ( fndecl ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) need_endbr = true ; } } if ( ! need_endbr ) continue ; endbr = gen_nop_endbr ( ) ; emit_insn_after_setloc ( endbr , insn , INSN_LOCATION ( insn ) ) ; continue ; } if ( JUMP_P ( insn ) && flag_cet_switch ) { rtx target = JUMP_LABEL ( insn ) ; if ( target == NULL_RTX || ANY_RETURN_P ( target ) ) continue ; rtx_insn * label = as_a < rtx_insn * > ( target ) ; rtx_insn * table = next_insn ( label ) ; if ( table == NULL_RTX || ! JUMP_TABLE_DATA_P ( table ) ) continue ; edge_iterator ei ; edge e ; basic_block dest_blk ; FOR_EACH_EDGE ( e , ei , bb -> succs ) { rtx_insn * insn ; dest_blk = e -> dest ; insn = BB_HEAD ( dest_blk ) ; gcc_assert ( LABEL_P ( insn ) ) ; endbr = gen_nop_endbr ( ) ; emit_insn_after ( endbr , insn ) ; } continue ;


<s> vmode = vmode_ ; 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 ) ;


<s> ref ; ref = DF_REF_NEXT_REG ( ref ) ) { if ( NONDEBUG_INSN_P ( DF_REF_INSN ( ref ) ) && ! bitmap_bit_p ( candidates , DF_REF_INSN_UID ( ref ) ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , DF_REF_INSN_UID ( ref ) ) ; bitmap_set_bit ( regs , regno ) ; break ;


<s> } for ( df_ref ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) { if ( NONDEBUG_INSN_P ( DF_REF_INSN ( ref ) ) && ! bitmap_bit_p ( candidates , DF_REF_INSN_UID ( ref ) ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , DF_REF_INSN_UID ( ref ) ) ;


<s> timode_scalar_chain ( ) : scalar_chain ( TImode , V1TImode ) {


<s> return true ; case CONST_INT : return standard_sse_constant_p ( src , TImode ) ; } } else if ( MEM_P ( src ) ) { return ( REG_P ( dst ) && ( ! misaligned_operand ( src , TImode ) || TARGET_SSE_UNALIGNED_LOAD_OPTIMAL ) ) ; }


<s> int general_scalar_chain :: vector_const_cost ( rtx exp ) { gcc_assert ( CONST_INT_P ( exp ) ) ; if ( standard_sse_constant_p ( exp , vmode ) ) return ix86_cost -> sse_op ;

return ix86_cost -> sse_load [ smode == DImode ? <NUM_LIT> : <NUM_LIT> ] ;


<s> if ( standard_sse_constant_p ( exp , vmode ) ) return ix86_cost -> sse_op ; return ix86_cost -> sse_load [ smode == DImode ? <NUM_LIT> : <NUM_LIT> ] ;


<s> for ( i = j = <NUM_LIT> ; i < MAX_REGS ; ++ i ) { unsigned regno = REG_ORDER [ i ] ; if ( regno == BP_REG && hfp ) continue ; if ( SSE_REGNO_P ( regno ) ) { offset += <NUM_LIT> ; gcc_assert ( ! ( ( stack_align_off_in + offset ) & <NUM_LIT> ) ) ; } else offset += <NUM_LIT> ; m_regs [ j ] . regno = regno ; m_regs [ j ++ ] . offset = offset - STUB_INDEX_OFFSET ; } gcc_assert ( j == m_nregs ) ;


<s> general_scalar_chain :: ~ general_scalar_chain ( ) {


<s> ix86_prefetch_sse = ptr -> prefetch_sse ; ix86_tune_defaulted = ptr -> tune_defaulted ; ix86_arch_specified = ptr -> arch_specified ; opts -> x_ix86_isa_flags_explicit = ptr -> x_ix86_isa_flags_explicit ; opts -> x_ix86_isa_flags2_explicit = ptr -> x_ix86_isa_flags2_explicit ; opts -> x_recip_mask_explicit = ptr -> x_recip_mask_explicit ; opts -> x_ix86_arch_string = ptr -> x_ix86_arch_string ; opts -> x_ix86_tune_string = ptr -> x_ix86_tune_string ; opts -> x_ix86_asm_dialect = ptr -> x_ix86_asm_dialect ; opts -> x_ix86_branch_cost = ptr -> x_ix86_branch_cost ; opts -> x_ix86_dump_tunes = ptr -> x_ix86_dump_tunes ; opts -> x_ix86_force_align_arg_pointer = ptr -> x_ix86_force_align_arg_pointer ; opts -> x_ix86_force_drap = ptr -> x_ix86_force_drap ; opts -> x_ix86_recip_name = ptr -> x_ix86_recip_name ; opts -> x_ix86_section_threshold = ptr -> x_ix86_section_threshold ; opts -> x_ix86_sse2avx = ptr -> x_ix86_sse2avx ; opts -> x_ix86_stack_protector_guard = ptr -> x_ix86_stack_protector_guard ; opts -> x_ix86_stringop_alg = ptr -> x_ix86_stringop_alg ; opts -> x_ix86_tls_dialect = ptr -> x_ix86_tls_dialect ; opts -> x_ix86_tune_ctrl_string = ptr -> x_ix86_tune_ctrl_string ; opts -> x_ix86_tune_memcpy_strategy = ptr -> x_ix86_tune_memcpy_strategy ; opts -> x_ix86_tune_memset_strategy = ptr -> x_ix86_tune_memset_strategy ; opts -> x_ix86_tune_no_default = ptr -> x_ix86_tune_no_default ; ix86_tune_cost = processor_cost_table [ ix86_tune ] ; if ( opts -> x_optimize_size ) ix86_cost = & ix86_size_cost ; else ix86_cost = ix86_tune_cost ;