* Cleanup optabs handler interface
@ 2007-07-31 18:30 Jan Hubicka
2007-08-06 2:56 ` Mark Mitchell
0 siblings, 1 reply; 2+ messages in thread
From: Jan Hubicka @ 2007-07-31 18:30 UTC (permalink / raw)
To: gcc-patches
Hi,
one of several obstackles on the plan to change obtabs representation
into something more space conservative (my plan is to use simple
compressed tries - adding optab ID into handler structure and puting all
handlers into one big table allowing handlers arrays from multiple
optabs to overlap) is the fact that the arrays are accessed directly
across the compiler.
This patch adds simple accestor macro optab_handler and
convert_optab_handler. It is 90% simple set script substitution with
manual cleanup of formatting and some nonstandard cases.
Bootstrapped/regtested i686-linux, OK?
:ADDPATCH middle-end:
Honza
* optabs.c (expand_widen_pattern_expr): Use optabs accestors.
(expand_ternary_op): Likewise.
(expand_vec_shift_expr): Likewise.
(expand_binop_directly): Likewise.
(expand_binop): Likewise.
(sign_expand_binop): Likewise.
(expand_twoval_unop): Likewise.
(expand_twoval_binop): Likewise.
(expand_twoval_binop_libfunc): Likewise.
(widen_clz): Likewise.
(widen_bswap): Likewise.
(expand_parity): Likewise.
(expand_unop): Likewise.
(expand_abs_nojump): Likewise.
(expand_copysign): Likewise.
(emit_no_conflict_block): Likewise.
(emit_libcall_block): Likewise.
(can_compare_p): Likewise.
(prepare_cmp_insn): Likewise.
(emit_cmp_and_jump_insn_1): Likewise.
(prepare_float_lib_cmp): Likewise.
(emit_conditional_add): Likewise.
(gen_add2_insn): Likewise.
(have_add2_insn): Likewise.
(gen_sub2_insn): Likewise.
(have_sub2_insn): Likewise.
(can_extend_p): Likewise.
(can_fix_p): Likewise.
(can_float_p): Likewise.
(expand_float): Likewise.
(expand_fix): Likewise.
(expand_sfix_optab): Likewise.
(new_optab): Likewise.
(new_convert_optab): Likewise.
(init_libfuncs): Likewise.
(init_interclass_conv_libfuncs): Likewise.
(init_intraclass_conv_libfuncs): Likewise.
(set_conv_libfunc): Likewise.
(init_optabs): Likewise.
(debug_optab_libfuncs): Likewise.
(gen_cond_trap): Likewise.
* optabs.h (optab_handler, convert_optab_hanlder): New.
* genopinit.c: Update optabs generation table.
* reload.c (find_reloads_address_1): Use optabs accestors.
* builtins.c (expand_builtin_mathfn): Likewise.
(expand_builtin_mathfn_2): Likewise.
(expand_builtin_mathfn_3): Likewise.
(expand_builtin_interclass_mathfn): Likewise.
(expand_builtin_sincos): Likewise.
(expand_builtin_cexpi): Likewise.
(expand_builtin_powi): Likewise.
(expand_builtin_strlen): Likewise.
* dojump.c (do_jump): Likewise.
* expr.c (convert_move): Likewise.
(move_by_pieces): Likewise.
(move_by_pieces_ninsns): Likewise.
(can_store_by_pieces): Likewise.
(store_by_pieces_1): Likewise.
(emit_move_via_integer): Likewise.
(emit_move_complex): Likewise.
(emit_move_ccmode): Likewise.
(emit_move_insn_1): Likewise.
(emit_single_push_insn): Likewise.
(store_constructor): Likewise.
(expand_expr_real_1): Likewise.
(do_store_flag): Likewise.
* ada/misc.c (gnat_compute_largest_alignment): Likewise.
(enumerate_modes): Likewise.
* tree-vectorizer.c (vect_supportable_dr_alignment): Likewise.
(supportable_widening_operation): Likewise.
(supportable_narrowing_operation): Likewise.
* expmed.c (store_bit_field_1): Likewise.
(extract_bit_field_1): Likewise.
(expand_mult_highpart_optab): Likewise.
(expand_smod_pow2): Likewise.
(expand_divmod): Likewise.
(emit_store_flag): Likewise.
* tree-vect-patterns.c
(vect_pattern_recog_1): Likewise.
* tree-ssa-loop-prefetch.c
(nontemporal_store_p): Likewise.
* tree-vect-transform.c (vect_model_reduction_cost): Likewise.
(vect_create_epilog_for_reduction): Likewise.
(vectorizable_reduction): Likewise.
(vectorizable_operation): Likewise.
(vect_strided_store_supported): Likewise.
(vectorizable_store): Likewise.
(vect_strided_load_supported): Likewise.
(vectorizable_load): Likewise.
* combine.c (simplify_comparison): Likewise.
* tree-vect-generic.c
(type_for_widest_vector_mode): Likewise.
(expand_vector_operations_1): Likewise.
* config/spu/spu.c (spu_expand_mov): Likewise.
(spu_emit_vector_compare): Likewise.
* config/rs6000/rs6000.c
(rs6000_emit_vector_compare): Likewise.
* stmt.c (add_case_node): Likewise.
* reload1.c (gen_reload):
Index: optabs.c
===================================================================
*** optabs.c (revision 127065)
--- optabs.c (working copy)
*************** expand_widen_pattern_expr (tree exp, rtx
*** 443,449 ****
tmode0 = TYPE_MODE (TREE_TYPE (oprnd0));
widen_pattern_optab =
optab_for_tree_code (TREE_CODE (exp), TREE_TYPE (oprnd0));
! icode = (int) widen_pattern_optab->handlers[(int) tmode0].insn_code;
gcc_assert (icode != CODE_FOR_nothing);
xmode0 = insn_data[icode].operand[1].mode;
--- 443,449 ----
tmode0 = TYPE_MODE (TREE_TYPE (oprnd0));
widen_pattern_optab =
optab_for_tree_code (TREE_CODE (exp), TREE_TYPE (oprnd0));
! icode = (int) optab_handler (widen_pattern_optab, tmode0)->insn_code;
gcc_assert (icode != CODE_FOR_nothing);
xmode0 = insn_data[icode].operand[1].mode;
*************** rtx
*** 568,574 ****
expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
rtx op1, rtx op2, rtx target, int unsignedp)
{
! int icode = (int) ternary_optab->handlers[(int) mode].insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
enum machine_mode mode2 = insn_data[icode].operand[3].mode;
--- 568,574 ----
expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
rtx op1, rtx op2, rtx target, int unsignedp)
{
! int icode = (int) optab_handler (ternary_optab, mode)->insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
enum machine_mode mode2 = insn_data[icode].operand[3].mode;
*************** expand_ternary_op (enum machine_mode mod
*** 576,582 ****
rtx pat;
rtx xop0 = op0, xop1 = op1, xop2 = op2;
! gcc_assert (ternary_optab->handlers[(int) mode].insn_code
!= CODE_FOR_nothing);
if (!target || !insn_data[icode].operand[0].predicate (target, mode))
--- 576,582 ----
rtx pat;
rtx xop0 = op0, xop1 = op1, xop2 = op2;
! gcc_assert (optab_handler (ternary_optab, mode)->insn_code
!= CODE_FOR_nothing);
if (!target || !insn_data[icode].operand[0].predicate (target, mode))
*************** expand_vec_shift_expr (tree vec_shift_ex
*** 697,703 ****
gcc_unreachable ();
}
! icode = (int) shift_optab->handlers[(int) mode].insn_code;
gcc_assert (icode != CODE_FOR_nothing);
mode1 = insn_data[icode].operand[1].mode;
--- 697,703 ----
gcc_unreachable ();
}
! icode = (int) optab_handler (shift_optab, mode)->insn_code;
gcc_assert (icode != CODE_FOR_nothing);
mode1 = insn_data[icode].operand[1].mode;
*************** expand_binop_directly (enum machine_mode
*** 1254,1260 ****
rtx target, int unsignedp, enum optab_methods methods,
int commutative_op, rtx last)
{
! int icode = (int) binoptab->handlers[(int) mode].insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
enum machine_mode tmp_mode;
--- 1254,1260 ----
rtx target, int unsignedp, enum optab_methods methods,
int commutative_op, rtx last)
{
! int icode = (int) optab_handler (binoptab, mode)->insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
enum machine_mode tmp_mode;
*************** expand_binop (enum machine_mode mode, op
*** 1437,1443 ****
/* If we can do it with a three-operand insn, do so. */
if (methods != OPTAB_MUST_WIDEN
! && binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
temp = expand_binop_directly (mode, binoptab, op0, op1, target,
unsignedp, methods, commutative_op, last);
--- 1437,1443 ----
/* If we can do it with a three-operand insn, do so. */
if (methods != OPTAB_MUST_WIDEN
! && optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing)
{
temp = expand_binop_directly (mode, binoptab, op0, op1, target,
unsignedp, methods, commutative_op, last);
*************** expand_binop (enum machine_mode mode, op
*** 1448,1456 ****
/* If we were trying to rotate, and that didn't work, try rotating
the other direction before falling back to shifts and bitwise-or. */
if (((binoptab == rotl_optab
! && rotr_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
|| (binoptab == rotr_optab
! && rotl_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing))
&& class == MODE_INT)
{
optab otheroptab = (binoptab == rotl_optab ? rotr_optab : rotl_optab);
--- 1448,1456 ----
/* If we were trying to rotate, and that didn't work, try rotating
the other direction before falling back to shifts and bitwise-or. */
if (((binoptab == rotl_optab
! && optab_handler (rotr_optab, mode)->insn_code != CODE_FOR_nothing)
|| (binoptab == rotr_optab
! && optab_handler (rotl_optab, mode)->insn_code != CODE_FOR_nothing))
&& class == MODE_INT)
{
optab otheroptab = (binoptab == rotl_optab ? rotr_optab : rotl_optab);
*************** expand_binop (enum machine_mode mode, op
*** 1478,1485 ****
if (binoptab == smul_optab
&& GET_MODE_WIDER_MODE (mode) != VOIDmode
! && (((unsignedp ? umul_widen_optab : smul_widen_optab)
! ->handlers[(int) GET_MODE_WIDER_MODE (mode)].insn_code)
!= CODE_FOR_nothing))
{
temp = expand_binop (GET_MODE_WIDER_MODE (mode),
--- 1478,1485 ----
if (binoptab == smul_optab
&& GET_MODE_WIDER_MODE (mode) != VOIDmode
! && ((optab_handler ((unsignedp ? umul_widen_optab : smul_widen_optab),
! GET_MODE_WIDER_MODE (mode))->insn_code)
!= CODE_FOR_nothing))
{
temp = expand_binop (GET_MODE_WIDER_MODE (mode),
*************** expand_binop (enum machine_mode mode, op
*** 1507,1517 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (binoptab->handlers[(int) wider_mode].insn_code != CODE_FOR_nothing
|| (binoptab == smul_optab
&& GET_MODE_WIDER_MODE (wider_mode) != VOIDmode
! && (((unsignedp ? umul_widen_optab : smul_widen_optab)
! ->handlers[(int) GET_MODE_WIDER_MODE (wider_mode)].insn_code)
!= CODE_FOR_nothing)))
{
rtx xop0 = op0, xop1 = op1;
--- 1507,1518 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (optab_handler (binoptab, wider_mode)->insn_code != CODE_FOR_nothing
|| (binoptab == smul_optab
&& GET_MODE_WIDER_MODE (wider_mode) != VOIDmode
! && ((optab_handler ((unsignedp ? umul_widen_optab
! : smul_widen_optab),
! GET_MODE_WIDER_MODE (wider_mode))->insn_code)
!= CODE_FOR_nothing)))
{
rtx xop0 = op0, xop1 = op1;
*************** expand_binop (enum machine_mode mode, op
*** 1559,1565 ****
if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
&& class == MODE_INT
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD
! && binoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
{
int i;
rtx insns;
--- 1560,1566 ----
if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
&& class == MODE_INT
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD
! && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing)
{
int i;
rtx insns;
*************** expand_binop (enum machine_mode mode, op
*** 1611,1619 ****
&& class == MODE_INT
&& (GET_CODE (op1) == CONST_INT || !optimize_size)
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && binoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
! && ashl_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
! && lshr_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
{
unsigned HOST_WIDE_INT shift_mask, double_shift_mask;
enum machine_mode op1_mode;
--- 1612,1620 ----
&& class == MODE_INT
&& (GET_CODE (op1) == CONST_INT || !optimize_size)
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing
! && optab_handler (ashl_optab, word_mode)->insn_code != CODE_FOR_nothing
! && optab_handler (lshr_optab, word_mode)->insn_code != CODE_FOR_nothing)
{
unsigned HOST_WIDE_INT shift_mask, double_shift_mask;
enum machine_mode op1_mode;
*************** expand_binop (enum machine_mode mode, op
*** 1682,1689 ****
&& class == MODE_INT
&& GET_CODE (op1) == CONST_INT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && ashl_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
! && lshr_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
{
rtx insns;
rtx into_target, outof_target;
--- 1683,1690 ----
&& class == MODE_INT
&& GET_CODE (op1) == CONST_INT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && optab_handler (ashl_optab, word_mode)->insn_code != CODE_FOR_nothing
! && optab_handler (lshr_optab, word_mode)->insn_code != CODE_FOR_nothing)
{
rtx insns;
rtx into_target, outof_target;
*************** expand_binop (enum machine_mode mode, op
*** 1799,1805 ****
if ((binoptab == add_optab || binoptab == sub_optab)
&& class == MODE_INT
&& GET_MODE_SIZE (mode) >= 2 * UNITS_PER_WORD
! && binoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
{
unsigned int i;
optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
--- 1800,1806 ----
if ((binoptab == add_optab || binoptab == sub_optab)
&& class == MODE_INT
&& GET_MODE_SIZE (mode) >= 2 * UNITS_PER_WORD
! && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing)
{
unsigned int i;
optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
*************** expand_binop (enum machine_mode mode, op
*** 1896,1902 ****
if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
{
! if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
|| ! rtx_equal_p (target, xtarget))
{
rtx temp = emit_move_insn (target, xtarget);
--- 1897,1903 ----
if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
{
! if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing
|| ! rtx_equal_p (target, xtarget))
{
rtx temp = emit_move_insn (target, xtarget);
*************** expand_binop (enum machine_mode mode, op
*** 1925,1936 ****
if (binoptab == smul_optab
&& class == MODE_INT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && smul_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
! && add_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
{
rtx product = NULL_RTX;
! if (umul_widen_optab->handlers[(int) mode].insn_code
!= CODE_FOR_nothing)
{
product = expand_doubleword_mult (mode, op0, op1, target,
--- 1926,1937 ----
if (binoptab == smul_optab
&& class == MODE_INT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && optab_handler (smul_optab, word_mode)->insn_code != CODE_FOR_nothing
! && optab_handler (add_optab, word_mode)->insn_code != CODE_FOR_nothing)
{
rtx product = NULL_RTX;
! if (optab_handler (umul_widen_optab, mode)->insn_code
!= CODE_FOR_nothing)
{
product = expand_doubleword_mult (mode, op0, op1, target,
*************** expand_binop (enum machine_mode mode, op
*** 1940,1946 ****
}
if (product == NULL_RTX
! && smul_widen_optab->handlers[(int) mode].insn_code
!= CODE_FOR_nothing)
{
product = expand_doubleword_mult (mode, op0, op1, target,
--- 1941,1947 ----
}
if (product == NULL_RTX
! && optab_handler (smul_widen_optab, mode)->insn_code
!= CODE_FOR_nothing)
{
product = expand_doubleword_mult (mode, op0, op1, target,
*************** expand_binop (enum machine_mode mode, op
*** 1951,1957 ****
if (product != NULL_RTX)
{
! if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
temp = emit_move_insn (target ? target : product, product);
set_unique_reg_note (temp,
--- 1952,1958 ----
if (product != NULL_RTX)
{
! if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing)
{
temp = emit_move_insn (target ? target : product, product);
set_unique_reg_note (temp,
*************** expand_binop (enum machine_mode mode, op
*** 1967,1973 ****
/* It can't be open-coded in this mode.
Use a library call if one is available and caller says that's ok. */
! if (binoptab->handlers[(int) mode].libfunc
&& (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN))
{
rtx insns;
--- 1968,1974 ----
/* It can't be open-coded in this mode.
Use a library call if one is available and caller says that's ok. */
! if (optab_handler (binoptab, mode)->libfunc
&& (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN))
{
rtx insns;
*************** expand_binop (enum machine_mode mode, op
*** 1991,1997 ****
/* Pass 1 for NO_QUEUE so we don't lose any increments
if the libcall is cse'd or moved. */
! value = emit_library_call_value (binoptab->handlers[(int) mode].libfunc,
NULL_RTX, LCT_CONST, mode, 2,
op0, mode, op1x, op1_mode);
--- 1992,1998 ----
/* Pass 1 for NO_QUEUE so we don't lose any increments
if the libcall is cse'd or moved. */
! value = emit_library_call_value (optab_handler (binoptab, mode)->libfunc,
NULL_RTX, LCT_CONST, mode, 2,
op0, mode, op1x, op1_mode);
*************** expand_binop (enum machine_mode mode, op
*** 2031,2040 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if ((binoptab->handlers[(int) wider_mode].insn_code
!= CODE_FOR_nothing)
|| (methods == OPTAB_LIB
! && binoptab->handlers[(int) wider_mode].libfunc))
{
rtx xop0 = op0, xop1 = op1;
int no_extend = 0;
--- 2032,2041 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if ((optab_handler (binoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
|| (methods == OPTAB_LIB
! && optab_handler (binoptab, wider_mode)->libfunc))
{
rtx xop0 = op0, xop1 = op1;
int no_extend = 0;
*************** sign_expand_binop (enum machine_mode mod
*** 2107,2117 ****
/* Try widening to a signed int. Make a fake signed optab that
hides any signed insn for direct use. */
! wide_soptab = *soptab;
! wide_soptab.handlers[(int) mode].insn_code = CODE_FOR_nothing;
! wide_soptab.handlers[(int) mode].libfunc = 0;
! temp = expand_binop (mode, &wide_soptab, op0, op1, target,
unsignedp, OPTAB_WIDEN);
/* For unsigned operands, try widening to an unsigned int. */
--- 2108,2117 ----
/* Try widening to a signed int. Make a fake signed optab that
hides any signed insn for direct use. */
! optab_handler (soptab, mode)->insn_code = CODE_FOR_nothing;
! optab_handler (soptab, mode)->libfunc = 0;
! temp = expand_binop (mode, soptab, op0, op1, target,
unsignedp, OPTAB_WIDEN);
/* For unsigned operands, try widening to an unsigned int. */
*************** expand_twoval_unop (optab unoptab, rtx o
*** 2168,2176 ****
/* Record where to go back to if we fail. */
last = get_last_insn ();
! if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
! int icode = (int) unoptab->handlers[(int) mode].insn_code;
enum machine_mode mode0 = insn_data[icode].operand[2].mode;
rtx pat;
rtx xop0 = op0;
--- 2168,2176 ----
/* Record where to go back to if we fail. */
last = get_last_insn ();
! if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing)
{
! int icode = (int) optab_handler (unoptab, mode)->insn_code;
enum machine_mode mode0 = insn_data[icode].operand[2].mode;
rtx pat;
rtx xop0 = op0;
*************** expand_twoval_unop (optab unoptab, rtx o
*** 2206,2212 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (unoptab->handlers[(int) wider_mode].insn_code
!= CODE_FOR_nothing)
{
rtx t0 = gen_reg_rtx (wider_mode);
--- 2206,2212 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (optab_handler (unoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
{
rtx t0 = gen_reg_rtx (wider_mode);
*************** expand_twoval_binop (optab binoptab, rtx
*** 2271,2279 ****
/* Record where to go back to if we fail. */
last = get_last_insn ();
! if (binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
! int icode = (int) binoptab->handlers[(int) mode].insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
rtx pat;
--- 2271,2279 ----
/* Record where to go back to if we fail. */
last = get_last_insn ();
! if (optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing)
{
! int icode = (int) optab_handler (binoptab, mode)->insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
rtx pat;
*************** expand_twoval_binop (optab binoptab, rtx
*** 2329,2335 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (binoptab->handlers[(int) wider_mode].insn_code
!= CODE_FOR_nothing)
{
rtx t0 = gen_reg_rtx (wider_mode);
--- 2329,2335 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (optab_handler (binoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
{
rtx t0 = gen_reg_rtx (wider_mode);
*************** expand_twoval_binop_libfunc (optab binop
*** 2376,2382 ****
gcc_assert (!targ0 != !targ1);
mode = GET_MODE (op0);
! if (!binoptab->handlers[(int) mode].libfunc)
return false;
/* The value returned by the library function will have twice as
--- 2376,2382 ----
gcc_assert (!targ0 != !targ1);
mode = GET_MODE (op0);
! if (!optab_handler (binoptab, mode)->libfunc)
return false;
/* The value returned by the library function will have twice as
*************** expand_twoval_binop_libfunc (optab binop
*** 2384,2390 ****
libval_mode = smallest_mode_for_size (2 * GET_MODE_BITSIZE (mode),
MODE_INT);
start_sequence ();
! libval = emit_library_call_value (binoptab->handlers[(int) mode].libfunc,
NULL_RTX, LCT_CONST,
libval_mode, 2,
op0, mode,
--- 2384,2390 ----
libval_mode = smallest_mode_for_size (2 * GET_MODE_BITSIZE (mode),
MODE_INT);
start_sequence ();
! libval = emit_library_call_value (optab_handler (binoptab, mode)->libfunc,
NULL_RTX, LCT_CONST,
libval_mode, 2,
op0, mode,
*************** widen_clz (enum machine_mode mode, rtx o
*** 2430,2436 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (clz_optab->handlers[(int) wider_mode].insn_code
!= CODE_FOR_nothing)
{
rtx xop0, temp, last;
--- 2430,2436 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (optab_handler (clz_optab, wider_mode)->insn_code
!= CODE_FOR_nothing)
{
rtx xop0, temp, last;
*************** widen_bswap (enum machine_mode mode, rtx
*** 2473,2479 ****
for (wider_mode = GET_MODE_WIDER_MODE (mode);
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
! if (bswap_optab->handlers[wider_mode].insn_code != CODE_FOR_nothing)
goto found;
return NULL_RTX;
--- 2473,2479 ----
for (wider_mode = GET_MODE_WIDER_MODE (mode);
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
! if (optab_handler (bswap_optab, wider_mode)->insn_code != CODE_FOR_nothing)
goto found;
return NULL_RTX;
*************** expand_parity (enum machine_mode mode, r
*** 2535,2541 ****
for (wider_mode = mode; wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (popcount_optab->handlers[(int) wider_mode].insn_code
!= CODE_FOR_nothing)
{
rtx xop0, temp, last;
--- 2535,2541 ----
for (wider_mode = mode; wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (optab_handler (popcount_optab, wider_mode)->insn_code
!= CODE_FOR_nothing)
{
rtx xop0, temp, last;
*************** expand_unop (enum machine_mode mode, opt
*** 2708,2716 ****
class = GET_MODE_CLASS (mode);
! if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
! int icode = (int) unoptab->handlers[(int) mode].insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
rtx xop0 = op0;
--- 2708,2716 ----
class = GET_MODE_CLASS (mode);
! if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing)
{
! int icode = (int) optab_handler (unoptab, mode)->insn_code;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
rtx xop0 = op0;
*************** expand_unop (enum machine_mode mode, opt
*** 2769,2775 ****
return temp;
if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && unoptab->handlers[word_mode].insn_code != CODE_FOR_nothing)
{
temp = expand_doubleword_bswap (mode, op0, target);
if (temp)
--- 2769,2775 ----
return temp;
if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
! && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
{
temp = expand_doubleword_bswap (mode, op0, target);
if (temp)
*************** expand_unop (enum machine_mode mode, opt
*** 2784,2790 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (unoptab->handlers[(int) wider_mode].insn_code != CODE_FOR_nothing)
{
rtx xop0 = op0;
--- 2784,2790 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if (optab_handler (unoptab, wider_mode)->insn_code != CODE_FOR_nothing)
{
rtx xop0 = op0;
*************** expand_unop (enum machine_mode mode, opt
*** 2823,2829 ****
if (unoptab == one_cmpl_optab
&& class == MODE_INT
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD
! && unoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
{
int i;
rtx insns;
--- 2823,2829 ----
if (unoptab == one_cmpl_optab
&& class == MODE_INT
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD
! && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
{
int i;
rtx insns;
*************** expand_unop (enum machine_mode mode, opt
*** 2887,2893 ****
try_libcall:
/* Now try a library call in this mode. */
! if (unoptab->handlers[(int) mode].libfunc)
{
rtx insns;
rtx value;
--- 2887,2893 ----
try_libcall:
/* Now try a library call in this mode. */
! if (optab_handler (unoptab, mode)->libfunc)
{
rtx insns;
rtx value;
*************** expand_unop (enum machine_mode mode, opt
*** 2904,2910 ****
/* Pass 1 for NO_QUEUE so we don't lose any increments
if the libcall is cse'd or moved. */
! value = emit_library_call_value (unoptab->handlers[(int) mode].libfunc,
NULL_RTX, LCT_CONST, outmode,
1, op0, mode);
insns = get_insns ();
--- 2904,2910 ----
/* Pass 1 for NO_QUEUE so we don't lose any increments
if the libcall is cse'd or moved. */
! value = emit_library_call_value (optab_handler (unoptab, mode)->libfunc,
NULL_RTX, LCT_CONST, outmode,
1, op0, mode);
insns = get_insns ();
*************** expand_unop (enum machine_mode mode, opt
*** 2925,2933 ****
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if ((unoptab->handlers[(int) wider_mode].insn_code
!= CODE_FOR_nothing)
! || unoptab->handlers[(int) wider_mode].libfunc)
{
rtx xop0 = op0;
--- 2925,2933 ----
wider_mode != VOIDmode;
wider_mode = GET_MODE_WIDER_MODE (wider_mode))
{
! if ((optab_handler (unoptab, wider_mode)->insn_code
!= CODE_FOR_nothing)
! || optab_handler (unoptab, wider_mode)->libfunc)
{
rtx xop0 = op0;
*************** expand_abs_nojump (enum machine_mode mod
*** 3018,3024 ****
}
/* If we have a MAX insn, we can do this as MAX (x, -x). */
! if (smax_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
&& !HONOR_SIGNED_ZEROS (mode))
{
rtx last = get_last_insn ();
--- 3018,3024 ----
}
/* If we have a MAX insn, we can do this as MAX (x, -x). */
! if (optab_handler (smax_optab, mode)->insn_code != CODE_FOR_nothing
&& !HONOR_SIGNED_ZEROS (mode))
{
rtx last = get_last_insn ();
*************** expand_copysign (rtx op0, rtx op1, rtx t
*** 3335,3342 ****
if (fmt->signbit_ro >= 0
&& (GET_CODE (op0) == CONST_DOUBLE
! || (neg_optab->handlers[mode].insn_code != CODE_FOR_nothing
! && abs_optab->handlers[mode].insn_code != CODE_FOR_nothing)))
{
temp = expand_copysign_absneg (mode, op0, op1, target,
fmt->signbit_ro, op0_is_abs);
--- 3335,3342 ----
if (fmt->signbit_ro >= 0
&& (GET_CODE (op0) == CONST_DOUBLE
! || (optab_handler (neg_optab, mode)->insn_code != CODE_FOR_nothing
! && optab_handler (abs_optab, mode)->insn_code != CODE_FOR_nothing)))
{
temp = expand_copysign_absneg (mode, op0, op1, target,
fmt->signbit_ro, op0_is_abs);
*************** emit_no_conflict_block (rtx insns, rtx t
*** 3562,3568 ****
REG_NOTES (insn));
}
! if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
!= CODE_FOR_nothing)
{
last = emit_move_insn (target, target);
--- 3562,3568 ----
REG_NOTES (insn));
}
! if (optab_handler (mov_optab, GET_MODE (target))->insn_code
!= CODE_FOR_nothing)
{
last = emit_move_insn (target, target);
*************** emit_libcall_block (rtx insns, rtx targe
*** 3720,3726 ****
}
last = emit_move_insn (target, result);
! if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
!= CODE_FOR_nothing)
set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv));
else
--- 3720,3726 ----
}
last = emit_move_insn (target, result);
! if (optab_handler (mov_optab, GET_MODE (target))->insn_code
!= CODE_FOR_nothing)
set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv));
else
*************** can_compare_p (enum rtx_code code, enum
*** 3758,3764 ****
{
do
{
! if (cmp_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
if (purpose == ccp_jump)
return bcc_gen_fctn[(int) code] != NULL;
--- 3758,3764 ----
{
do
{
! if (optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing)
{
if (purpose == ccp_jump)
return bcc_gen_fctn[(int) code] != NULL;
*************** can_compare_p (enum rtx_code code, enum
*** 3769,3781 ****
return 1;
}
if (purpose == ccp_jump
! && cbranch_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
return 1;
if (purpose == ccp_cmov
! && cmov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
return 1;
if (purpose == ccp_store_flag
! && cstore_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
return 1;
mode = GET_MODE_WIDER_MODE (mode);
}
--- 3769,3781 ----
return 1;
}
if (purpose == ccp_jump
! && optab_handler (cbranch_optab, mode)->insn_code != CODE_FOR_nothing)
return 1;
if (purpose == ccp_cmov
! && optab_handler (cmov_optab, mode)->insn_code != CODE_FOR_nothing)
return 1;
if (purpose == ccp_store_flag
! && optab_handler (cstore_optab, mode)->insn_code != CODE_FOR_nothing)
return 1;
mode = GET_MODE_WIDER_MODE (mode);
}
*************** prepare_cmp_insn (rtx *px, rtx *py, enum
*** 3913,3927 ****
/* Handle a lib call just for the mode we are using. */
! if (cmp_optab->handlers[(int) mode].libfunc && !SCALAR_FLOAT_MODE_P (mode))
{
! rtx libfunc = cmp_optab->handlers[(int) mode].libfunc;
rtx result;
/* If we want unsigned, and this mode has a distinct unsigned
comparison routine, use that. */
! if (unsignedp && ucmp_optab->handlers[(int) mode].libfunc)
! libfunc = ucmp_optab->handlers[(int) mode].libfunc;
result = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST_MAKE_BLOCK,
targetm.libgcc_cmp_return_mode (),
--- 3913,3927 ----
/* Handle a lib call just for the mode we are using. */
! if (optab_handler (cmp_optab, mode)->libfunc && !SCALAR_FLOAT_MODE_P (mode))
{
! rtx libfunc = optab_handler (cmp_optab, mode)->libfunc;
rtx result;
/* If we want unsigned, and this mode has a distinct unsigned
comparison routine, use that. */
! if (unsignedp && optab_handler (ucmp_optab, mode)->libfunc)
! libfunc = optab_handler (ucmp_optab, mode)->libfunc;
result = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST_MAKE_BLOCK,
targetm.libgcc_cmp_return_mode (),
*************** emit_cmp_and_jump_insn_1 (rtx x, rtx y,
*** 3997,4003 ****
if (label)
{
! icode = cbranch_optab->handlers[(int) wider_mode].insn_code;
if (icode != CODE_FOR_nothing
&& insn_data[icode].operand[0].predicate (test, wider_mode))
--- 3997,4003 ----
if (label)
{
! icode = optab_handler (cbranch_optab, wider_mode)->insn_code;
if (icode != CODE_FOR_nothing
&& insn_data[icode].operand[0].predicate (test, wider_mode))
*************** emit_cmp_and_jump_insn_1 (rtx x, rtx y,
*** 4010,4016 ****
}
/* Handle some compares against zero. */
! icode = (int) tst_optab->handlers[(int) wider_mode].insn_code;
if (y == CONST0_RTX (mode) && icode != CODE_FOR_nothing)
{
x = prepare_operand (icode, x, 0, mode, wider_mode, unsignedp);
--- 4010,4016 ----
}
/* Handle some compares against zero. */
! icode = (int) optab_handler (tst_optab, wider_mode)->insn_code;
if (y == CONST0_RTX (mode) && icode != CODE_FOR_nothing)
{
x = prepare_operand (icode, x, 0, mode, wider_mode, unsignedp);
*************** emit_cmp_and_jump_insn_1 (rtx x, rtx y,
*** 4022,4028 ****
/* Handle compares for which there is a directly suitable insn. */
! icode = (int) cmp_optab->handlers[(int) wider_mode].insn_code;
if (icode != CODE_FOR_nothing)
{
x = prepare_operand (icode, x, 0, mode, wider_mode, unsignedp);
--- 4022,4028 ----
/* Handle compares for which there is a directly suitable insn. */
! icode = (int) optab_handler (cmp_optab, wider_mode)->insn_code;
if (icode != CODE_FOR_nothing)
{
x = prepare_operand (icode, x, 0, mode, wider_mode, unsignedp);
*************** prepare_float_lib_cmp (rtx *px, rtx *py,
*** 4125,4134 ****
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
! if ((libfunc = code_to_optab[comparison]->handlers[mode].libfunc))
break;
! if ((libfunc = code_to_optab[swapped]->handlers[mode].libfunc))
{
rtx tmp;
tmp = x; x = y; y = tmp;
--- 4125,4134 ----
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
! if ((libfunc = optab_handler (code_to_optab[comparison], mode)->libfunc))
break;
! if ((libfunc = optab_handler (code_to_optab[swapped], mode)->libfunc))
{
rtx tmp;
tmp = x; x = y; y = tmp;
*************** prepare_float_lib_cmp (rtx *px, rtx *py,
*** 4136,4142 ****
break;
}
! if ((libfunc = code_to_optab[reversed]->handlers[mode].libfunc)
&& FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, reversed))
{
comparison = reversed;
--- 4136,4142 ----
break;
}
! if ((libfunc = optab_handler (code_to_optab[reversed], mode)->libfunc)
&& FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, reversed))
{
comparison = reversed;
*************** emit_conditional_add (rtx target, enum r
*** 4431,4437 ****
if (mode == VOIDmode)
mode = GET_MODE (op2);
! icode = addcc_optab->handlers[(int) mode].insn_code;
if (icode == CODE_FOR_nothing)
return 0;
--- 4431,4437 ----
if (mode == VOIDmode)
mode = GET_MODE (op2);
! icode = optab_handler (addcc_optab, mode)->insn_code;
if (icode == CODE_FOR_nothing)
return 0;
*************** emit_conditional_add (rtx target, enum r
*** 4491,4497 ****
rtx
gen_add2_insn (rtx x, rtx y)
{
! int icode = (int) add_optab->handlers[(int) GET_MODE (x)].insn_code;
gcc_assert (insn_data[icode].operand[0].predicate
(x, insn_data[icode].operand[0].mode));
--- 4491,4497 ----
rtx
gen_add2_insn (rtx x, rtx y)
{
! int icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
gcc_assert (insn_data[icode].operand[0].predicate
(x, insn_data[icode].operand[0].mode));
*************** gen_add2_insn (rtx x, rtx y)
*** 4508,4514 ****
rtx
gen_add3_insn (rtx r0, rtx r1, rtx c)
{
! int icode = (int) add_optab->handlers[(int) GET_MODE (r0)].insn_code;
if (icode == CODE_FOR_nothing
|| !(insn_data[icode].operand[0].predicate
--- 4508,4514 ----
rtx
gen_add3_insn (rtx r0, rtx r1, rtx c)
{
! int icode = (int) optab_handler (add_optab, GET_MODE (r0))->insn_code;
if (icode == CODE_FOR_nothing
|| !(insn_data[icode].operand[0].predicate
*************** have_add2_insn (rtx x, rtx y)
*** 4529,4535 ****
gcc_assert (GET_MODE (x) != VOIDmode);
! icode = (int) add_optab->handlers[(int) GET_MODE (x)].insn_code;
if (icode == CODE_FOR_nothing)
return 0;
--- 4529,4535 ----
gcc_assert (GET_MODE (x) != VOIDmode);
! icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
if (icode == CODE_FOR_nothing)
return 0;
*************** have_add2_insn (rtx x, rtx y)
*** 4550,4556 ****
rtx
gen_sub2_insn (rtx x, rtx y)
{
! int icode = (int) sub_optab->handlers[(int) GET_MODE (x)].insn_code;
gcc_assert (insn_data[icode].operand[0].predicate
(x, insn_data[icode].operand[0].mode));
--- 4550,4556 ----
rtx
gen_sub2_insn (rtx x, rtx y)
{
! int icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code;
gcc_assert (insn_data[icode].operand[0].predicate
(x, insn_data[icode].operand[0].mode));
*************** gen_sub2_insn (rtx x, rtx y)
*** 4567,4573 ****
rtx
gen_sub3_insn (rtx r0, rtx r1, rtx c)
{
! int icode = (int) sub_optab->handlers[(int) GET_MODE (r0)].insn_code;
if (icode == CODE_FOR_nothing
|| !(insn_data[icode].operand[0].predicate
--- 4567,4573 ----
rtx
gen_sub3_insn (rtx r0, rtx r1, rtx c)
{
! int icode = (int) optab_handler (sub_optab, GET_MODE (r0))->insn_code;
if (icode == CODE_FOR_nothing
|| !(insn_data[icode].operand[0].predicate
*************** have_sub2_insn (rtx x, rtx y)
*** 4588,4594 ****
gcc_assert (GET_MODE (x) != VOIDmode);
! icode = (int) sub_optab->handlers[(int) GET_MODE (x)].insn_code;
if (icode == CODE_FOR_nothing)
return 0;
--- 4588,4594 ----
gcc_assert (GET_MODE (x) != VOIDmode);
! icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code;
if (icode == CODE_FOR_nothing)
return 0;
*************** can_extend_p (enum machine_mode to_mode,
*** 4634,4640 ****
#endif
tab = unsignedp ? zext_optab : sext_optab;
! return tab->handlers[to_mode][from_mode].insn_code;
}
/* Generate the body of an insn to extend Y (with mode MFROM)
--- 4634,4640 ----
#endif
tab = unsignedp ? zext_optab : sext_optab;
! return convert_optab_handler (tab, to_mode, from_mode)->insn_code;
}
/* Generate the body of an insn to extend Y (with mode MFROM)
*************** can_fix_p (enum machine_mode fixmode, en
*** 4665,4671 ****
enum insn_code icode;
tab = unsignedp ? ufixtrunc_optab : sfixtrunc_optab;
! icode = tab->handlers[fixmode][fltmode].insn_code;
if (icode != CODE_FOR_nothing)
{
*truncp_ptr = 0;
--- 4665,4671 ----
enum insn_code icode;
tab = unsignedp ? ufixtrunc_optab : sfixtrunc_optab;
! icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code;
if (icode != CODE_FOR_nothing)
{
*truncp_ptr = 0;
*************** can_fix_p (enum machine_mode fixmode, en
*** 4676,4684 ****
for this to work. We need to rework the fix* and ftrunc* patterns
and documentation. */
tab = unsignedp ? ufix_optab : sfix_optab;
! icode = tab->handlers[fixmode][fltmode].insn_code;
if (icode != CODE_FOR_nothing
! && ftrunc_optab->handlers[fltmode].insn_code != CODE_FOR_nothing)
{
*truncp_ptr = 1;
return icode;
--- 4676,4684 ----
for this to work. We need to rework the fix* and ftrunc* patterns
and documentation. */
tab = unsignedp ? ufix_optab : sfix_optab;
! icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code;
if (icode != CODE_FOR_nothing
! && optab_handler (ftrunc_optab, fltmode)->insn_code != CODE_FOR_nothing)
{
*truncp_ptr = 1;
return icode;
*************** can_float_p (enum machine_mode fltmode,
*** 4695,4701 ****
convert_optab tab;
tab = unsignedp ? ufloat_optab : sfloat_optab;
! return tab->handlers[fltmode][fixmode].insn_code;
}
\f
/* Generate code to convert FROM to floating point
--- 4695,4701 ----
convert_optab tab;
tab = unsignedp ? ufloat_optab : sfloat_optab;
! return convert_optab_handler (tab, fltmode, fixmode)->insn_code;
}
\f
/* Generate code to convert FROM to floating point
*************** expand_float (rtx to, rtx from, int unsi
*** 4874,4880 ****
if (GET_MODE_SIZE (GET_MODE (from)) < GET_MODE_SIZE (SImode))
from = convert_to_mode (SImode, from, unsignedp);
! libfunc = tab->handlers[GET_MODE (to)][GET_MODE (from)].libfunc;
gcc_assert (libfunc);
start_sequence ();
--- 4874,4881 ----
if (GET_MODE_SIZE (GET_MODE (from)) < GET_MODE_SIZE (SImode))
from = convert_to_mode (SImode, from, unsignedp);
! libfunc = convert_optab_handler (tab, GET_MODE (to),
! GET_MODE (from))->libfunc;
gcc_assert (libfunc);
start_sequence ();
*************** expand_fix (rtx to, rtx from, int unsign
*** 5022,5028 ****
emit_label (lab2);
! if (mov_optab->handlers[(int) GET_MODE (to)].insn_code
!= CODE_FOR_nothing)
{
/* Make a place for a REG_NOTE and add it. */
--- 5023,5029 ----
emit_label (lab2);
! if (optab_handler (mov_optab, GET_MODE (to))->insn_code
!= CODE_FOR_nothing)
{
/* Make a place for a REG_NOTE and add it. */
*************** expand_fix (rtx to, rtx from, int unsign
*** 5054,5060 ****
rtx libfunc;
convert_optab tab = unsignedp ? ufix_optab : sfix_optab;
! libfunc = tab->handlers[GET_MODE (to)][GET_MODE (from)].libfunc;
gcc_assert (libfunc);
start_sequence ();
--- 5055,5062 ----
rtx libfunc;
convert_optab tab = unsignedp ? ufix_optab : sfix_optab;
! libfunc = convert_optab_handler (tab, GET_MODE (to),
! GET_MODE (from))->libfunc;
gcc_assert (libfunc);
start_sequence ();
*************** expand_sfix_optab (rtx to, rtx from, con
*** 5100,5106 ****
for (imode = GET_MODE (to); imode != VOIDmode;
imode = GET_MODE_WIDER_MODE (imode))
{
! icode = tab->handlers[imode][fmode].insn_code;
if (icode != CODE_FOR_nothing)
{
if (fmode != GET_MODE (from))
--- 5102,5108 ----
for (imode = GET_MODE (to); imode != VOIDmode;
imode = GET_MODE_WIDER_MODE (imode))
{
! icode = convert_optab_handler (tab, imode, fmode)->insn_code;
if (icode != CODE_FOR_nothing)
{
if (fmode != GET_MODE (from))
*************** int
*** 5125,5131 ****
have_insn_for (enum rtx_code code, enum machine_mode mode)
{
return (code_to_optab[(int) code] != 0
! && (code_to_optab[(int) code]->handlers[(int) mode].insn_code
!= CODE_FOR_nothing));
}
--- 5127,5133 ----
have_insn_for (enum rtx_code code, enum machine_mode mode)
{
return (code_to_optab[(int) code] != 0
! && (optab_handler (code_to_optab[(int) code], mode)->insn_code
!= CODE_FOR_nothing));
}
*************** new_optab (void)
*** 5137,5144 ****
optab op = ggc_alloc (sizeof (struct optab));
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
! op->handlers[i].insn_code = CODE_FOR_nothing;
! op->handlers[i].libfunc = 0;
}
return op;
--- 5139,5146 ----
optab op = ggc_alloc (sizeof (struct optab));
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
! optab_handler (op, i)->insn_code = CODE_FOR_nothing;
! optab_handler (op, i)->libfunc = 0;
}
return op;
*************** new_convert_optab (void)
*** 5152,5159 ****
for (i = 0; i < NUM_MACHINE_MODES; i++)
for (j = 0; j < NUM_MACHINE_MODES; j++)
{
! op->handlers[i][j].insn_code = CODE_FOR_nothing;
! op->handlers[i][j].libfunc = 0;
}
return op;
}
--- 5154,5161 ----
for (i = 0; i < NUM_MACHINE_MODES; i++)
for (j = 0; j < NUM_MACHINE_MODES; j++)
{
! convert_optab_handler (op, i, j)->insn_code = CODE_FOR_nothing;
! convert_optab_handler (op, i, j)->libfunc = 0;
}
return op;
}
*************** init_libfuncs (optab optable, int first_
*** 5231,5237 ****
*p++ = suffix;
*p = '\0';
! optable->handlers[(int) mode].libfunc
= init_one_libfunc (ggc_alloc_string (libfunc_name, p - libfunc_name));
}
}
--- 5233,5239 ----
*p++ = suffix;
*p = '\0';
! optab_handler (optable, mode)->libfunc
= init_one_libfunc (ggc_alloc_string (libfunc_name, p - libfunc_name));
}
}
*************** init_interclass_conv_libfuncs (convert_o
*** 5348,5354 ****
*p = '\0';
! tab->handlers[tmode][fmode].libfunc
= init_one_libfunc (ggc_alloc_string (libfunc_name,
p - libfunc_name));
}
--- 5350,5356 ----
*p = '\0';
! convert_optab_handler (tab, tmode, fmode)->libfunc
= init_one_libfunc (ggc_alloc_string (libfunc_name,
p - libfunc_name));
}
*************** init_intraclass_conv_libfuncs (convert_o
*** 5423,5430 ****
*p++ = '2';
*p = '\0';
! tab->handlers[widening ? wmode : nmode]
! [widening ? nmode : wmode].libfunc
= init_one_libfunc (ggc_alloc_string (libfunc_name,
p - libfunc_name));
}
--- 5425,5432 ----
*p++ = '2';
*p = '\0';
! convert_optab_handler(tab, widening ? wmode : nmode,
! widening ? nmode : wmode)->libfunc
= init_one_libfunc (ggc_alloc_string (libfunc_name,
p - libfunc_name));
}
*************** void
*** 5461,5469 ****
set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
{
if (name)
! optable->handlers[mode].libfunc = init_one_libfunc (name);
else
! optable->handlers[mode].libfunc = 0;
}
/* Call this to reset the function entry for one conversion optab
--- 5463,5471 ----
set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
{
if (name)
! optab_handler (optable, mode)->libfunc = init_one_libfunc (name);
else
! optab_handler (optable, mode)->libfunc = 0;
}
/* Call this to reset the function entry for one conversion optab
*************** set_conv_libfunc (convert_optab optable,
*** 5474,5482 ****
enum machine_mode fmode, const char *name)
{
if (name)
! optable->handlers[tmode][fmode].libfunc = init_one_libfunc (name);
else
! optable->handlers[tmode][fmode].libfunc = 0;
}
/* Call this once to initialize the contents of the optabs
--- 5476,5485 ----
enum machine_mode fmode, const char *name)
{
if (name)
! convert_optab_handler (optable, tmode, fmode)->libfunc
! = init_one_libfunc (name);
else
! convert_optab_handler (optable, tmode, fmode)->libfunc = 0;
}
/* Call this once to initialize the contents of the optabs
*************** init_optabs (void)
*** 5710,5716 ****
/* The ffs function operates on `int'. Fall back on it if we do not
have a libgcc2 function for that width. */
int_mode = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
! ffs_optab->handlers[(int) int_mode].libfunc = init_one_libfunc ("ffs");
/* Initialize the optabs with the names of the library functions. */
init_integral_libfuncs (add_optab, "add", '3');
--- 5713,5719 ----
/* The ffs function operates on `int'. Fall back on it if we do not
have a libgcc2 function for that width. */
int_mode = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
! optab_handler (ffs_optab, int_mode)->libfunc = init_one_libfunc ("ffs");
/* Initialize the optabs with the names of the library functions. */
init_integral_libfuncs (add_optab, "add", '3');
*************** init_optabs (void)
*** 5820,5826 ****
/* Use cabs for double complex abs, since systems generally have cabs.
Don't define any libcall for float complex, so that cabs will be used. */
if (complex_double_type_node)
! abs_optab->handlers[TYPE_MODE (complex_double_type_node)].libfunc
= init_one_libfunc ("cabs");
abort_libfunc = init_one_libfunc ("abort");
--- 5823,5829 ----
/* Use cabs for double complex abs, since systems generally have cabs.
Don't define any libcall for float complex, so that cabs will be used. */
if (complex_double_type_node)
! optab_handler (abs_optab, TYPE_MODE (complex_double_type_node))->libfunc
= init_one_libfunc ("cabs");
abort_libfunc = init_one_libfunc ("abort");
*************** debug_optab_libfuncs (void)
*** 5876,5882 ****
struct optab_handlers *h;
o = optab_table[i];
! h = &o->handlers[j];
if (h->libfunc)
{
gcc_assert (GET_CODE (h->libfunc) == SYMBOL_REF);
--- 5879,5885 ----
struct optab_handlers *h;
o = optab_table[i];
! h = optab_handler (o, j);
if (h->libfunc)
{
gcc_assert (GET_CODE (h->libfunc) == SYMBOL_REF);
*************** debug_optab_libfuncs (void)
*** 5896,5902 ****
struct optab_handlers *h;
o = &convert_optab_table[i];
! h = &o->handlers[j][k];
if (h->libfunc)
{
gcc_assert (GET_CODE (h->libfunc) == SYMBOL_REF);
--- 5899,5905 ----
struct optab_handlers *h;
o = &convert_optab_table[i];
! h = convert_optab_handler(o, j, k);
if (h->libfunc)
{
gcc_assert (GET_CODE (h->libfunc) == SYMBOL_REF);
*************** gen_cond_trap (enum rtx_code code ATTRIB
*** 5929,5935 ****
if (mode == VOIDmode)
return 0;
! icode = cmp_optab->handlers[(int) mode].insn_code;
if (icode == CODE_FOR_nothing)
return 0;
--- 5932,5938 ----
if (mode == VOIDmode)
return 0;
! icode = optab_handler (cmp_optab, mode)->insn_code;
if (icode == CODE_FOR_nothing)
return 0;
Index: optabs.h
===================================================================
*** optabs.h (revision 127065)
--- optabs.h (working copy)
*************** extern rtx expand_vec_cond_expr (tree, r
*** 705,708 ****
--- 705,712 ----
/* Generate code for VEC_LSHIFT_EXPR and VEC_RSHIFT_EXPR. */
extern rtx expand_vec_shift_expr (tree, rtx);
+ #define optab_handler(optab,mode) (&(optab)->handlers[(int) (mode)])
+ #define convert_optab_handler(optab,mode,mode2) \
+ (&(optab)->handlers[(int) (mode)][(int) (mode2)])
+
#endif /* GCC_OPTABS_H */
Index: genopinit.c
===================================================================
*** genopinit.c (revision 127065)
--- genopinit.c (working copy)
*************** along with GCC; see the file COPYING3.
*** 58,180 ****
upper-case forms of the comparison, respectively. */
static const char * const optabs[] =
! { "sext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(extend$a$b2$)",
! "zext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(zero_extend$a$b2$)",
! "sfix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
! "ufix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
! "sfixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
! "ufixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
! "sfloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(float$I$a$F$b2$)",
! "ufloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
! "trunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(trunc$a$b2$)",
! "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$P$a3$)",
! "addv_optab->handlers[$A].insn_code =\n\
! add_optab->handlers[$A].insn_code = CODE_FOR_$(add$F$a3$)",
! "addv_optab->handlers[$A].insn_code = CODE_FOR_$(addv$I$a3$)",
! "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$P$a3$)",
! "subv_optab->handlers[$A].insn_code =\n\
! sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$F$a3$)",
! "subv_optab->handlers[$A].insn_code = CODE_FOR_$(subv$I$a3$)",
! "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$P$a3$)",
! "smulv_optab->handlers[$A].insn_code =\n\
! smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$F$a3$)",
! "smulv_optab->handlers[$A].insn_code = CODE_FOR_$(mulv$I$a3$)",
! "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
! "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
! "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
! "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
! "usmul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(usmul$a$b3$)$N",
! "smadd_widen_optab->handlers[$B].insn_code = CODE_FOR_$(madd$a$b4$)$N",
! "umadd_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umadd$a$b4$)$N",
! "smsub_widen_optab->handlers[$B].insn_code = CODE_FOR_$(msub$a$b4$)$N",
! "umsub_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umsub$a$b4$)$N",
! "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$a3$)",
! "sdivv_optab->handlers[$A].insn_code = CODE_FOR_$(div$V$I$a3$)",
! "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
! "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
! "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
! "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
! "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
! "fmod_optab->handlers[$A].insn_code = CODE_FOR_$(fmod$a3$)",
! "remainder_optab->handlers[$A].insn_code = CODE_FOR_$(remainder$a3$)",
! "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
! "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
! "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
! "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
! "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
! "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
! "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
! "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
! "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
! "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$a3$)",
! "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$a3$)",
! "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
! "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
! "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
! "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
! "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
! "negv_optab->handlers[$A].insn_code =\n\
! neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$F$a2$)",
! "negv_optab->handlers[$A].insn_code = CODE_FOR_$(negv$I$a2$)",
! "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
! "absv_optab->handlers[$A].insn_code =\n\
! abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$F$a2$)",
! "absv_optab->handlers[$A].insn_code = CODE_FOR_$(absv$I$a2$)",
! "copysign_optab->handlers[$A].insn_code = CODE_FOR_$(copysign$F$a3$)",
! "signbit_optab->handlers[$A].insn_code = CODE_FOR_$(signbit$F$a2$)",
! "isinf_optab->handlers[$A].insn_code = CODE_FOR_$(isinf$a2$)",
! "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
! "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
! "lfloor_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lfloor$F$a$I$b2$)",
! "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
! "lceil_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lceil$F$a$I$b2$)",
! "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
! "btrunc_optab->handlers[$A].insn_code = CODE_FOR_$(btrunc$a2$)",
! "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
! "rint_optab->handlers[$A].insn_code = CODE_FOR_$(rint$a2$)",
! "lrint_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lrint$F$a$I$b2$)",
! "lround_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lround$F$a$I$b2$)",
! "sincos_optab->handlers[$A].insn_code = CODE_FOR_$(sincos$a3$)",
! "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
! "asin_optab->handlers[$A].insn_code = CODE_FOR_$(asin$a2$)",
! "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
! "acos_optab->handlers[$A].insn_code = CODE_FOR_$(acos$a2$)",
! "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
! "exp10_optab->handlers[$A].insn_code = CODE_FOR_$(exp10$a2$)",
! "exp2_optab->handlers[$A].insn_code = CODE_FOR_$(exp2$a2$)",
! "expm1_optab->handlers[$A].insn_code = CODE_FOR_$(expm1$a2$)",
! "ldexp_optab->handlers[$A].insn_code = CODE_FOR_$(ldexp$a3$)",
! "scalb_optab->handlers[$A].insn_code = CODE_FOR_$(scalb$a3$)",
! "logb_optab->handlers[$A].insn_code = CODE_FOR_$(logb$a2$)",
! "ilogb_optab->handlers[$A].insn_code = CODE_FOR_$(ilogb$a2$)",
! "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
! "log10_optab->handlers[$A].insn_code = CODE_FOR_$(log10$a2$)",
! "log2_optab->handlers[$A].insn_code = CODE_FOR_$(log2$a2$)",
! "log1p_optab->handlers[$A].insn_code = CODE_FOR_$(log1p$a2$)",
! "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
! "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
! "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
! "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
! "bswap_optab->handlers[$A].insn_code = CODE_FOR_$(bswap$a2$)",
! "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
! "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
! "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
! "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
! "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
! "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
! "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
! "movmisalign_optab->handlers[$A].insn_code = CODE_FOR_$(movmisalign$a$)",
! "storent_optab->handlers[$A].insn_code = CODE_FOR_$(storent$a$)",
! "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
! "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
! "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
"bcc_gen_fctn[$C] = gen_$(b$c$)",
"setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
"movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
! "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
! "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
! "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
! "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
"reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
"reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
"movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
--- 58,180 ----
upper-case forms of the comparison, respectively. */
static const char * const optabs[] =
! { "convert_optab_handler (sext_optab, $B, $A)->insn_code = CODE_FOR_$(extend$a$b2$)",
! "convert_optab_handler (zext_optab, $B, $A)->insn_code = CODE_FOR_$(zero_extend$a$b2$)",
! "convert_optab_handler (sfix_optab, $B, $A)->insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
! "convert_optab_handler (ufix_optab, $B, $A)->insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
! "convert_optab_handler (sfixtrunc_optab, $B, $A)->insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
! "convert_optab_handler (ufixtrunc_optab, $B, $A)->insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
! "convert_optab_handler (sfloat_optab, $B, $A)->insn_code = CODE_FOR_$(float$I$a$F$b2$)",
! "convert_optab_handler (ufloat_optab, $B, $A)->insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
! "convert_optab_handler (trunc_optab, $B, $A)->insn_code = CODE_FOR_$(trunc$a$b2$)",
! "optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$P$a3$)",
! "optab_handler (addv_optab, $A)->insn_code =\n\
! optab_handler (add_optab, $A)->insn_code = CODE_FOR_$(add$F$a3$)",
! "optab_handler (addv_optab, $A)->insn_code = CODE_FOR_$(addv$I$a3$)",
! "optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$P$a3$)",
! "optab_handler (subv_optab, $A)->insn_code =\n\
! optab_handler (sub_optab, $A)->insn_code = CODE_FOR_$(sub$F$a3$)",
! "optab_handler (subv_optab, $A)->insn_code = CODE_FOR_$(subv$I$a3$)",
! "optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$P$a3$)",
! "optab_handler (smulv_optab, $A)->insn_code =\n\
! optab_handler (smul_optab, $A)->insn_code = CODE_FOR_$(mul$F$a3$)",
! "optab_handler (smulv_optab, $A)->insn_code = CODE_FOR_$(mulv$I$a3$)",
! "optab_handler (umul_highpart_optab, $A)->insn_code = CODE_FOR_$(umul$a3_highpart$)",
! "optab_handler (smul_highpart_optab, $A)->insn_code = CODE_FOR_$(smul$a3_highpart$)",
! "optab_handler (smul_widen_optab, $B)->insn_code = CODE_FOR_$(mul$a$b3$)$N",
! "optab_handler (umul_widen_optab, $B)->insn_code = CODE_FOR_$(umul$a$b3$)$N",
! "optab_handler (usmul_widen_optab, $B)->insn_code = CODE_FOR_$(usmul$a$b3$)$N",
! "optab_handler (smadd_widen_optab, $B)->insn_code = CODE_FOR_$(madd$a$b4$)$N",
! "optab_handler (umadd_widen_optab, $B)->insn_code = CODE_FOR_$(umadd$a$b4$)$N",
! "optab_handler (smsub_widen_optab, $B)->insn_code = CODE_FOR_$(msub$a$b4$)$N",
! "optab_handler (umsub_widen_optab, $B)->insn_code = CODE_FOR_$(umsub$a$b4$)$N",
! "optab_handler (sdiv_optab, $A)->insn_code = CODE_FOR_$(div$a3$)",
! "optab_handler (sdivv_optab, $A)->insn_code = CODE_FOR_$(div$V$I$a3$)",
! "optab_handler (udiv_optab, $A)->insn_code = CODE_FOR_$(udiv$I$a3$)",
! "optab_handler (sdivmod_optab, $A)->insn_code = CODE_FOR_$(divmod$a4$)",
! "optab_handler (udivmod_optab, $A)->insn_code = CODE_FOR_$(udivmod$a4$)",
! "optab_handler (smod_optab, $A)->insn_code = CODE_FOR_$(mod$a3$)",
! "optab_handler (umod_optab, $A)->insn_code = CODE_FOR_$(umod$a3$)",
! "optab_handler (fmod_optab, $A)->insn_code = CODE_FOR_$(fmod$a3$)",
! "optab_handler (remainder_optab, $A)->insn_code = CODE_FOR_$(remainder$a3$)",
! "optab_handler (ftrunc_optab, $A)->insn_code = CODE_FOR_$(ftrunc$F$a2$)",
! "optab_handler (and_optab, $A)->insn_code = CODE_FOR_$(and$a3$)",
! "optab_handler (ior_optab, $A)->insn_code = CODE_FOR_$(ior$a3$)",
! "optab_handler (xor_optab, $A)->insn_code = CODE_FOR_$(xor$a3$)",
! "optab_handler (ashl_optab, $A)->insn_code = CODE_FOR_$(ashl$a3$)",
! "optab_handler (ashr_optab, $A)->insn_code = CODE_FOR_$(ashr$a3$)",
! "optab_handler (lshr_optab, $A)->insn_code = CODE_FOR_$(lshr$a3$)",
! "optab_handler (rotl_optab, $A)->insn_code = CODE_FOR_$(rotl$a3$)",
! "optab_handler (rotr_optab, $A)->insn_code = CODE_FOR_$(rotr$a3$)",
! "optab_handler (smin_optab, $A)->insn_code = CODE_FOR_$(smin$a3$)",
! "optab_handler (smax_optab, $A)->insn_code = CODE_FOR_$(smax$a3$)",
! "optab_handler (umin_optab, $A)->insn_code = CODE_FOR_$(umin$I$a3$)",
! "optab_handler (umax_optab, $A)->insn_code = CODE_FOR_$(umax$I$a3$)",
! "optab_handler (pow_optab, $A)->insn_code = CODE_FOR_$(pow$a3$)",
! "optab_handler (atan2_optab, $A)->insn_code = CODE_FOR_$(atan2$a3$)",
! "optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$P$a2$)",
! "optab_handler (negv_optab, $A)->insn_code =\n\
! optab_handler (neg_optab, $A)->insn_code = CODE_FOR_$(neg$F$a2$)",
! "optab_handler (negv_optab, $A)->insn_code = CODE_FOR_$(negv$I$a2$)",
! "optab_handler (abs_optab, $A)->insn_code = CODE_FOR_$(abs$P$a2$)",
! "optab_handler (absv_optab, $A)->insn_code =\n\
! optab_handler (abs_optab, $A)->insn_code = CODE_FOR_$(abs$F$a2$)",
! "optab_handler (absv_optab, $A)->insn_code = CODE_FOR_$(absv$I$a2$)",
! "optab_handler (copysign_optab, $A)->insn_code = CODE_FOR_$(copysign$F$a3$)",
! "optab_handler (signbit_optab, $A)->insn_code = CODE_FOR_$(signbit$F$a2$)",
! "optab_handler (isinf_optab, $A)->insn_code = CODE_FOR_$(isinf$a2$)",
! "optab_handler (sqrt_optab, $A)->insn_code = CODE_FOR_$(sqrt$a2$)",
! "optab_handler (floor_optab, $A)->insn_code = CODE_FOR_$(floor$a2$)",
! "convert_optab_handler (lfloor_optab, $B, $A)->insn_code = CODE_FOR_$(lfloor$F$a$I$b2$)",
! "optab_handler (ceil_optab, $A)->insn_code = CODE_FOR_$(ceil$a2$)",
! "convert_optab_handler (lceil_optab, $B, $A)->insn_code = CODE_FOR_$(lceil$F$a$I$b2$)",
! "optab_handler (round_optab, $A)->insn_code = CODE_FOR_$(round$a2$)",
! "optab_handler (btrunc_optab, $A)->insn_code = CODE_FOR_$(btrunc$a2$)",
! "optab_handler (nearbyint_optab, $A)->insn_code = CODE_FOR_$(nearbyint$a2$)",
! "optab_handler (rint_optab, $A)->insn_code = CODE_FOR_$(rint$a2$)",
! "convert_optab_handler (lrint_optab, $B, $A)->insn_code = CODE_FOR_$(lrint$F$a$I$b2$)",
! "convert_optab_handler (lround_optab, $B, $A)->insn_code = CODE_FOR_$(lround$F$a$I$b2$)",
! "optab_handler (sincos_optab, $A)->insn_code = CODE_FOR_$(sincos$a3$)",
! "optab_handler (sin_optab, $A)->insn_code = CODE_FOR_$(sin$a2$)",
! "optab_handler (asin_optab, $A)->insn_code = CODE_FOR_$(asin$a2$)",
! "optab_handler (cos_optab, $A)->insn_code = CODE_FOR_$(cos$a2$)",
! "optab_handler (acos_optab, $A)->insn_code = CODE_FOR_$(acos$a2$)",
! "optab_handler (exp_optab, $A)->insn_code = CODE_FOR_$(exp$a2$)",
! "optab_handler (exp10_optab, $A)->insn_code = CODE_FOR_$(exp10$a2$)",
! "optab_handler (exp2_optab, $A)->insn_code = CODE_FOR_$(exp2$a2$)",
! "optab_handler (expm1_optab, $A)->insn_code = CODE_FOR_$(expm1$a2$)",
! "optab_handler (ldexp_optab, $A)->insn_code = CODE_FOR_$(ldexp$a3$)",
! "optab_handler (scalb_optab, $A)->insn_code = CODE_FOR_$(scalb$a3$)",
! "optab_handler (logb_optab, $A)->insn_code = CODE_FOR_$(logb$a2$)",
! "optab_handler (ilogb_optab, $A)->insn_code = CODE_FOR_$(ilogb$a2$)",
! "optab_handler (log_optab, $A)->insn_code = CODE_FOR_$(log$a2$)",
! "optab_handler (log10_optab, $A)->insn_code = CODE_FOR_$(log10$a2$)",
! "optab_handler (log2_optab, $A)->insn_code = CODE_FOR_$(log2$a2$)",
! "optab_handler (log1p_optab, $A)->insn_code = CODE_FOR_$(log1p$a2$)",
! "optab_handler (tan_optab, $A)->insn_code = CODE_FOR_$(tan$a2$)",
! "optab_handler (atan_optab, $A)->insn_code = CODE_FOR_$(atan$a2$)",
! "optab_handler (strlen_optab, $A)->insn_code = CODE_FOR_$(strlen$a$)",
! "optab_handler (one_cmpl_optab, $A)->insn_code = CODE_FOR_$(one_cmpl$a2$)",
! "optab_handler (bswap_optab, $A)->insn_code = CODE_FOR_$(bswap$a2$)",
! "optab_handler (ffs_optab, $A)->insn_code = CODE_FOR_$(ffs$a2$)",
! "optab_handler (clz_optab, $A)->insn_code = CODE_FOR_$(clz$a2$)",
! "optab_handler (ctz_optab, $A)->insn_code = CODE_FOR_$(ctz$a2$)",
! "optab_handler (popcount_optab, $A)->insn_code = CODE_FOR_$(popcount$a2$)",
! "optab_handler (parity_optab, $A)->insn_code = CODE_FOR_$(parity$a2$)",
! "optab_handler (mov_optab, $A)->insn_code = CODE_FOR_$(mov$a$)",
! "optab_handler (movstrict_optab, $A)->insn_code = CODE_FOR_$(movstrict$a$)",
! "optab_handler (movmisalign_optab, $A)->insn_code = CODE_FOR_$(movmisalign$a$)",
! "optab_handler (storent_optab, $A)->insn_code = CODE_FOR_$(storent$a$)",
! "optab_handler (cmp_optab, $A)->insn_code = CODE_FOR_$(cmp$a$)",
! "optab_handler (tst_optab, $A)->insn_code = CODE_FOR_$(tst$a$)",
! "optab_handler (addcc_optab, $A)->insn_code = CODE_FOR_$(add$acc$)",
"bcc_gen_fctn[$C] = gen_$(b$c$)",
"setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
"movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
! "optab_handler (cbranch_optab, $A)->insn_code = CODE_FOR_$(cbranch$a4$)",
! "optab_handler (cmov_optab, $A)->insn_code = CODE_FOR_$(cmov$a6$)",
! "optab_handler (cstore_optab, $A)->insn_code = CODE_FOR_$(cstore$a4$)",
! "optab_handler (push_optab, $A)->insn_code = CODE_FOR_$(push$a1$)",
"reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
"reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
"movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
*************** static const char * const optabs[] =
*** 204,248 ****
"sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
"sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
"sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
! "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
! "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
! "vec_extract_even_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract_even$a$)",
! "vec_extract_odd_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract_odd$a$)",
! "vec_interleave_high_optab->handlers[$A].insn_code = CODE_FOR_$(vec_interleave_high$a$)",
! "vec_interleave_low_optab->handlers[$A].insn_code = CODE_FOR_$(vec_interleave_low$a$)",
! "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)",
! "vec_shl_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shl_$a$)",
! "vec_shr_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shr_$a$)",
! "vec_realign_load_optab->handlers[$A].insn_code = CODE_FOR_$(vec_realign_load_$a$)",
"vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
"vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
! "ssum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_ssum$I$a3$)",
! "usum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_usum$I$a3$)",
! "udot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(udot_prod$I$a$)",
! "sdot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(sdot_prod$I$a$)",
! "reduc_smax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smax_$a$)",
! "reduc_umax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umax_$a$)",
! "reduc_smin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smin_$a$)",
! "reduc_umin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umin_$a$)",
! "reduc_splus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
! "reduc_uplus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_uplus_$a$)",
! "vec_widen_umult_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_umult_hi_$a$)",
! "vec_widen_umult_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_umult_lo_$a$)",
! "vec_widen_smult_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_smult_hi_$a$)",
! "vec_widen_smult_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_smult_lo_$a$)",
! "vec_unpacks_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_hi_$a$)",
! "vec_unpacks_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_lo_$a$)",
! "vec_unpacku_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_hi_$a$)",
! "vec_unpacku_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_lo_$a$)",
! "vec_unpacks_float_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_float_hi_$a$)",
! "vec_unpacks_float_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_float_lo_$a$)",
! "vec_unpacku_float_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_float_hi_$a$)",
! "vec_unpacku_float_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_float_lo_$a$)",
! "vec_pack_trunc_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_trunc_$a$)",
! "vec_pack_ssat_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_ssat_$a$)",
! "vec_pack_usat_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_usat_$a$)",
! "vec_pack_sfix_trunc_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_sfix_trunc_$a$)",
! "vec_pack_ufix_trunc_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_ufix_trunc_$a$)"
};
static void gen_insn (rtx);
--- 204,248 ----
"sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
"sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
"sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
! "optab_handler (vec_set_optab, $A)->insn_code = CODE_FOR_$(vec_set$a$)",
! "optab_handler (vec_extract_optab, $A)->insn_code = CODE_FOR_$(vec_extract$a$)",
! "optab_handler (vec_extract_even_optab, $A)->insn_code = CODE_FOR_$(vec_extract_even$a$)",
! "optab_handler (vec_extract_odd_optab, $A)->insn_code = CODE_FOR_$(vec_extract_odd$a$)",
! "optab_handler (vec_interleave_high_optab, $A)->insn_code = CODE_FOR_$(vec_interleave_high$a$)",
! "optab_handler (vec_interleave_low_optab, $A)->insn_code = CODE_FOR_$(vec_interleave_low$a$)",
! "optab_handler (vec_init_optab, $A)->insn_code = CODE_FOR_$(vec_init$a$)",
! "optab_handler (vec_shl_optab, $A)->insn_code = CODE_FOR_$(vec_shl_$a$)",
! "optab_handler (vec_shr_optab, $A)->insn_code = CODE_FOR_$(vec_shr_$a$)",
! "optab_handler (vec_realign_load_optab, $A)->insn_code = CODE_FOR_$(vec_realign_load_$a$)",
"vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
"vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
! "optab_handler (ssum_widen_optab, $A)->insn_code = CODE_FOR_$(widen_ssum$I$a3$)",
! "optab_handler (usum_widen_optab, $A)->insn_code = CODE_FOR_$(widen_usum$I$a3$)",
! "optab_handler (udot_prod_optab, $A)->insn_code = CODE_FOR_$(udot_prod$I$a$)",
! "optab_handler (sdot_prod_optab, $A)->insn_code = CODE_FOR_$(sdot_prod$I$a$)",
! "optab_handler (reduc_smax_optab, $A)->insn_code = CODE_FOR_$(reduc_smax_$a$)",
! "optab_handler (reduc_umax_optab, $A)->insn_code = CODE_FOR_$(reduc_umax_$a$)",
! "optab_handler (reduc_smin_optab, $A)->insn_code = CODE_FOR_$(reduc_smin_$a$)",
! "optab_handler (reduc_umin_optab, $A)->insn_code = CODE_FOR_$(reduc_umin_$a$)",
! "optab_handler (reduc_splus_optab, $A)->insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
! "optab_handler (reduc_uplus_optab, $A)->insn_code = CODE_FOR_$(reduc_uplus_$a$)",
! "optab_handler (vec_widen_umult_hi_optab, $A)->insn_code = CODE_FOR_$(vec_widen_umult_hi_$a$)",
! "optab_handler (vec_widen_umult_lo_optab, $A)->insn_code = CODE_FOR_$(vec_widen_umult_lo_$a$)",
! "optab_handler (vec_widen_smult_hi_optab, $A)->insn_code = CODE_FOR_$(vec_widen_smult_hi_$a$)",
! "optab_handler (vec_widen_smult_lo_optab, $A)->insn_code = CODE_FOR_$(vec_widen_smult_lo_$a$)",
! "optab_handler (vec_unpacks_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_hi_$a$)",
! "optab_handler (vec_unpacks_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_lo_$a$)",
! "optab_handler (vec_unpacku_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_hi_$a$)",
! "optab_handler (vec_unpacku_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_lo_$a$)",
! "optab_handler (vec_unpacks_float_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_float_hi_$a$)",
! "optab_handler (vec_unpacks_float_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacks_float_lo_$a$)",
! "optab_handler (vec_unpacku_float_hi_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_float_hi_$a$)",
! "optab_handler (vec_unpacku_float_lo_optab, $A)->insn_code = CODE_FOR_$(vec_unpacku_float_lo_$a$)",
! "optab_handler (vec_pack_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_trunc_$a$)",
! "optab_handler (vec_pack_ssat_optab, $A)->insn_code = CODE_FOR_$(vec_pack_ssat_$a$)",
! "optab_handler (vec_pack_usat_optab, $A)->insn_code = CODE_FOR_$(vec_pack_usat_$a$)",
! "optab_handler (vec_pack_sfix_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_sfix_trunc_$a$)",
! "optab_handler (vec_pack_ufix_trunc_optab, $A)->insn_code = CODE_FOR_$(vec_pack_ufix_trunc_$a$)"
};
static void gen_insn (rtx);
*************** from the machine description file `md'.
*** 475,482 ****
also convert validly to an unsigned one. */\n\
for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
! ufixtrunc_optab->handlers[i][j].insn_code\n\
! = sfixtrunc_optab->handlers[i][j].insn_code;\n\
#endif\n\
}");
--- 475,482 ----
also convert validly to an unsigned one. */\n\
for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
! convert_optab_handler (ufixtrunc_optab, i, j)->insn_code\n\
! = convert_optab_handler (sfixtrunc_optab, i, j)->insn_code;\n\
#endif\n\
}");
Index: reload.c
===================================================================
*** reload.c (revision 127065)
--- reload.c (working copy)
*************** find_reloads_address_1 (enum machine_mod
*** 5690,5696 ****
rtx equiv = (MEM_P (XEXP (x, 0))
? XEXP (x, 0)
: reg_equiv_mem[regno]);
! int icode = (int) add_optab->handlers[(int) Pmode].insn_code;
if (insn && NONJUMP_INSN_P (insn) && equiv
&& memory_operand (equiv, GET_MODE (equiv))
#ifdef HAVE_cc0
--- 5690,5696 ----
rtx equiv = (MEM_P (XEXP (x, 0))
? XEXP (x, 0)
: reg_equiv_mem[regno]);
! int icode = (int) optab_handler (add_optab, Pmode)->insn_code;
if (insn && NONJUMP_INSN_P (insn) && equiv
&& memory_operand (equiv, GET_MODE (equiv))
#ifdef HAVE_cc0
Index: builtins.c
===================================================================
*** builtins.c (revision 127065)
--- builtins.c (working copy)
*************** expand_builtin_mathfn (tree exp, rtx tar
*** 1879,1885 ****
errno_set = false;
/* Before working hard, check whether the instruction is available. */
! if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
target = gen_reg_rtx (mode);
--- 1879,1885 ----
errno_set = false;
/* Before working hard, check whether the instruction is available. */
! if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
{
target = gen_reg_rtx (mode);
*************** expand_builtin_mathfn_2 (tree exp, rtx t
*** 2030,2036 ****
mode = TYPE_MODE (TREE_TYPE (exp));
/* Before working hard, check whether the instruction is available. */
! if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
return NULL_RTX;
target = gen_reg_rtx (mode);
--- 2030,2036 ----
mode = TYPE_MODE (TREE_TYPE (exp));
/* Before working hard, check whether the instruction is available. */
! if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
return NULL_RTX;
target = gen_reg_rtx (mode);
*************** expand_builtin_mathfn_3 (tree exp, rtx t
*** 2120,2126 ****
/* Check if sincos insn is available, otherwise fallback
to sin or cos insn. */
! if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
switch (DECL_FUNCTION_CODE (fndecl))
{
CASE_FLT_FN (BUILT_IN_SIN):
--- 2120,2126 ----
/* Check if sincos insn is available, otherwise fallback
to sin or cos insn. */
! if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
switch (DECL_FUNCTION_CODE (fndecl))
{
CASE_FLT_FN (BUILT_IN_SIN):
*************** expand_builtin_mathfn_3 (tree exp, rtx t
*** 2132,2138 ****
}
/* Before working hard, check whether the instruction is available. */
! if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
target = gen_reg_rtx (mode);
--- 2132,2138 ----
}
/* Before working hard, check whether the instruction is available. */
! if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
{
target = gen_reg_rtx (mode);
*************** expand_builtin_interclass_mathfn (tree e
*** 2241,2247 ****
mode = TYPE_MODE (TREE_TYPE (arg));
if (builtin_optab)
! icode = builtin_optab->handlers[(int) mode].insn_code;
/* Before working hard, check whether the instruction is available. */
if (icode != CODE_FOR_nothing)
--- 2241,2247 ----
mode = TYPE_MODE (TREE_TYPE (arg));
if (builtin_optab)
! icode = optab_handler (builtin_optab, mode)->insn_code;
/* Before working hard, check whether the instruction is available. */
if (icode != CODE_FOR_nothing)
*************** expand_builtin_sincos (tree exp)
*** 2367,2373 ****
mode = TYPE_MODE (TREE_TYPE (arg));
/* Check if sincos insn is available, otherwise emit the call. */
! if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
return NULL_RTX;
target1 = gen_reg_rtx (mode);
--- 2367,2373 ----
mode = TYPE_MODE (TREE_TYPE (arg));
/* Check if sincos insn is available, otherwise emit the call. */
! if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
return NULL_RTX;
target1 = gen_reg_rtx (mode);
*************** expand_builtin_cexpi (tree exp, rtx targ
*** 2413,2419 ****
/* Try expanding via a sincos optab, fall back to emitting a libcall
to sincos or cexp. We are sure we have sincos or cexp because cexpi
is only generated from sincos, cexp or if we have either of them. */
! if (sincos_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
op1 = gen_reg_rtx (mode);
op2 = gen_reg_rtx (mode);
--- 2413,2419 ----
/* Try expanding via a sincos optab, fall back to emitting a libcall
to sincos or cexp. We are sure we have sincos or cexp because cexpi
is only generated from sincos, cexp or if we have either of them. */
! if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
{
op1 = gen_reg_rtx (mode);
op2 = gen_reg_rtx (mode);
*************** expand_builtin_powi (tree exp, rtx targe
*** 3100,3106 ****
if (GET_MODE (op1) != mode2)
op1 = convert_to_mode (mode2, op1, 0);
! target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
target, LCT_CONST_MAKE_BLOCK, mode, 2,
op0, mode, op1, mode2);
--- 3100,3106 ----
if (GET_MODE (op1) != mode2)
op1 = convert_to_mode (mode2, op1, 0);
! target = emit_library_call_value (optab_handler (powi_optab, mode)->libfunc,
target, LCT_CONST_MAKE_BLOCK, mode, 2,
op0, mode, op1, mode2);
*************** expand_builtin_strlen (tree exp, rtx tar
*** 3153,3159 ****
/* Bail out if we can't compute strlen in the right mode. */
while (insn_mode != VOIDmode)
{
! icode = strlen_optab->handlers[(int) insn_mode].insn_code;
if (icode != CODE_FOR_nothing)
break;
--- 3153,3159 ----
/* Bail out if we can't compute strlen in the right mode. */
while (insn_mode != VOIDmode)
{
! icode = optab_handler (strlen_optab, insn_mode)->insn_code;
if (icode != CODE_FOR_nothing)
break;
Index: dojump.c
===================================================================
*** dojump.c (revision 127065)
--- dojump.c (working copy)
*************** do_jump (tree exp, rtx if_false_label, r
*** 275,281 ****
&& (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
&& (type = lang_hooks.types.type_for_mode (mode, 1)) != 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
! && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
!= CODE_FOR_nothing))
{
do_jump (fold_convert (type, exp), if_false_label, if_true_label);
--- 275,281 ----
&& (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
&& (type = lang_hooks.types.type_for_mode (mode, 1)) != 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
! && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code
!= CODE_FOR_nothing))
{
do_jump (fold_convert (type, exp), if_false_label, if_true_label);
*************** do_jump (tree exp, rtx if_false_label, r
*** 334,340 ****
if (! SLOW_BYTE_ACCESS
&& type != 0 && bitsize >= 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
! && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
!= CODE_FOR_nothing))
{
do_jump (fold_convert (type, exp), if_false_label, if_true_label);
--- 334,340 ----
if (! SLOW_BYTE_ACCESS
&& type != 0 && bitsize >= 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
! && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code
!= CODE_FOR_nothing))
{
do_jump (fold_convert (type, exp), if_false_label, if_true_label);
Index: expr.c
===================================================================
*** expr.c (revision 127065)
--- expr.c (working copy)
*************** convert_move (rtx to, rtx from, int unsi
*** 426,432 ****
/* Try converting directly if the insn is supported. */
! code = tab->handlers[to_mode][from_mode].insn_code;
if (code != CODE_FOR_nothing)
{
emit_unop_insn (code, to, from,
--- 426,432 ----
/* Try converting directly if the insn is supported. */
! code = convert_optab_handler (tab, to_mode, from_mode)->insn_code;
if (code != CODE_FOR_nothing)
{
emit_unop_insn (code, to, from,
*************** convert_move (rtx to, rtx from, int unsi
*** 435,441 ****
}
/* Otherwise use a libcall. */
! libcall = tab->handlers[to_mode][from_mode].libfunc;
/* Is this conversion implemented yet? */
gcc_assert (libcall);
--- 435,441 ----
}
/* Otherwise use a libcall. */
! libcall = convert_optab_handler (tab, to_mode, from_mode)->libfunc;
/* Is this conversion implemented yet? */
gcc_assert (libcall);
*************** convert_move (rtx to, rtx from, int unsi
*** 460,471 ****
enum machine_mode full_mode
= smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);
! gcc_assert (trunc_optab->handlers[to_mode][full_mode].insn_code
!= CODE_FOR_nothing);
if (full_mode != from_mode)
from = convert_to_mode (full_mode, from, unsignedp);
! emit_unop_insn (trunc_optab->handlers[to_mode][full_mode].insn_code,
to, from, UNKNOWN);
return;
}
--- 460,471 ----
enum machine_mode full_mode
= smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);
! gcc_assert (convert_optab_handler (trunc_optab, to_mode, full_mode)->insn_code
!= CODE_FOR_nothing);
if (full_mode != from_mode)
from = convert_to_mode (full_mode, from, unsignedp);
! emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, full_mode)->insn_code,
to, from, UNKNOWN);
return;
}
*************** convert_move (rtx to, rtx from, int unsi
*** 475,492 ****
enum machine_mode full_mode
= smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);
! gcc_assert (sext_optab->handlers[full_mode][from_mode].insn_code
!= CODE_FOR_nothing);
if (to_mode == full_mode)
{
! emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,
to, from, UNKNOWN);
return;
}
new_from = gen_reg_rtx (full_mode);
! emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,
new_from, from, UNKNOWN);
/* else proceed to integer conversions below. */
--- 475,492 ----
enum machine_mode full_mode
= smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);
! gcc_assert (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code
!= CODE_FOR_nothing);
if (to_mode == full_mode)
{
! emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code,
to, from, UNKNOWN);
return;
}
new_from = gen_reg_rtx (full_mode);
! emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code,
new_from, from, UNKNOWN);
/* else proceed to integer conversions below. */
*************** convert_move (rtx to, rtx from, int unsi
*** 690,698 ****
}
/* Support special truncate insns for certain modes. */
! if (trunc_optab->handlers[to_mode][from_mode].insn_code != CODE_FOR_nothing)
{
! emit_unop_insn (trunc_optab->handlers[to_mode][from_mode].insn_code,
to, from, UNKNOWN);
return;
}
--- 690,698 ----
}
/* Support special truncate insns for certain modes. */
! if (convert_optab_handler (trunc_optab, to_mode, from_mode)->insn_code != CODE_FOR_nothing)
{
! emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, from_mode)->insn_code,
to, from, UNKNOWN);
return;
}
*************** move_by_pieces (rtx to, rtx from, unsign
*** 984,990 ****
if (mode == VOIDmode)
break;
! icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
move_by_pieces_1 (GEN_FCN (icode), mode, &data);
--- 984,990 ----
if (mode == VOIDmode)
break;
! icode = optab_handler (mov_optab, mode)->insn_code;
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
move_by_pieces_1 (GEN_FCN (icode), mode, &data);
*************** move_by_pieces_ninsns (unsigned HOST_WID
*** 1064,1070 ****
if (mode == VOIDmode)
break;
! icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
--- 1064,1070 ----
if (mode == VOIDmode)
break;
! icode = optab_handler (mov_optab, mode)->insn_code;
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
*************** can_store_by_pieces (unsigned HOST_WIDE_
*** 2250,2256 ****
if (mode == VOIDmode)
break;
! icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing
&& align >= GET_MODE_ALIGNMENT (mode))
{
--- 2250,2256 ----
if (mode == VOIDmode)
break;
! icode = optab_handler (mov_optab, mode)->insn_code;
if (icode != CODE_FOR_nothing
&& align >= GET_MODE_ALIGNMENT (mode))
{
*************** store_by_pieces_1 (struct store_by_piece
*** 2454,2460 ****
if (mode == VOIDmode)
break;
! icode = mov_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
store_by_pieces_2 (GEN_FCN (icode), mode, data);
--- 2454,2460 ----
if (mode == VOIDmode)
break;
! icode = optab_handler (mov_optab, mode)->insn_code;
if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
store_by_pieces_2 (GEN_FCN (icode), mode, data);
*************** emit_move_via_integer (enum machine_mode
*** 2921,2927 ****
return NULL_RTX;
/* The target must support moves in this mode. */
! code = mov_optab->handlers[imode].insn_code;
if (code == CODE_FOR_nothing)
return NULL_RTX;
--- 2921,2927 ----
return NULL_RTX;
/* The target must support moves in this mode. */
! code = optab_handler (mov_optab, imode)->insn_code;
if (code == CODE_FOR_nothing)
return NULL_RTX;
*************** emit_move_complex (enum machine_mode mod
*** 3071,3077 ****
/* Move floating point as parts. */
if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
! && mov_optab->handlers[GET_MODE_INNER (mode)].insn_code != CODE_FOR_nothing)
try_int = false;
/* Not possible if the values are inherently not adjacent. */
else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
--- 3071,3077 ----
/* Move floating point as parts. */
if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
! && optab_handler (mov_optab, GET_MODE_INNER (mode))->insn_code != CODE_FOR_nothing)
try_int = false;
/* Not possible if the values are inherently not adjacent. */
else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
*************** emit_move_ccmode (enum machine_mode mode
*** 3122,3128 ****
/* Assume all MODE_CC modes are equivalent; if we have movcc, use it. */
if (mode != CCmode)
{
! enum insn_code code = mov_optab->handlers[CCmode].insn_code;
if (code != CODE_FOR_nothing)
{
x = emit_move_change_mode (CCmode, mode, x, true);
--- 3122,3128 ----
/* Assume all MODE_CC modes are equivalent; if we have movcc, use it. */
if (mode != CCmode)
{
! enum insn_code code = optab_handler (mov_optab, CCmode)->insn_code;
if (code != CODE_FOR_nothing)
{
x = emit_move_change_mode (CCmode, mode, x, true);
*************** emit_move_insn_1 (rtx x, rtx y)
*** 3262,3268 ****
gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE);
! code = mov_optab->handlers[mode].insn_code;
if (code != CODE_FOR_nothing)
return emit_insn (GEN_FCN (code) (x, y));
--- 3262,3268 ----
gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE);
! code = optab_handler (mov_optab, mode)->insn_code;
if (code != CODE_FOR_nothing)
return emit_insn (GEN_FCN (code) (x, y));
*************** emit_single_push_insn (enum machine_mode
*** 3514,3520 ****
stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
/* If there is push pattern, use it. Otherwise try old way of throwing
MEM representing push operation to move expander. */
! icode = push_optab->handlers[(int) mode].insn_code;
if (icode != CODE_FOR_nothing)
{
if (((pred = insn_data[(int) icode].operand[0].predicate)
--- 3514,3520 ----
stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
/* If there is push pattern, use it. Otherwise try old way of throwing
MEM representing push operation to move expander. */
! icode = optab_handler (push_optab, mode)->insn_code;
if (icode != CODE_FOR_nothing)
{
if (((pred = insn_data[(int) icode].operand[0].predicate)
*************** static bool
*** 4319,4325 ****
emit_storent_insn (rtx to, rtx from)
{
enum machine_mode mode = GET_MODE (to), imode;
! enum insn_code code = storent_optab->handlers[mode].insn_code;
rtx pattern;
if (code == CODE_FOR_nothing)
--- 4319,4325 ----
emit_storent_insn (rtx to, rtx from)
{
enum machine_mode mode = GET_MODE (to), imode;
! enum insn_code code = optab_handler (storent_optab, mode)->insn_code;
rtx pattern;
if (code == CODE_FOR_nothing)
*************** store_constructor (tree exp, rtx target,
*** 5458,5464 ****
{
enum machine_mode mode = GET_MODE (target);
! icode = (int) vec_init_optab->handlers[mode].insn_code;
if (icode != CODE_FOR_nothing)
{
unsigned int i;
--- 5458,5464 ----
{
enum machine_mode mode = GET_MODE (target);
! icode = (int) optab_handler (vec_init_optab, mode)->insn_code;
if (icode != CODE_FOR_nothing)
{
unsigned int i;
*************** expand_expr_real_1 (tree exp, rtx target
*** 7394,7400 ****
|| modifier == EXPAND_STACK_PARM);
/* The vectorizer should have already checked the mode. */
! icode = movmisalign_optab->handlers[mode].insn_code;
gcc_assert (icode != CODE_FOR_nothing);
/* We've already validated the memory, and we're creating a
--- 7394,7400 ----
|| modifier == EXPAND_STACK_PARM);
/* The vectorizer should have already checked the mode. */
! icode = optab_handler (movmisalign_optab, mode)->insn_code;
gcc_assert (icode != CODE_FOR_nothing);
/* We've already validated the memory, and we're creating a
*************** expand_expr_real_1 (tree exp, rtx target
*** 8107,8113 ****
bool zextend_p = TYPE_UNSIGNED (op0type);
this_optab = zextend_p ? umadd_widen_optab : smadd_widen_optab;
if (mode == GET_MODE_2XWIDER_MODE (innermode)
! && (this_optab->handlers[(int) mode].insn_code
!= CODE_FOR_nothing))
{
expand_operands (TREE_OPERAND (subsubexp0, 0),
--- 8107,8113 ----
bool zextend_p = TYPE_UNSIGNED (op0type);
this_optab = zextend_p ? umadd_widen_optab : smadd_widen_optab;
if (mode == GET_MODE_2XWIDER_MODE (innermode)
! && (optab_handler (this_optab, mode)->insn_code
!= CODE_FOR_nothing))
{
expand_operands (TREE_OPERAND (subsubexp0, 0),
*************** expand_expr_real_1 (tree exp, rtx target
*** 8262,8268 ****
bool zextend_p = TYPE_UNSIGNED (op0type);
this_optab = zextend_p ? umsub_widen_optab : smsub_widen_optab;
if (mode == GET_MODE_2XWIDER_MODE (innermode)
! && (this_optab->handlers[(int) mode].insn_code
!= CODE_FOR_nothing))
{
expand_operands (TREE_OPERAND (subsubexp0, 0),
--- 8262,8268 ----
bool zextend_p = TYPE_UNSIGNED (op0type);
this_optab = zextend_p ? umsub_widen_optab : smsub_widen_optab;
if (mode == GET_MODE_2XWIDER_MODE (innermode)
! && (optab_handler (this_optab, mode)->insn_code
!= CODE_FOR_nothing))
{
expand_operands (TREE_OPERAND (subsubexp0, 0),
*************** expand_expr_real_1 (tree exp, rtx target
*** 8377,8383 ****
this_optab = usmul_widen_optab;
if (mode == GET_MODE_WIDER_MODE (innermode))
{
! if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (subexp0, 0))))
expand_operands (TREE_OPERAND (subexp0, 0),
--- 8377,8383 ----
this_optab = usmul_widen_optab;
if (mode == GET_MODE_WIDER_MODE (innermode))
{
! if (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing)
{
if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (subexp0, 0))))
expand_operands (TREE_OPERAND (subexp0, 0),
*************** expand_expr_real_1 (tree exp, rtx target
*** 8427,8433 ****
if (mode == GET_MODE_2XWIDER_MODE (innermode))
{
! if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
expand_operands (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
--- 8427,8433 ----
if (mode == GET_MODE_2XWIDER_MODE (innermode))
{
! if (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing)
{
if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
expand_operands (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
*************** expand_expr_real_1 (tree exp, rtx target
*** 8439,8445 ****
NULL_RTX, &op0, &op1, EXPAND_NORMAL);
goto binop3;
}
! else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
&& innermode == word_mode)
{
rtx htem, hipart;
--- 8439,8445 ----
NULL_RTX, &op0, &op1, EXPAND_NORMAL);
goto binop3;
}
! else if (optab_handler (other_optab, mode)->insn_code != CODE_FOR_nothing
&& innermode == word_mode)
{
rtx htem, hipart;
*************** do_store_flag (tree exp, rtx target, enu
*** 9552,9558 ****
for (wmode = operand_mode;
icode == CODE_FOR_nothing && wmode != VOIDmode;
wmode = GET_MODE_WIDER_MODE (wmode))
! icode = cstore_optab->handlers[(int) wmode].insn_code;
}
if (icode == CODE_FOR_nothing
--- 9552,9558 ----
for (wmode = operand_mode;
icode == CODE_FOR_nothing && wmode != VOIDmode;
wmode = GET_MODE_WIDER_MODE (wmode))
! icode = optab_handler (cstore_optab, wmode)->insn_code;
}
if (icode == CODE_FOR_nothing
*************** do_store_flag (tree exp, rtx target, enu
*** 9565,9573 ****
;
else if (! only_cheap && (code == NE || code == EQ)
&& TREE_CODE (type) != REAL_TYPE
! && ((abs_optab->handlers[(int) operand_mode].insn_code
!= CODE_FOR_nothing)
! || (ffs_optab->handlers[(int) operand_mode].insn_code
!= CODE_FOR_nothing)))
;
else
--- 9565,9573 ----
;
else if (! only_cheap && (code == NE || code == EQ)
&& TREE_CODE (type) != REAL_TYPE
! && ((optab_handler (abs_optab, operand_mode)->insn_code
!= CODE_FOR_nothing)
! || (optab_handler (ffs_optab, operand_mode)->insn_code
!= CODE_FOR_nothing)))
;
else
Index: ada/misc.c
===================================================================
*** ada/misc.c (revision 127065)
--- ada/misc.c (working copy)
*************** gnat_compute_largest_alignment (void)
*** 480,486 ****
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
largest_move_alignment = MIN (BIGGEST_ALIGNMENT,
MAX (largest_move_alignment,
GET_MODE_ALIGNMENT (mode)));
--- 480,486 ----
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing)
largest_move_alignment = MIN (BIGGEST_ALIGNMENT,
MAX (largest_move_alignment,
GET_MODE_ALIGNMENT (mode)));
*************** enumerate_modes (void (*f) (int, int, in
*** 900,906 ****
any wider mode), meaning it is not supported by the hardware. If
this a complex or vector mode, we care about the inner mode. */
for (j = inner_mode; j != VOIDmode; j = GET_MODE_WIDER_MODE (j))
! if (add_optab->handlers[j].insn_code != CODE_FOR_nothing)
break;
if (float_p)
--- 900,906 ----
any wider mode), meaning it is not supported by the hardware. If
this a complex or vector mode, we care about the inner mode. */
for (j = inner_mode; j != VOIDmode; j = GET_MODE_WIDER_MODE (j))
! if (optab_handler (add_optab, j)->insn_code != CODE_FOR_nothing)
break;
if (float_p)
Index: tree-vectorizer.c
===================================================================
*** tree-vectorizer.c (revision 127065)
--- tree-vectorizer.c (working copy)
*************** along with GCC; see the file COPYING3.
*** 111,117 ****
Since we only vectorize operations which vector form can be
expressed using existing tree codes, to verify that an operation is
supported, the vectorizer checks the relevant optab at the relevant
! machine_mode (e.g, add_optab->handlers[(int) V8HImode].insn_code). If
the value found is CODE_FOR_nothing, then there's no target support, and
we can't vectorize the stmt.
--- 111,117 ----
Since we only vectorize operations which vector form can be
expressed using existing tree codes, to verify that an operation is
supported, the vectorizer checks the relevant optab at the relevant
! machine_mode (e.g, optab_handler (add_optab, V8HImode)->insn_code). If
the value found is CODE_FOR_nothing, then there's no target support, and
we can't vectorize the stmt.
*************** vect_supportable_dr_alignment (struct da
*** 1596,1607 ****
if (DR_IS_READ (dr))
{
! if (vec_realign_load_optab->handlers[mode].insn_code != CODE_FOR_nothing
&& (!targetm.vectorize.builtin_mask_for_load
|| targetm.vectorize.builtin_mask_for_load ()))
return dr_unaligned_software_pipeline;
! if (movmisalign_optab->handlers[mode].insn_code != CODE_FOR_nothing)
/* Can't software pipeline the loads, but can at least do them. */
return dr_unaligned_supported;
}
--- 1596,1607 ----
if (DR_IS_READ (dr))
{
! if (optab_handler (vec_realign_load_optab, mode)->insn_code != CODE_FOR_nothing
&& (!targetm.vectorize.builtin_mask_for_load
|| targetm.vectorize.builtin_mask_for_load ()))
return dr_unaligned_software_pipeline;
! if (optab_handler (movmisalign_optab, mode)->insn_code != CODE_FOR_nothing)
/* Can't software pipeline the loads, but can at least do them. */
return dr_unaligned_supported;
}
*************** supportable_widening_operation (enum tre
*** 1869,1877 ****
return false;
vec_mode = TYPE_MODE (vectype);
! if ((icode1 = optab1->handlers[(int) vec_mode].insn_code) == CODE_FOR_nothing
|| insn_data[icode1].operand[0].mode != TYPE_MODE (wide_vectype)
! || (icode2 = optab2->handlers[(int) vec_mode].insn_code)
== CODE_FOR_nothing
|| insn_data[icode2].operand[0].mode != TYPE_MODE (wide_vectype))
return false;
--- 1869,1877 ----
return false;
vec_mode = TYPE_MODE (vectype);
! if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) == CODE_FOR_nothing
|| insn_data[icode1].operand[0].mode != TYPE_MODE (wide_vectype)
! || (icode2 = optab_handler (optab2, vec_mode)->insn_code)
== CODE_FOR_nothing
|| insn_data[icode2].operand[0].mode != TYPE_MODE (wide_vectype))
return false;
*************** supportable_narrowing_operation (enum tr
*** 1939,1945 ****
return false;
vec_mode = TYPE_MODE (vectype);
! if ((icode1 = optab1->handlers[(int) vec_mode].insn_code) == CODE_FOR_nothing
|| insn_data[icode1].operand[0].mode != TYPE_MODE (narrow_vectype))
return false;
--- 1939,1945 ----
return false;
vec_mode = TYPE_MODE (vectype);
! if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) == CODE_FOR_nothing
|| insn_data[icode1].operand[0].mode != TYPE_MODE (narrow_vectype))
return false;
Index: expmed.c
===================================================================
*** expmed.c (revision 127065)
--- expmed.c (working copy)
*************** store_bit_field_1 (rtx str_rtx, unsigned
*** 403,409 ****
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
&& !MEM_P (op0)
! && (vec_set_optab->handlers[GET_MODE (op0)].insn_code
!= CODE_FOR_nothing)
&& fieldmode == GET_MODE_INNER (GET_MODE (op0))
&& bitsize == GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))
--- 403,409 ----
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
&& !MEM_P (op0)
! && (optab_handler (vec_set_optab, GET_MODE (op0))->insn_code
!= CODE_FOR_nothing)
&& fieldmode == GET_MODE_INNER (GET_MODE (op0))
&& bitsize == GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))
*************** store_bit_field_1 (rtx str_rtx, unsigned
*** 411,417 ****
{
enum machine_mode outermode = GET_MODE (op0);
enum machine_mode innermode = GET_MODE_INNER (outermode);
! int icode = (int) vec_set_optab->handlers[outermode].insn_code;
int pos = bitnum / GET_MODE_BITSIZE (innermode);
rtx rtxpos = GEN_INT (pos);
rtx src = value;
--- 411,417 ----
{
enum machine_mode outermode = GET_MODE (op0);
enum machine_mode innermode = GET_MODE_INNER (outermode);
! int icode = (int) optab_handler (vec_set_optab, outermode)->insn_code;
int pos = bitnum / GET_MODE_BITSIZE (innermode);
rtx rtxpos = GEN_INT (pos);
rtx src = value;
*************** store_bit_field_1 (rtx str_rtx, unsigned
*** 517,526 ****
if (!MEM_P (op0)
&& (BYTES_BIG_ENDIAN ? bitpos + bitsize == unit : bitpos == 0)
&& bitsize == GET_MODE_BITSIZE (fieldmode)
! && (movstrict_optab->handlers[fieldmode].insn_code
!= CODE_FOR_nothing))
{
! int icode = movstrict_optab->handlers[fieldmode].insn_code;
/* Get appropriate low part of the value being stored. */
if (GET_CODE (value) == CONST_INT || REG_P (value))
--- 517,526 ----
if (!MEM_P (op0)
&& (BYTES_BIG_ENDIAN ? bitpos + bitsize == unit : bitpos == 0)
&& bitsize == GET_MODE_BITSIZE (fieldmode)
! && (optab_handler (movstrict_optab, fieldmode)->insn_code
!= CODE_FOR_nothing))
{
! int icode = optab_handler (movstrict_optab, fieldmode)->insn_code;
/* Get appropriate low part of the value being stored. */
if (GET_CODE (value) == CONST_INT || REG_P (value))
*************** extract_bit_field_1 (rtx str_rtx, unsign
*** 1198,1211 ****
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
&& !MEM_P (op0)
! && (vec_extract_optab->handlers[GET_MODE (op0)].insn_code
!= CODE_FOR_nothing)
&& ((bitnum + bitsize - 1) / GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))
== bitnum / GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))))
{
enum machine_mode outermode = GET_MODE (op0);
enum machine_mode innermode = GET_MODE_INNER (outermode);
! int icode = (int) vec_extract_optab->handlers[outermode].insn_code;
unsigned HOST_WIDE_INT pos = bitnum / GET_MODE_BITSIZE (innermode);
rtx rtxpos = GEN_INT (pos);
rtx src = op0;
--- 1198,1211 ----
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
&& !MEM_P (op0)
! && (optab_handler (vec_extract_optab, GET_MODE (op0))->insn_code
!= CODE_FOR_nothing)
&& ((bitnum + bitsize - 1) / GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))
== bitnum / GET_MODE_BITSIZE (GET_MODE_INNER (GET_MODE (op0)))))
{
enum machine_mode outermode = GET_MODE (op0);
enum machine_mode innermode = GET_MODE_INNER (outermode);
! int icode = (int) optab_handler (vec_extract_optab, outermode)->insn_code;
unsigned HOST_WIDE_INT pos = bitnum / GET_MODE_BITSIZE (innermode);
rtx rtxpos = GEN_INT (pos);
rtx src = op0;
*************** expand_mult_highpart_optab (enum machine
*** 3414,3420 ****
/* Try widening multiplication. */
moptab = unsignedp ? umul_widen_optab : smul_widen_optab;
! if (moptab->handlers[wider_mode].insn_code != CODE_FOR_nothing
&& mul_widen_cost[wider_mode] < max_cost)
{
tem = expand_binop (wider_mode, moptab, op0, narrow_op1, 0,
--- 3414,3420 ----
/* Try widening multiplication. */
moptab = unsignedp ? umul_widen_optab : smul_widen_optab;
! if (optab_handler (moptab, wider_mode)->insn_code != CODE_FOR_nothing
&& mul_widen_cost[wider_mode] < max_cost)
{
tem = expand_binop (wider_mode, moptab, op0, narrow_op1, 0,
*************** expand_mult_highpart_optab (enum machine
*** 3424,3430 ****
}
/* Try widening the mode and perform a non-widening multiplication. */
! if (smul_optab->handlers[wider_mode].insn_code != CODE_FOR_nothing
&& size - 1 < BITS_PER_WORD
&& mul_cost[wider_mode] + shift_cost[mode][size-1] < max_cost)
{
--- 3424,3430 ----
}
/* Try widening the mode and perform a non-widening multiplication. */
! if (optab_handler (smul_optab, wider_mode)->insn_code != CODE_FOR_nothing
&& size - 1 < BITS_PER_WORD
&& mul_cost[wider_mode] + shift_cost[mode][size-1] < max_cost)
{
*************** expand_mult_highpart_optab (enum machine
*** 3451,3457 ****
/* Try widening multiplication of opposite signedness, and adjust. */
moptab = unsignedp ? smul_widen_optab : umul_widen_optab;
! if (moptab->handlers[wider_mode].insn_code != CODE_FOR_nothing
&& size - 1 < BITS_PER_WORD
&& (mul_widen_cost[wider_mode] + 2 * shift_cost[mode][size-1]
+ 4 * add_cost[mode] < max_cost))
--- 3451,3457 ----
/* Try widening multiplication of opposite signedness, and adjust. */
moptab = unsignedp ? smul_widen_optab : umul_widen_optab;
! if (optab_handler (moptab, wider_mode)->insn_code != CODE_FOR_nothing
&& size - 1 < BITS_PER_WORD
&& (mul_widen_cost[wider_mode] + 2 * shift_cost[mode][size-1]
+ 4 * add_cost[mode] < max_cost))
*************** expand_smod_pow2 (enum machine_mode mode
*** 3572,3578 ****
use a LSHIFTRT, 1 ADD, 1 SUB and an AND. */
temp = gen_rtx_LSHIFTRT (mode, result, shift);
! if (lshr_optab->handlers[mode].insn_code == CODE_FOR_nothing
|| rtx_cost (temp, SET) > COSTS_N_INSNS (2))
{
temp = expand_binop (mode, xor_optab, op0, signmask,
--- 3572,3578 ----
use a LSHIFTRT, 1 ADD, 1 SUB and an AND. */
temp = gen_rtx_LSHIFTRT (mode, result, shift);
! if (optab_handler (lshr_optab, mode)->insn_code == CODE_FOR_nothing
|| rtx_cost (temp, SET) > COSTS_N_INSNS (2))
{
temp = expand_binop (mode, xor_optab, op0, signmask,
*************** expand_divmod (int rem_flag, enum tree_c
*** 3871,3885 ****
for (compute_mode = mode; compute_mode != VOIDmode;
compute_mode = GET_MODE_WIDER_MODE (compute_mode))
! if (optab1->handlers[compute_mode].insn_code != CODE_FOR_nothing
! || optab2->handlers[compute_mode].insn_code != CODE_FOR_nothing)
break;
if (compute_mode == VOIDmode)
for (compute_mode = mode; compute_mode != VOIDmode;
compute_mode = GET_MODE_WIDER_MODE (compute_mode))
! if (optab1->handlers[compute_mode].libfunc
! || optab2->handlers[compute_mode].libfunc)
break;
/* If we still couldn't find a mode, use MODE, but expand_binop will
--- 3871,3885 ----
for (compute_mode = mode; compute_mode != VOIDmode;
compute_mode = GET_MODE_WIDER_MODE (compute_mode))
! if (optab_handler (optab1, compute_mode)->insn_code != CODE_FOR_nothing
! || optab_handler (optab2, compute_mode)->insn_code != CODE_FOR_nothing)
break;
if (compute_mode == VOIDmode)
for (compute_mode = mode; compute_mode != VOIDmode;
compute_mode = GET_MODE_WIDER_MODE (compute_mode))
! if (optab_handler (optab1, compute_mode)->libfunc
! || optab_handler (optab2, compute_mode)->libfunc)
break;
/* If we still couldn't find a mode, use MODE, but expand_binop will
*************** expand_divmod (int rem_flag, enum tree_c
*** 4126,4136 ****
: sdiv_pow2_cheap[compute_mode])
/* We assume that cheap metric is true if the
optab has an expander for this mode. */
! && (((rem_flag ? smod_optab : sdiv_optab)
! ->handlers[compute_mode].insn_code
!= CODE_FOR_nothing)
! || (sdivmod_optab->handlers[compute_mode]
! .insn_code != CODE_FOR_nothing)))
;
else if (EXACT_POWER_OF_2_OR_ZERO_P (abs_d))
{
--- 4126,4138 ----
: sdiv_pow2_cheap[compute_mode])
/* We assume that cheap metric is true if the
optab has an expander for this mode. */
! && ((optab_handler ((rem_flag ? smod_optab
! : sdiv_optab),
! compute_mode)->insn_code
!= CODE_FOR_nothing)
! || (optab_handler(sdivmod_optab,
! compute_mode)
! ->insn_code != CODE_FOR_nothing)))
;
else if (EXACT_POWER_OF_2_OR_ZERO_P (abs_d))
{
*************** expand_divmod (int rem_flag, enum tree_c
*** 4142,4150 ****
}
if (sdiv_pow2_cheap[compute_mode]
! && ((sdiv_optab->handlers[compute_mode].insn_code
!= CODE_FOR_nothing)
! || (sdivmod_optab->handlers[compute_mode].insn_code
!= CODE_FOR_nothing)))
quotient = expand_divmod (0, TRUNC_DIV_EXPR,
compute_mode, op0,
--- 4144,4152 ----
}
if (sdiv_pow2_cheap[compute_mode]
! && ((optab_handler (sdiv_optab, compute_mode)->insn_code
!= CODE_FOR_nothing)
! || (optab_handler (sdivmod_optab, compute_mode)->insn_code
!= CODE_FOR_nothing)))
quotient = expand_divmod (0, TRUNC_DIV_EXPR,
compute_mode, op0,
*************** expand_divmod (int rem_flag, enum tree_c
*** 4792,4798 ****
= sign_expand_binop (compute_mode, umod_optab, smod_optab,
op0, op1, target,
unsignedp,
! ((optab2->handlers[compute_mode].insn_code
!= CODE_FOR_nothing)
? OPTAB_DIRECT : OPTAB_WIDEN));
if (remainder == 0)
--- 4794,4800 ----
= sign_expand_binop (compute_mode, umod_optab, smod_optab,
op0, op1, target,
unsignedp,
! ((optab_handler (optab2, compute_mode)->insn_code
!= CODE_FOR_nothing)
? OPTAB_DIRECT : OPTAB_WIDEN));
if (remainder == 0)
*************** expand_divmod (int rem_flag, enum tree_c
*** 4820,4826 ****
= sign_expand_binop (compute_mode, udiv_optab, sdiv_optab,
op0, op1, rem_flag ? NULL_RTX : target,
unsignedp,
! ((optab2->handlers[compute_mode].insn_code
!= CODE_FOR_nothing)
? OPTAB_DIRECT : OPTAB_WIDEN));
--- 4822,4828 ----
= sign_expand_binop (compute_mode, udiv_optab, sdiv_optab,
op0, op1, rem_flag ? NULL_RTX : target,
unsignedp,
! ((optab_handler (optab2, compute_mode)->insn_code
!= CODE_FOR_nothing)
? OPTAB_DIRECT : OPTAB_WIDEN));
*************** emit_store_flag (rtx target, enum rtx_co
*** 5340,5346 ****
for (compare_mode = mode; compare_mode != VOIDmode;
compare_mode = GET_MODE_WIDER_MODE (compare_mode))
{
! icode = cstore_optab->handlers[(int) compare_mode].insn_code;
if (icode != CODE_FOR_nothing)
break;
}
--- 5342,5348 ----
for (compare_mode = mode; compare_mode != VOIDmode;
compare_mode = GET_MODE_WIDER_MODE (compare_mode))
{
! icode = optab_handler (cstore_optab, compare_mode)->insn_code;
if (icode != CODE_FOR_nothing)
break;
}
*************** emit_store_flag (rtx target, enum rtx_co
*** 5504,5512 ****
that is compensated by the subsequent overflow when subtracting
one / negating. */
! if (abs_optab->handlers[mode].insn_code != CODE_FOR_nothing)
tem = expand_unop (mode, abs_optab, op0, subtarget, 1);
! else if (ffs_optab->handlers[mode].insn_code != CODE_FOR_nothing)
tem = expand_unop (mode, ffs_optab, op0, subtarget, 1);
else if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
{
--- 5506,5514 ----
that is compensated by the subsequent overflow when subtracting
one / negating. */
! if (optab_handler (abs_optab, mode)->insn_code != CODE_FOR_nothing)
tem = expand_unop (mode, abs_optab, op0, subtarget, 1);
! else if (optab_handler (ffs_optab, mode)->insn_code != CODE_FOR_nothing)
tem = expand_unop (mode, ffs_optab, op0, subtarget, 1);
else if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
{
Index: tree-vect-patterns.c
===================================================================
*** tree-vect-patterns.c (revision 127065)
--- tree-vect-patterns.c (working copy)
*************** vect_pattern_recog_1 (
*** 647,653 ****
optab = optab_for_tree_code (TREE_CODE (pattern_expr), pattern_vectype);
vec_mode = TYPE_MODE (pattern_vectype);
if (!optab
! || (icode = optab->handlers[(int) vec_mode].insn_code) ==
CODE_FOR_nothing
|| (type_out
&& (!get_vectype_for_scalar_type (type_out)
--- 647,653 ----
optab = optab_for_tree_code (TREE_CODE (pattern_expr), pattern_vectype);
vec_mode = TYPE_MODE (pattern_vectype);
if (!optab
! || (icode = optab_handler (optab, vec_mode)->insn_code) ==
CODE_FOR_nothing
|| (type_out
&& (!get_vectype_for_scalar_type (type_out)
Index: tree-ssa-loop-prefetch.c
===================================================================
*** tree-ssa-loop-prefetch.c (revision 127065)
--- tree-ssa-loop-prefetch.c (working copy)
*************** nontemporal_store_p (struct mem_ref *ref
*** 941,947 ****
if (mode == BLKmode)
return false;
! code = storent_optab->handlers[mode].insn_code;
return code != CODE_FOR_nothing;
}
--- 941,947 ----
if (mode == BLKmode)
return false;
! code = optab_handler (storent_optab, mode)->insn_code;
return code != CODE_FOR_nothing;
}
Index: tree-vect-transform.c
===================================================================
*** tree-vect-transform.c (revision 127065)
--- tree-vect-transform.c (working copy)
*************** vect_model_reduction_cost (stmt_vec_info
*** 396,403 ****
/* We have a whole vector shift available. */
if (VECTOR_MODE_P (mode)
! && optab->handlers[mode].insn_code != CODE_FOR_nothing
! && vec_shr_optab->handlers[mode].insn_code != CODE_FOR_nothing)
/* Final reduction via vector shifts and the reduction operator. Also
requires scalar extract. */
outer_cost += ((exact_log2(nelements) * 2) * TARG_VEC_STMT_COST
--- 396,403 ----
/* We have a whole vector shift available. */
if (VECTOR_MODE_P (mode)
! && optab_handler (optab, mode)->insn_code != CODE_FOR_nothing
! && optab_handler (vec_shr_optab, mode)->insn_code != CODE_FOR_nothing)
/* Final reduction via vector shifts and the reduction operator. Also
requires scalar extract. */
outer_cost += ((exact_log2(nelements) * 2) * TARG_VEC_STMT_COST
*************** vect_create_epilog_for_reduction (tree v
*** 1809,1815 ****
int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
tree vec_temp;
! if (vec_shr_optab->handlers[mode].insn_code != CODE_FOR_nothing)
shift_code = VEC_RSHIFT_EXPR;
else
have_whole_vector_shift = false;
--- 1809,1815 ----
int vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
tree vec_temp;
! if (optab_handler (vec_shr_optab, mode)->insn_code != CODE_FOR_nothing)
shift_code = VEC_RSHIFT_EXPR;
else
have_whole_vector_shift = false;
*************** vect_create_epilog_for_reduction (tree v
*** 1825,1831 ****
else
{
optab optab = optab_for_tree_code (code, vectype);
! if (optab->handlers[mode].insn_code == CODE_FOR_nothing)
have_whole_vector_shift = false;
}
--- 1825,1831 ----
else
{
optab optab = optab_for_tree_code (code, vectype);
! if (optab_handler (optab, mode)->insn_code == CODE_FOR_nothing)
have_whole_vector_shift = false;
}
*************** vectorizable_reduction (tree stmt, block
*** 2138,2144 ****
return false;
}
vec_mode = TYPE_MODE (vectype);
! if (optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "op not supported by target.");
--- 2138,2144 ----
return false;
}
vec_mode = TYPE_MODE (vectype);
! if (optab_handler (optab, vec_mode)->insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "op not supported by target.");
*************** vectorizable_reduction (tree stmt, block
*** 2218,2224 ****
fprintf (vect_dump, "no optab for reduction.");
epilog_reduc_code = NUM_TREE_CODES;
}
! if (reduc_optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "reduc op not supported by target.");
--- 2218,2224 ----
fprintf (vect_dump, "no optab for reduction.");
epilog_reduc_code = NUM_TREE_CODES;
}
! if (optab_handler (reduc_optab, vec_mode)->insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "reduc op not supported by target.");
*************** vectorizable_operation (tree stmt, block
*** 3175,3181 ****
return false;
}
vec_mode = TYPE_MODE (vectype);
! icode = (int) optab->handlers[(int) vec_mode].insn_code;
if (icode == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
--- 3175,3181 ----
return false;
}
vec_mode = TYPE_MODE (vectype);
! icode = (int) optab_handler (optab, vec_mode)->insn_code;
if (icode == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
*************** vect_strided_store_supported (tree vecty
*** 3691,3699 ****
return false;
}
! if (interleave_high_optab->handlers[(int) mode].insn_code
== CODE_FOR_nothing
! || interleave_low_optab->handlers[(int) mode].insn_code
== CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
--- 3691,3699 ----
return false;
}
! if (optab_handler (interleave_high_optab, mode)->insn_code
== CODE_FOR_nothing
! || optab_handler (interleave_low_optab, mode)->insn_code
== CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
*************** vectorizable_store (tree stmt, block_stm
*** 3910,3916 ****
vec_mode = TYPE_MODE (vectype);
/* FORNOW. In some cases can vectorize even if data-type not supported
(e.g. - array initialization with 0). */
! if (mov_optab->handlers[(int)vec_mode].insn_code == CODE_FOR_nothing)
return false;
if (!STMT_VINFO_DATA_REF (stmt_info))
--- 3910,3916 ----
vec_mode = TYPE_MODE (vectype);
/* FORNOW. In some cases can vectorize even if data-type not supported
(e.g. - array initialization with 0). */
! if (optab_handler (mov_optab, (int)vec_mode)->insn_code == CODE_FOR_nothing)
return false;
if (!STMT_VINFO_DATA_REF (stmt_info))
*************** vect_strided_load_supported (tree vectyp
*** 4252,4258 ****
return false;
}
! if (perm_even_optab->handlers[mode].insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "perm_even op not supported by target.");
--- 4252,4258 ----
return false;
}
! if (optab_handler (perm_even_optab, mode)->insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "perm_even op not supported by target.");
*************** vect_strided_load_supported (tree vectyp
*** 4267,4273 ****
return false;
}
! if (perm_odd_optab->handlers[mode].insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "perm_odd op not supported by target.");
--- 4267,4273 ----
return false;
}
! if (optab_handler (perm_odd_optab, mode)->insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "perm_odd op not supported by target.");
*************** vectorizable_load (tree stmt, block_stmt
*** 4570,4576 ****
/* FORNOW. In some cases can vectorize even if data-type not supported
(e.g. - data copies). */
! if (mov_optab->handlers[mode].insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "Aligned load, but unsupported type.");
--- 4570,4576 ----
/* FORNOW. In some cases can vectorize even if data-type not supported
(e.g. - data copies). */
! if (optab_handler (mov_optab, mode)->insn_code == CODE_FOR_nothing)
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "Aligned load, but unsupported type.");
Index: combine.c
===================================================================
*** combine.c (revision 127065)
--- combine.c (working copy)
*************** simplify_comparison (enum rtx_code code,
*** 10442,10448 ****
&& ((unsigned HOST_WIDE_INT) const_op
< (((unsigned HOST_WIDE_INT) 1
<< (GET_MODE_BITSIZE (mode) - 1))))
! && cmp_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
op0 = XEXP (op0, 0);
continue;
--- 10442,10448 ----
&& ((unsigned HOST_WIDE_INT) const_op
< (((unsigned HOST_WIDE_INT) 1
<< (GET_MODE_BITSIZE (mode) - 1))))
! && optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing)
{
op0 = XEXP (op0, 0);
continue;
*************** simplify_comparison (enum rtx_code code,
*** 10523,10529 ****
&& (unsigned_comparison_p || equality_comparison_p)
&& (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
&& ((unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode))
! && cmp_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
op0 = XEXP (op0, 0);
continue;
--- 10523,10529 ----
&& (unsigned_comparison_p || equality_comparison_p)
&& (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
&& ((unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode))
! && optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing)
{
op0 = XEXP (op0, 0);
continue;
Index: tree-vect-generic.c
===================================================================
*** tree-vect-generic.c (revision 127065)
--- tree-vect-generic.c (working copy)
*************** type_for_widest_vector_mode (enum machin
*** 355,361 ****
for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
if (GET_MODE_INNER (mode) == inner_mode
&& GET_MODE_NUNITS (mode) > best_nunits
! && op->handlers[mode].insn_code != CODE_FOR_nothing)
best_mode = mode, best_nunits = GET_MODE_NUNITS (mode);
if (best_mode == VOIDmode)
--- 355,361 ----
for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
if (GET_MODE_INNER (mode) == inner_mode
&& GET_MODE_NUNITS (mode) > best_nunits
! && optab_handler (op, mode)->insn_code != CODE_FOR_nothing)
best_mode = mode, best_nunits = GET_MODE_NUNITS (mode);
if (best_mode == VOIDmode)
*************** expand_vector_operations_1 (block_stmt_i
*** 459,465 ****
if ((GET_MODE_CLASS (compute_mode) == MODE_VECTOR_INT
|| GET_MODE_CLASS (compute_mode) == MODE_VECTOR_FLOAT)
&& op != NULL
! && op->handlers[compute_mode].insn_code != CODE_FOR_nothing)
return;
else
/* There is no operation in hardware, so fall back to scalars. */
--- 459,465 ----
if ((GET_MODE_CLASS (compute_mode) == MODE_VECTOR_INT
|| GET_MODE_CLASS (compute_mode) == MODE_VECTOR_FLOAT)
&& op != NULL
! && optab_handler (op, compute_mode)->insn_code != CODE_FOR_nothing)
return;
else
/* There is no operation in hardware, so fall back to scalars. */
Index: config/spu/spu.c
===================================================================
*** config/spu/spu.c (revision 127065)
--- config/spu/spu.c (working copy)
*************** spu_expand_mov (rtx * ops, enum machine_
*** 3461,3467 ****
if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (imode))
{
! enum insn_code icode = trunc_optab->handlers[mode][imode].insn_code;
emit_insn (GEN_FCN (icode) (ops[0], from));
}
else
--- 3461,3467 ----
if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (imode))
{
! enum insn_code icode = convert_optab_handler (trunc_optab, mode, imode)->insn_code;
emit_insn (GEN_FCN (icode) (ops[0], from));
}
else
*************** spu_emit_vector_compare (enum rtx_code r
*** 5031,5037 ****
{
enum insn_code nor_code;
rtx eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
! nor_code = one_cmpl_optab->handlers[(int)dest_mode].insn_code;
gcc_assert (nor_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (nor_code) (mask, eq_rtx));
if (dmode != dest_mode)
--- 5031,5037 ----
{
enum insn_code nor_code;
rtx eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
! nor_code = optab_handler (one_cmpl_optab, (int)dest_mode)->insn_code;
gcc_assert (nor_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (nor_code) (mask, eq_rtx));
if (dmode != dest_mode)
*************** spu_emit_vector_compare (enum rtx_code r
*** 5066,5072 ****
c_rtx = spu_emit_vector_compare (new_code, op0, op1, dest_mode);
eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
! ior_code = ior_optab->handlers[(int)dest_mode].insn_code;
gcc_assert (ior_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
if (dmode != dest_mode)
--- 5066,5072 ----
c_rtx = spu_emit_vector_compare (new_code, op0, op1, dest_mode);
eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
! ior_code = optab_handler (ior_optab, (int)dest_mode)->insn_code;
gcc_assert (ior_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
if (dmode != dest_mode)
Index: config/rs6000/rs6000.c
===================================================================
*** config/rs6000/rs6000.c (revision 127065)
--- config/rs6000/rs6000.c (working copy)
*************** rs6000_emit_vector_compare (enum rtx_cod
*** 12254,12260 ****
eq_rtx = rs6000_emit_vector_compare (rev_code, op0, op1,
dest_mode);
! nor_code = one_cmpl_optab->handlers[(int)dest_mode].insn_code;
gcc_assert (nor_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (nor_code) (mask, eq_rtx));
--- 12254,12260 ----
eq_rtx = rs6000_emit_vector_compare (rev_code, op0, op1,
dest_mode);
! nor_code = optab_handler (one_cmpl_optab, (int)dest_mode)->insn_code;
gcc_assert (nor_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (nor_code) (mask, eq_rtx));
*************** rs6000_emit_vector_compare (enum rtx_cod
*** 12304,12310 ****
eq_rtx = rs6000_emit_vector_compare (EQ, op0, op1,
dest_mode);
! ior_code = ior_optab->handlers[(int)dest_mode].insn_code;
gcc_assert (ior_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
if (dmode != dest_mode)
--- 12304,12310 ----
eq_rtx = rs6000_emit_vector_compare (EQ, op0, op1,
dest_mode);
! ior_code = optab_handler (ior_optab, (int)dest_mode)->insn_code;
gcc_assert (ior_code != CODE_FOR_nothing);
emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
if (dmode != dest_mode)
Index: stmt.c
===================================================================
*** stmt.c (revision 127065)
--- stmt.c (working copy)
*************** add_case_node (struct case_node *head, t
*** 2143,2149 ****
/* By default, enable case bit tests on targets with ashlsi3. */
#ifndef CASE_USE_BIT_TESTS
! #define CASE_USE_BIT_TESTS (ashl_optab->handlers[word_mode].insn_code \
!= CODE_FOR_nothing)
#endif
--- 2143,2149 ----
/* By default, enable case bit tests on targets with ashlsi3. */
#ifndef CASE_USE_BIT_TESTS
! #define CASE_USE_BIT_TESTS (optab_handler (ashl_optab, word_mode)->insn_code \
!= CODE_FOR_nothing)
#endif
Index: reload1.c
===================================================================
*** reload1.c (revision 127065)
--- reload1.c (working copy)
*************** gen_reload (rtx out, rtx in, int opnum,
*** 7940,7946 ****
DEFINE_PEEPHOLE should be specified that recognizes the sequence
we emit below. */
! code = (int) add_optab->handlers[(int) GET_MODE (out)].insn_code;
if (CONSTANT_P (op1) || MEM_P (op1) || GET_CODE (op1) == SUBREG
|| (REG_P (op1)
--- 7940,7946 ----
DEFINE_PEEPHOLE should be specified that recognizes the sequence
we emit below. */
! code = (int) optab_handler (add_optab, GET_MODE (out))->insn_code;
if (CONSTANT_P (op1) || MEM_P (op1) || GET_CODE (op1) == SUBREG
|| (REG_P (op1)
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: Cleanup optabs handler interface
2007-07-31 18:30 Cleanup optabs handler interface Jan Hubicka
@ 2007-08-06 2:56 ` Mark Mitchell
0 siblings, 0 replies; 2+ messages in thread
From: Mark Mitchell @ 2007-08-06 2:56 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-patches
Jan Hubicka wrote:
> * optabs.c (expand_widen_pattern_expr): Use optabs accestors.
> (expand_ternary_op): Likewise.
> ...
OK.
--
Mark Mitchell
CodeSourcery
mark@codesourcery.com
(650) 331-3385 x713
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2007-08-06 2:56 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2007-07-31 18:30 Cleanup optabs handler interface Jan Hubicka
2007-08-06 2:56 ` Mark Mitchell
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).