procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

optabs.c (expand_widen_pattern_expr): Use optabs accestors.

Browse source 
* 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
This commit is contained in:
Jan Hubicka 2007-08-09 16:01:22 +02:00 • committed by Jan Hubicka
parent 3eb0da77ce
commit 166cdb08f2
20 changed files with 470 additions and 358 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

102
gcc/ChangeLog
View file

@ -1,3 +1,105 @@
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.

4
gcc/ada/misc.c
View file

@ -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)

18
gcc/builtins.c
View file

@ -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;

4
gcc/combine.c
View file

@ -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;

4
gcc/config/rs6000/rs6000.c
View file

@ -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)

6
gcc/config/spu/spu.c
View file

@ -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)

4
gcc/dojump.c
View file

@ -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);

52
gcc/expmed.c
View file

@ -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)
{

58
gcc/expr.c
View file

@ -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

306
gcc/genopinit.c
View file

@ -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\
}");

214
gcc/optabs.c
View file

@ -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;

4
gcc/optabs.h
View file

@ -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 */

2
gcc/reload.c
View file

@ -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

2
gcc/reload1.c
View file

@ -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)

2
gcc/stmt.c
View file

@ -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

2
gcc/tree-ssa-loop-prefetch.c
View file

@ -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;
}

4
gcc/tree-vect-generic.c
View file

@ -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. */

2
gcc/tree-vect-patterns.c
View file

@ -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)

26
gcc/tree-vect-transform.c
View file

@ -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.");

12
gcc/tree-vectorizer.c
View file

@ -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;