From 166cdb08f21ed5009f1890b717a4eaf0d7f5d3a6 Mon Sep 17 00:00:00 2001 From: Jan Hubicka Date: Thu, 9 Aug 2007 16:01:22 +0200 Subject: [PATCH] optabs.c (expand_widen_pattern_expr): Use optabs accestors. * 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): From-SVN: r127317 --- gcc/ChangeLog | 102 ++++++++++++ gcc/ada/misc.c | 4 +- gcc/builtins.c | 18 +-- gcc/combine.c | 4 +- gcc/config/rs6000/rs6000.c | 4 +- gcc/config/spu/spu.c | 6 +- gcc/dojump.c | 4 +- gcc/expmed.c | 52 +++--- gcc/expr.c | 58 +++---- gcc/genopinit.c | 306 +++++++++++++++++------------------ gcc/optabs.c | 214 ++++++++++++------------ gcc/optabs.h | 4 + gcc/reload.c | 2 +- gcc/reload1.c | 2 +- gcc/stmt.c | 2 +- gcc/tree-ssa-loop-prefetch.c | 2 +- gcc/tree-vect-generic.c | 4 +- gcc/tree-vect-patterns.c | 2 +- gcc/tree-vect-transform.c | 26 +-- gcc/tree-vectorizer.c | 12 +- 20 files changed, 470 insertions(+), 358 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8dcf5b193e1..d5170d8e9f9 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,105 @@ +2007-08-09 Jan Hubicka + + * 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): + 2007-08-09 Michael Matz * tree.h (fixed_zerop): Declare as taking a const_tree. diff --git a/gcc/ada/misc.c b/gcc/ada/misc.c index 5abb3988f57..24d450e9640 100644 --- a/gcc/ada/misc.c +++ b/gcc/ada/misc.c @@ -480,7 +480,7 @@ gnat_compute_largest_alignment (void) 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) + 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))); @@ -900,7 +900,7 @@ enumerate_modes (void (*f) (int, int, int, int, int, int, unsigned int)) 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) + if (optab_handler (add_optab, j)->insn_code != CODE_FOR_nothing) break; if (float_p) diff --git a/gcc/builtins.c b/gcc/builtins.c index 39b4fcc8dd2..48350d7fdf4 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -1879,7 +1879,7 @@ expand_builtin_mathfn (tree exp, rtx target, rtx subtarget) errno_set = false; /* Before working hard, check whether the instruction is available. */ - if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing) { target = gen_reg_rtx (mode); @@ -2030,7 +2030,7 @@ expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget) 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) + if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing) return NULL_RTX; target = gen_reg_rtx (mode); @@ -2120,7 +2120,7 @@ expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget) /* Check if sincos insn is available, otherwise fallback to sin or cos insn. */ - if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing) + if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing) switch (DECL_FUNCTION_CODE (fndecl)) { CASE_FLT_FN (BUILT_IN_SIN): @@ -2132,7 +2132,7 @@ expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget) } /* Before working hard, check whether the instruction is available. */ - if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing) { target = gen_reg_rtx (mode); @@ -2241,7 +2241,7 @@ expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget) mode = TYPE_MODE (TREE_TYPE (arg)); if (builtin_optab) - icode = builtin_optab->handlers[(int) mode].insn_code; + icode = optab_handler (builtin_optab, mode)->insn_code; /* Before working hard, check whether the instruction is available. */ if (icode != CODE_FOR_nothing) @@ -2367,7 +2367,7 @@ expand_builtin_sincos (tree exp) 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) + if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing) return NULL_RTX; target1 = gen_reg_rtx (mode); @@ -2413,7 +2413,7 @@ expand_builtin_cexpi (tree exp, rtx target, rtx subtarget) /* 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) + if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing) { op1 = gen_reg_rtx (mode); op2 = gen_reg_rtx (mode); @@ -3100,7 +3100,7 @@ expand_builtin_powi (tree exp, rtx target, rtx subtarget) if (GET_MODE (op1) != mode2) op1 = convert_to_mode (mode2, op1, 0); - target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc, + target = emit_library_call_value (optab_handler (powi_optab, mode)->libfunc, target, LCT_CONST_MAKE_BLOCK, mode, 2, op0, mode, op1, mode2); @@ -3153,7 +3153,7 @@ expand_builtin_strlen (tree exp, rtx target, /* 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; + icode = optab_handler (strlen_optab, insn_mode)->insn_code; if (icode != CODE_FOR_nothing) break; diff --git a/gcc/combine.c b/gcc/combine.c index 3fe9a166a9f..c794e11857f 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -10442,7 +10442,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1) && ((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) + && optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing) { op0 = XEXP (op0, 0); continue; @@ -10523,7 +10523,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1) && (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) + && optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing) { op0 = XEXP (op0, 0); continue; diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index b579cec1b3a..d26da5272ee 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -12277,7 +12277,7 @@ rs6000_emit_vector_compare (enum rtx_code rcode, eq_rtx = rs6000_emit_vector_compare (rev_code, op0, op1, dest_mode); - nor_code = one_cmpl_optab->handlers[(int)dest_mode].insn_code; + 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)); @@ -12327,7 +12327,7 @@ rs6000_emit_vector_compare (enum rtx_code rcode, eq_rtx = rs6000_emit_vector_compare (EQ, op0, op1, dest_mode); - ior_code = ior_optab->handlers[(int)dest_mode].insn_code; + 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) diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c index 02f07b8f752..555beab5318 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -3460,7 +3460,7 @@ spu_expand_mov (rtx * ops, enum machine_mode mode) if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (imode)) { - enum insn_code icode = trunc_optab->handlers[mode][imode].insn_code; + enum insn_code icode = convert_optab_handler (trunc_optab, mode, imode)->insn_code; emit_insn (GEN_FCN (icode) (ops[0], from)); } else @@ -5030,7 +5030,7 @@ spu_emit_vector_compare (enum rtx_code rcode, { 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; + 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) @@ -5065,7 +5065,7 @@ spu_emit_vector_compare (enum rtx_code rcode, 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; + 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) diff --git a/gcc/dojump.c b/gcc/dojump.c index c0ff1a1f61c..b619e0f49de 100644 --- a/gcc/dojump.c +++ b/gcc/dojump.c @@ -275,7 +275,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) && (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 + && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code != CODE_FOR_nothing)) { do_jump (fold_convert (type, exp), if_false_label, if_true_label); @@ -334,7 +334,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) 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 + && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code != CODE_FOR_nothing)) { do_jump (fold_convert (type, exp), if_false_label, if_true_label); diff --git a/gcc/expmed.c b/gcc/expmed.c index 061fbbbd448..84a709adaa1 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -403,7 +403,7 @@ store_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize, available. */ if (VECTOR_MODE_P (GET_MODE (op0)) && !MEM_P (op0) - && (vec_set_optab->handlers[GET_MODE (op0)].insn_code + && (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))) @@ -411,7 +411,7 @@ store_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize, { 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 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; @@ -517,10 +517,10 @@ store_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize, if (!MEM_P (op0) && (BYTES_BIG_ENDIAN ? bitpos + bitsize == unit : bitpos == 0) && bitsize == GET_MODE_BITSIZE (fieldmode) - && (movstrict_optab->handlers[fieldmode].insn_code + && (optab_handler (movstrict_optab, fieldmode)->insn_code != CODE_FOR_nothing)) { - int icode = movstrict_optab->handlers[fieldmode].insn_code; + 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)) @@ -1206,14 +1206,14 @@ extract_bit_field_1 (rtx str_rtx, unsigned HOST_WIDE_INT bitsize, available. */ if (VECTOR_MODE_P (GET_MODE (op0)) && !MEM_P (op0) - && (vec_extract_optab->handlers[GET_MODE (op0)].insn_code + && (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) vec_extract_optab->handlers[outermode].insn_code; + 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; @@ -3422,7 +3422,7 @@ expand_mult_highpart_optab (enum machine_mode mode, rtx op0, rtx op1, /* Try widening multiplication. */ moptab = unsignedp ? umul_widen_optab : smul_widen_optab; - if (moptab->handlers[wider_mode].insn_code != CODE_FOR_nothing + 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, @@ -3432,7 +3432,7 @@ expand_mult_highpart_optab (enum machine_mode mode, rtx op0, rtx op1, } /* Try widening the mode and perform a non-widening multiplication. */ - if (smul_optab->handlers[wider_mode].insn_code != CODE_FOR_nothing + 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) { @@ -3459,7 +3459,7 @@ expand_mult_highpart_optab (enum machine_mode mode, rtx op0, rtx op1, /* 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 + 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)) @@ -3580,7 +3580,7 @@ expand_smod_pow2 (enum machine_mode mode, rtx op0, HOST_WIDE_INT d) 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 + 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, @@ -3879,15 +3879,15 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode, 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) + 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 (optab1->handlers[compute_mode].libfunc - || optab2->handlers[compute_mode].libfunc) + 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 @@ -4134,11 +4134,13 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode, : 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 + && ((optab_handler ((rem_flag ? smod_optab + : sdiv_optab), + compute_mode)->insn_code != CODE_FOR_nothing) - || (sdivmod_optab->handlers[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)) { @@ -4150,9 +4152,9 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode, } if (sdiv_pow2_cheap[compute_mode] - && ((sdiv_optab->handlers[compute_mode].insn_code + && ((optab_handler (sdiv_optab, compute_mode)->insn_code != CODE_FOR_nothing) - || (sdivmod_optab->handlers[compute_mode].insn_code + || (optab_handler (sdivmod_optab, compute_mode)->insn_code != CODE_FOR_nothing))) quotient = expand_divmod (0, TRUNC_DIV_EXPR, compute_mode, op0, @@ -4800,7 +4802,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode, = sign_expand_binop (compute_mode, umod_optab, smod_optab, op0, op1, target, unsignedp, - ((optab2->handlers[compute_mode].insn_code + ((optab_handler (optab2, compute_mode)->insn_code != CODE_FOR_nothing) ? OPTAB_DIRECT : OPTAB_WIDEN)); if (remainder == 0) @@ -4828,7 +4830,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode, = sign_expand_binop (compute_mode, udiv_optab, sdiv_optab, op0, op1, rem_flag ? NULL_RTX : target, unsignedp, - ((optab2->handlers[compute_mode].insn_code + ((optab_handler (optab2, compute_mode)->insn_code != CODE_FOR_nothing) ? OPTAB_DIRECT : OPTAB_WIDEN)); @@ -5348,7 +5350,7 @@ emit_store_flag (rtx target, enum rtx_code code, rtx op0, rtx op1, for (compare_mode = mode; compare_mode != VOIDmode; compare_mode = GET_MODE_WIDER_MODE (compare_mode)) { - icode = cstore_optab->handlers[(int) compare_mode].insn_code; + icode = optab_handler (cstore_optab, compare_mode)->insn_code; if (icode != CODE_FOR_nothing) break; } @@ -5512,9 +5514,9 @@ emit_store_flag (rtx target, enum rtx_code code, rtx op0, rtx op1, that is compensated by the subsequent overflow when subtracting one / negating. */ - if (abs_optab->handlers[mode].insn_code != CODE_FOR_nothing) + if (optab_handler (abs_optab, 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) + 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) { diff --git a/gcc/expr.c b/gcc/expr.c index 2119ab7d5ce..a002b0d30ec 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -426,7 +426,7 @@ convert_move (rtx to, rtx from, int unsignedp) /* Try converting directly if the insn is supported. */ - code = tab->handlers[to_mode][from_mode].insn_code; + code = convert_optab_handler (tab, to_mode, from_mode)->insn_code; if (code != CODE_FOR_nothing) { emit_unop_insn (code, to, from, @@ -435,7 +435,7 @@ convert_move (rtx to, rtx from, int unsignedp) } /* Otherwise use a libcall. */ - libcall = tab->handlers[to_mode][from_mode].libfunc; + libcall = convert_optab_handler (tab, to_mode, from_mode)->libfunc; /* Is this conversion implemented yet? */ gcc_assert (libcall); @@ -460,12 +460,12 @@ convert_move (rtx to, rtx from, int unsignedp) 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 + 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 (trunc_optab->handlers[to_mode][full_mode].insn_code, + emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, full_mode)->insn_code, to, from, UNKNOWN); return; } @@ -475,18 +475,18 @@ convert_move (rtx to, rtx from, int unsignedp) 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 + gcc_assert (convert_optab_handler (sext_optab, 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, + 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 (sext_optab->handlers[full_mode][from_mode].insn_code, + emit_unop_insn (convert_optab_handler (sext_optab, full_mode, from_mode)->insn_code, new_from, from, UNKNOWN); /* else proceed to integer conversions below. */ @@ -690,9 +690,9 @@ convert_move (rtx to, rtx from, int unsignedp) } /* Support special truncate insns for certain modes. */ - if (trunc_optab->handlers[to_mode][from_mode].insn_code != CODE_FOR_nothing) + if (convert_optab_handler (trunc_optab, to_mode, from_mode)->insn_code != CODE_FOR_nothing) { - emit_unop_insn (trunc_optab->handlers[to_mode][from_mode].insn_code, + emit_unop_insn (convert_optab_handler (trunc_optab, to_mode, from_mode)->insn_code, to, from, UNKNOWN); return; } @@ -984,7 +984,7 @@ move_by_pieces (rtx to, rtx from, unsigned HOST_WIDE_INT len, if (mode == VOIDmode) break; - icode = mov_optab->handlers[(int) mode].insn_code; + 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); @@ -1064,7 +1064,7 @@ move_by_pieces_ninsns (unsigned HOST_WIDE_INT l, unsigned int align, if (mode == VOIDmode) break; - icode = mov_optab->handlers[(int) mode].insn_code; + 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); @@ -2250,7 +2250,7 @@ can_store_by_pieces (unsigned HOST_WIDE_INT len, if (mode == VOIDmode) break; - icode = mov_optab->handlers[(int) mode].insn_code; + icode = optab_handler (mov_optab, mode)->insn_code; if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode)) { @@ -2454,7 +2454,7 @@ store_by_pieces_1 (struct store_by_pieces *data ATTRIBUTE_UNUSED, if (mode == VOIDmode) break; - icode = mov_optab->handlers[(int) mode].insn_code; + 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); @@ -2921,7 +2921,7 @@ emit_move_via_integer (enum machine_mode mode, rtx x, rtx y, bool force) return NULL_RTX; /* The target must support moves in this mode. */ - code = mov_optab->handlers[imode].insn_code; + code = optab_handler (mov_optab, imode)->insn_code; if (code == CODE_FOR_nothing) return NULL_RTX; @@ -3071,7 +3071,7 @@ emit_move_complex (enum machine_mode mode, rtx x, rtx y) /* 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) + && 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) @@ -3122,7 +3122,7 @@ emit_move_ccmode (enum machine_mode mode, rtx x, rtx y) /* 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; + 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); @@ -3262,7 +3262,7 @@ emit_move_insn_1 (rtx x, rtx y) gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE); - code = mov_optab->handlers[mode].insn_code; + code = optab_handler (mov_optab, mode)->insn_code; if (code != CODE_FOR_nothing) return emit_insn (GEN_FCN (code) (x, y)); @@ -3514,7 +3514,7 @@ emit_single_push_insn (enum machine_mode mode, rtx x, tree type) 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; + icode = optab_handler (push_optab, mode)->insn_code; if (icode != CODE_FOR_nothing) { if (((pred = insn_data[(int) icode].operand[0].predicate) @@ -4319,7 +4319,7 @@ static bool 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; + enum insn_code code = optab_handler (storent_optab, mode)->insn_code; rtx pattern; if (code == CODE_FOR_nothing) @@ -5458,7 +5458,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) { enum machine_mode mode = GET_MODE (target); - icode = (int) vec_init_optab->handlers[mode].insn_code; + icode = (int) optab_handler (vec_init_optab, mode)->insn_code; if (icode != CODE_FOR_nothing) { unsigned int i; @@ -7394,7 +7394,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, || modifier == EXPAND_STACK_PARM); /* The vectorizer should have already checked the mode. */ - icode = movmisalign_optab->handlers[mode].insn_code; + 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 @@ -8107,7 +8107,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, 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 + && (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing)) { expand_operands (TREE_OPERAND (subsubexp0, 0), @@ -8262,7 +8262,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, 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 + && (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing)) { expand_operands (TREE_OPERAND (subsubexp0, 0), @@ -8377,7 +8377,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, this_optab = usmul_widen_optab; if (mode == GET_MODE_WIDER_MODE (innermode)) { - if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + 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), @@ -8427,7 +8427,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, if (mode == GET_MODE_2XWIDER_MODE (innermode)) { - if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + 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), @@ -8439,7 +8439,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, NULL_RTX, &op0, &op1, EXPAND_NORMAL); goto binop3; } - else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing + else if (optab_handler (other_optab, mode)->insn_code != CODE_FOR_nothing && innermode == word_mode) { rtx htem, hipart; @@ -9552,7 +9552,7 @@ do_store_flag (tree exp, rtx target, enum machine_mode mode, int only_cheap) for (wmode = operand_mode; icode == CODE_FOR_nothing && wmode != VOIDmode; wmode = GET_MODE_WIDER_MODE (wmode)) - icode = cstore_optab->handlers[(int) wmode].insn_code; + icode = optab_handler (cstore_optab, wmode)->insn_code; } if (icode == CODE_FOR_nothing @@ -9565,9 +9565,9 @@ do_store_flag (tree exp, rtx target, enum machine_mode mode, int only_cheap) ; else if (! only_cheap && (code == NE || code == EQ) && TREE_CODE (type) != REAL_TYPE - && ((abs_optab->handlers[(int) operand_mode].insn_code + && ((optab_handler (abs_optab, operand_mode)->insn_code != CODE_FOR_nothing) - || (ffs_optab->handlers[(int) operand_mode].insn_code + || (optab_handler (ffs_optab, operand_mode)->insn_code != CODE_FOR_nothing))) ; else diff --git a/gcc/genopinit.c b/gcc/genopinit.c index b30d6d51073..44c48c7a663 100644 --- a/gcc/genopinit.c +++ b/gcc/genopinit.c @@ -58,123 +58,123 @@ along with GCC; see the file COPYING3. If not see 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$)", +{ "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$)", - "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$)", + "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$)", @@ -204,45 +204,45 @@ static const char * const optabs[] = "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$)", + "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$)", - "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$)" + "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); @@ -475,8 +475,8 @@ from the machine description file `md'. */\n\n"); 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\ + convert_optab_handler (ufixtrunc_optab, i, j)->insn_code\n\ + = convert_optab_handler (sfixtrunc_optab, i, j)->insn_code;\n\ #endif\n\ }"); diff --git a/gcc/optabs.c b/gcc/optabs.c index 3741139ea6c..5afd935657d 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -443,7 +443,7 @@ expand_widen_pattern_expr (tree exp, rtx op0, rtx op1, rtx wide_op, rtx target, 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; + icode = (int) optab_handler (widen_pattern_optab, tmode0)->insn_code; gcc_assert (icode != CODE_FOR_nothing); xmode0 = insn_data[icode].operand[1].mode; @@ -568,7 +568,7 @@ rtx 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; + 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; @@ -576,7 +576,7 @@ expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0, rtx pat; rtx xop0 = op0, xop1 = op1, xop2 = op2; - gcc_assert (ternary_optab->handlers[(int) mode].insn_code + gcc_assert (optab_handler (ternary_optab, mode)->insn_code != CODE_FOR_nothing); if (!target || !insn_data[icode].operand[0].predicate (target, mode)) @@ -697,7 +697,7 @@ expand_vec_shift_expr (tree vec_shift_expr, rtx target) gcc_unreachable (); } - icode = (int) shift_optab->handlers[(int) mode].insn_code; + icode = (int) optab_handler (shift_optab, mode)->insn_code; gcc_assert (icode != CODE_FOR_nothing); mode1 = insn_data[icode].operand[1].mode; @@ -1254,7 +1254,7 @@ expand_binop_directly (enum machine_mode mode, optab binoptab, rtx target, int unsignedp, enum optab_methods methods, int commutative_op, rtx last) { - int icode = (int) binoptab->handlers[(int) mode].insn_code; + 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; @@ -1437,7 +1437,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, /* 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) + && optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing) { temp = expand_binop_directly (mode, binoptab, op0, op1, target, unsignedp, methods, commutative_op, last); @@ -1448,9 +1448,9 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, /* 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) + && optab_handler (rotr_optab, mode)->insn_code != CODE_FOR_nothing) || (binoptab == rotr_optab - && rotl_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)) + && optab_handler (rotl_optab, mode)->insn_code != CODE_FOR_nothing)) && class == MODE_INT) { optab otheroptab = (binoptab == rotl_optab ? rotr_optab : rotl_optab); @@ -1478,8 +1478,8 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, 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) + && ((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), @@ -1507,11 +1507,12 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if (binoptab->handlers[(int) wider_mode].insn_code != CODE_FOR_nothing + if (optab_handler (binoptab, 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) + && ((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; @@ -1559,7 +1560,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, 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) + && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing) { int i; rtx insns; @@ -1611,9 +1612,9 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, && 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) + && 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; @@ -1682,8 +1683,8 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, && 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) + && 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; @@ -1799,7 +1800,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, 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) + && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing) { unsigned int i; optab otheroptab = binoptab == add_optab ? sub_optab : add_optab; @@ -1896,7 +1897,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD) { - if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing + if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing || ! rtx_equal_p (target, xtarget)) { rtx temp = emit_move_insn (target, xtarget); @@ -1925,12 +1926,12 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, 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) + && 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 (umul_widen_optab->handlers[(int) mode].insn_code + if (optab_handler (umul_widen_optab, mode)->insn_code != CODE_FOR_nothing) { product = expand_doubleword_mult (mode, op0, op1, target, @@ -1940,7 +1941,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, } if (product == NULL_RTX - && smul_widen_optab->handlers[(int) mode].insn_code + && optab_handler (smul_widen_optab, mode)->insn_code != CODE_FOR_nothing) { product = expand_doubleword_mult (mode, op0, op1, target, @@ -1951,7 +1952,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, if (product != NULL_RTX) { - if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing) { temp = emit_move_insn (target ? target : product, product); set_unique_reg_note (temp, @@ -1967,7 +1968,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, /* 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 + if (optab_handler (binoptab, mode)->libfunc && (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN)) { rtx insns; @@ -1991,7 +1992,7 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, /* 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, + value = emit_library_call_value (optab_handler (binoptab, mode)->libfunc, NULL_RTX, LCT_CONST, mode, 2, op0, mode, op1x, op1_mode); @@ -2031,10 +2032,10 @@ expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1, wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if ((binoptab->handlers[(int) wider_mode].insn_code + if ((optab_handler (binoptab, wider_mode)->insn_code != CODE_FOR_nothing) || (methods == OPTAB_LIB - && binoptab->handlers[(int) wider_mode].libfunc)) + && optab_handler (binoptab, wider_mode)->libfunc)) { rtx xop0 = op0, xop1 = op1; int no_extend = 0; @@ -2108,8 +2109,8 @@ sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab, /* 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; + optab_handler (&wide_soptab, mode)->insn_code = CODE_FOR_nothing; + optab_handler (&wide_soptab, mode)->libfunc = 0; temp = expand_binop (mode, &wide_soptab, op0, op1, target, unsignedp, OPTAB_WIDEN); @@ -2168,9 +2169,9 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1, /* Record where to go back to if we fail. */ last = get_last_insn (); - if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing) { - int icode = (int) unoptab->handlers[(int) mode].insn_code; + int icode = (int) optab_handler (unoptab, mode)->insn_code; enum machine_mode mode0 = insn_data[icode].operand[2].mode; rtx pat; rtx xop0 = op0; @@ -2206,7 +2207,7 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1, wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if (unoptab->handlers[(int) wider_mode].insn_code + if (optab_handler (unoptab, wider_mode)->insn_code != CODE_FOR_nothing) { rtx t0 = gen_reg_rtx (wider_mode); @@ -2271,9 +2272,9 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1, /* Record where to go back to if we fail. */ last = get_last_insn (); - if (binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing) { - int icode = (int) binoptab->handlers[(int) mode].insn_code; + 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; @@ -2329,7 +2330,7 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1, wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if (binoptab->handlers[(int) wider_mode].insn_code + if (optab_handler (binoptab, wider_mode)->insn_code != CODE_FOR_nothing) { rtx t0 = gen_reg_rtx (wider_mode); @@ -2376,7 +2377,7 @@ expand_twoval_binop_libfunc (optab binoptab, rtx op0, rtx op1, gcc_assert (!targ0 != !targ1); mode = GET_MODE (op0); - if (!binoptab->handlers[(int) mode].libfunc) + if (!optab_handler (binoptab, mode)->libfunc) return false; /* The value returned by the library function will have twice as @@ -2384,7 +2385,7 @@ expand_twoval_binop_libfunc (optab binoptab, rtx op0, rtx op1, 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, + libval = emit_library_call_value (optab_handler (binoptab, mode)->libfunc, NULL_RTX, LCT_CONST, libval_mode, 2, op0, mode, @@ -2430,7 +2431,7 @@ widen_clz (enum machine_mode mode, rtx op0, rtx target) wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if (clz_optab->handlers[(int) wider_mode].insn_code + if (optab_handler (clz_optab, wider_mode)->insn_code != CODE_FOR_nothing) { rtx xop0, temp, last; @@ -2473,7 +2474,7 @@ widen_bswap (enum machine_mode mode, rtx op0, rtx target) 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) + if (optab_handler (bswap_optab, wider_mode)->insn_code != CODE_FOR_nothing) goto found; return NULL_RTX; @@ -2535,7 +2536,7 @@ expand_parity (enum machine_mode mode, rtx op0, rtx target) for (wider_mode = mode; wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if (popcount_optab->handlers[(int) wider_mode].insn_code + if (optab_handler (popcount_optab, wider_mode)->insn_code != CODE_FOR_nothing) { rtx xop0, temp, last; @@ -2708,9 +2709,9 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, class = GET_MODE_CLASS (mode); - if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing) { - int icode = (int) unoptab->handlers[(int) mode].insn_code; + int icode = (int) optab_handler (unoptab, mode)->insn_code; enum machine_mode mode0 = insn_data[icode].operand[1].mode; rtx xop0 = op0; @@ -2769,7 +2770,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, return temp; if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD - && unoptab->handlers[word_mode].insn_code != CODE_FOR_nothing) + && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing) { temp = expand_doubleword_bswap (mode, op0, target); if (temp) @@ -2784,7 +2785,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if (unoptab->handlers[(int) wider_mode].insn_code != CODE_FOR_nothing) + if (optab_handler (unoptab, wider_mode)->insn_code != CODE_FOR_nothing) { rtx xop0 = op0; @@ -2823,7 +2824,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, 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) + && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing) { int i; rtx insns; @@ -2887,7 +2888,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, try_libcall: /* Now try a library call in this mode. */ - if (unoptab->handlers[(int) mode].libfunc) + if (optab_handler (unoptab, mode)->libfunc) { rtx insns; rtx value; @@ -2904,7 +2905,7 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, /* 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, + value = emit_library_call_value (optab_handler (unoptab, mode)->libfunc, NULL_RTX, LCT_CONST, outmode, 1, op0, mode); insns = get_insns (); @@ -2925,9 +2926,9 @@ expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target, wider_mode != VOIDmode; wider_mode = GET_MODE_WIDER_MODE (wider_mode)) { - if ((unoptab->handlers[(int) wider_mode].insn_code + if ((optab_handler (unoptab, wider_mode)->insn_code != CODE_FOR_nothing) - || unoptab->handlers[(int) wider_mode].libfunc) + || optab_handler (unoptab, wider_mode)->libfunc) { rtx xop0 = op0; @@ -3018,7 +3019,7 @@ expand_abs_nojump (enum machine_mode mode, rtx op0, rtx target, } /* 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 + if (optab_handler (smax_optab, mode)->insn_code != CODE_FOR_nothing && !HONOR_SIGNED_ZEROS (mode)) { rtx last = get_last_insn (); @@ -3335,8 +3336,8 @@ expand_copysign (rtx op0, rtx op1, rtx target) 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))) + || (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); @@ -3562,7 +3563,7 @@ emit_no_conflict_block (rtx insns, rtx target, rtx op0, rtx op1, rtx equiv) REG_NOTES (insn)); } - if (mov_optab->handlers[(int) GET_MODE (target)].insn_code + if (optab_handler (mov_optab, GET_MODE (target))->insn_code != CODE_FOR_nothing) { last = emit_move_insn (target, target); @@ -3720,7 +3721,7 @@ emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv) } last = emit_move_insn (target, result); - if (mov_optab->handlers[(int) GET_MODE (target)].insn_code + if (optab_handler (mov_optab, GET_MODE (target))->insn_code != CODE_FOR_nothing) set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv)); else @@ -3758,7 +3759,7 @@ can_compare_p (enum rtx_code code, enum machine_mode mode, { do { - if (cmp_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + if (optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing) { if (purpose == ccp_jump) return bcc_gen_fctn[(int) code] != NULL; @@ -3769,13 +3770,13 @@ can_compare_p (enum rtx_code code, enum machine_mode mode, return 1; } if (purpose == ccp_jump - && cbranch_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + && optab_handler (cbranch_optab, mode)->insn_code != CODE_FOR_nothing) return 1; if (purpose == ccp_cmov - && cmov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + && optab_handler (cmov_optab, mode)->insn_code != CODE_FOR_nothing) return 1; if (purpose == ccp_store_flag - && cstore_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing) + && optab_handler (cstore_optab, mode)->insn_code != CODE_FOR_nothing) return 1; mode = GET_MODE_WIDER_MODE (mode); } @@ -3913,15 +3914,15 @@ prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size, /* Handle a lib call just for the mode we are using. */ - if (cmp_optab->handlers[(int) mode].libfunc && !SCALAR_FLOAT_MODE_P (mode)) + if (optab_handler (cmp_optab, mode)->libfunc && !SCALAR_FLOAT_MODE_P (mode)) { - rtx libfunc = cmp_optab->handlers[(int) mode].libfunc; + 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 && ucmp_optab->handlers[(int) mode].libfunc) - libfunc = ucmp_optab->handlers[(int) mode].libfunc; + 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 (), @@ -3997,7 +3998,7 @@ emit_cmp_and_jump_insn_1 (rtx x, rtx y, enum machine_mode mode, if (label) { - icode = cbranch_optab->handlers[(int) wider_mode].insn_code; + icode = optab_handler (cbranch_optab, wider_mode)->insn_code; if (icode != CODE_FOR_nothing && insn_data[icode].operand[0].predicate (test, wider_mode)) @@ -4010,7 +4011,7 @@ emit_cmp_and_jump_insn_1 (rtx x, rtx y, enum machine_mode mode, } /* Handle some compares against zero. */ - icode = (int) tst_optab->handlers[(int) wider_mode].insn_code; + 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); @@ -4022,7 +4023,7 @@ emit_cmp_and_jump_insn_1 (rtx x, rtx y, enum machine_mode mode, /* Handle compares for which there is a directly suitable insn. */ - icode = (int) cmp_optab->handlers[(int) wider_mode].insn_code; + 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); @@ -4125,10 +4126,10 @@ prepare_float_lib_cmp (rtx *px, rtx *py, enum rtx_code *pcomparison, mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) { - if ((libfunc = code_to_optab[comparison]->handlers[mode].libfunc)) + if ((libfunc = optab_handler (code_to_optab[comparison], mode)->libfunc)) break; - if ((libfunc = code_to_optab[swapped]->handlers[mode].libfunc)) + if ((libfunc = optab_handler (code_to_optab[swapped], mode)->libfunc)) { rtx tmp; tmp = x; x = y; y = tmp; @@ -4136,7 +4137,7 @@ prepare_float_lib_cmp (rtx *px, rtx *py, enum rtx_code *pcomparison, break; } - if ((libfunc = code_to_optab[reversed]->handlers[mode].libfunc) + if ((libfunc = optab_handler (code_to_optab[reversed], mode)->libfunc) && FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, reversed)) { comparison = reversed; @@ -4431,7 +4432,7 @@ emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1, if (mode == VOIDmode) mode = GET_MODE (op2); - icode = addcc_optab->handlers[(int) mode].insn_code; + icode = optab_handler (addcc_optab, mode)->insn_code; if (icode == CODE_FOR_nothing) return 0; @@ -4491,7 +4492,7 @@ emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1, rtx gen_add2_insn (rtx x, rtx y) { - int icode = (int) add_optab->handlers[(int) GET_MODE (x)].insn_code; + 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)); @@ -4508,7 +4509,7 @@ gen_add2_insn (rtx x, rtx y) rtx gen_add3_insn (rtx r0, rtx r1, rtx c) { - int icode = (int) add_optab->handlers[(int) GET_MODE (r0)].insn_code; + int icode = (int) optab_handler (add_optab, GET_MODE (r0))->insn_code; if (icode == CODE_FOR_nothing || !(insn_data[icode].operand[0].predicate @@ -4529,7 +4530,7 @@ have_add2_insn (rtx x, rtx y) gcc_assert (GET_MODE (x) != VOIDmode); - icode = (int) add_optab->handlers[(int) GET_MODE (x)].insn_code; + icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code; if (icode == CODE_FOR_nothing) return 0; @@ -4550,7 +4551,7 @@ have_add2_insn (rtx x, rtx y) rtx gen_sub2_insn (rtx x, rtx y) { - int icode = (int) sub_optab->handlers[(int) GET_MODE (x)].insn_code; + 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)); @@ -4567,7 +4568,7 @@ gen_sub2_insn (rtx x, rtx y) rtx gen_sub3_insn (rtx r0, rtx r1, rtx c) { - int icode = (int) sub_optab->handlers[(int) GET_MODE (r0)].insn_code; + int icode = (int) optab_handler (sub_optab, GET_MODE (r0))->insn_code; if (icode == CODE_FOR_nothing || !(insn_data[icode].operand[0].predicate @@ -4588,7 +4589,7 @@ have_sub2_insn (rtx x, rtx y) gcc_assert (GET_MODE (x) != VOIDmode); - icode = (int) sub_optab->handlers[(int) GET_MODE (x)].insn_code; + icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code; if (icode == CODE_FOR_nothing) return 0; @@ -4634,7 +4635,7 @@ can_extend_p (enum machine_mode to_mode, enum machine_mode from_mode, #endif tab = unsignedp ? zext_optab : sext_optab; - return tab->handlers[to_mode][from_mode].insn_code; + return convert_optab_handler (tab, to_mode, from_mode)->insn_code; } /* Generate the body of an insn to extend Y (with mode MFROM) @@ -4665,7 +4666,7 @@ can_fix_p (enum machine_mode fixmode, enum machine_mode fltmode, enum insn_code icode; tab = unsignedp ? ufixtrunc_optab : sfixtrunc_optab; - icode = tab->handlers[fixmode][fltmode].insn_code; + icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code; if (icode != CODE_FOR_nothing) { *truncp_ptr = 0; @@ -4676,9 +4677,9 @@ can_fix_p (enum machine_mode fixmode, enum machine_mode fltmode, 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; + icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code; if (icode != CODE_FOR_nothing - && ftrunc_optab->handlers[fltmode].insn_code != CODE_FOR_nothing) + && optab_handler (ftrunc_optab, fltmode)->insn_code != CODE_FOR_nothing) { *truncp_ptr = 1; return icode; @@ -4695,7 +4696,7 @@ can_float_p (enum machine_mode fltmode, enum machine_mode fixmode, convert_optab tab; tab = unsignedp ? ufloat_optab : sfloat_optab; - return tab->handlers[fltmode][fixmode].insn_code; + return convert_optab_handler (tab, fltmode, fixmode)->insn_code; } /* Generate code to convert FROM to floating point @@ -4874,7 +4875,8 @@ expand_float (rtx to, rtx from, int unsignedp) 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; + libfunc = convert_optab_handler (tab, GET_MODE (to), + GET_MODE (from))->libfunc; gcc_assert (libfunc); start_sequence (); @@ -5022,7 +5024,7 @@ expand_fix (rtx to, rtx from, int unsignedp) emit_label (lab2); - if (mov_optab->handlers[(int) GET_MODE (to)].insn_code + if (optab_handler (mov_optab, GET_MODE (to))->insn_code != CODE_FOR_nothing) { /* Make a place for a REG_NOTE and add it. */ @@ -5054,7 +5056,8 @@ expand_fix (rtx to, rtx from, int unsignedp) rtx libfunc; convert_optab tab = unsignedp ? ufix_optab : sfix_optab; - libfunc = tab->handlers[GET_MODE (to)][GET_MODE (from)].libfunc; + libfunc = convert_optab_handler (tab, GET_MODE (to), + GET_MODE (from))->libfunc; gcc_assert (libfunc); start_sequence (); @@ -5100,7 +5103,7 @@ expand_sfix_optab (rtx to, rtx from, convert_optab tab) for (imode = GET_MODE (to); imode != VOIDmode; imode = GET_MODE_WIDER_MODE (imode)) { - icode = tab->handlers[imode][fmode].insn_code; + icode = convert_optab_handler (tab, imode, fmode)->insn_code; if (icode != CODE_FOR_nothing) { if (fmode != GET_MODE (from)) @@ -5125,7 +5128,7 @@ int 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 + && (optab_handler (code_to_optab[(int) code], mode)->insn_code != CODE_FOR_nothing)); } @@ -5137,8 +5140,8 @@ new_optab (void) 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; + optab_handler (op, i)->insn_code = CODE_FOR_nothing; + optab_handler (op, i)->libfunc = 0; } return op; @@ -5152,8 +5155,8 @@ new_convert_optab (void) 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; + convert_optab_handler (op, i, j)->insn_code = CODE_FOR_nothing; + convert_optab_handler (op, i, j)->libfunc = 0; } return op; } @@ -5231,7 +5234,7 @@ init_libfuncs (optab optable, int first_mode, int last_mode, *p++ = suffix; *p = '\0'; - optable->handlers[(int) mode].libfunc + optab_handler (optable, mode)->libfunc = init_one_libfunc (ggc_alloc_string (libfunc_name, p - libfunc_name)); } } @@ -5348,7 +5351,7 @@ init_interclass_conv_libfuncs (convert_optab tab, const char *opname, *p = '\0'; - tab->handlers[tmode][fmode].libfunc + convert_optab_handler (tab, tmode, fmode)->libfunc = init_one_libfunc (ggc_alloc_string (libfunc_name, p - libfunc_name)); } @@ -5423,8 +5426,8 @@ init_intraclass_conv_libfuncs (convert_optab tab, const char *opname, *p++ = '2'; *p = '\0'; - tab->handlers[widening ? wmode : nmode] - [widening ? nmode : wmode].libfunc + convert_optab_handler(tab, widening ? wmode : nmode, + widening ? nmode : wmode)->libfunc = init_one_libfunc (ggc_alloc_string (libfunc_name, p - libfunc_name)); } @@ -5461,9 +5464,9 @@ void set_optab_libfunc (optab optable, enum machine_mode mode, const char *name) { if (name) - optable->handlers[mode].libfunc = init_one_libfunc (name); + optab_handler (optable, mode)->libfunc = init_one_libfunc (name); else - optable->handlers[mode].libfunc = 0; + optab_handler (optable, mode)->libfunc = 0; } /* Call this to reset the function entry for one conversion optab @@ -5474,9 +5477,10 @@ set_conv_libfunc (convert_optab optable, enum machine_mode tmode, enum machine_mode fmode, const char *name) { if (name) - optable->handlers[tmode][fmode].libfunc = init_one_libfunc (name); + convert_optab_handler (optable, tmode, fmode)->libfunc + = init_one_libfunc (name); else - optable->handlers[tmode][fmode].libfunc = 0; + convert_optab_handler (optable, tmode, fmode)->libfunc = 0; } /* Call this once to initialize the contents of the optabs @@ -5710,7 +5714,7 @@ init_optabs (void) /* 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"); + 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'); @@ -5820,7 +5824,7 @@ init_optabs (void) /* 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 + optab_handler (abs_optab, TYPE_MODE (complex_double_type_node))->libfunc = init_one_libfunc ("cabs"); abort_libfunc = init_one_libfunc ("abort"); @@ -5876,7 +5880,7 @@ debug_optab_libfuncs (void) struct optab_handlers *h; o = optab_table[i]; - h = &o->handlers[j]; + h = optab_handler (o, j); if (h->libfunc) { gcc_assert (GET_CODE (h->libfunc) == SYMBOL_REF); @@ -5896,7 +5900,7 @@ debug_optab_libfuncs (void) struct optab_handlers *h; o = &convert_optab_table[i]; - h = &o->handlers[j][k]; + h = convert_optab_handler(o, j, k); if (h->libfunc) { gcc_assert (GET_CODE (h->libfunc) == SYMBOL_REF); @@ -5929,7 +5933,7 @@ gen_cond_trap (enum rtx_code code ATTRIBUTE_UNUSED, rtx op1, if (mode == VOIDmode) return 0; - icode = cmp_optab->handlers[(int) mode].insn_code; + icode = optab_handler (cmp_optab, mode)->insn_code; if (icode == CODE_FOR_nothing) return 0; diff --git a/gcc/optabs.h b/gcc/optabs.h index 1e97b57034d..57cc4ff2361 100644 --- a/gcc/optabs.h +++ b/gcc/optabs.h @@ -705,4 +705,8 @@ extern rtx expand_vec_cond_expr (tree, rtx); /* 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 */ diff --git a/gcc/reload.c b/gcc/reload.c index 0d676a29215..ae913bf094f 100644 --- a/gcc/reload.c +++ b/gcc/reload.c @@ -5690,7 +5690,7 @@ find_reloads_address_1 (enum machine_mode mode, rtx x, int context, rtx equiv = (MEM_P (XEXP (x, 0)) ? XEXP (x, 0) : reg_equiv_mem[regno]); - int icode = (int) add_optab->handlers[(int) Pmode].insn_code; + 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 diff --git a/gcc/reload1.c b/gcc/reload1.c index bbea449d9f0..e41dc9a8cfe 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -7940,7 +7940,7 @@ gen_reload (rtx out, rtx in, int opnum, enum reload_type type) DEFINE_PEEPHOLE should be specified that recognizes the sequence we emit below. */ - code = (int) add_optab->handlers[(int) GET_MODE (out)].insn_code; + 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) diff --git a/gcc/stmt.c b/gcc/stmt.c index d6637535cdc..cb4b1bd19e3 100644 --- a/gcc/stmt.c +++ b/gcc/stmt.c @@ -2143,7 +2143,7 @@ add_case_node (struct case_node *head, tree type, tree low, tree high, /* 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 \ +#define CASE_USE_BIT_TESTS (optab_handler (ashl_optab, word_mode)->insn_code \ != CODE_FOR_nothing) #endif diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c index 28cd3223c9c..705848216be 100644 --- a/gcc/tree-ssa-loop-prefetch.c +++ b/gcc/tree-ssa-loop-prefetch.c @@ -940,7 +940,7 @@ nontemporal_store_p (struct mem_ref *ref) if (mode == BLKmode) return false; - code = storent_optab->handlers[mode].insn_code; + code = optab_handler (storent_optab, mode)->insn_code; return code != CODE_FOR_nothing; } diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c index aa673255ea3..76a51e0f090 100644 --- a/gcc/tree-vect-generic.c +++ b/gcc/tree-vect-generic.c @@ -369,7 +369,7 @@ type_for_widest_vector_mode (enum machine_mode inner_mode, optab op, int satp) 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) + && optab_handler (op, mode)->insn_code != CODE_FOR_nothing) best_mode = mode, best_nunits = GET_MODE_NUNITS (mode); if (best_mode == VOIDmode) @@ -484,7 +484,7 @@ expand_vector_operations_1 (block_stmt_iterator *bsi) || GET_MODE_CLASS (compute_mode) == MODE_VECTOR_ACCUM || GET_MODE_CLASS (compute_mode) == MODE_VECTOR_UACCUM) && op != NULL - && op->handlers[compute_mode].insn_code != CODE_FOR_nothing) + && optab_handler (op, compute_mode)->insn_code != CODE_FOR_nothing) return; else /* There is no operation in hardware, so fall back to scalars. */ diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index 0e54850b00b..054bfcbc937 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -647,7 +647,7 @@ vect_pattern_recog_1 ( 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) == + || (icode = optab_handler (optab, vec_mode)->insn_code) == CODE_FOR_nothing || (type_out && (!get_vectype_for_scalar_type (type_out) diff --git a/gcc/tree-vect-transform.c b/gcc/tree-vect-transform.c index ac5c00d46ce..8316aab9e86 100644 --- a/gcc/tree-vect-transform.c +++ b/gcc/tree-vect-transform.c @@ -395,8 +395,8 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code, /* 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) + && 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 @@ -1819,7 +1819,7 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, 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) + if (optab_handler (vec_shr_optab, mode)->insn_code != CODE_FOR_nothing) shift_code = VEC_RSHIFT_EXPR; else have_whole_vector_shift = false; @@ -1835,7 +1835,7 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt, else { optab optab = optab_for_tree_code (code, vectype); - if (optab->handlers[mode].insn_code == CODE_FOR_nothing) + if (optab_handler (optab, mode)->insn_code == CODE_FOR_nothing) have_whole_vector_shift = false; } @@ -2148,7 +2148,7 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) return false; } vec_mode = TYPE_MODE (vectype); - if (optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing) + 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."); @@ -2228,7 +2228,7 @@ vectorizable_reduction (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) 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 (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."); @@ -3185,7 +3185,7 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) return false; } vec_mode = TYPE_MODE (vectype); - icode = (int) optab->handlers[(int) vec_mode].insn_code; + icode = (int) optab_handler (optab, vec_mode)->insn_code; if (icode == CODE_FOR_nothing) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3701,9 +3701,9 @@ vect_strided_store_supported (tree vectype) return false; } - if (interleave_high_optab->handlers[(int) mode].insn_code + if (optab_handler (interleave_high_optab, mode)->insn_code == CODE_FOR_nothing - || interleave_low_optab->handlers[(int) mode].insn_code + || optab_handler (interleave_low_optab, mode)->insn_code == CODE_FOR_nothing) { if (vect_print_dump_info (REPORT_DETAILS)) @@ -3918,7 +3918,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) 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) + if (optab_handler (mov_optab, (int)vec_mode)->insn_code == CODE_FOR_nothing) return false; if (!STMT_VINFO_DATA_REF (stmt_info)) @@ -4234,7 +4234,7 @@ vect_strided_load_supported (tree vectype) return false; } - if (perm_even_optab->handlers[mode].insn_code == CODE_FOR_nothing) + 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."); @@ -4249,7 +4249,7 @@ vect_strided_load_supported (tree vectype) return false; } - if (perm_odd_optab->handlers[mode].insn_code == CODE_FOR_nothing) + 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."); @@ -4552,7 +4552,7 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) /* 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 (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."); diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c index 47a25f8fe5e..396146d803a 100644 --- a/gcc/tree-vectorizer.c +++ b/gcc/tree-vectorizer.c @@ -111,7 +111,7 @@ along with GCC; see the file COPYING3. If not see 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 + 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. @@ -1596,12 +1596,12 @@ vect_supportable_dr_alignment (struct data_reference *dr) if (DR_IS_READ (dr)) { - if (vec_realign_load_optab->handlers[mode].insn_code != CODE_FOR_nothing + 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 (movmisalign_optab->handlers[mode].insn_code != CODE_FOR_nothing) + 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; } @@ -1869,9 +1869,9 @@ supportable_widening_operation (enum tree_code code, tree stmt, tree vectype, return false; vec_mode = TYPE_MODE (vectype); - if ((icode1 = optab1->handlers[(int) vec_mode].insn_code) == CODE_FOR_nothing + if ((icode1 = optab_handler (optab1, 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) + || (icode2 = optab_handler (optab2, vec_mode)->insn_code) == CODE_FOR_nothing || insn_data[icode2].operand[0].mode != TYPE_MODE (wide_vectype)) return false; @@ -1939,7 +1939,7 @@ supportable_narrowing_operation (enum tree_code code, return false; vec_mode = TYPE_MODE (vectype); - if ((icode1 = optab1->handlers[(int) vec_mode].insn_code) == CODE_FOR_nothing + if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) == CODE_FOR_nothing || insn_data[icode1].operand[0].mode != TYPE_MODE (narrow_vectype)) return false; -- 2.30.2