* 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
+2007-08-09 Jan Hubicka <jh@suse.cz>
+
+ * 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 <matz@suse.de>
* tree.h (fixed_zerop): Declare as taking a const_tree.
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)));
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)
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);
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);
/* 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):
}
/* 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);
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)
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);
/* 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);
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);
/* 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;
&& ((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;
&& (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;
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));
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)
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
{
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)
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)
&& (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);
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);
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)))
{
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;
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))
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;
/* 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,
}
/* 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)
{
/* 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))
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,
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
: 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))
{
}
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,
= 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)
= 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));
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;
}
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)
{
/* 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,
}
/* 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);
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;
}
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. */
}
/* 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;
}
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);
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);
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))
{
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);
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;
/* 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)
/* 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);
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));
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)
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)
{
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;
|| 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
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),
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),
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),
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),
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;
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
;
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
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$)",
"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);
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\
}");
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;
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;
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))
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;
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;
/* 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);
/* 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);
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),
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;
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;
&& 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;
&& 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;
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;
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);
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,
}
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,
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,
/* 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;
/* 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);
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;
/* 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);
/* 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;
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);
/* 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;
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);
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
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,
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;
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;
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;
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;
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)
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;
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;
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;
/* 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 ();
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;
}
/* 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 ();
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);
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);
}
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
{
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;
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);
}
/* 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 (),
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))
}
/* 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);
/* 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);
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;
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;
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;
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));
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
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;
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));
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
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;
#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)
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;
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;
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;
}
\f
/* Generate code to convert FROM to floating point
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 ();
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. */
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 ();
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))
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));
}
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;
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;
}
*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));
}
}
*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));
}
*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));
}
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
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
/* 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');
/* 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");
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);
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);
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;
/* 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 */
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
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)
/* 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
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;
}
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)
|| 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. */
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)
/* 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
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;
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;
}
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.");
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.");
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))
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))
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))
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.");
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.");
/* 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.");
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.
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;
}
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;
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;
projects / gcc.git / commitdiff