Reduce the size of optabs representation
From-SVN: r189821
This commit is contained in:
Richard Henderson
Richard Henderson
parent
658e8ebaac
commit
cd1440b199
136
gcc/ChangeLog
136
gcc/ChangeLog
|
|
@ -1,3 +1,139 @@
|
|||
2012-07-24 Richard Henderson <rth@redhat.com>
|
||||
|
||||
* optabs.def: New file.
|
||||
* Makefile.in (OPTABS_H): Add insn-opinit.h.
|
||||
(MOSTLYCLEANFILES): Likewise.
|
||||
(insn-opinit.o): Remove reload.h
|
||||
(simple_rtl_generated_c): Remove insn-opinit.c.
|
||||
(s-opinit): New rule.
|
||||
(build/genopinit.o): Add optabs.def.
|
||||
* genopinit.c (rtx_upname): New.
|
||||
(optabs): Extract to optabs.def
|
||||
(enum optab_tag, struct optab_def_d, optabs): New.
|
||||
(struct pattern_d, patterns): New.
|
||||
(match_pattern): Split out from ...
|
||||
(gen_insn): ... here. Push matches on patterns vec.
|
||||
(pattern_cmp, optab_kind_cmp, optab_rcode_cmp): New.
|
||||
(header_file_name, source_file_name, handle_arg): New.
|
||||
(open_outfile): New.
|
||||
(main): Sort and emit new tables. Generate lookup_handler,
|
||||
raw_optab_handler, swap_optab_enable.
|
||||
* libfuncs.h (libfunc_entry): Change "size_t optab" to "optab op".
|
||||
* optabs.c (code_to_optab_): Remove.
|
||||
(hash_libfunc): Update for optab name change.
|
||||
(eq_libfunc): Likewise.
|
||||
(convert_optab_libfunc): Update computation of optab member;
|
||||
use the new convlib_def table.
|
||||
(optab_libfunc): Similarly.
|
||||
(set_optab_libfunc, set_conv_libfunc): Likewise.
|
||||
(sign_expand_binop): Use swap_optab_enable instead of fake optabs.
|
||||
(init_insn_codes, init_optab, init_optabv, init_convert_optab): Remove.
|
||||
(init_optabs): Don't call them; export the data to optabs.def.
|
||||
(gen_int_libfunc, gen_fp_libfunc): Export non-static.
|
||||
(gen_fixed_libfunc, gen_signed_fixed_libfunc): Likewise.
|
||||
(gen_unsigned_fixed_libfunc, gen_int_fp_libfunc): Likewise.
|
||||
(gen_intv_fp_libfunc, gen_int_fp_fixed_libfunc): Likewise.
|
||||
(gen_int_fp_signed_fixed_libfunc, gen_int_fixed_libfunc): Likewise.
|
||||
(gen_int_signed_fixed_libfunc): Likewise.
|
||||
(gen_int_unsigned_fixed_libfunc): Likewise.
|
||||
(gen_interclass_conv_libfunc, gen_int_to_fp_conv_libfunc): Likewise.
|
||||
(gen_ufloat_conv_libfunc): Likewise.
|
||||
(gen_int_to_fp_nondecimal_conv_libfunc): Likewise.
|
||||
(gen_fp_to_int_conv_libfunc, gen_intraclass_conv_libfunc): Likewise.
|
||||
(gen_trunc_conv_libfunc, gen_extend_conv_libfunc): Likewise.
|
||||
(gen_fract_conv_libfunc, gen_fractuns_conv_libfunc): Likewise.
|
||||
(gen_satfract_conv_libfunc, gen_satfractuns_conv_libfunc): Likewise.
|
||||
(debug_optab_libfuncs): Update for optab representation change.
|
||||
* optabs.h: Include insn-opinit.h.
|
||||
(optab, convert_optab, direct_optab): New typedefs.
|
||||
(struct optab_handlers, struct widening_optab_handlers): Remove.
|
||||
(struct optab_libcall_d): Rename from optab_d; remove code_,
|
||||
handlers, widening members.
|
||||
(struct convert_optab_libcall_d): Rename from convert_optab_d;
|
||||
remove code_ and handlers members.
|
||||
(enum optab_index, enum convert_optab_index): Remove.
|
||||
(enum direct_optab_index): Remove.
|
||||
(code_to_optab_): Fix array range.
|
||||
(optab_to_code): Covert to inline function.
|
||||
(optab_to_code_, convlib_def, normlib_def): Declare.
|
||||
(raw_optab_handler, swap_optab_enable): Declare.
|
||||
(unknown_optab): Remove; export to optabs.def
|
||||
(ssadd_optab, usadd_optab, sssub_optab, ussub_optab, ssmul_optab,
|
||||
usmul_optab, ssdiv_optab, usdiv_optab, ssneg_optab, usneg_optab,
|
||||
ssashl_optab, usashl_optab, add_optab, sub_optab, smul_optab,
|
||||
addv_optab, subv_optab, smul_highpart_optab, umul_highpart_optab,
|
||||
smul_widen_optab, umul_widen_optab, usmul_widen_optab,
|
||||
smadd_widen_optab, umadd_widen_optab, ssmadd_widen_optab,
|
||||
usmadd_widen_optab, smsub_widen_optab, umsub_widen_optab,
|
||||
ssmsub_widen_optab, usmsub_widen_optab, sdiv_optab, smulv_optab,
|
||||
sdivv_optab, sdivmod_optab, udiv_optab, udivmod_optab, smod_optab,
|
||||
umod_optab, fmod_optab, remainder_optab, ftrunc_optab, and_optab,
|
||||
ior_optab, xor_optab, ashl_optab, lshr_optab, ashr_optab, rotl_optab,
|
||||
rotr_optab, vashl_optab, vlshr_optab, vashr_optab, vrotl_optab,
|
||||
vrotr_optab, smin_optab, smax_optab, umin_optab, umax_optab, pow_optab,
|
||||
atan2_optab, fma_optab, fms_optab, fnma_optab, fnms_optab, mov_optab,
|
||||
movstrict_optab, movmisalign_optab, storent_optab, neg_optab,
|
||||
negv_optab, abs_optab, absv_optab, one_cmpl_optab, bswap_optab,
|
||||
ffs_optab, clz_optab, ctz_optab, clrsb_optab, popcount_optab,
|
||||
parity_optab, sqrt_optab, sincos_optab, sin_optab, asin_optab,
|
||||
cos_optab, acos_optab, exp_optab, exp10_optab, exp2_optab, expm1_optab,
|
||||
ldexp_optab, scalb_optab, significand_optab, logb_optab, ilogb_optab,
|
||||
log_optab, log10_optab, log2_optab, log1p_optab, floor_optab,
|
||||
ceil_optab, btrunc_optab, round_optab, nearbyint_optab, rint_optab,
|
||||
tan_optab, atan_optab, copysign_optab, signbit_optab, isinf_optab,
|
||||
cmp_optab, ucmp_optab, eq_optab, ne_optab, gt_optab, ge_optab,
|
||||
lt_optab, le_optab, unord_optab, strlen_optab, cbranch_optab,
|
||||
cmov_optab, cstore_optab, ctrap_optab, push_optab, addcc_optab,
|
||||
reduc_smax_optab, reduc_umax_optab, reduc_smin_optab, reduc_umin_optab,
|
||||
reduc_splus_optab, reduc_uplus_optab, ssum_widen_optab,
|
||||
usum_widen_optab, sdot_prod_optab, udot_prod_optab, vec_set_optab,
|
||||
vec_extract_optab, vec_init_optab, vec_shl_optab, vec_shr_optab,
|
||||
vec_realign_load_optab, vec_widen_umult_hi_optab,
|
||||
vec_widen_umult_lo_optab, vec_widen_smult_hi_optab,
|
||||
vec_widen_smult_lo_optab, vec_widen_umult_even_optab,
|
||||
vec_widen_umult_odd_optab, vec_widen_smult_even_optab,
|
||||
vec_widen_smult_odd_optab, vec_widen_ushiftl_hi_optab,
|
||||
vec_widen_ushiftl_lo_optab, vec_widen_sshiftl_hi_optab,
|
||||
vec_widen_sshiftl_lo_optab, vec_unpacks_hi_optab, vec_unpacks_lo_optab,
|
||||
vec_unpacku_hi_optab, vec_unpacku_lo_optab, vec_unpacks_float_hi_optab,
|
||||
vec_unpacks_float_lo_optab, vec_unpacku_float_hi_optab,
|
||||
vec_unpacku_float_lo_optab, vec_pack_trunc_optab, vec_pack_ssat_optab,
|
||||
vec_pack_usat_optab, vec_pack_sfix_trunc_optab,
|
||||
vec_pack_ufix_trunc_optab, powi_optab, sync_compare_and_swap_optab,
|
||||
sync_lock_test_and_set_optab, sync_old_add_optab, sync_old_sub_optab,
|
||||
sync_old_ior_optab, sync_old_and_optab, sync_old_xor_optab,
|
||||
sync_old_nand_optab, sync_new_add_optab, sync_new_sub_optab,
|
||||
sync_new_ior_optab, sync_new_and_optab, sync_new_xor_optab,
|
||||
sync_new_nand_optab, sext_optab, zext_optab, trunc_optab, sfix_optab,
|
||||
ufix_optab, sfixtrunc_optab, ufixtrunc_optab, sfloat_optab,
|
||||
ufloat_optab, lrint_optab, lround_optab, lfloor_optab, lceil_optab,
|
||||
fract_optab, fractuns_optab, satfract_optab, satfractuns_optab,
|
||||
vec_load_lanes_optab, vec_store_lanes_optab, vcond_optab, vcondu_optab,
|
||||
movcc_optab, reload_in_optab, reload_out_optab, movmem_optab,
|
||||
setmem_optab, cmpstr_optab, cmpstrn_optab, cmpmem_optab,
|
||||
sync_lock_release_optab, sync_add_optab, sync_sub_optab,
|
||||
sync_ior_optab, sync_and_optab, sync_xor_optab, sync_nand_optab,
|
||||
atomic_exchange_optab, atomic_compare_and_swap_optab,
|
||||
atomic_load_optab, atomic_store_optab, atomic_add_fetch_optab,
|
||||
atomic_sub_fetch_optab, atomic_and_fetch_optab,
|
||||
atomic_nand_fetch_optab, atomic_xor_fetch_optab, atomic_or_fetch_optab,
|
||||
atomic_fetch_add_optab, atomic_fetch_sub_optab, atomic_fetch_and_optab,
|
||||
atomic_fetch_nand_optab, atomic_fetch_xor_optab, atomic_fetch_or_optab,
|
||||
atomic_add_optab, atomic_sub_optab, atomic_and_optab,
|
||||
atomic_nand_optab, atomic_xor_optab, atomic_or_optab,
|
||||
atomic_always_lock_free_optab, atomic_is_lock_free_optab,
|
||||
atomic_thread_fence_optab, atomic_signal_fence_optab,
|
||||
vec_perm_optab, vec_perm_const_optab): Likewise.
|
||||
(struct target_optabs): Remove x_optab_table, x_convert_optab_table,
|
||||
and x_direct_optab_table members; add pat_enable.
|
||||
(optab_table, convert_optab_table, direct_optab_table): Remove.
|
||||
(optab_handler): Use raw_optab_handler.
|
||||
(widening_optab_handler, convert_optab_handler): Likewise.
|
||||
(set_optab_handler, set_widening_optab_handler): Remove.
|
||||
(set_convert_optab_handler, set_direct_optab_handler): Remove.
|
||||
(direct_optab_handler): Defer to optab_handler.
|
||||
* rtl.h (NON_GENERATOR_NUM_RTX_CODE): New.
|
||||
|
||||
2012-07-24 Jason Merrill <jason@redhat.com>
|
||||
|
||||
* bitmap.c (bitmap_descriptor): Adjust order of parameters to
|
||||
|
|
|
|||
|
|
@ -889,7 +889,7 @@ OPTIONS_H = options.h flag-types.h $(OPTIONS_H_EXTRA)
|
|||
FUNCTION_H = function.h $(HASHTAB_H) vecprim.h $(TM_H) hard-reg-set.h \
|
||||
$(VEC_H) vecir.h $(INPUT_H) $(MACHMODE_H)
|
||||
EXPR_H = expr.h insn-config.h $(FUNCTION_H) $(RTL_H) $(FLAGS_H) $(TREE_H) $(MACHMODE_H) $(EMIT_RTL_H)
|
||||
OPTABS_H = optabs.h insn-codes.h
|
||||
OPTABS_H = optabs.h insn-codes.h insn-opinit.h
|
||||
REGS_H = regs.h $(MACHMODE_H) hard-reg-set.h
|
||||
SCHED_INT_H = sched-int.h $(INSN_ATTR_H) $(BASIC_BLOCK_H) $(RTL_H) $(DF_H) \
|
||||
vecprim.h $(REGSET_H)
|
||||
|
|
@ -1484,7 +1484,7 @@ BACKEND = libbackend.a main.o @TREEBROWSER@ libcommon-target.a libcommon.a \
|
|||
MOSTLYCLEANFILES = insn-flags.h insn-config.h insn-codes.h \
|
||||
insn-output.c insn-recog.c insn-emit.c insn-extract.c insn-peep.c \
|
||||
insn-attr.h insn-attr-common.h insn-attrtab.c insn-dfatab.c \
|
||||
insn-latencytab.c insn-opinit.c insn-preds.c insn-constants.h \
|
||||
insn-latencytab.c insn-opinit.c insn-opinit.h insn-preds.c insn-constants.h \
|
||||
tm-preds.h tm-constrs.h checksum-options \
|
||||
tree-check.h min-insn-modes.c insn-modes.c insn-modes.h \
|
||||
genrtl.h gt-*.h gtype-*.h gtype-desc.c gtyp-input.list \
|
||||
|
|
@ -3430,7 +3430,7 @@ insn-modes.o : insn-modes.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
|
|||
$(MACHMODE_H)
|
||||
insn-opinit.o : insn-opinit.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
|
||||
$(TM_H) $(RTL_H) $(TM_P_H) insn-config.h $(FLAGS_H) $(RECOG_H) \
|
||||
$(EXPR_H) $(OPTABS_H) reload.h
|
||||
$(EXPR_H) $(OPTABS_H)
|
||||
insn-output.o : insn-output.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
|
||||
$(TM_H) $(RTL_H) $(GGC_H) $(REGS_H) conditions.h \
|
||||
hard-reg-set.h insn-config.h $(INSN_ATTR_H) $(EXPR_H) output.h \
|
||||
|
|
@ -3459,7 +3459,7 @@ simple_rtl_generated_h = insn-attr.h insn-attr-common.h insn-codes.h \
|
|||
insn-config.h insn-flags.h
|
||||
|
||||
simple_rtl_generated_c = insn-automata.c insn-emit.c \
|
||||
insn-extract.c insn-opinit.c insn-output.c \
|
||||
insn-extract.c insn-output.c \
|
||||
insn-peep.c insn-recog.c
|
||||
|
||||
simple_generated_h = $(simple_rtl_generated_h) insn-constants.h
|
||||
|
|
@ -3506,6 +3506,15 @@ s-attrtab : $(MD_DEPS) build/genattrtab$(build_exeext) \
|
|||
$(SHELL) $(srcdir)/../move-if-change tmp-latencytab.c insn-latencytab.c
|
||||
$(STAMP) s-attrtab
|
||||
|
||||
# genopinit produces two files.
|
||||
insn-opinit.c insn-opinit.h: s-opinit ; @true
|
||||
s-opinit: $(MD_DEPS) build/genopinit$(build_exeext) insn-conditions.md
|
||||
$(RUN_GEN) build/genopinit$(build_exeext) $(md_file) \
|
||||
insn-conditions.md -htmp-opinit.h -ctmp-opinit.c
|
||||
$(SHELL) $(srcdir)/../move-if-change tmp-opinit.h insn-opinit.h
|
||||
$(SHELL) $(srcdir)/../move-if-change tmp-opinit.c insn-opinit.c
|
||||
$(STAMP) s-opinit
|
||||
|
||||
# gencondmd doesn't use the standard naming convention.
|
||||
build/gencondmd.c: s-conditions; @true
|
||||
s-conditions: $(MD_DEPS) build/genconditions$(build_exeext)
|
||||
|
|
@ -3859,7 +3868,7 @@ build/genmddeps.o: genmddeps.c $(BCONFIG_H) $(SYSTEM_H) coretypes.h \
|
|||
build/genmodes.o : genmodes.c $(BCONFIG_H) $(SYSTEM_H) errors.h \
|
||||
$(HASHTAB_H) machmode.def $(extra_modes_file)
|
||||
build/genopinit.o : genopinit.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \
|
||||
coretypes.h $(GTM_H) errors.h gensupport.h
|
||||
coretypes.h $(GTM_H) errors.h gensupport.h optabs.def
|
||||
build/genoutput.o : genoutput.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \
|
||||
coretypes.h $(GTM_H) errors.h $(READ_MD_H) gensupport.h
|
||||
build/genpeep.o : genpeep.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \
|
||||
|
|
|
|||
938
gcc/genopinit.c
938
gcc/genopinit.c
|
|
@ -1,7 +1,5 @@
|
|||
/* Generate code to initialize optabs from machine description.
|
||||
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
||||
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
|
||||
Free Software Foundation, Inc.
|
||||
Copyright (C) 1993-2012 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GCC.
|
||||
|
||||
|
|
@ -29,542 +27,498 @@ along with GCC; see the file COPYING3. If not see
|
|||
#include "gensupport.h"
|
||||
|
||||
|
||||
/* Many parts of GCC use arrays that are indexed by machine mode and
|
||||
contain the insn codes for pattern in the MD file that perform a given
|
||||
operation on operands of that mode.
|
||||
#define DEF_RTL_EXPR(V, N, X, C) #V,
|
||||
|
||||
These patterns are present in the MD file with names that contain
|
||||
the mode(s) used and the name of the operation. This program
|
||||
writes a function `init_all_optabs' that initializes the optabs with
|
||||
all the insn codes of the relevant patterns present in the MD file.
|
||||
static const char * const rtx_upname[] = {
|
||||
#include "rtl.def"
|
||||
};
|
||||
|
||||
This array contains a list of optabs that need to be initialized. Within
|
||||
each string, the name of the pattern to be matched against is delimited
|
||||
with $( and $). In the string, $a and $b are used to match a short mode
|
||||
name (the part of the mode name not including `mode' and converted to
|
||||
lower-case). When writing out the initializer, the entire string is
|
||||
used. $A and $B are replaced with the full name of the mode; $a and $b
|
||||
are replaced with the short form of the name, as above.
|
||||
#undef DEF_RTL_EXPR
|
||||
|
||||
If $N is present in the pattern, it means the two modes must be in
|
||||
the same mode class, and $b must be greater than $a (e.g, QImode
|
||||
and HImode).
|
||||
|
||||
/* The entries in optabs.def are categorized:
|
||||
C: A "conversion" optab, which uses two modes; has libcall data.
|
||||
N: A "normal" optab, which uses one mode; has libcall data.
|
||||
D: A "direct" optab, which uses one mode; does not have libcall data.
|
||||
V: An "oVerflow" optab. Like N, but does not record its code in
|
||||
code_to_optab.
|
||||
|
||||
CX, NX, VX: An extra pattern entry for a conversion or normal optab.
|
||||
|
||||
These patterns may be present in the MD file with names that contain
|
||||
the mode(s) used and the name of the operation. This array contains
|
||||
a list of optabs that need to be initialized. Within each name,
|
||||
$a and $b are used to match a short mode name (the part of the mode
|
||||
name not including `mode' and converted to lower-case).
|
||||
|
||||
$I means that only full integer modes should be considered for the
|
||||
next mode, and $F means that only float modes should be considered.
|
||||
$P means that both full and partial integer modes should be considered.
|
||||
$Q means that only fixed-point modes should be considered.
|
||||
|
||||
$V means to emit 'v' if the first mode is a MODE_FLOAT mode.
|
||||
The pattern may be NULL if the optab exists only for the libcalls
|
||||
that we plan to attach to it, and there are no named patterns in
|
||||
the md files. */
|
||||
|
||||
For some optabs, we store the operation by RTL codes. These are only
|
||||
used for comparisons. In that case, $c and $C are the lower-case and
|
||||
upper-case forms of the comparison, respectively. */
|
||||
#define OPTAB_CL(name, pat, c, b, l) name,
|
||||
#define OPTAB_CX(name, pat)
|
||||
#define OPTAB_CD(name, pat) name,
|
||||
#define OPTAB_NL(name, pat, c, b, s, l) name,
|
||||
#define OPTAB_NC(name, pat, c) name,
|
||||
#define OPTAB_NX(name, pat)
|
||||
#define OPTAB_VL(name, pat, c, b, s, l) name,
|
||||
#define OPTAB_VC(name, pat, c) name,
|
||||
#define OPTAB_VX(name, pat)
|
||||
#define OPTAB_DC(name, pat, c) name,
|
||||
#define OPTAB_D(name, pat) name,
|
||||
|
||||
static const char * const optabs[] =
|
||||
{ "set_convert_optab_handler (sext_optab, $B, $A, CODE_FOR_$(extend$a$b2$))",
|
||||
"set_convert_optab_handler (zext_optab, $B, $A, CODE_FOR_$(zero_extend$a$b2$))",
|
||||
"set_convert_optab_handler (sfix_optab, $B, $A, CODE_FOR_$(fix$F$a$I$b2$))",
|
||||
"set_convert_optab_handler (ufix_optab, $B, $A, CODE_FOR_$(fixuns$F$a$b2$))",
|
||||
"set_convert_optab_handler (sfixtrunc_optab, $B, $A, CODE_FOR_$(fix_trunc$F$a$I$b2$))",
|
||||
"set_convert_optab_handler (ufixtrunc_optab, $B, $A, CODE_FOR_$(fixuns_trunc$F$a$I$b2$))",
|
||||
"set_convert_optab_handler (sfloat_optab, $B, $A, CODE_FOR_$(float$I$a$F$b2$))",
|
||||
"set_convert_optab_handler (ufloat_optab, $B, $A, CODE_FOR_$(floatuns$I$a$F$b2$))",
|
||||
"set_convert_optab_handler (trunc_optab, $B, $A, CODE_FOR_$(trunc$a$b2$))",
|
||||
"set_convert_optab_handler (fract_optab, $B, $A, CODE_FOR_$(fract$a$b2$))",
|
||||
"set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$I$a$Q$b2$))",
|
||||
"set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$Q$a$I$b2$))",
|
||||
"set_convert_optab_handler (satfract_optab, $B, $A, CODE_FOR_$(satfract$a$Q$b2$))",
|
||||
"set_convert_optab_handler (satfractuns_optab, $B, $A, CODE_FOR_$(satfractuns$I$a$Q$b2$))",
|
||||
"set_convert_optab_handler (vec_load_lanes_optab, $A, $B, CODE_FOR_$(vec_load_lanes$a$b$))",
|
||||
"set_convert_optab_handler (vec_store_lanes_optab, $A, $B, CODE_FOR_$(vec_store_lanes$a$b$))",
|
||||
"set_optab_handler (add_optab, $A, CODE_FOR_$(add$P$a3$))",
|
||||
"set_optab_handler (addv_optab, $A, CODE_FOR_$(add$F$a3$)),\n\
|
||||
set_optab_handler (add_optab, $A, CODE_FOR_$(add$F$a3$))",
|
||||
"set_optab_handler (addv_optab, $A, CODE_FOR_$(addv$I$a3$))",
|
||||
"set_optab_handler (add_optab, $A, CODE_FOR_$(add$Q$a3$))",
|
||||
"set_optab_handler (ssadd_optab, $A, CODE_FOR_$(ssadd$Q$a3$))",
|
||||
"set_optab_handler (usadd_optab, $A, CODE_FOR_$(usadd$Q$a3$))",
|
||||
"set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$P$a3$))",
|
||||
"set_optab_handler (subv_optab, $A, CODE_FOR_$(sub$F$a3$)),\n\
|
||||
set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$F$a3$))",
|
||||
"set_optab_handler (subv_optab, $A, CODE_FOR_$(subv$I$a3$))",
|
||||
"set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$Q$a3$))",
|
||||
"set_optab_handler (sssub_optab, $A, CODE_FOR_$(sssub$Q$a3$))",
|
||||
"set_optab_handler (ussub_optab, $A, CODE_FOR_$(ussub$Q$a3$))",
|
||||
"set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$Q$a3$))",
|
||||
"set_optab_handler (ssmul_optab, $A, CODE_FOR_$(ssmul$Q$a3$))",
|
||||
"set_optab_handler (usmul_optab, $A, CODE_FOR_$(usmul$Q$a3$))",
|
||||
"set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$P$a3$))",
|
||||
"set_optab_handler (smulv_optab, $A, CODE_FOR_$(mul$F$a3$)),\n\
|
||||
set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$F$a3$))",
|
||||
"set_optab_handler (smulv_optab, $A, CODE_FOR_$(mulv$I$a3$))",
|
||||
"set_optab_handler (umul_highpart_optab, $A, CODE_FOR_$(umul$a3_highpart$))",
|
||||
"set_optab_handler (smul_highpart_optab, $A, CODE_FOR_$(smul$a3_highpart$))",
|
||||
"set_widening_optab_handler (smul_widen_optab, $B, $A, CODE_FOR_$(mul$a$b3$)$N)",
|
||||
"set_widening_optab_handler (umul_widen_optab, $B, $A, CODE_FOR_$(umul$a$b3$)$N)",
|
||||
"set_widening_optab_handler (usmul_widen_optab, $B, $A, CODE_FOR_$(usmul$a$b3$)$N)",
|
||||
"set_widening_optab_handler (smadd_widen_optab, $B, $A, CODE_FOR_$(madd$a$b4$)$N)",
|
||||
"set_widening_optab_handler (umadd_widen_optab, $B, $A, CODE_FOR_$(umadd$a$b4$)$N)",
|
||||
"set_widening_optab_handler (ssmadd_widen_optab, $B, $A, CODE_FOR_$(ssmadd$a$b4$)$N)",
|
||||
"set_widening_optab_handler (usmadd_widen_optab, $B, $A, CODE_FOR_$(usmadd$a$b4$)$N)",
|
||||
"set_widening_optab_handler (smsub_widen_optab, $B, $A, CODE_FOR_$(msub$a$b4$)$N)",
|
||||
"set_widening_optab_handler (umsub_widen_optab, $B, $A, CODE_FOR_$(umsub$a$b4$)$N)",
|
||||
"set_widening_optab_handler (ssmsub_widen_optab, $B, $A, CODE_FOR_$(ssmsub$a$b4$)$N)",
|
||||
"set_widening_optab_handler (usmsub_widen_optab, $B, $A, CODE_FOR_$(usmsub$a$b4$)$N)",
|
||||
"set_optab_handler (sdiv_optab, $A, CODE_FOR_$(div$a3$))",
|
||||
"set_optab_handler (ssdiv_optab, $A, CODE_FOR_$(ssdiv$Q$a3$))",
|
||||
"set_optab_handler (sdivv_optab, $A, CODE_FOR_$(div$V$I$a3$))",
|
||||
"set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$I$a3$))",
|
||||
"set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$Q$a3$))",
|
||||
"set_optab_handler (usdiv_optab, $A, CODE_FOR_$(usdiv$Q$a3$))",
|
||||
"set_optab_handler (sdivmod_optab, $A, CODE_FOR_$(divmod$a4$))",
|
||||
"set_optab_handler (udivmod_optab, $A, CODE_FOR_$(udivmod$a4$))",
|
||||
"set_optab_handler (smod_optab, $A, CODE_FOR_$(mod$a3$))",
|
||||
"set_optab_handler (umod_optab, $A, CODE_FOR_$(umod$a3$))",
|
||||
"set_optab_handler (fmod_optab, $A, CODE_FOR_$(fmod$a3$))",
|
||||
"set_optab_handler (remainder_optab, $A, CODE_FOR_$(remainder$a3$))",
|
||||
"set_optab_handler (ftrunc_optab, $A, CODE_FOR_$(ftrunc$F$a2$))",
|
||||
"set_optab_handler (and_optab, $A, CODE_FOR_$(and$a3$))",
|
||||
"set_optab_handler (ior_optab, $A, CODE_FOR_$(ior$a3$))",
|
||||
"set_optab_handler (xor_optab, $A, CODE_FOR_$(xor$a3$))",
|
||||
"set_optab_handler (ashl_optab, $A, CODE_FOR_$(ashl$a3$))",
|
||||
"set_optab_handler (ssashl_optab, $A, CODE_FOR_$(ssashl$Q$a3$))",
|
||||
"set_optab_handler (usashl_optab, $A, CODE_FOR_$(usashl$Q$a3$))",
|
||||
"set_optab_handler (ashr_optab, $A, CODE_FOR_$(ashr$a3$))",
|
||||
"set_optab_handler (lshr_optab, $A, CODE_FOR_$(lshr$a3$))",
|
||||
"set_optab_handler (rotl_optab, $A, CODE_FOR_$(rotl$a3$))",
|
||||
"set_optab_handler (rotr_optab, $A, CODE_FOR_$(rotr$a3$))",
|
||||
"set_optab_handler (vashr_optab, $A, CODE_FOR_$(vashr$a3$))",
|
||||
"set_optab_handler (vlshr_optab, $A, CODE_FOR_$(vlshr$a3$))",
|
||||
"set_optab_handler (vashl_optab, $A, CODE_FOR_$(vashl$a3$))",
|
||||
"set_optab_handler (vrotl_optab, $A, CODE_FOR_$(vrotl$a3$))",
|
||||
"set_optab_handler (vrotr_optab, $A, CODE_FOR_$(vrotr$a3$))",
|
||||
"set_optab_handler (smin_optab, $A, CODE_FOR_$(smin$a3$))",
|
||||
"set_optab_handler (smax_optab, $A, CODE_FOR_$(smax$a3$))",
|
||||
"set_optab_handler (umin_optab, $A, CODE_FOR_$(umin$I$a3$))",
|
||||
"set_optab_handler (umax_optab, $A, CODE_FOR_$(umax$I$a3$))",
|
||||
"set_optab_handler (pow_optab, $A, CODE_FOR_$(pow$a3$))",
|
||||
"set_optab_handler (atan2_optab, $A, CODE_FOR_$(atan2$a3$))",
|
||||
"set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$P$a2$))",
|
||||
"set_optab_handler (negv_optab, $A, CODE_FOR_$(neg$F$a2$)),\n\
|
||||
set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$F$a2$))",
|
||||
"set_optab_handler (negv_optab, $A, CODE_FOR_$(negv$I$a2$))",
|
||||
"set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$Q$a2$))",
|
||||
"set_optab_handler (ssneg_optab, $A, CODE_FOR_$(ssneg$Q$a2$))",
|
||||
"set_optab_handler (usneg_optab, $A, CODE_FOR_$(usneg$Q$a2$))",
|
||||
"set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$P$a2$))",
|
||||
"set_optab_handler (absv_optab, $A, CODE_FOR_$(abs$F$a2$)),\n\
|
||||
set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$F$a2$))",
|
||||
"set_optab_handler (absv_optab, $A, CODE_FOR_$(absv$I$a2$))",
|
||||
"set_optab_handler (copysign_optab, $A, CODE_FOR_$(copysign$F$a3$))",
|
||||
"set_optab_handler (signbit_optab, $A, CODE_FOR_$(signbit$F$a2$))",
|
||||
"set_optab_handler (isinf_optab, $A, CODE_FOR_$(isinf$a2$))",
|
||||
"set_optab_handler (sqrt_optab, $A, CODE_FOR_$(sqrt$a2$))",
|
||||
"set_optab_handler (floor_optab, $A, CODE_FOR_$(floor$a2$))",
|
||||
"set_convert_optab_handler (lfloor_optab, $B, $A, CODE_FOR_$(lfloor$F$a$I$b2$))",
|
||||
"set_optab_handler (fma_optab, $A, CODE_FOR_$(fma$a4$))",
|
||||
"set_optab_handler (fms_optab, $A, CODE_FOR_$(fms$a4$))",
|
||||
"set_optab_handler (fnma_optab, $A, CODE_FOR_$(fnma$a4$))",
|
||||
"set_optab_handler (fnms_optab, $A, CODE_FOR_$(fnms$a4$))",
|
||||
"set_optab_handler (ceil_optab, $A, CODE_FOR_$(ceil$a2$))",
|
||||
"set_convert_optab_handler (lceil_optab, $B, $A, CODE_FOR_$(lceil$F$a$I$b2$))",
|
||||
"set_optab_handler (round_optab, $A, CODE_FOR_$(round$a2$))",
|
||||
"set_optab_handler (btrunc_optab, $A, CODE_FOR_$(btrunc$a2$))",
|
||||
"set_optab_handler (nearbyint_optab, $A, CODE_FOR_$(nearbyint$a2$))",
|
||||
"set_optab_handler (rint_optab, $A, CODE_FOR_$(rint$a2$))",
|
||||
"set_convert_optab_handler (lrint_optab, $B, $A, CODE_FOR_$(lrint$F$a$I$b2$))",
|
||||
"set_convert_optab_handler (lround_optab, $B, $A, CODE_FOR_$(lround$F$a$I$b2$))",
|
||||
"set_optab_handler (sincos_optab, $A, CODE_FOR_$(sincos$a3$))",
|
||||
"set_optab_handler (sin_optab, $A, CODE_FOR_$(sin$a2$))",
|
||||
"set_optab_handler (asin_optab, $A, CODE_FOR_$(asin$a2$))",
|
||||
"set_optab_handler (cos_optab, $A, CODE_FOR_$(cos$a2$))",
|
||||
"set_optab_handler (acos_optab, $A, CODE_FOR_$(acos$a2$))",
|
||||
"set_optab_handler (exp_optab, $A, CODE_FOR_$(exp$a2$))",
|
||||
"set_optab_handler (exp10_optab, $A, CODE_FOR_$(exp10$a2$))",
|
||||
"set_optab_handler (exp2_optab, $A, CODE_FOR_$(exp2$a2$))",
|
||||
"set_optab_handler (expm1_optab, $A, CODE_FOR_$(expm1$a2$))",
|
||||
"set_optab_handler (ldexp_optab, $A, CODE_FOR_$(ldexp$a3$))",
|
||||
"set_optab_handler (scalb_optab, $A, CODE_FOR_$(scalb$a3$))",
|
||||
"set_optab_handler (significand_optab, $A, CODE_FOR_$(significand$a2$))",
|
||||
"set_optab_handler (logb_optab, $A, CODE_FOR_$(logb$a2$))",
|
||||
"set_optab_handler (ilogb_optab, $A, CODE_FOR_$(ilogb$a2$))",
|
||||
"set_optab_handler (log_optab, $A, CODE_FOR_$(log$a2$))",
|
||||
"set_optab_handler (log10_optab, $A, CODE_FOR_$(log10$a2$))",
|
||||
"set_optab_handler (log2_optab, $A, CODE_FOR_$(log2$a2$))",
|
||||
"set_optab_handler (log1p_optab, $A, CODE_FOR_$(log1p$a2$))",
|
||||
"set_optab_handler (tan_optab, $A, CODE_FOR_$(tan$a2$))",
|
||||
"set_optab_handler (atan_optab, $A, CODE_FOR_$(atan$a2$))",
|
||||
"set_optab_handler (strlen_optab, $A, CODE_FOR_$(strlen$a$))",
|
||||
"set_optab_handler (one_cmpl_optab, $A, CODE_FOR_$(one_cmpl$a2$))",
|
||||
"set_optab_handler (bswap_optab, $A, CODE_FOR_$(bswap$a2$))",
|
||||
"set_optab_handler (ffs_optab, $A, CODE_FOR_$(ffs$a2$))",
|
||||
"set_optab_handler (clz_optab, $A, CODE_FOR_$(clz$a2$))",
|
||||
"set_optab_handler (ctz_optab, $A, CODE_FOR_$(ctz$a2$))",
|
||||
"set_optab_handler (clrsb_optab, $A, CODE_FOR_$(clrsb$a2$))",
|
||||
"set_optab_handler (popcount_optab, $A, CODE_FOR_$(popcount$a2$))",
|
||||
"set_optab_handler (parity_optab, $A, CODE_FOR_$(parity$a2$))",
|
||||
"set_optab_handler (mov_optab, $A, CODE_FOR_$(mov$a$))",
|
||||
"set_optab_handler (movstrict_optab, $A, CODE_FOR_$(movstrict$a$))",
|
||||
"set_optab_handler (movmisalign_optab, $A, CODE_FOR_$(movmisalign$a$))",
|
||||
"set_optab_handler (storent_optab, $A, CODE_FOR_$(storent$a$))",
|
||||
"set_optab_handler (addcc_optab, $A, CODE_FOR_$(add$acc$))",
|
||||
"set_direct_optab_handler (movcc_optab, $A, CODE_FOR_$(mov$acc$))",
|
||||
"set_optab_handler (cbranch_optab, $A, CODE_FOR_$(cbranch$a4$))",
|
||||
"set_optab_handler (cmov_optab, $A, CODE_FOR_$(cmov$a6$))",
|
||||
"set_optab_handler (cstore_optab, $A, CODE_FOR_$(cstore$a4$))",
|
||||
"set_optab_handler (ctrap_optab, $A, CODE_FOR_$(ctrap$a4$))",
|
||||
"set_optab_handler (push_optab, $A, CODE_FOR_$(push$a1$))",
|
||||
"set_direct_optab_handler (reload_in_optab, $A, CODE_FOR_$(reload_in$a$))",
|
||||
"set_direct_optab_handler (reload_out_optab, $A, CODE_FOR_$(reload_out$a$))",
|
||||
"set_direct_optab_handler (movmem_optab, $A, CODE_FOR_$(movmem$a$))",
|
||||
"set_direct_optab_handler (cmpstr_optab, $A, CODE_FOR_$(cmpstr$a$))",
|
||||
"set_direct_optab_handler (cmpstrn_optab, $A, CODE_FOR_$(cmpstrn$a$))",
|
||||
"set_direct_optab_handler (cmpmem_optab, $A, CODE_FOR_$(cmpmem$a$))",
|
||||
"set_direct_optab_handler (setmem_optab, $A, CODE_FOR_$(setmem$a$))",
|
||||
"set_direct_optab_handler (sync_add_optab, $A, CODE_FOR_$(sync_add$I$a$))",
|
||||
"set_direct_optab_handler (sync_sub_optab, $A, CODE_FOR_$(sync_sub$I$a$))",
|
||||
"set_direct_optab_handler (sync_ior_optab, $A, CODE_FOR_$(sync_ior$I$a$))",
|
||||
"set_direct_optab_handler (sync_and_optab, $A, CODE_FOR_$(sync_and$I$a$))",
|
||||
"set_direct_optab_handler (sync_xor_optab, $A, CODE_FOR_$(sync_xor$I$a$))",
|
||||
"set_direct_optab_handler (sync_nand_optab, $A, CODE_FOR_$(sync_nand$I$a$))",
|
||||
"set_optab_handler (sync_old_add_optab, $A, CODE_FOR_$(sync_old_add$I$a$))",
|
||||
"set_optab_handler (sync_old_sub_optab, $A, CODE_FOR_$(sync_old_sub$I$a$))",
|
||||
"set_optab_handler (sync_old_ior_optab, $A, CODE_FOR_$(sync_old_ior$I$a$))",
|
||||
"set_optab_handler (sync_old_and_optab, $A, CODE_FOR_$(sync_old_and$I$a$))",
|
||||
"set_optab_handler (sync_old_xor_optab, $A, CODE_FOR_$(sync_old_xor$I$a$))",
|
||||
"set_optab_handler (sync_old_nand_optab, $A, CODE_FOR_$(sync_old_nand$I$a$))",
|
||||
"set_optab_handler (sync_new_add_optab, $A, CODE_FOR_$(sync_new_add$I$a$))",
|
||||
"set_optab_handler (sync_new_sub_optab, $A, CODE_FOR_$(sync_new_sub$I$a$))",
|
||||
"set_optab_handler (sync_new_ior_optab, $A, CODE_FOR_$(sync_new_ior$I$a$))",
|
||||
"set_optab_handler (sync_new_and_optab, $A, CODE_FOR_$(sync_new_and$I$a$))",
|
||||
"set_optab_handler (sync_new_xor_optab, $A, CODE_FOR_$(sync_new_xor$I$a$))",
|
||||
"set_optab_handler (sync_new_nand_optab, $A, CODE_FOR_$(sync_new_nand$I$a$))",
|
||||
"set_optab_handler (sync_compare_and_swap_optab, $A, CODE_FOR_$(sync_compare_and_swap$I$a$))",
|
||||
"set_optab_handler (sync_lock_test_and_set_optab, $A, CODE_FOR_$(sync_lock_test_and_set$I$a$))",
|
||||
"set_direct_optab_handler (sync_lock_release_optab, $A, CODE_FOR_$(sync_lock_release$I$a$))",
|
||||
"set_direct_optab_handler (atomic_exchange_optab, $A, CODE_FOR_$(atomic_exchange$I$a$))",
|
||||
"set_direct_optab_handler (atomic_compare_and_swap_optab, $A, CODE_FOR_$(atomic_compare_and_swap$I$a$))",
|
||||
"set_direct_optab_handler (atomic_load_optab, $A, CODE_FOR_$(atomic_load$I$a$))",
|
||||
"set_direct_optab_handler (atomic_store_optab, $A, CODE_FOR_$(atomic_store$I$a$))",
|
||||
"set_direct_optab_handler (atomic_add_fetch_optab, $A, CODE_FOR_$(atomic_add_fetch$I$a$))",
|
||||
"set_direct_optab_handler (atomic_sub_fetch_optab, $A, CODE_FOR_$(atomic_sub_fetch$I$a$))",
|
||||
"set_direct_optab_handler (atomic_and_fetch_optab, $A, CODE_FOR_$(atomic_and_fetch$I$a$))",
|
||||
"set_direct_optab_handler (atomic_nand_fetch_optab, $A, CODE_FOR_$(atomic_nand_fetch$I$a$))",
|
||||
"set_direct_optab_handler (atomic_xor_fetch_optab, $A, CODE_FOR_$(atomic_xor_fetch$I$a$))",
|
||||
"set_direct_optab_handler (atomic_or_fetch_optab, $A, CODE_FOR_$(atomic_or_fetch$I$a$))",
|
||||
"set_direct_optab_handler (atomic_fetch_add_optab, $A, CODE_FOR_$(atomic_fetch_add$I$a$))",
|
||||
"set_direct_optab_handler (atomic_fetch_sub_optab, $A, CODE_FOR_$(atomic_fetch_sub$I$a$))",
|
||||
"set_direct_optab_handler (atomic_fetch_and_optab, $A, CODE_FOR_$(atomic_fetch_and$I$a$))",
|
||||
"set_direct_optab_handler (atomic_fetch_nand_optab, $A, CODE_FOR_$(atomic_fetch_nand$I$a$))",
|
||||
"set_direct_optab_handler (atomic_fetch_xor_optab, $A, CODE_FOR_$(atomic_fetch_xor$I$a$))",
|
||||
"set_direct_optab_handler (atomic_fetch_or_optab, $A, CODE_FOR_$(atomic_fetch_or$I$a$))",
|
||||
"set_direct_optab_handler (atomic_add_optab, $A, CODE_FOR_$(atomic_add$I$a$))",
|
||||
"set_direct_optab_handler (atomic_sub_optab, $A, CODE_FOR_$(atomic_sub$I$a$))",
|
||||
"set_direct_optab_handler (atomic_and_optab, $A, CODE_FOR_$(atomic_and$I$a$))",
|
||||
"set_direct_optab_handler (atomic_nand_optab, $A, CODE_FOR_$(atomic_nand$I$a$))",
|
||||
"set_direct_optab_handler (atomic_xor_optab, $A, CODE_FOR_$(atomic_xor$I$a$))",
|
||||
"set_direct_optab_handler (atomic_or_optab, $A, CODE_FOR_$(atomic_or$I$a$))",
|
||||
"set_optab_handler (vec_set_optab, $A, CODE_FOR_$(vec_set$a$))",
|
||||
"set_optab_handler (vec_extract_optab, $A, CODE_FOR_$(vec_extract$a$))",
|
||||
"set_optab_handler (vec_init_optab, $A, CODE_FOR_$(vec_init$a$))",
|
||||
"set_optab_handler (vec_shl_optab, $A, CODE_FOR_$(vec_shl_$a$))",
|
||||
"set_optab_handler (vec_shr_optab, $A, CODE_FOR_$(vec_shr_$a$))",
|
||||
"set_optab_handler (vec_realign_load_optab, $A, CODE_FOR_$(vec_realign_load_$a$))",
|
||||
"set_direct_optab_handler (vec_perm_optab, $A, CODE_FOR_$(vec_perm$a$))",
|
||||
"set_direct_optab_handler (vec_perm_const_optab, $A, CODE_FOR_$(vec_perm_const$a$))",
|
||||
"set_convert_optab_handler (vcond_optab, $A, $B, CODE_FOR_$(vcond$a$b$))",
|
||||
"set_convert_optab_handler (vcondu_optab, $A, $B, CODE_FOR_$(vcondu$a$b$))",
|
||||
"set_optab_handler (ssum_widen_optab, $A, CODE_FOR_$(widen_ssum$I$a3$))",
|
||||
"set_optab_handler (usum_widen_optab, $A, CODE_FOR_$(widen_usum$I$a3$))",
|
||||
"set_optab_handler (udot_prod_optab, $A, CODE_FOR_$(udot_prod$I$a$))",
|
||||
"set_optab_handler (sdot_prod_optab, $A, CODE_FOR_$(sdot_prod$I$a$))",
|
||||
"set_optab_handler (reduc_smax_optab, $A, CODE_FOR_$(reduc_smax_$a$))",
|
||||
"set_optab_handler (reduc_umax_optab, $A, CODE_FOR_$(reduc_umax_$a$))",
|
||||
"set_optab_handler (reduc_smin_optab, $A, CODE_FOR_$(reduc_smin_$a$))",
|
||||
"set_optab_handler (reduc_umin_optab, $A, CODE_FOR_$(reduc_umin_$a$))",
|
||||
"set_optab_handler (reduc_splus_optab, $A, CODE_FOR_$(reduc_splus_$a$))" ,
|
||||
"set_optab_handler (reduc_uplus_optab, $A, CODE_FOR_$(reduc_uplus_$a$))",
|
||||
"set_optab_handler (vec_widen_umult_hi_optab, $A, CODE_FOR_$(vec_widen_umult_hi_$a$))",
|
||||
"set_optab_handler (vec_widen_umult_lo_optab, $A, CODE_FOR_$(vec_widen_umult_lo_$a$))",
|
||||
"set_optab_handler (vec_widen_smult_hi_optab, $A, CODE_FOR_$(vec_widen_smult_hi_$a$))",
|
||||
"set_optab_handler (vec_widen_smult_lo_optab, $A, CODE_FOR_$(vec_widen_smult_lo_$a$))",
|
||||
"set_optab_handler (vec_widen_umult_even_optab, $A, CODE_FOR_$(vec_widen_umult_even_$a$))",
|
||||
"set_optab_handler (vec_widen_umult_odd_optab, $A, CODE_FOR_$(vec_widen_umult_odd_$a$))",
|
||||
"set_optab_handler (vec_widen_smult_even_optab, $A, CODE_FOR_$(vec_widen_smult_even_$a$))",
|
||||
"set_optab_handler (vec_widen_smult_odd_optab, $A, CODE_FOR_$(vec_widen_smult_odd_$a$))",
|
||||
"set_optab_handler (vec_widen_ushiftl_hi_optab, $A, CODE_FOR_$(vec_widen_ushiftl_hi_$a$))",
|
||||
"set_optab_handler (vec_widen_ushiftl_lo_optab, $A, CODE_FOR_$(vec_widen_ushiftl_lo_$a$))",
|
||||
"set_optab_handler (vec_widen_sshiftl_hi_optab, $A, CODE_FOR_$(vec_widen_sshiftl_hi_$a$))",
|
||||
"set_optab_handler (vec_widen_sshiftl_lo_optab, $A, CODE_FOR_$(vec_widen_sshiftl_lo_$a$))",
|
||||
"set_optab_handler (vec_unpacks_hi_optab, $A, CODE_FOR_$(vec_unpacks_hi_$a$))",
|
||||
"set_optab_handler (vec_unpacks_lo_optab, $A, CODE_FOR_$(vec_unpacks_lo_$a$))",
|
||||
"set_optab_handler (vec_unpacku_hi_optab, $A, CODE_FOR_$(vec_unpacku_hi_$a$))",
|
||||
"set_optab_handler (vec_unpacku_lo_optab, $A, CODE_FOR_$(vec_unpacku_lo_$a$))",
|
||||
"set_optab_handler (vec_unpacks_float_hi_optab, $A, CODE_FOR_$(vec_unpacks_float_hi_$a$))",
|
||||
"set_optab_handler (vec_unpacks_float_lo_optab, $A, CODE_FOR_$(vec_unpacks_float_lo_$a$))",
|
||||
"set_optab_handler (vec_unpacku_float_hi_optab, $A, CODE_FOR_$(vec_unpacku_float_hi_$a$))",
|
||||
"set_optab_handler (vec_unpacku_float_lo_optab, $A, CODE_FOR_$(vec_unpacku_float_lo_$a$))",
|
||||
"set_optab_handler (vec_pack_trunc_optab, $A, CODE_FOR_$(vec_pack_trunc_$a$))",
|
||||
"set_optab_handler (vec_pack_ssat_optab, $A, CODE_FOR_$(vec_pack_ssat_$a$))",
|
||||
"set_optab_handler (vec_pack_usat_optab, $A, CODE_FOR_$(vec_pack_usat_$a$))",
|
||||
"set_optab_handler (vec_pack_sfix_trunc_optab, $A, CODE_FOR_$(vec_pack_sfix_trunc_$a$))",
|
||||
"set_optab_handler (vec_pack_ufix_trunc_optab, $A, CODE_FOR_$(vec_pack_ufix_trunc_$a$))"
|
||||
typedef enum optab_tag {
|
||||
unknown_optab,
|
||||
#include "optabs.def"
|
||||
NUM_OPTABS
|
||||
} optab;
|
||||
|
||||
#undef OPTAB_CL
|
||||
#undef OPTAB_CX
|
||||
#undef OPTAB_CD
|
||||
#undef OPTAB_NL
|
||||
#undef OPTAB_NC
|
||||
#undef OPTAB_NX
|
||||
#undef OPTAB_VL
|
||||
#undef OPTAB_VC
|
||||
#undef OPTAB_VX
|
||||
#undef OPTAB_DC
|
||||
#undef OPTAB_D
|
||||
|
||||
#define NS "NULL"
|
||||
#define ZS "'\\0'"
|
||||
#define OPTAB_CL(o, p, c, b, l) { #o, p, #b, ZS, #l, o, c, UNKNOWN, 1 },
|
||||
#define OPTAB_CX(o, p) { #o, p, NULL, NULL, NULL, o, UNKNOWN, UNKNOWN, 1 },
|
||||
#define OPTAB_CD(o, p) { #o, p, NS, ZS, NS, o, UNKNOWN, UNKNOWN, 2 },
|
||||
#define OPTAB_NL(o, p, c, b, s, l) { #o, p, #b, #s, #l, o, c, c, 3 },
|
||||
#define OPTAB_NC(o, p, c) { #o, p, NS, ZS, NS, o, c, c, 3 },
|
||||
#define OPTAB_NX(o, p) { #o, p, NULL, NULL, NULL, o, UNKNOWN, UNKNOWN, 3 },
|
||||
#define OPTAB_VL(o, p, c, b, s, l) { #o, p, #b, #s, #l, o, c, UNKNOWN, 3 },
|
||||
#define OPTAB_VC(o, p, c) { #o, p, NS, ZS, NS, o, c, UNKNOWN, 3 },
|
||||
#define OPTAB_VX(o, p) { #o, p, NULL, NULL, NULL, o, UNKNOWN, UNKNOWN, 3 },
|
||||
#define OPTAB_DC(o, p, c) { #o, p, NS, ZS, NS, o, c, c, 4 },
|
||||
#define OPTAB_D(o, p) { #o, p, NS, ZS, NS, o, UNKNOWN, UNKNOWN, 4 },
|
||||
|
||||
typedef struct optab_def_d
|
||||
{
|
||||
const char *name;
|
||||
const char *pattern;
|
||||
const char *base;
|
||||
const char *suffix;
|
||||
const char *libcall;
|
||||
unsigned int op;
|
||||
enum rtx_code fcode;
|
||||
enum rtx_code rcode;
|
||||
unsigned int kind;
|
||||
} optab_def;
|
||||
|
||||
static optab_def optabs[] = {
|
||||
{ "unknown_optab", NULL, NS, ZS, NS, unknown_optab, UNKNOWN, UNKNOWN, 0 },
|
||||
#include "optabs.def"
|
||||
};
|
||||
|
||||
static void gen_insn (rtx);
|
||||
#undef OPTAB_CL
|
||||
#undef OPTAB_CX
|
||||
#undef OPTAB_CD
|
||||
#undef OPTAB_NL
|
||||
#undef OPTAB_NC
|
||||
#undef OPTAB_NX
|
||||
#undef OPTAB_VL
|
||||
#undef OPTAB_VC
|
||||
#undef OPTAB_VX
|
||||
#undef OPTAB_DC
|
||||
#undef OPTAB_D
|
||||
|
||||
/* Vector in which to collect insns that match. */
|
||||
|
||||
typedef struct pattern_d
|
||||
{
|
||||
const char *name;
|
||||
unsigned int op;
|
||||
unsigned int m1, m2;
|
||||
unsigned int sort_num;
|
||||
} pattern;
|
||||
|
||||
DEF_VEC_O(pattern);
|
||||
DEF_VEC_ALLOC_O(pattern, heap);
|
||||
|
||||
static VEC(pattern, heap) *patterns;
|
||||
|
||||
static bool
|
||||
match_pattern (pattern *p, const char *name, const char *pat)
|
||||
{
|
||||
bool force_float = false;
|
||||
bool force_int = false;
|
||||
bool force_partial_int = false;
|
||||
bool force_fixed = false;
|
||||
|
||||
if (pat == NULL)
|
||||
return false;
|
||||
for (; ; ++pat)
|
||||
{
|
||||
if (*pat != '$')
|
||||
{
|
||||
if (*pat != *name++)
|
||||
return false;
|
||||
if (*pat == '\0')
|
||||
return true;
|
||||
continue;
|
||||
}
|
||||
switch (*++pat)
|
||||
{
|
||||
case 'I':
|
||||
force_int = 1;
|
||||
break;
|
||||
case 'P':
|
||||
force_partial_int = 1;
|
||||
break;
|
||||
case 'F':
|
||||
force_float = 1;
|
||||
break;
|
||||
case 'Q':
|
||||
force_fixed = 1;
|
||||
break;
|
||||
|
||||
case 'a':
|
||||
case 'b':
|
||||
{
|
||||
int i;
|
||||
|
||||
/* This loop will stop at the first prefix match, so
|
||||
look through the modes in reverse order, in case
|
||||
there are extra CC modes and CC is a prefix of the
|
||||
CC modes (as it should be). */
|
||||
for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
|
||||
{
|
||||
const char *p, *q;
|
||||
for (p = GET_MODE_NAME(i), q = name; *p; p++, q++)
|
||||
if (TOLOWER (*p) != *q)
|
||||
break;
|
||||
if (*p == 0
|
||||
&& (! force_int || mode_class[i] == MODE_INT
|
||||
|| mode_class[i] == MODE_VECTOR_INT)
|
||||
&& (! force_partial_int
|
||||
|| mode_class[i] == MODE_INT
|
||||
|| mode_class[i] == MODE_PARTIAL_INT
|
||||
|| mode_class[i] == MODE_VECTOR_INT)
|
||||
&& (! force_float
|
||||
|| mode_class[i] == MODE_FLOAT
|
||||
|| mode_class[i] == MODE_DECIMAL_FLOAT
|
||||
|| mode_class[i] == MODE_COMPLEX_FLOAT
|
||||
|| mode_class[i] == MODE_VECTOR_FLOAT)
|
||||
&& (! force_fixed
|
||||
|| mode_class[i] == MODE_FRACT
|
||||
|| mode_class[i] == MODE_UFRACT
|
||||
|| mode_class[i] == MODE_ACCUM
|
||||
|| mode_class[i] == MODE_UACCUM
|
||||
|| mode_class[i] == MODE_VECTOR_FRACT
|
||||
|| mode_class[i] == MODE_VECTOR_UFRACT
|
||||
|| mode_class[i] == MODE_VECTOR_ACCUM
|
||||
|| mode_class[i] == MODE_VECTOR_UACCUM))
|
||||
break;
|
||||
}
|
||||
|
||||
if (i < 0)
|
||||
return false;
|
||||
name += strlen (GET_MODE_NAME (i));
|
||||
if (*pat == 'a')
|
||||
p->m1 = i;
|
||||
else
|
||||
p->m2 = i;
|
||||
|
||||
force_int = false;
|
||||
force_partial_int = false;
|
||||
force_float = false;
|
||||
force_fixed = false;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
gcc_unreachable ();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gen_insn (rtx insn)
|
||||
{
|
||||
const char *name = XSTR (insn, 0);
|
||||
int m1 = 0, m2 = 0, op = 0;
|
||||
size_t pindex;
|
||||
int i;
|
||||
const char *np, *pp, *p, *q;
|
||||
pattern p;
|
||||
unsigned pindex;
|
||||
|
||||
/* Don't mention instructions whose names are the null string.
|
||||
They are in the machine description just to be recognized. */
|
||||
if (*name == 0)
|
||||
/* Don't mention "unnamed" instructions. */
|
||||
if (*name == 0 || *name == '*')
|
||||
return;
|
||||
p.name = name;
|
||||
|
||||
/* See if NAME matches one of the patterns we have for the optabs we know
|
||||
about. */
|
||||
|
||||
/* See if NAME matches one of the patterns we have for the optabs
|
||||
we know about. */
|
||||
for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
|
||||
{
|
||||
int force_float = 0, force_int = 0, force_partial_int = 0;
|
||||
int force_fixed = 0;
|
||||
int force_wider = 0;
|
||||
int matches = 1;
|
||||
|
||||
for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
|
||||
;
|
||||
|
||||
for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
|
||||
pp++)
|
||||
p.m1 = p.m2 = 0;
|
||||
if (match_pattern (&p, name, optabs[pindex].pattern))
|
||||
{
|
||||
if (*pp != '$')
|
||||
{
|
||||
if (*pp != *np++)
|
||||
break;
|
||||
}
|
||||
else
|
||||
switch (*++pp)
|
||||
{
|
||||
case 'N':
|
||||
force_wider = 1;
|
||||
break;
|
||||
case 'I':
|
||||
force_int = 1;
|
||||
break;
|
||||
case 'P':
|
||||
force_partial_int = 1;
|
||||
break;
|
||||
case 'F':
|
||||
force_float = 1;
|
||||
break;
|
||||
case 'Q':
|
||||
force_fixed = 1;
|
||||
break;
|
||||
case 'V':
|
||||
break;
|
||||
case 'c':
|
||||
for (op = 0; op < NUM_RTX_CODE; op++)
|
||||
{
|
||||
for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
|
||||
if (*p != *q)
|
||||
break;
|
||||
|
||||
/* We have to be concerned about matching "gt" and
|
||||
missing "gtu", e.g., so verify we have reached the
|
||||
end of thing we are to match. */
|
||||
if (*p == 0 && *q == 0
|
||||
&& (GET_RTX_CLASS (op) == RTX_COMPARE
|
||||
|| GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
|
||||
break;
|
||||
}
|
||||
|
||||
if (op == NUM_RTX_CODE)
|
||||
matches = 0;
|
||||
else
|
||||
np += strlen (GET_RTX_NAME(op));
|
||||
break;
|
||||
case 'a':
|
||||
case 'b':
|
||||
/* This loop will stop at the first prefix match, so
|
||||
look through the modes in reverse order, in case
|
||||
there are extra CC modes and CC is a prefix of the
|
||||
CC modes (as it should be). */
|
||||
for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
|
||||
{
|
||||
for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
|
||||
if (TOLOWER (*p) != *q)
|
||||
break;
|
||||
|
||||
if (*p == 0
|
||||
&& (! force_int || mode_class[i] == MODE_INT
|
||||
|| mode_class[i] == MODE_VECTOR_INT)
|
||||
&& (! force_partial_int
|
||||
|| mode_class[i] == MODE_INT
|
||||
|| mode_class[i] == MODE_PARTIAL_INT
|
||||
|| mode_class[i] == MODE_VECTOR_INT)
|
||||
&& (! force_float
|
||||
|| mode_class[i] == MODE_FLOAT
|
||||
|| mode_class[i] == MODE_DECIMAL_FLOAT
|
||||
|| mode_class[i] == MODE_COMPLEX_FLOAT
|
||||
|| mode_class[i] == MODE_VECTOR_FLOAT)
|
||||
&& (! force_fixed
|
||||
|| mode_class[i] == MODE_FRACT
|
||||
|| mode_class[i] == MODE_UFRACT
|
||||
|| mode_class[i] == MODE_ACCUM
|
||||
|| mode_class[i] == MODE_UACCUM
|
||||
|| mode_class[i] == MODE_VECTOR_FRACT
|
||||
|| mode_class[i] == MODE_VECTOR_UFRACT
|
||||
|| mode_class[i] == MODE_VECTOR_ACCUM
|
||||
|| mode_class[i] == MODE_VECTOR_UACCUM)
|
||||
&& (! force_wider
|
||||
|| *pp == 'a'
|
||||
|| m1 < i))
|
||||
break;
|
||||
}
|
||||
|
||||
if (i < 0)
|
||||
matches = 0;
|
||||
else if (*pp == 'a')
|
||||
m1 = i, np += strlen (GET_MODE_NAME(i));
|
||||
else
|
||||
m2 = i, np += strlen (GET_MODE_NAME(i));
|
||||
|
||||
force_int = force_partial_int = force_float = force_fixed = 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
gcc_unreachable ();
|
||||
}
|
||||
p.op = optabs[pindex].op;
|
||||
p.sort_num = (p.op << 16) | (p.m2 << 8) | p.m1;
|
||||
VEC_safe_push (pattern, heap, patterns, &p);
|
||||
return;
|
||||
}
|
||||
|
||||
if (matches && pp[0] == '$' && pp[1] == ')'
|
||||
&& *np == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if (pindex == ARRAY_SIZE (optabs))
|
||||
return;
|
||||
|
||||
/* We found a match. If this pattern is only conditionally present,
|
||||
write out the "if" and two extra blanks. */
|
||||
|
||||
if (*XSTR (insn, 2) != 0)
|
||||
printf (" if (HAVE_%s)\n ", name);
|
||||
|
||||
printf (" ");
|
||||
|
||||
/* Now write out the initialization, making all required substitutions. */
|
||||
for (pp = optabs[pindex]; *pp; pp++)
|
||||
{
|
||||
if (*pp != '$')
|
||||
putchar (*pp);
|
||||
else
|
||||
switch (*++pp)
|
||||
{
|
||||
case '(': case ')':
|
||||
case 'I': case 'F': case 'N':
|
||||
break;
|
||||
case 'V':
|
||||
if (SCALAR_FLOAT_MODE_P (m1))
|
||||
printf ("v");
|
||||
break;
|
||||
case 'a':
|
||||
for (np = GET_MODE_NAME(m1); *np; np++)
|
||||
putchar (TOLOWER (*np));
|
||||
break;
|
||||
case 'b':
|
||||
for (np = GET_MODE_NAME(m2); *np; np++)
|
||||
putchar (TOLOWER (*np));
|
||||
break;
|
||||
case 'A':
|
||||
printf ("%smode", GET_MODE_NAME(m1));
|
||||
break;
|
||||
case 'B':
|
||||
printf ("%smode", GET_MODE_NAME(m2));
|
||||
break;
|
||||
case 'c':
|
||||
printf ("%s", GET_RTX_NAME(op));
|
||||
break;
|
||||
case 'C':
|
||||
for (np = GET_RTX_NAME(op); *np; np++)
|
||||
putchar (TOUPPER (*np));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
printf (";\n");
|
||||
}
|
||||
|
||||
extern int main (int, char **);
|
||||
static int
|
||||
pattern_cmp (const void *va, const void *vb)
|
||||
{
|
||||
const pattern *a = (const pattern *)va;
|
||||
const pattern *b = (const pattern *)vb;
|
||||
return a->sort_num - b->sort_num;
|
||||
}
|
||||
|
||||
static int
|
||||
optab_kind_cmp (const void *va, const void *vb)
|
||||
{
|
||||
const optab_def *a = (const optab_def *)va;
|
||||
const optab_def *b = (const optab_def *)vb;
|
||||
int diff = a->kind - b->kind;
|
||||
if (diff == 0)
|
||||
diff = a->op - b->op;
|
||||
return diff;
|
||||
}
|
||||
|
||||
static int
|
||||
optab_rcode_cmp (const void *va, const void *vb)
|
||||
{
|
||||
const optab_def *a = (const optab_def *)va;
|
||||
const optab_def *b = (const optab_def *)vb;
|
||||
return a->rcode - b->rcode;
|
||||
}
|
||||
|
||||
static const char *header_file_name = "init-opinit.h";
|
||||
static const char *source_file_name = "init-opinit.c";
|
||||
|
||||
static bool
|
||||
handle_arg (const char *arg)
|
||||
{
|
||||
switch (arg[1])
|
||||
{
|
||||
case 'h':
|
||||
header_file_name = &arg[2];
|
||||
return true;
|
||||
case 'c':
|
||||
source_file_name = &arg[2];
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static FILE *
|
||||
open_outfile (const char *file_name)
|
||||
{
|
||||
FILE *f = fopen (file_name, "w");
|
||||
if (!f)
|
||||
fatal ("cannot open file %s: %s", file_name, xstrerror (errno));
|
||||
fprintf (f,
|
||||
"/* Generated automatically by the program `genopinit'\n"
|
||||
" from the machine description file `md'. */\n\n");
|
||||
return f;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
rtx desc;
|
||||
FILE *h_file, *s_file;
|
||||
unsigned int i, j, n, last_kind[5];
|
||||
pattern *p;
|
||||
|
||||
progname = "genopinit";
|
||||
|
||||
if (!init_rtx_reader_args (argc, argv))
|
||||
if (NUM_OPTABS > 0xffff || MAX_MACHINE_MODE >= 0xff)
|
||||
fatal ("genopinit range assumptions invalid");
|
||||
|
||||
if (!init_rtx_reader_args_cb (argc, argv, handle_arg))
|
||||
return (FATAL_EXIT_CODE);
|
||||
|
||||
printf ("/* Generated automatically by the program `genopinit'\n\
|
||||
from the machine description file `md'. */\n\n");
|
||||
|
||||
printf ("#include \"config.h\"\n");
|
||||
printf ("#include \"system.h\"\n");
|
||||
printf ("#include \"coretypes.h\"\n");
|
||||
printf ("#include \"tm.h\"\n");
|
||||
printf ("#include \"rtl.h\"\n");
|
||||
printf ("#include \"tm_p.h\"\n");
|
||||
printf ("#include \"flags.h\"\n");
|
||||
printf ("#include \"insn-config.h\"\n");
|
||||
printf ("#include \"recog.h\"\n");
|
||||
printf ("#include \"expr.h\"\n");
|
||||
printf ("#include \"optabs.h\"\n");
|
||||
printf ("#include \"reload.h\"\n\n");
|
||||
|
||||
printf ("void\ninit_all_optabs (void)\n{\n");
|
||||
|
||||
puts ("\
|
||||
#ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
|
||||
int i, j;\n\
|
||||
#endif\n");
|
||||
h_file = open_outfile (header_file_name);
|
||||
s_file = open_outfile (source_file_name);
|
||||
|
||||
/* Read the machine description. */
|
||||
|
||||
while (1)
|
||||
{
|
||||
int line_no, insn_code_number = 0;
|
||||
|
||||
desc = read_md_rtx (&line_no, &insn_code_number);
|
||||
rtx desc = read_md_rtx (&line_no, &insn_code_number);
|
||||
if (desc == NULL)
|
||||
break;
|
||||
|
||||
if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
|
||||
gen_insn (desc);
|
||||
}
|
||||
|
||||
puts ("\
|
||||
\n\
|
||||
#ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
|
||||
/* This flag says the same insns that convert to a signed fixnum\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\
|
||||
set_convert_optab_handler\n\
|
||||
(ufixtrunc_optab, (enum machine_mode) i, (enum machine_mode) j,\n\
|
||||
convert_optab_handler (sfixtrunc_optab, (enum machine_mode) i,\n\
|
||||
(enum machine_mode) j));\n\
|
||||
#endif\n\
|
||||
}");
|
||||
/* Sort the collected patterns. */
|
||||
qsort (VEC_address (pattern, patterns), VEC_length (pattern, patterns),
|
||||
sizeof (pattern), pattern_cmp);
|
||||
|
||||
fflush (stdout);
|
||||
return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
|
||||
/* Now that we've handled the "extra" patterns, eliminate them from
|
||||
the optabs array. That way they don't get in the way below. */
|
||||
n = ARRAY_SIZE (optabs);
|
||||
for (i = 0; i < n; )
|
||||
if (optabs[i].base == NULL)
|
||||
optabs[i] = optabs[--n];
|
||||
else
|
||||
++i;
|
||||
|
||||
/* Sort the (real) optabs. Better than forcing the optabs.def file to
|
||||
remain sorted by kind. We also scrogged any real ordering with the
|
||||
purging of the X patterns above. */
|
||||
qsort (optabs, n, sizeof(optab_def), optab_kind_cmp);
|
||||
|
||||
/* Emit the optab enumeration for the header file. */
|
||||
fprintf (h_file, "enum optab_tag {\n");
|
||||
for (i = j = 0; i < n; ++i)
|
||||
{
|
||||
optabs[i].op = i;
|
||||
fprintf (h_file, " %s,\n", optabs[i].name);
|
||||
if (optabs[i].kind != j)
|
||||
last_kind[j++] = i - 1;
|
||||
}
|
||||
fprintf (h_file, " FIRST_CONV_OPTAB = %s,\n", optabs[last_kind[0]+1].name);
|
||||
fprintf (h_file, " LAST_CONVLIB_OPTAB = %s,\n", optabs[last_kind[1]].name);
|
||||
fprintf (h_file, " LAST_CONV_OPTAB = %s,\n", optabs[last_kind[2]].name);
|
||||
fprintf (h_file, " FIRST_NORM_OPTAB = %s,\n", optabs[last_kind[2]+1].name);
|
||||
fprintf (h_file, " LAST_NORMLIB_OPTAB = %s,\n", optabs[last_kind[3]].name);
|
||||
fprintf (h_file, " LAST_NORM_OPTAB = %s\n", optabs[i-1].name);
|
||||
fprintf (h_file, "};\n\n");
|
||||
|
||||
fprintf (h_file, "#define NUM_OPTABS %u\n", n);
|
||||
fprintf (h_file, "#define NUM_CONVLIB_OPTABS %u\n",
|
||||
last_kind[1] - last_kind[0]);
|
||||
fprintf (h_file, "#define NUM_NORMLIB_OPTABS %u\n",
|
||||
last_kind[3] - last_kind[2]);
|
||||
fprintf (h_file, "#define NUM_OPTAB_PATTERNS %u\n",
|
||||
(unsigned) VEC_length (pattern, patterns));
|
||||
|
||||
fprintf (s_file,
|
||||
"#include \"config.h\"\n"
|
||||
"#include \"system.h\"\n"
|
||||
"#include \"coretypes.h\"\n"
|
||||
"#include \"tm.h\"\n"
|
||||
"#include \"rtl.h\"\n"
|
||||
"#include \"tm_p.h\"\n"
|
||||
"#include \"flags.h\"\n"
|
||||
"#include \"insn-config.h\"\n"
|
||||
"#include \"expr.h\"\n"
|
||||
"#include \"optabs.h\"\n"
|
||||
"\n"
|
||||
"struct optab_pat {\n"
|
||||
" unsigned scode;\n"
|
||||
" enum insn_code icode;\n"
|
||||
"};\n\n");
|
||||
|
||||
fprintf (s_file,
|
||||
"static const struct optab_pat pats[NUM_OPTAB_PATTERNS] = {\n");
|
||||
for (i = 0; VEC_iterate (pattern, patterns, i, p); ++i)
|
||||
fprintf (s_file, " { %#08x, CODE_FOR_%s },\n", p->sort_num, p->name);
|
||||
fprintf (s_file, "};\n\n");
|
||||
|
||||
fprintf (s_file, "void\ninit_all_optabs (void)\n{\n");
|
||||
fprintf (s_file, " bool *ena = this_target_optabs->pat_enable;\n");
|
||||
for (i = 0; VEC_iterate (pattern, patterns, i, p); ++i)
|
||||
fprintf (s_file, " ena[%u] = HAVE_%s;\n", i, p->name);
|
||||
fprintf (s_file, "}\n\n");
|
||||
|
||||
/* Perform a binary search on a pre-encoded optab+mode*2. */
|
||||
/* ??? Perhaps even better to generate a minimal perfect hash.
|
||||
Using gperf directly is awkward since it's so geared to working
|
||||
with strings. Plus we have no visibility into the ordering of
|
||||
the hash entries, which complicates the pat_enable array. */
|
||||
fprintf (s_file,
|
||||
"static int\n"
|
||||
"lookup_handler (unsigned scode)\n"
|
||||
"{\n"
|
||||
" int l = 0, h = ARRAY_SIZE (pats), m;\n"
|
||||
" while (h > l)\n"
|
||||
" {\n"
|
||||
" m = (h + l) / 2;\n"
|
||||
" if (scode == pats[m].scode)\n"
|
||||
" return m;\n"
|
||||
" else if (scode < pats[m].scode)\n"
|
||||
" h = m;\n"
|
||||
" else\n"
|
||||
" l = m + 1;\n"
|
||||
" }\n"
|
||||
" return -1;\n"
|
||||
"}\n\n");
|
||||
|
||||
fprintf (s_file,
|
||||
"enum insn_code\n"
|
||||
"raw_optab_handler (unsigned scode)\n"
|
||||
"{\n"
|
||||
" int i = lookup_handler (scode);\n"
|
||||
" return (i >= 0 && this_target_optabs->pat_enable[i]\n"
|
||||
" ? pats[i].icode : CODE_FOR_nothing);\n"
|
||||
"}\n\n");
|
||||
|
||||
fprintf (s_file,
|
||||
"bool\n"
|
||||
"swap_optab_enable (optab op, enum machine_mode m, bool set)\n"
|
||||
"{\n"
|
||||
" unsigned scode = (op << 16) | m;\n"
|
||||
" int i = lookup_handler (scode);\n"
|
||||
" if (i >= 0)\n"
|
||||
" {\n"
|
||||
" bool ret = this_target_optabs->pat_enable[i];\n"
|
||||
" this_target_optabs->pat_enable[i] = set;\n"
|
||||
" return ret;\n"
|
||||
" }\n"
|
||||
" else\n"
|
||||
" {\n"
|
||||
" gcc_assert (!set);\n"
|
||||
" return false;\n"
|
||||
" }\n"
|
||||
"}\n\n");
|
||||
|
||||
/* C++ (even G++) does not support (non-trivial) designated initializers.
|
||||
To work around that, generate these arrays programatically rather than
|
||||
by our traditional multiple inclusion of def files. */
|
||||
|
||||
fprintf (s_file,
|
||||
"const struct convert_optab_libcall_d "
|
||||
"convlib_def[NUM_CONVLIB_OPTABS] = {\n");
|
||||
for (i = last_kind[0] + 1; i <= last_kind[1]; ++i)
|
||||
fprintf (s_file, " { %s, %s },\n", optabs[i].base, optabs[i].libcall);
|
||||
fprintf (s_file, "};\n\n");
|
||||
|
||||
fprintf (s_file,
|
||||
"const struct optab_libcall_d "
|
||||
"normlib_def[NUM_NORMLIB_OPTABS] = {\n");
|
||||
for (i = last_kind[2] + 1; i <= last_kind[3]; ++i)
|
||||
fprintf (s_file, " { %s, %s, %s },\n",
|
||||
optabs[i].suffix, optabs[i].base, optabs[i].libcall);
|
||||
fprintf (s_file, "};\n\n");
|
||||
|
||||
fprintf (s_file, "enum rtx_code const optab_to_code_[NUM_OPTABS] = {\n");
|
||||
for (i = 0; i < n; ++i)
|
||||
fprintf (s_file, " %s,\n", rtx_upname[optabs[i].fcode]);
|
||||
fprintf (s_file, "};\n\n");
|
||||
|
||||
qsort (optabs, n, sizeof (optab_def), optab_rcode_cmp);
|
||||
|
||||
fprintf (s_file, "const optab code_to_optab_[NUM_RTX_CODE] = {\n");
|
||||
for (j = 0; optabs[j].rcode == UNKNOWN; ++j)
|
||||
continue;
|
||||
for (i = 0; i < NON_GENERATOR_NUM_RTX_CODE; ++i)
|
||||
{
|
||||
if (j < n && optabs[j].rcode == i)
|
||||
fprintf (s_file, " %s,\n", optabs[j++].name);
|
||||
else
|
||||
fprintf (s_file, " unknown_optab,\n");
|
||||
}
|
||||
fprintf (s_file, "};\n\n");
|
||||
|
||||
return (fclose (h_file) == 0 && fclose (s_file) == 0
|
||||
? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ enum libfunc_index
|
|||
for normal optabs and conversion optabs. In the first case mode2
|
||||
is unused. */
|
||||
struct GTY(()) libfunc_entry {
|
||||
size_t optab;
|
||||
optab op;
|
||||
enum machine_mode mode1, mode2;
|
||||
rtx libfunc;
|
||||
};
|
||||
|
|
|
|||
653
gcc/optabs.c
653
gcc/optabs.c
|
|
@ -54,9 +54,6 @@ struct target_libfuncs *this_target_libfuncs = &default_target_libfuncs;
|
|||
#define libfunc_hash \
|
||||
(this_target_libfuncs->x_libfunc_hash)
|
||||
|
||||
/* Contains the optab used for each rtx code. */
|
||||
optab code_to_optab_[NUM_RTX_CODE + 1];
|
||||
|
||||
static void prepare_float_lib_cmp (rtx, rtx, enum rtx_code, rtx *,
|
||||
enum machine_mode *);
|
||||
static rtx expand_unop_direct (enum machine_mode, optab, rtx, rtx, int);
|
||||
|
|
@ -78,9 +75,7 @@ static hashval_t
|
|||
hash_libfunc (const void *p)
|
||||
{
|
||||
const struct libfunc_entry *const e = (const struct libfunc_entry *) p;
|
||||
|
||||
return (((int) e->mode1 + (int) e->mode2 * NUM_MACHINE_MODES)
|
||||
^ e->optab);
|
||||
return (((int) e->mode1 + (int) e->mode2 * NUM_MACHINE_MODES) ^ e->op);
|
||||
}
|
||||
|
||||
/* Used for libfunc_hash. */
|
||||
|
|
@ -90,10 +85,7 @@ eq_libfunc (const void *p, const void *q)
|
|||
{
|
||||
const struct libfunc_entry *const e1 = (const struct libfunc_entry *) p;
|
||||
const struct libfunc_entry *const e2 = (const struct libfunc_entry *) q;
|
||||
|
||||
return (e1->optab == e2->optab
|
||||
&& e1->mode1 == e2->mode1
|
||||
&& e1->mode2 == e2->mode2);
|
||||
return e1->op == e2->op && e1->mode1 == e2->mode1 && e1->mode2 == e2->mode2;
|
||||
}
|
||||
|
||||
/* Return libfunc corresponding operation defined by OPTAB converting
|
||||
|
|
@ -106,22 +98,30 @@ convert_optab_libfunc (convert_optab optab, enum machine_mode mode1,
|
|||
struct libfunc_entry e;
|
||||
struct libfunc_entry **slot;
|
||||
|
||||
e.optab = (size_t) (optab - &convert_optab_table[0]);
|
||||
/* ??? This ought to be an assert, but not all of the places
|
||||
that we expand optabs know about the optabs that got moved
|
||||
to being direct. */
|
||||
if (!(optab >= FIRST_CONV_OPTAB && optab <= LAST_CONVLIB_OPTAB))
|
||||
return NULL_RTX;
|
||||
|
||||
e.op = optab;
|
||||
e.mode1 = mode1;
|
||||
e.mode2 = mode2;
|
||||
slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
slot = (struct libfunc_entry **)
|
||||
htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
if (!slot)
|
||||
{
|
||||
if (optab->libcall_gen)
|
||||
{
|
||||
optab->libcall_gen (optab, optab->libcall_basename, mode1, mode2);
|
||||
slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
if (slot)
|
||||
return (*slot)->libfunc;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
return NULL;
|
||||
const struct convert_optab_libcall_d *d
|
||||
= &convlib_def[optab - FIRST_CONV_OPTAB];
|
||||
|
||||
if (d->libcall_gen == NULL)
|
||||
return NULL;
|
||||
|
||||
d->libcall_gen (optab, d->libcall_basename, mode1, mode2);
|
||||
slot = (struct libfunc_entry **)
|
||||
htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
if (!slot)
|
||||
return NULL;
|
||||
}
|
||||
return (*slot)->libfunc;
|
||||
}
|
||||
|
|
@ -135,24 +135,30 @@ optab_libfunc (optab optab, enum machine_mode mode)
|
|||
struct libfunc_entry e;
|
||||
struct libfunc_entry **slot;
|
||||
|
||||
e.optab = (size_t) (optab - &optab_table[0]);
|
||||
/* ??? This ought to be an assert, but not all of the places
|
||||
that we expand optabs know about the optabs that got moved
|
||||
to being direct. */
|
||||
if (!(optab >= FIRST_NORM_OPTAB && optab <= LAST_NORMLIB_OPTAB))
|
||||
return NULL_RTX;
|
||||
|
||||
e.op = optab;
|
||||
e.mode1 = mode;
|
||||
e.mode2 = VOIDmode;
|
||||
slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
slot = (struct libfunc_entry **)
|
||||
htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
if (!slot)
|
||||
{
|
||||
if (optab->libcall_gen)
|
||||
{
|
||||
optab->libcall_gen (optab, optab->libcall_basename,
|
||||
optab->libcall_suffix, mode);
|
||||
slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash,
|
||||
&e, NO_INSERT);
|
||||
if (slot)
|
||||
return (*slot)->libfunc;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
return NULL;
|
||||
const struct optab_libcall_d *d
|
||||
= &normlib_def[optab - FIRST_NORM_OPTAB];
|
||||
|
||||
if (d->libcall_gen == NULL)
|
||||
return NULL;
|
||||
|
||||
d->libcall_gen (optab, d->libcall_basename, d->libcall_suffix, mode);
|
||||
slot = (struct libfunc_entry **)
|
||||
htab_find_slot (libfunc_hash, &e, NO_INSERT);
|
||||
if (!slot)
|
||||
return NULL;
|
||||
}
|
||||
return (*slot)->libfunc;
|
||||
}
|
||||
|
|
@ -2227,7 +2233,7 @@ sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab,
|
|||
{
|
||||
rtx temp;
|
||||
optab direct_optab = unsignedp ? uoptab : soptab;
|
||||
struct optab_d wide_soptab;
|
||||
bool save_enable;
|
||||
|
||||
/* Do it without widening, if possible. */
|
||||
temp = expand_binop (mode, direct_optab, op0, op1, target,
|
||||
|
|
@ -2235,38 +2241,38 @@ sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab,
|
|||
if (temp || methods == OPTAB_DIRECT)
|
||||
return temp;
|
||||
|
||||
/* Try widening to a signed int. Make a fake signed optab that
|
||||
hides any signed insn for direct use. */
|
||||
wide_soptab = *soptab;
|
||||
set_optab_handler (&wide_soptab, mode, CODE_FOR_nothing);
|
||||
/* We don't want to generate new hash table entries from this fake
|
||||
optab. */
|
||||
wide_soptab.libcall_gen = NULL;
|
||||
/* Try widening to a signed int. Disable any direct use of any
|
||||
signed insn in the current mode. */
|
||||
save_enable = swap_optab_enable (soptab, mode, false);
|
||||
|
||||
temp = expand_binop (mode, &wide_soptab, op0, op1, target,
|
||||
temp = expand_binop (mode, soptab, op0, op1, target,
|
||||
unsignedp, OPTAB_WIDEN);
|
||||
|
||||
/* For unsigned operands, try widening to an unsigned int. */
|
||||
if (temp == 0 && unsignedp)
|
||||
if (!temp && unsignedp)
|
||||
temp = expand_binop (mode, uoptab, op0, op1, target,
|
||||
unsignedp, OPTAB_WIDEN);
|
||||
if (temp || methods == OPTAB_WIDEN)
|
||||
return temp;
|
||||
goto egress;
|
||||
|
||||
/* Use the right width libcall if that exists. */
|
||||
temp = expand_binop (mode, direct_optab, op0, op1, target, unsignedp, OPTAB_LIB);
|
||||
temp = expand_binop (mode, direct_optab, op0, op1, target,
|
||||
unsignedp, OPTAB_LIB);
|
||||
if (temp || methods == OPTAB_LIB)
|
||||
return temp;
|
||||
goto egress;
|
||||
|
||||
/* Must widen and use a libcall, use either signed or unsigned. */
|
||||
temp = expand_binop (mode, &wide_soptab, op0, op1, target,
|
||||
temp = expand_binop (mode, soptab, op0, op1, target,
|
||||
unsignedp, methods);
|
||||
if (temp != 0)
|
||||
return temp;
|
||||
if (unsignedp)
|
||||
return expand_binop (mode, uoptab, op0, op1, target,
|
||||
if (!temp && unsignedp)
|
||||
temp = expand_binop (mode, uoptab, op0, op1, target,
|
||||
unsignedp, methods);
|
||||
return 0;
|
||||
|
||||
egress:
|
||||
/* Undo the fiddling above. */
|
||||
if (save_enable)
|
||||
swap_optab_enable (soptab, mode, true);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/* Generate code to perform an operation specified by UNOPPTAB
|
||||
|
|
@ -5415,39 +5421,6 @@ have_insn_for (enum rtx_code code, enum machine_mode mode)
|
|||
!= CODE_FOR_nothing));
|
||||
}
|
||||
|
||||
/* Set all insn_code fields to CODE_FOR_nothing. */
|
||||
|
||||
static void
|
||||
init_insn_codes (void)
|
||||
{
|
||||
memset (optab_table, 0, sizeof (optab_table));
|
||||
memset (convert_optab_table, 0, sizeof (convert_optab_table));
|
||||
memset (direct_optab_table, 0, sizeof (direct_optab_table));
|
||||
}
|
||||
|
||||
/* Initialize OP's code to CODE, and write it into the code_to_optab table. */
|
||||
static inline void
|
||||
init_optab (optab op, enum rtx_code code)
|
||||
{
|
||||
op->code_ = code;
|
||||
code_to_optab_[(int) code] = op;
|
||||
}
|
||||
|
||||
/* Same, but fill in its code as CODE, and do _not_ write it into
|
||||
the code_to_optab table. */
|
||||
static inline void
|
||||
init_optabv (optab op, enum rtx_code code)
|
||||
{
|
||||
op->code_ = code;
|
||||
}
|
||||
|
||||
/* Conversion optabs never go in the code_to_optab table. */
|
||||
static void
|
||||
init_convert_optab (convert_optab op, enum rtx_code code)
|
||||
{
|
||||
op->code_ = code;
|
||||
}
|
||||
|
||||
/* Initialize the libfunc fields of an entire group of entries in some
|
||||
optab. Each entry is set equal to a string consisting of a leading
|
||||
pair of underscores followed by a generic operation name followed by
|
||||
|
|
@ -5463,7 +5436,8 @@ init_convert_optab (convert_optab op, enum rtx_code code)
|
|||
*/
|
||||
|
||||
static void
|
||||
gen_libfunc (optab optable, const char *opname, int suffix, enum machine_mode mode)
|
||||
gen_libfunc (optab optable, const char *opname, int suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
unsigned opname_len = strlen (opname);
|
||||
const char *mname = GET_MODE_NAME (mode);
|
||||
|
|
@ -5497,7 +5471,7 @@ gen_libfunc (optab optable, const char *opname, int suffix, enum machine_mode mo
|
|||
|
||||
/* Like gen_libfunc, but verify that integer operation is involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_libfunc (optab optable, const char *opname, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5515,7 +5489,7 @@ gen_int_libfunc (optab optable, const char *opname, char suffix,
|
|||
|
||||
/* Like gen_libfunc, but verify that FP and set decimal prefix if needed. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_fp_libfunc (optab optable, const char *opname, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5536,7 +5510,7 @@ gen_fp_libfunc (optab optable, const char *opname, char suffix,
|
|||
|
||||
/* Like gen_libfunc, but verify that fixed-point operation is involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_fixed_libfunc (optab optable, const char *opname, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5548,7 +5522,7 @@ gen_fixed_libfunc (optab optable, const char *opname, char suffix,
|
|||
/* Like gen_libfunc, but verify that signed fixed-point operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_signed_fixed_libfunc (optab optable, const char *opname, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5560,7 +5534,7 @@ gen_signed_fixed_libfunc (optab optable, const char *opname, char suffix,
|
|||
/* Like gen_libfunc, but verify that unsigned fixed-point operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_unsigned_fixed_libfunc (optab optable, const char *opname, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5571,7 +5545,7 @@ gen_unsigned_fixed_libfunc (optab optable, const char *opname, char suffix,
|
|||
|
||||
/* Like gen_libfunc, but verify that FP or INT operation is involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_fp_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5584,7 +5558,7 @@ gen_int_fp_libfunc (optab optable, const char *name, char suffix,
|
|||
/* Like gen_libfunc, but verify that FP or INT operation is involved
|
||||
and add 'v' suffix for integer operation. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_intv_fp_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5604,7 +5578,7 @@ gen_intv_fp_libfunc (optab optable, const char *name, char suffix,
|
|||
/* Like gen_libfunc, but verify that FP or INT or FIXED operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_fp_fixed_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5619,7 +5593,7 @@ gen_int_fp_fixed_libfunc (optab optable, const char *name, char suffix,
|
|||
/* Like gen_libfunc, but verify that FP or INT or signed FIXED operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_fp_signed_fixed_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5634,7 +5608,7 @@ gen_int_fp_signed_fixed_libfunc (optab optable, const char *name, char suffix,
|
|||
/* Like gen_libfunc, but verify that INT or FIXED operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_fixed_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5647,7 +5621,7 @@ gen_int_fixed_libfunc (optab optable, const char *name, char suffix,
|
|||
/* Like gen_libfunc, but verify that INT or signed FIXED operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_signed_fixed_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5660,7 +5634,7 @@ gen_int_signed_fixed_libfunc (optab optable, const char *name, char suffix,
|
|||
/* Like gen_libfunc, but verify that INT or unsigned FIXED operation is
|
||||
involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_unsigned_fixed_libfunc (optab optable, const char *name, char suffix,
|
||||
enum machine_mode mode)
|
||||
{
|
||||
|
|
@ -5676,7 +5650,7 @@ gen_int_unsigned_fixed_libfunc (optab optable, const char *name, char suffix,
|
|||
a mode name and an operand count these functions have two mode names
|
||||
and no operand count. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_interclass_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5748,7 +5722,7 @@ gen_interclass_conv_libfunc (convert_optab tab,
|
|||
/* Same as gen_interclass_conv_libfunc but verify that we are producing
|
||||
int->fp conversion. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_to_fp_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5764,7 +5738,7 @@ gen_int_to_fp_conv_libfunc (convert_optab tab,
|
|||
/* ufloat_optab is special by using floatun for FP and floatuns decimal fp
|
||||
naming scheme. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_ufloat_conv_libfunc (convert_optab tab,
|
||||
const char *opname ATTRIBUTE_UNUSED,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5779,7 +5753,7 @@ gen_ufloat_conv_libfunc (convert_optab tab,
|
|||
/* Same as gen_interclass_conv_libfunc but verify that we are producing
|
||||
fp->int conversion. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5795,7 +5769,7 @@ gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab,
|
|||
/* Same as gen_interclass_conv_libfunc but verify that we are producing
|
||||
fp->int conversion with no decimal floating point involved. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_fp_to_int_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5812,7 +5786,7 @@ gen_fp_to_int_conv_libfunc (convert_optab tab,
|
|||
The string formation rules are
|
||||
similar to the ones for init_libfunc, above. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_intraclass_conv_libfunc (convert_optab tab, const char *opname,
|
||||
enum machine_mode tmode, enum machine_mode fmode)
|
||||
{
|
||||
|
|
@ -5882,7 +5856,7 @@ gen_intraclass_conv_libfunc (convert_optab tab, const char *opname,
|
|||
/* Pick proper libcall for trunc_optab. We need to chose if we do
|
||||
truncation or extension and interclass or intraclass. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_trunc_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5911,7 +5885,7 @@ gen_trunc_conv_libfunc (convert_optab tab,
|
|||
/* Pick proper libcall for extend_optab. We need to chose if we do
|
||||
truncation or extension and interclass or intraclass. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_extend_conv_libfunc (convert_optab tab,
|
||||
const char *opname ATTRIBUTE_UNUSED,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5940,7 +5914,7 @@ gen_extend_conv_libfunc (convert_optab tab,
|
|||
/* Pick proper libcall for fract_optab. We need to chose if we do
|
||||
interclass or intraclass. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_fract_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5959,7 +5933,7 @@ gen_fract_conv_libfunc (convert_optab tab,
|
|||
|
||||
/* Pick proper libcall for fractuns_optab. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_fractuns_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -5980,7 +5954,7 @@ gen_fractuns_conv_libfunc (convert_optab tab,
|
|||
/* Pick proper libcall for satfract_optab. We need to chose if we do
|
||||
interclass or intraclass. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_satfract_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -6000,7 +5974,7 @@ gen_satfract_conv_libfunc (convert_optab tab,
|
|||
|
||||
/* Pick proper libcall for satfractuns_optab. */
|
||||
|
||||
static void
|
||||
void
|
||||
gen_satfractuns_conv_libfunc (convert_optab tab,
|
||||
const char *opname,
|
||||
enum machine_mode tmode,
|
||||
|
|
@ -6101,12 +6075,13 @@ set_user_assembler_libfunc (const char *name, const char *asmspec)
|
|||
/* Call this to reset the function entry for one optab (OPTABLE) in mode
|
||||
MODE to NAME, which should be either 0 or a string constant. */
|
||||
void
|
||||
set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
|
||||
set_optab_libfunc (optab op, enum machine_mode mode, const char *name)
|
||||
{
|
||||
rtx val;
|
||||
struct libfunc_entry e;
|
||||
struct libfunc_entry **slot;
|
||||
e.optab = (size_t) (optable - &optab_table[0]);
|
||||
|
||||
e.op = op;
|
||||
e.mode1 = mode;
|
||||
e.mode2 = VOIDmode;
|
||||
|
||||
|
|
@ -6117,7 +6092,7 @@ set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
|
|||
slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, INSERT);
|
||||
if (*slot == NULL)
|
||||
*slot = ggc_alloc_libfunc_entry ();
|
||||
(*slot)->optab = (size_t) (optable - &optab_table[0]);
|
||||
(*slot)->op = op;
|
||||
(*slot)->mode1 = mode;
|
||||
(*slot)->mode2 = VOIDmode;
|
||||
(*slot)->libfunc = val;
|
||||
|
|
@ -6127,13 +6102,14 @@ set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
|
|||
(OPTABLE) from mode FMODE to mode TMODE to NAME, which should be
|
||||
either 0 or a string constant. */
|
||||
void
|
||||
set_conv_libfunc (convert_optab optable, enum machine_mode tmode,
|
||||
set_conv_libfunc (convert_optab optab, enum machine_mode tmode,
|
||||
enum machine_mode fmode, const char *name)
|
||||
{
|
||||
rtx val;
|
||||
struct libfunc_entry e;
|
||||
struct libfunc_entry **slot;
|
||||
e.optab = (size_t) (optable - &convert_optab_table[0]);
|
||||
|
||||
e.op = optab;
|
||||
e.mode1 = tmode;
|
||||
e.mode2 = fmode;
|
||||
|
||||
|
|
@ -6144,7 +6120,7 @@ set_conv_libfunc (convert_optab optable, enum machine_mode tmode,
|
|||
slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, INSERT);
|
||||
if (*slot == NULL)
|
||||
*slot = ggc_alloc_libfunc_entry ();
|
||||
(*slot)->optab = (size_t) (optable - &convert_optab_table[0]);
|
||||
(*slot)->op = optab;
|
||||
(*slot)->mode1 = tmode;
|
||||
(*slot)->mode2 = fmode;
|
||||
(*slot)->libfunc = val;
|
||||
|
|
@ -6157,421 +6133,13 @@ void
|
|||
init_optabs (void)
|
||||
{
|
||||
if (libfunc_hash)
|
||||
{
|
||||
htab_empty (libfunc_hash);
|
||||
/* We statically initialize the insn_codes with the equivalent of
|
||||
CODE_FOR_nothing. Repeat the process if reinitialising. */
|
||||
init_insn_codes ();
|
||||
}
|
||||
htab_empty (libfunc_hash);
|
||||
else
|
||||
libfunc_hash = htab_create_ggc (10, hash_libfunc, eq_libfunc, NULL);
|
||||
|
||||
init_optab (add_optab, PLUS);
|
||||
init_optabv (addv_optab, PLUS);
|
||||
init_optab (sub_optab, MINUS);
|
||||
init_optabv (subv_optab, MINUS);
|
||||
init_optab (ssadd_optab, SS_PLUS);
|
||||
init_optab (usadd_optab, US_PLUS);
|
||||
init_optab (sssub_optab, SS_MINUS);
|
||||
init_optab (ussub_optab, US_MINUS);
|
||||
init_optab (smul_optab, MULT);
|
||||
init_optab (ssmul_optab, SS_MULT);
|
||||
init_optab (usmul_optab, US_MULT);
|
||||
init_optabv (smulv_optab, MULT);
|
||||
init_optab (smul_highpart_optab, UNKNOWN);
|
||||
init_optab (umul_highpart_optab, UNKNOWN);
|
||||
init_optab (smul_widen_optab, UNKNOWN);
|
||||
init_optab (umul_widen_optab, UNKNOWN);
|
||||
init_optab (usmul_widen_optab, UNKNOWN);
|
||||
init_optab (smadd_widen_optab, UNKNOWN);
|
||||
init_optab (umadd_widen_optab, UNKNOWN);
|
||||
init_optab (ssmadd_widen_optab, UNKNOWN);
|
||||
init_optab (usmadd_widen_optab, UNKNOWN);
|
||||
init_optab (smsub_widen_optab, UNKNOWN);
|
||||
init_optab (umsub_widen_optab, UNKNOWN);
|
||||
init_optab (ssmsub_widen_optab, UNKNOWN);
|
||||
init_optab (usmsub_widen_optab, UNKNOWN);
|
||||
init_optab (sdiv_optab, DIV);
|
||||
init_optab (ssdiv_optab, SS_DIV);
|
||||
init_optab (usdiv_optab, US_DIV);
|
||||
init_optabv (sdivv_optab, DIV);
|
||||
init_optab (sdivmod_optab, UNKNOWN);
|
||||
init_optab (udiv_optab, UDIV);
|
||||
init_optab (udivmod_optab, UNKNOWN);
|
||||
init_optab (smod_optab, MOD);
|
||||
init_optab (umod_optab, UMOD);
|
||||
init_optab (fmod_optab, UNKNOWN);
|
||||
init_optab (remainder_optab, UNKNOWN);
|
||||
init_optab (ftrunc_optab, UNKNOWN);
|
||||
init_optab (and_optab, AND);
|
||||
init_optab (ior_optab, IOR);
|
||||
init_optab (xor_optab, XOR);
|
||||
init_optab (ashl_optab, ASHIFT);
|
||||
init_optab (ssashl_optab, SS_ASHIFT);
|
||||
init_optab (usashl_optab, US_ASHIFT);
|
||||
init_optab (ashr_optab, ASHIFTRT);
|
||||
init_optab (lshr_optab, LSHIFTRT);
|
||||
init_optabv (vashl_optab, ASHIFT);
|
||||
init_optabv (vashr_optab, ASHIFTRT);
|
||||
init_optabv (vlshr_optab, LSHIFTRT);
|
||||
init_optab (rotl_optab, ROTATE);
|
||||
init_optab (rotr_optab, ROTATERT);
|
||||
init_optab (smin_optab, SMIN);
|
||||
init_optab (smax_optab, SMAX);
|
||||
init_optab (umin_optab, UMIN);
|
||||
init_optab (umax_optab, UMAX);
|
||||
init_optab (pow_optab, UNKNOWN);
|
||||
init_optab (atan2_optab, UNKNOWN);
|
||||
init_optab (fma_optab, FMA);
|
||||
init_optab (fms_optab, UNKNOWN);
|
||||
init_optab (fnma_optab, UNKNOWN);
|
||||
init_optab (fnms_optab, UNKNOWN);
|
||||
|
||||
/* These three have codes assigned exclusively for the sake of
|
||||
have_insn_for. */
|
||||
init_optab (mov_optab, SET);
|
||||
init_optab (movstrict_optab, STRICT_LOW_PART);
|
||||
init_optab (cbranch_optab, COMPARE);
|
||||
|
||||
init_optab (cmov_optab, UNKNOWN);
|
||||
init_optab (cstore_optab, UNKNOWN);
|
||||
init_optab (ctrap_optab, UNKNOWN);
|
||||
|
||||
init_optab (storent_optab, UNKNOWN);
|
||||
|
||||
init_optab (cmp_optab, UNKNOWN);
|
||||
init_optab (ucmp_optab, UNKNOWN);
|
||||
|
||||
init_optab (eq_optab, EQ);
|
||||
init_optab (ne_optab, NE);
|
||||
init_optab (gt_optab, GT);
|
||||
init_optab (ge_optab, GE);
|
||||
init_optab (lt_optab, LT);
|
||||
init_optab (le_optab, LE);
|
||||
init_optab (unord_optab, UNORDERED);
|
||||
|
||||
init_optab (neg_optab, NEG);
|
||||
init_optab (ssneg_optab, SS_NEG);
|
||||
init_optab (usneg_optab, US_NEG);
|
||||
init_optabv (negv_optab, NEG);
|
||||
init_optab (abs_optab, ABS);
|
||||
init_optabv (absv_optab, ABS);
|
||||
init_optab (addcc_optab, UNKNOWN);
|
||||
init_optab (one_cmpl_optab, NOT);
|
||||
init_optab (bswap_optab, BSWAP);
|
||||
init_optab (ffs_optab, FFS);
|
||||
init_optab (clz_optab, CLZ);
|
||||
init_optab (ctz_optab, CTZ);
|
||||
init_optab (clrsb_optab, CLRSB);
|
||||
init_optab (popcount_optab, POPCOUNT);
|
||||
init_optab (parity_optab, PARITY);
|
||||
init_optab (sqrt_optab, SQRT);
|
||||
init_optab (floor_optab, UNKNOWN);
|
||||
init_optab (ceil_optab, UNKNOWN);
|
||||
init_optab (round_optab, UNKNOWN);
|
||||
init_optab (btrunc_optab, UNKNOWN);
|
||||
init_optab (nearbyint_optab, UNKNOWN);
|
||||
init_optab (rint_optab, UNKNOWN);
|
||||
init_optab (sincos_optab, UNKNOWN);
|
||||
init_optab (sin_optab, UNKNOWN);
|
||||
init_optab (asin_optab, UNKNOWN);
|
||||
init_optab (cos_optab, UNKNOWN);
|
||||
init_optab (acos_optab, UNKNOWN);
|
||||
init_optab (exp_optab, UNKNOWN);
|
||||
init_optab (exp10_optab, UNKNOWN);
|
||||
init_optab (exp2_optab, UNKNOWN);
|
||||
init_optab (expm1_optab, UNKNOWN);
|
||||
init_optab (ldexp_optab, UNKNOWN);
|
||||
init_optab (scalb_optab, UNKNOWN);
|
||||
init_optab (significand_optab, UNKNOWN);
|
||||
init_optab (logb_optab, UNKNOWN);
|
||||
init_optab (ilogb_optab, UNKNOWN);
|
||||
init_optab (log_optab, UNKNOWN);
|
||||
init_optab (log10_optab, UNKNOWN);
|
||||
init_optab (log2_optab, UNKNOWN);
|
||||
init_optab (log1p_optab, UNKNOWN);
|
||||
init_optab (tan_optab, UNKNOWN);
|
||||
init_optab (atan_optab, UNKNOWN);
|
||||
init_optab (copysign_optab, UNKNOWN);
|
||||
init_optab (signbit_optab, UNKNOWN);
|
||||
|
||||
init_optab (isinf_optab, UNKNOWN);
|
||||
|
||||
init_optab (strlen_optab, UNKNOWN);
|
||||
init_optab (push_optab, UNKNOWN);
|
||||
|
||||
init_optab (reduc_smax_optab, UNKNOWN);
|
||||
init_optab (reduc_umax_optab, UNKNOWN);
|
||||
init_optab (reduc_smin_optab, UNKNOWN);
|
||||
init_optab (reduc_umin_optab, UNKNOWN);
|
||||
init_optab (reduc_splus_optab, UNKNOWN);
|
||||
init_optab (reduc_uplus_optab, UNKNOWN);
|
||||
|
||||
init_optab (ssum_widen_optab, UNKNOWN);
|
||||
init_optab (usum_widen_optab, UNKNOWN);
|
||||
init_optab (sdot_prod_optab, UNKNOWN);
|
||||
init_optab (udot_prod_optab, UNKNOWN);
|
||||
|
||||
init_optab (vec_extract_optab, UNKNOWN);
|
||||
init_optab (vec_set_optab, UNKNOWN);
|
||||
init_optab (vec_init_optab, UNKNOWN);
|
||||
init_optab (vec_shl_optab, UNKNOWN);
|
||||
init_optab (vec_shr_optab, UNKNOWN);
|
||||
init_optab (vec_realign_load_optab, UNKNOWN);
|
||||
init_optab (movmisalign_optab, UNKNOWN);
|
||||
init_optab (vec_widen_umult_hi_optab, UNKNOWN);
|
||||
init_optab (vec_widen_umult_lo_optab, UNKNOWN);
|
||||
init_optab (vec_widen_smult_hi_optab, UNKNOWN);
|
||||
init_optab (vec_widen_smult_lo_optab, UNKNOWN);
|
||||
init_optab (vec_widen_ushiftl_hi_optab, UNKNOWN);
|
||||
init_optab (vec_widen_ushiftl_lo_optab, UNKNOWN);
|
||||
init_optab (vec_widen_sshiftl_hi_optab, UNKNOWN);
|
||||
init_optab (vec_widen_sshiftl_lo_optab, UNKNOWN);
|
||||
init_optab (vec_unpacks_hi_optab, UNKNOWN);
|
||||
init_optab (vec_unpacks_lo_optab, UNKNOWN);
|
||||
init_optab (vec_unpacku_hi_optab, UNKNOWN);
|
||||
init_optab (vec_unpacku_lo_optab, UNKNOWN);
|
||||
init_optab (vec_unpacks_float_hi_optab, UNKNOWN);
|
||||
init_optab (vec_unpacks_float_lo_optab, UNKNOWN);
|
||||
init_optab (vec_unpacku_float_hi_optab, UNKNOWN);
|
||||
init_optab (vec_unpacku_float_lo_optab, UNKNOWN);
|
||||
init_optab (vec_pack_trunc_optab, UNKNOWN);
|
||||
init_optab (vec_pack_usat_optab, UNKNOWN);
|
||||
init_optab (vec_pack_ssat_optab, UNKNOWN);
|
||||
init_optab (vec_pack_ufix_trunc_optab, UNKNOWN);
|
||||
init_optab (vec_pack_sfix_trunc_optab, UNKNOWN);
|
||||
|
||||
init_optab (powi_optab, UNKNOWN);
|
||||
|
||||
/* Conversions. */
|
||||
init_convert_optab (sext_optab, SIGN_EXTEND);
|
||||
init_convert_optab (zext_optab, ZERO_EXTEND);
|
||||
init_convert_optab (trunc_optab, TRUNCATE);
|
||||
init_convert_optab (sfix_optab, FIX);
|
||||
init_convert_optab (ufix_optab, UNSIGNED_FIX);
|
||||
init_convert_optab (sfixtrunc_optab, UNKNOWN);
|
||||
init_convert_optab (ufixtrunc_optab, UNKNOWN);
|
||||
init_convert_optab (sfloat_optab, FLOAT);
|
||||
init_convert_optab (ufloat_optab, UNSIGNED_FLOAT);
|
||||
init_convert_optab (lrint_optab, UNKNOWN);
|
||||
init_convert_optab (lround_optab, UNKNOWN);
|
||||
init_convert_optab (lfloor_optab, UNKNOWN);
|
||||
init_convert_optab (lceil_optab, UNKNOWN);
|
||||
|
||||
init_convert_optab (fract_optab, FRACT_CONVERT);
|
||||
init_convert_optab (fractuns_optab, UNSIGNED_FRACT_CONVERT);
|
||||
init_convert_optab (satfract_optab, SAT_FRACT);
|
||||
init_convert_optab (satfractuns_optab, UNSIGNED_SAT_FRACT);
|
||||
|
||||
/* Fill in the optabs with the insns we support. */
|
||||
init_all_optabs ();
|
||||
|
||||
/* Initialize the optabs with the names of the library functions. */
|
||||
add_optab->libcall_basename = "add";
|
||||
add_optab->libcall_suffix = '3';
|
||||
add_optab->libcall_gen = gen_int_fp_fixed_libfunc;
|
||||
addv_optab->libcall_basename = "add";
|
||||
addv_optab->libcall_suffix = '3';
|
||||
addv_optab->libcall_gen = gen_intv_fp_libfunc;
|
||||
ssadd_optab->libcall_basename = "ssadd";
|
||||
ssadd_optab->libcall_suffix = '3';
|
||||
ssadd_optab->libcall_gen = gen_signed_fixed_libfunc;
|
||||
usadd_optab->libcall_basename = "usadd";
|
||||
usadd_optab->libcall_suffix = '3';
|
||||
usadd_optab->libcall_gen = gen_unsigned_fixed_libfunc;
|
||||
sub_optab->libcall_basename = "sub";
|
||||
sub_optab->libcall_suffix = '3';
|
||||
sub_optab->libcall_gen = gen_int_fp_fixed_libfunc;
|
||||
subv_optab->libcall_basename = "sub";
|
||||
subv_optab->libcall_suffix = '3';
|
||||
subv_optab->libcall_gen = gen_intv_fp_libfunc;
|
||||
sssub_optab->libcall_basename = "sssub";
|
||||
sssub_optab->libcall_suffix = '3';
|
||||
sssub_optab->libcall_gen = gen_signed_fixed_libfunc;
|
||||
ussub_optab->libcall_basename = "ussub";
|
||||
ussub_optab->libcall_suffix = '3';
|
||||
ussub_optab->libcall_gen = gen_unsigned_fixed_libfunc;
|
||||
smul_optab->libcall_basename = "mul";
|
||||
smul_optab->libcall_suffix = '3';
|
||||
smul_optab->libcall_gen = gen_int_fp_fixed_libfunc;
|
||||
smulv_optab->libcall_basename = "mul";
|
||||
smulv_optab->libcall_suffix = '3';
|
||||
smulv_optab->libcall_gen = gen_intv_fp_libfunc;
|
||||
ssmul_optab->libcall_basename = "ssmul";
|
||||
ssmul_optab->libcall_suffix = '3';
|
||||
ssmul_optab->libcall_gen = gen_signed_fixed_libfunc;
|
||||
usmul_optab->libcall_basename = "usmul";
|
||||
usmul_optab->libcall_suffix = '3';
|
||||
usmul_optab->libcall_gen = gen_unsigned_fixed_libfunc;
|
||||
sdiv_optab->libcall_basename = "div";
|
||||
sdiv_optab->libcall_suffix = '3';
|
||||
sdiv_optab->libcall_gen = gen_int_fp_signed_fixed_libfunc;
|
||||
sdivv_optab->libcall_basename = "divv";
|
||||
sdivv_optab->libcall_suffix = '3';
|
||||
sdivv_optab->libcall_gen = gen_int_libfunc;
|
||||
ssdiv_optab->libcall_basename = "ssdiv";
|
||||
ssdiv_optab->libcall_suffix = '3';
|
||||
ssdiv_optab->libcall_gen = gen_signed_fixed_libfunc;
|
||||
udiv_optab->libcall_basename = "udiv";
|
||||
udiv_optab->libcall_suffix = '3';
|
||||
udiv_optab->libcall_gen = gen_int_unsigned_fixed_libfunc;
|
||||
usdiv_optab->libcall_basename = "usdiv";
|
||||
usdiv_optab->libcall_suffix = '3';
|
||||
usdiv_optab->libcall_gen = gen_unsigned_fixed_libfunc;
|
||||
sdivmod_optab->libcall_basename = "divmod";
|
||||
sdivmod_optab->libcall_suffix = '4';
|
||||
sdivmod_optab->libcall_gen = gen_int_libfunc;
|
||||
udivmod_optab->libcall_basename = "udivmod";
|
||||
udivmod_optab->libcall_suffix = '4';
|
||||
udivmod_optab->libcall_gen = gen_int_libfunc;
|
||||
smod_optab->libcall_basename = "mod";
|
||||
smod_optab->libcall_suffix = '3';
|
||||
smod_optab->libcall_gen = gen_int_libfunc;
|
||||
umod_optab->libcall_basename = "umod";
|
||||
umod_optab->libcall_suffix = '3';
|
||||
umod_optab->libcall_gen = gen_int_libfunc;
|
||||
ftrunc_optab->libcall_basename = "ftrunc";
|
||||
ftrunc_optab->libcall_suffix = '2';
|
||||
ftrunc_optab->libcall_gen = gen_fp_libfunc;
|
||||
and_optab->libcall_basename = "and";
|
||||
and_optab->libcall_suffix = '3';
|
||||
and_optab->libcall_gen = gen_int_libfunc;
|
||||
ior_optab->libcall_basename = "ior";
|
||||
ior_optab->libcall_suffix = '3';
|
||||
ior_optab->libcall_gen = gen_int_libfunc;
|
||||
xor_optab->libcall_basename = "xor";
|
||||
xor_optab->libcall_suffix = '3';
|
||||
xor_optab->libcall_gen = gen_int_libfunc;
|
||||
ashl_optab->libcall_basename = "ashl";
|
||||
ashl_optab->libcall_suffix = '3';
|
||||
ashl_optab->libcall_gen = gen_int_fixed_libfunc;
|
||||
ssashl_optab->libcall_basename = "ssashl";
|
||||
ssashl_optab->libcall_suffix = '3';
|
||||
ssashl_optab->libcall_gen = gen_signed_fixed_libfunc;
|
||||
usashl_optab->libcall_basename = "usashl";
|
||||
usashl_optab->libcall_suffix = '3';
|
||||
usashl_optab->libcall_gen = gen_unsigned_fixed_libfunc;
|
||||
ashr_optab->libcall_basename = "ashr";
|
||||
ashr_optab->libcall_suffix = '3';
|
||||
ashr_optab->libcall_gen = gen_int_signed_fixed_libfunc;
|
||||
lshr_optab->libcall_basename = "lshr";
|
||||
lshr_optab->libcall_suffix = '3';
|
||||
lshr_optab->libcall_gen = gen_int_unsigned_fixed_libfunc;
|
||||
smin_optab->libcall_basename = "min";
|
||||
smin_optab->libcall_suffix = '3';
|
||||
smin_optab->libcall_gen = gen_int_fp_libfunc;
|
||||
smax_optab->libcall_basename = "max";
|
||||
smax_optab->libcall_suffix = '3';
|
||||
smax_optab->libcall_gen = gen_int_fp_libfunc;
|
||||
umin_optab->libcall_basename = "umin";
|
||||
umin_optab->libcall_suffix = '3';
|
||||
umin_optab->libcall_gen = gen_int_libfunc;
|
||||
umax_optab->libcall_basename = "umax";
|
||||
umax_optab->libcall_suffix = '3';
|
||||
umax_optab->libcall_gen = gen_int_libfunc;
|
||||
neg_optab->libcall_basename = "neg";
|
||||
neg_optab->libcall_suffix = '2';
|
||||
neg_optab->libcall_gen = gen_int_fp_fixed_libfunc;
|
||||
ssneg_optab->libcall_basename = "ssneg";
|
||||
ssneg_optab->libcall_suffix = '2';
|
||||
ssneg_optab->libcall_gen = gen_signed_fixed_libfunc;
|
||||
usneg_optab->libcall_basename = "usneg";
|
||||
usneg_optab->libcall_suffix = '2';
|
||||
usneg_optab->libcall_gen = gen_unsigned_fixed_libfunc;
|
||||
negv_optab->libcall_basename = "neg";
|
||||
negv_optab->libcall_suffix = '2';
|
||||
negv_optab->libcall_gen = gen_intv_fp_libfunc;
|
||||
one_cmpl_optab->libcall_basename = "one_cmpl";
|
||||
one_cmpl_optab->libcall_suffix = '2';
|
||||
one_cmpl_optab->libcall_gen = gen_int_libfunc;
|
||||
ffs_optab->libcall_basename = "ffs";
|
||||
ffs_optab->libcall_suffix = '2';
|
||||
ffs_optab->libcall_gen = gen_int_libfunc;
|
||||
clz_optab->libcall_basename = "clz";
|
||||
clz_optab->libcall_suffix = '2';
|
||||
clz_optab->libcall_gen = gen_int_libfunc;
|
||||
ctz_optab->libcall_basename = "ctz";
|
||||
ctz_optab->libcall_suffix = '2';
|
||||
ctz_optab->libcall_gen = gen_int_libfunc;
|
||||
clrsb_optab->libcall_basename = "clrsb";
|
||||
clrsb_optab->libcall_suffix = '2';
|
||||
clrsb_optab->libcall_gen = gen_int_libfunc;
|
||||
popcount_optab->libcall_basename = "popcount";
|
||||
popcount_optab->libcall_suffix = '2';
|
||||
popcount_optab->libcall_gen = gen_int_libfunc;
|
||||
parity_optab->libcall_basename = "parity";
|
||||
parity_optab->libcall_suffix = '2';
|
||||
parity_optab->libcall_gen = gen_int_libfunc;
|
||||
|
||||
/* Comparison libcalls for integers MUST come in pairs,
|
||||
signed/unsigned. */
|
||||
cmp_optab->libcall_basename = "cmp";
|
||||
cmp_optab->libcall_suffix = '2';
|
||||
cmp_optab->libcall_gen = gen_int_fp_fixed_libfunc;
|
||||
ucmp_optab->libcall_basename = "ucmp";
|
||||
ucmp_optab->libcall_suffix = '2';
|
||||
ucmp_optab->libcall_gen = gen_int_libfunc;
|
||||
|
||||
/* EQ etc are floating point only. */
|
||||
eq_optab->libcall_basename = "eq";
|
||||
eq_optab->libcall_suffix = '2';
|
||||
eq_optab->libcall_gen = gen_fp_libfunc;
|
||||
ne_optab->libcall_basename = "ne";
|
||||
ne_optab->libcall_suffix = '2';
|
||||
ne_optab->libcall_gen = gen_fp_libfunc;
|
||||
gt_optab->libcall_basename = "gt";
|
||||
gt_optab->libcall_suffix = '2';
|
||||
gt_optab->libcall_gen = gen_fp_libfunc;
|
||||
ge_optab->libcall_basename = "ge";
|
||||
ge_optab->libcall_suffix = '2';
|
||||
ge_optab->libcall_gen = gen_fp_libfunc;
|
||||
lt_optab->libcall_basename = "lt";
|
||||
lt_optab->libcall_suffix = '2';
|
||||
lt_optab->libcall_gen = gen_fp_libfunc;
|
||||
le_optab->libcall_basename = "le";
|
||||
le_optab->libcall_suffix = '2';
|
||||
le_optab->libcall_gen = gen_fp_libfunc;
|
||||
unord_optab->libcall_basename = "unord";
|
||||
unord_optab->libcall_suffix = '2';
|
||||
unord_optab->libcall_gen = gen_fp_libfunc;
|
||||
|
||||
powi_optab->libcall_basename = "powi";
|
||||
powi_optab->libcall_suffix = '2';
|
||||
powi_optab->libcall_gen = gen_fp_libfunc;
|
||||
|
||||
/* Conversions. */
|
||||
sfloat_optab->libcall_basename = "float";
|
||||
sfloat_optab->libcall_gen = gen_int_to_fp_conv_libfunc;
|
||||
ufloat_optab->libcall_gen = gen_ufloat_conv_libfunc;
|
||||
sfix_optab->libcall_basename = "fix";
|
||||
sfix_optab->libcall_gen = gen_fp_to_int_conv_libfunc;
|
||||
ufix_optab->libcall_basename = "fixuns";
|
||||
ufix_optab->libcall_gen = gen_fp_to_int_conv_libfunc;
|
||||
lrint_optab->libcall_basename = "lrint";
|
||||
lrint_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
|
||||
lround_optab->libcall_basename = "lround";
|
||||
lround_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
|
||||
lfloor_optab->libcall_basename = "lfloor";
|
||||
lfloor_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
|
||||
lceil_optab->libcall_basename = "lceil";
|
||||
lceil_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
|
||||
|
||||
/* trunc_optab is also used for FLOAT_EXTEND. */
|
||||
sext_optab->libcall_basename = "extend";
|
||||
sext_optab->libcall_gen = gen_extend_conv_libfunc;
|
||||
trunc_optab->libcall_basename = "trunc";
|
||||
trunc_optab->libcall_gen = gen_trunc_conv_libfunc;
|
||||
|
||||
/* Conversions for fixed-point modes and other modes. */
|
||||
fract_optab->libcall_basename = "fract";
|
||||
fract_optab->libcall_gen = gen_fract_conv_libfunc;
|
||||
satfract_optab->libcall_basename = "satfract";
|
||||
satfract_optab->libcall_gen = gen_satfract_conv_libfunc;
|
||||
fractuns_optab->libcall_basename = "fractuns";
|
||||
fractuns_optab->libcall_gen = gen_fractuns_conv_libfunc;
|
||||
satfractuns_optab->libcall_basename = "satfractuns";
|
||||
satfractuns_optab->libcall_gen = gen_satfractuns_conv_libfunc;
|
||||
|
||||
/* The ffs function operates on `int'. Fall back on it if we do not
|
||||
have a libgcc2 function for that width. */
|
||||
if (INT_TYPE_SIZE < BITS_PER_WORD)
|
||||
|
|
@ -6594,7 +6162,8 @@ 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)
|
||||
set_optab_libfunc (abs_optab, TYPE_MODE (complex_double_type_node), "cabs");
|
||||
set_optab_libfunc (abs_optab, TYPE_MODE (complex_double_type_node),
|
||||
"cabs");
|
||||
|
||||
abort_libfunc = init_one_libfunc ("abort");
|
||||
memcpy_libfunc = init_one_libfunc ("memcpy");
|
||||
|
|
@ -6686,45 +6255,35 @@ init_sync_libfuncs (int max)
|
|||
DEBUG_FUNCTION void
|
||||
debug_optab_libfuncs (void)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
int i, j, k;
|
||||
|
||||
/* Dump the arithmetic optabs. */
|
||||
for (i = 0; i != (int) OTI_MAX; i++)
|
||||
for (i = FIRST_NORM_OPTAB; i <= LAST_NORMLIB_OPTAB; ++i)
|
||||
for (j = 0; j < NUM_MACHINE_MODES; ++j)
|
||||
{
|
||||
optab o;
|
||||
rtx l;
|
||||
|
||||
o = &optab_table[i];
|
||||
l = optab_libfunc (o, (enum machine_mode) j);
|
||||
rtx l = optab_libfunc ((optab) i, (enum machine_mode) j);
|
||||
if (l)
|
||||
{
|
||||
gcc_assert (GET_CODE (l) == SYMBOL_REF);
|
||||
fprintf (stderr, "%s\t%s:\t%s\n",
|
||||
GET_RTX_NAME (optab_to_code (o)),
|
||||
GET_RTX_NAME (optab_to_code ((optab) i)),
|
||||
GET_MODE_NAME (j),
|
||||
XSTR (l, 0));
|
||||
}
|
||||
}
|
||||
|
||||
/* Dump the conversion optabs. */
|
||||
for (i = 0; i < (int) COI_MAX; ++i)
|
||||
for (i = FIRST_CONV_OPTAB; i <= LAST_CONVLIB_OPTAB; ++i)
|
||||
for (j = 0; j < NUM_MACHINE_MODES; ++j)
|
||||
for (k = 0; k < NUM_MACHINE_MODES; ++k)
|
||||
{
|
||||
convert_optab o;
|
||||
rtx l;
|
||||
|
||||
o = &convert_optab_table[i];
|
||||
l = convert_optab_libfunc (o, (enum machine_mode) j,
|
||||
(enum machine_mode) k);
|
||||
rtx l = convert_optab_libfunc ((optab) i, (enum machine_mode) j,
|
||||
(enum machine_mode) k);
|
||||
if (l)
|
||||
{
|
||||
gcc_assert (GET_CODE (l) == SYMBOL_REF);
|
||||
fprintf (stderr, "%s\t%s\t%s:\t%s\n",
|
||||
GET_RTX_NAME (optab_to_code (o)),
|
||||
GET_RTX_NAME (optab_to_code ((optab) i)),
|
||||
GET_MODE_NAME (j),
|
||||
GET_MODE_NAME (k),
|
||||
XSTR (l, 0));
|
||||
|
|
|
|||
|
|
@ -0,0 +1,308 @@
|
|||
/* Definitions for operation tables, or "optabs".
|
||||
Copyright (C) 1987-2012 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GCC.
|
||||
|
||||
GCC is free software; you can redistribute it and/or modify it under
|
||||
the terms of the GNU General Public License as published by the Free
|
||||
Software Foundation; either version 3, or (at your option) any later
|
||||
version.
|
||||
|
||||
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GCC; see the file COPYING3. If not see
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
/* Entries here are categorized C, D, N, V. See genopinit.c for details
|
||||
on the meaning of the categories and for the pattern dollar codes. */
|
||||
|
||||
/* The extension libcalls are used for float extension. */
|
||||
OPTAB_CL(sext_optab, "extend$b$a2", SIGN_EXTEND, "extend", gen_extend_conv_libfunc)
|
||||
OPTAB_CL(trunc_optab, "trunc$b$a2", TRUNCATE, "trunc", gen_trunc_conv_libfunc)
|
||||
OPTAB_CL(zext_optab, "zero_extend$b$a2", ZERO_EXTEND, NULL, NULL)
|
||||
|
||||
OPTAB_CL(sfix_optab, "fix$F$b$I$a2", FIX, "fix", gen_fp_to_int_conv_libfunc)
|
||||
OPTAB_CL(ufix_optab, "fixuns$F$b$a2", UNSIGNED_FIX, "fixuns", gen_fp_to_int_conv_libfunc)
|
||||
OPTAB_CL(sfloat_optab, "float$I$b$F$a2", FLOAT, "float", gen_int_to_fp_conv_libfunc)
|
||||
OPTAB_CL(ufloat_optab, "floatuns$I$b$F$a2", UNSIGNED_FLOAT, NULL, gen_ufloat_conv_libfunc)
|
||||
|
||||
OPTAB_CL(lrint_optab, "lrint$F$b$I$a2", UNKNOWN, "lrint", gen_int_to_fp_nondecimal_conv_libfunc)
|
||||
OPTAB_CL(lround_optab, "lround$F$b$I$a2", UNKNOWN, "lround", gen_int_to_fp_nondecimal_conv_libfunc)
|
||||
OPTAB_CL(lfloor_optab, "lfloor$F$b$I$a2", UNKNOWN, "lfloor", gen_int_to_fp_nondecimal_conv_libfunc)
|
||||
OPTAB_CL(lceil_optab, "lceil$F$b$I$a2", UNKNOWN, "lceil", gen_int_to_fp_nondecimal_conv_libfunc)
|
||||
|
||||
/* Conversions for fixed-point modes and other modes. */
|
||||
OPTAB_CL(fract_optab, "fract$b$a2", FRACT_CONVERT, "fract", gen_fract_conv_libfunc)
|
||||
OPTAB_CL(fractuns_optab, "fractuns$I$b$Q$a2", UNSIGNED_FRACT_CONVERT, "fractuns", gen_fractuns_conv_libfunc)
|
||||
OPTAB_CX(fractuns_optab, "fractuns$Q$b$I$a2")
|
||||
OPTAB_CL(satfract_optab, "satfract$b$Q$a2", SAT_FRACT, "satfract", gen_satfract_conv_libfunc)
|
||||
OPTAB_CL(satfractuns_optab, "satfractuns$I$b$Q$a2", UNSIGNED_SAT_FRACT, "satfractuns", gen_satfractuns_conv_libfunc)
|
||||
|
||||
OPTAB_CD(sfixtrunc_optab, "fix_trunc$F$b$I$a2")
|
||||
OPTAB_CD(ufixtrunc_optab, "fixuns_trunc$F$b$I$a2")
|
||||
|
||||
/* Misc optabs that use two modes; model them as "conversions". */
|
||||
OPTAB_CD(smul_widen_optab, "mul$b$a3")
|
||||
OPTAB_CD(umul_widen_optab, "umul$b$a3")
|
||||
OPTAB_CD(usmul_widen_optab, "usmul$b$a3")
|
||||
OPTAB_CD(smadd_widen_optab, "madd$b$a4")
|
||||
OPTAB_CD(umadd_widen_optab, "umadd$b$a4")
|
||||
OPTAB_CD(ssmadd_widen_optab, "ssmadd$b$a4")
|
||||
OPTAB_CD(usmadd_widen_optab, "usmadd$b$a4")
|
||||
OPTAB_CD(smsub_widen_optab, "msub$b$a4")
|
||||
OPTAB_CD(umsub_widen_optab, "umsub$b$a4")
|
||||
OPTAB_CD(ssmsub_widen_optab, "ssmsub$b$a4")
|
||||
OPTAB_CD(usmsub_widen_optab, "usmsub$a$b4")
|
||||
OPTAB_CD(vec_load_lanes_optab, "vec_load_lanes$a$b")
|
||||
OPTAB_CD(vec_store_lanes_optab, "vec_store_lanes$a$b")
|
||||
OPTAB_CD(vcond_optab, "vcond$a$b")
|
||||
OPTAB_CD(vcondu_optab, "vcondu$a$b")
|
||||
|
||||
OPTAB_NL(add_optab, "add$P$a3", PLUS, "add", '3', gen_int_fp_fixed_libfunc)
|
||||
OPTAB_NX(add_optab, "add$F$a3")
|
||||
OPTAB_NX(add_optab, "add$Q$a3")
|
||||
OPTAB_VL(addv_optab, "addv$I$a3", PLUS, "add", '3', gen_intv_fp_libfunc)
|
||||
OPTAB_VX(addv_optab, "add$F$a3")
|
||||
OPTAB_NL(ssadd_optab, "ssadd$Q$a3", SS_PLUS, "ssadd", '3', gen_signed_fixed_libfunc)
|
||||
OPTAB_NL(usadd_optab, "usadd$Q$a3", US_PLUS, "usadd", '3', gen_unsigned_fixed_libfunc)
|
||||
OPTAB_NL(sub_optab, "sub$P$a3", MINUS, "sub", '3', gen_int_fp_fixed_libfunc)
|
||||
OPTAB_NX(sub_optab, "sub$F$a3")
|
||||
OPTAB_NX(sub_optab, "sub$Q$a3")
|
||||
OPTAB_VL(subv_optab, "subv$I$a3", MINUS, "sub", '3', gen_intv_fp_libfunc)
|
||||
OPTAB_VX(subv_optab, "sub$F$a3")
|
||||
OPTAB_NL(sssub_optab, "sssub$Q$a3", SS_MINUS, "sssub", '3', gen_signed_fixed_libfunc)
|
||||
OPTAB_NL(ussub_optab, "ussub$Q$a3", US_MINUS, "ussub", '3', gen_unsigned_fixed_libfunc)
|
||||
OPTAB_NL(smul_optab, "mul$Q$a3", MULT, "mul", '3', gen_int_fp_fixed_libfunc)
|
||||
OPTAB_NX(smul_optab, "mul$P$a3")
|
||||
OPTAB_NX(smul_optab, "mul$F$a3")
|
||||
OPTAB_VL(smulv_optab, "mulv$I$a3", MULT, "mul", '3', gen_intv_fp_libfunc)
|
||||
OPTAB_VX(smulv_optab, "mul$F$a3")
|
||||
OPTAB_NL(ssmul_optab, "ssmul$Q$a3", SS_MULT, "ssmul", '3', gen_signed_fixed_libfunc)
|
||||
OPTAB_NL(usmul_optab, "usmul$Q$a3", US_MULT, "usmul", '3', gen_unsigned_fixed_libfunc)
|
||||
OPTAB_NL(sdiv_optab, "div$a3", DIV, "div", '3', gen_int_fp_signed_fixed_libfunc)
|
||||
OPTAB_VL(sdivv_optab, "divv$I$a3", DIV, "divv", '3', gen_int_libfunc)
|
||||
OPTAB_VX(sdivv_optab, "div$F$a3")
|
||||
OPTAB_NL(ssdiv_optab, "ssdiv$Q$a3", SS_DIV, "ssdiv", '3', gen_signed_fixed_libfunc)
|
||||
OPTAB_NL(udiv_optab, "udiv$I$a3", UDIV, "udiv", '3', gen_int_unsigned_fixed_libfunc)
|
||||
OPTAB_NX(udiv_optab, "udiv$Q$a3")
|
||||
OPTAB_NL(usdiv_optab, "usdiv$Q$a3", US_DIV, "usdiv", '3', gen_unsigned_fixed_libfunc)
|
||||
OPTAB_NL(sdivmod_optab, "divmod$a4", UNKNOWN, "divmod", '4', gen_int_libfunc)
|
||||
OPTAB_NL(udivmod_optab, "udivmod$a4", UNKNOWN, "udivmod", '4', gen_int_libfunc)
|
||||
OPTAB_NL(smod_optab, "mod$a3", MOD, "mod", '3', gen_int_libfunc)
|
||||
OPTAB_NL(umod_optab, "umod$a3", UMOD, "umod", '3', gen_int_libfunc)
|
||||
OPTAB_NL(ftrunc_optab, "ftrunc$F$a2", UNKNOWN, "ftrunc", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(and_optab, "and$a3", AND, "and", '3', gen_int_libfunc)
|
||||
OPTAB_NL(ior_optab, "ior$a3", IOR, "ior", '3', gen_int_libfunc)
|
||||
OPTAB_NL(xor_optab, "xor$a3", XOR, "xor", '3', gen_int_libfunc)
|
||||
OPTAB_NL(ashl_optab, "ashl$a3", ASHIFT, "ashl", '3', gen_int_fixed_libfunc)
|
||||
OPTAB_NL(ssashl_optab, "ssashl$Q$a3", SS_ASHIFT, "ssashl", '3', gen_signed_fixed_libfunc)
|
||||
OPTAB_NL(usashl_optab, "usashl$Q$a3", US_ASHIFT, "usashl", '3', gen_unsigned_fixed_libfunc)
|
||||
OPTAB_NL(ashr_optab, "ashr$a3", ASHIFTRT, "ashr", '3', gen_int_signed_fixed_libfunc)
|
||||
OPTAB_NL(lshr_optab, "lshr$a3", LSHIFTRT, "lshr", '3', gen_int_unsigned_fixed_libfunc)
|
||||
OPTAB_NC(rotl_optab, "rotl$a3", ROTATE)
|
||||
OPTAB_NC(rotr_optab, "rotr$a3", ROTATERT)
|
||||
OPTAB_VC(vashl_optab, "vashl$a3", ASHIFT)
|
||||
OPTAB_VC(vashr_optab, "vashr$a3", ASHIFTRT)
|
||||
OPTAB_VC(vlshr_optab, "vlshr$a3", LSHIFTRT)
|
||||
OPTAB_VC(vrotl_optab, "vrotl$a3", ROTATE)
|
||||
OPTAB_VC(vrotr_optab, "vrotr$a3", ROTATERT)
|
||||
OPTAB_NL(smin_optab, "smin$a3", SMIN, "min", '3', gen_int_fp_libfunc)
|
||||
OPTAB_NL(smax_optab, "smax$a3", SMAX, "max", '3', gen_int_fp_libfunc)
|
||||
OPTAB_NL(umin_optab, "umin$I$a3", UMIN, "umin", '3', gen_int_libfunc)
|
||||
OPTAB_NL(umax_optab, "umax$I$a3", UMAX, "umax", '3', gen_int_libfunc)
|
||||
|
||||
OPTAB_NL(neg_optab, "neg$P$a2", NEG, "neg", '2', gen_int_fp_fixed_libfunc)
|
||||
OPTAB_NX(neg_optab, "neg$F$a2")
|
||||
OPTAB_NX(neg_optab, "neg$Q$a2")
|
||||
OPTAB_VL(negv_optab, "negv$I$a2", NEG, "neg", '2', gen_intv_fp_libfunc)
|
||||
OPTAB_VX(negv_optab, "neg$F$a2")
|
||||
OPTAB_NL(ssneg_optab, "ssneg$Q$a2", SS_NEG, "ssneg", '2', gen_signed_fixed_libfunc)
|
||||
OPTAB_NL(usneg_optab, "usneg$Q$a2", US_NEG, "usneg", '2', gen_unsigned_fixed_libfunc)
|
||||
OPTAB_NC(abs_optab, "abs$P$a2", ABS)
|
||||
OPTAB_NX(abs_optab, "abs$F$a2")
|
||||
OPTAB_VC(absv_optab, "absv$I$a2", ABS)
|
||||
OPTAB_VX(absv_optab, "abs$F$a2")
|
||||
OPTAB_NL(one_cmpl_optab, "one_cmpl$a2", NOT, "one_cmpl", '2', gen_int_libfunc)
|
||||
OPTAB_NC(bswap_optab, "bswap$a2", BSWAP)
|
||||
OPTAB_NL(ffs_optab, "ffs$a2", FFS, "ffs", '2', gen_int_libfunc)
|
||||
OPTAB_NL(clz_optab, "clz$a2", CLZ, "clz", '2', gen_int_libfunc)
|
||||
OPTAB_NL(ctz_optab, "ctz$a2", CTZ, "ctz", '2', gen_int_libfunc)
|
||||
OPTAB_NL(clrsb_optab, "clrsb$a2", CLRSB, "clrsb", '2', gen_int_libfunc)
|
||||
OPTAB_NL(popcount_optab, "popcount$a2", POPCOUNT, "popcount", '2', gen_int_libfunc)
|
||||
OPTAB_NL(parity_optab, "parity$a2", PARITY, "parity", '2', gen_int_libfunc)
|
||||
|
||||
/* Comparison libcalls for integers MUST come in pairs, signed/unsigned. */
|
||||
OPTAB_NL(cmp_optab, NULL, UNKNOWN, "cmp", '2', gen_int_fp_fixed_libfunc)
|
||||
OPTAB_NL(ucmp_optab, NULL, UNKNOWN, "ucmp", '2', gen_int_libfunc)
|
||||
|
||||
/* EQ etc are floating point comparisons. */
|
||||
OPTAB_NL(eq_optab, NULL, EQ, "eq", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(ne_optab, NULL, NE, "ne", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(gt_optab, NULL, GT, "gt", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(ge_optab, NULL, GE, "ge", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(lt_optab, NULL, LT, "lt", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(le_optab, NULL, LE, "le", '2', gen_fp_libfunc)
|
||||
OPTAB_NL(unord_optab, NULL, UNORDERED, "unord", '2', gen_fp_libfunc)
|
||||
|
||||
OPTAB_NL(powi_optab, NULL, UNKNOWN, "powi", '2', gen_fp_libfunc)
|
||||
|
||||
/* These are all initialized individually, on a per-host basis. */
|
||||
OPTAB_NC(sqrt_optab, "sqrt$a2", SQRT)
|
||||
OPTAB_NC(sync_old_add_optab, "sync_old_add$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_old_sub_optab, "sync_old_sub$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_old_ior_optab, "sync_old_ior$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_old_and_optab, "sync_old_and$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_old_xor_optab, "sync_old_xor$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_old_nand_optab, "sync_old_nand$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_new_add_optab, "sync_new_add$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_new_sub_optab, "sync_new_sub$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_new_ior_optab, "sync_new_ior$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_new_and_optab, "sync_new_and$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_new_xor_optab, "sync_new_xor$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_new_nand_optab, "sync_new_nand$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_compare_and_swap_optab, "sync_compare_and_swap$I$a", UNKNOWN)
|
||||
OPTAB_NC(sync_lock_test_and_set_optab, "sync_lock_test_and_set$I$a", UNKNOWN)
|
||||
|
||||
OPTAB_DC(mov_optab, "mov$a", SET)
|
||||
OPTAB_DC(movstrict_optab, "movstrict$a", STRICT_LOW_PART)
|
||||
OPTAB_D (movmisalign_optab, "movmisalign$a")
|
||||
OPTAB_D (storent_optab, "storent$a")
|
||||
OPTAB_D (push_optab, "push$a1")
|
||||
OPTAB_D (reload_in_optab, "reload_in$a")
|
||||
OPTAB_D (reload_out_optab, "reload_out$a")
|
||||
|
||||
OPTAB_DC(cbranch_optab, "cbranch$a4", COMPARE)
|
||||
OPTAB_D (addcc_optab, "add$acc")
|
||||
OPTAB_D (movcc_optab, "mov$acc")
|
||||
OPTAB_D (cmov_optab, "cmov$a6")
|
||||
OPTAB_D (cstore_optab, "cstore$a4")
|
||||
OPTAB_D (ctrap_optab, "ctrap$a4")
|
||||
|
||||
OPTAB_D (smul_highpart_optab, "smul$a3_highpart")
|
||||
OPTAB_D (umul_highpart_optab, "umul$a3_highpart")
|
||||
|
||||
OPTAB_D (cmpmem_optab, "cmpmem$a")
|
||||
OPTAB_D (cmpstr_optab, "cmpstr$a")
|
||||
OPTAB_D (cmpstrn_optab, "cmpstrn$a")
|
||||
OPTAB_D (movmem_optab, "movmem$a")
|
||||
OPTAB_D (setmem_optab, "setmem$a")
|
||||
OPTAB_D (strlen_optab, "strlen$a")
|
||||
|
||||
OPTAB_DC(fma_optab, "fma$a4", FMA)
|
||||
OPTAB_D (fms_optab, "fms$a4")
|
||||
OPTAB_D (fnma_optab, "fnma$a4")
|
||||
OPTAB_D (fnms_optab, "fnms$a4")
|
||||
|
||||
OPTAB_D (rint_optab, "rint$a2")
|
||||
OPTAB_D (round_optab, "round$a2")
|
||||
OPTAB_D (floor_optab, "floor$a2")
|
||||
OPTAB_D (ceil_optab, "ceil$a2")
|
||||
OPTAB_D (btrunc_optab, "btrunc$a2")
|
||||
OPTAB_D (nearbyint_optab, "nearbyint$a2")
|
||||
|
||||
OPTAB_D (acos_optab, "acos$a2")
|
||||
OPTAB_D (asin_optab, "asin$a2")
|
||||
OPTAB_D (atan2_optab, "atan2$a3")
|
||||
OPTAB_D (atan_optab, "atan$a2")
|
||||
OPTAB_D (copysign_optab, "copysign$F$a3")
|
||||
OPTAB_D (cos_optab, "cos$a2")
|
||||
OPTAB_D (exp10_optab, "exp10$a2")
|
||||
OPTAB_D (exp2_optab, "exp2$a2")
|
||||
OPTAB_D (exp_optab, "exp$a2")
|
||||
OPTAB_D (expm1_optab, "expm1$a2")
|
||||
OPTAB_D (fmod_optab, "fmod$a3")
|
||||
OPTAB_D (ilogb_optab, "ilogb$a2")
|
||||
OPTAB_D (isinf_optab, "isinf$a2")
|
||||
OPTAB_D (ldexp_optab, "ldexp$a3")
|
||||
OPTAB_D (log10_optab, "log10$a2")
|
||||
OPTAB_D (log1p_optab, "log1p$a2")
|
||||
OPTAB_D (log2_optab, "log2$a2")
|
||||
OPTAB_D (log_optab, "log$a2")
|
||||
OPTAB_D (logb_optab, "logb$a2")
|
||||
OPTAB_D (pow_optab, "pow$a3")
|
||||
OPTAB_D (remainder_optab, "remainder$a3")
|
||||
OPTAB_D (scalb_optab, "scalb$a3")
|
||||
OPTAB_D (signbit_optab, "signbit$F$a2")
|
||||
OPTAB_D (significand_optab, "significand$a2")
|
||||
OPTAB_D (sin_optab, "sin$a2")
|
||||
OPTAB_D (sincos_optab, "sincos$a3")
|
||||
OPTAB_D (tan_optab, "tan$a2")
|
||||
|
||||
OPTAB_D (reduc_smax_optab, "reduc_smax_$a")
|
||||
OPTAB_D (reduc_smin_optab, "reduc_smin_$a")
|
||||
OPTAB_D (reduc_splus_optab, "reduc_splus_$a")
|
||||
OPTAB_D (reduc_umax_optab, "reduc_umax_$a")
|
||||
OPTAB_D (reduc_umin_optab, "reduc_umin_$a")
|
||||
OPTAB_D (reduc_uplus_optab, "reduc_uplus_$a")
|
||||
OPTAB_D (sdot_prod_optab, "sdot_prod$I$a")
|
||||
OPTAB_D (ssum_widen_optab, "widen_ssum$I$a3")
|
||||
OPTAB_D (udot_prod_optab, "udot_prod$I$a")
|
||||
OPTAB_D (usum_widen_optab, "widen_usum$I$a3")
|
||||
OPTAB_D (vec_extract_optab, "vec_extract$a")
|
||||
OPTAB_D (vec_init_optab, "vec_init$a")
|
||||
OPTAB_D (vec_pack_sfix_trunc_optab, "vec_pack_sfix_trunc_$a")
|
||||
OPTAB_D (vec_pack_ssat_optab, "vec_pack_ssat_$a")
|
||||
OPTAB_D (vec_pack_trunc_optab, "vec_pack_trunc_$a")
|
||||
OPTAB_D (vec_pack_ufix_trunc_optab, "vec_pack_ufix_trunc_$a")
|
||||
OPTAB_D (vec_pack_usat_optab, "vec_pack_usat_$a")
|
||||
OPTAB_D (vec_perm_const_optab, "vec_perm_const$a")
|
||||
OPTAB_D (vec_perm_optab, "vec_perm$a")
|
||||
OPTAB_D (vec_realign_load_optab, "vec_realign_load_$a")
|
||||
OPTAB_D (vec_set_optab, "vec_set$a")
|
||||
OPTAB_D (vec_shl_optab, "vec_shl_$a")
|
||||
OPTAB_D (vec_shr_optab, "vec_shr_$a")
|
||||
OPTAB_D (vec_unpacks_float_hi_optab, "vec_unpacks_float_hi_$a")
|
||||
OPTAB_D (vec_unpacks_float_lo_optab, "vec_unpacks_float_lo_$a")
|
||||
OPTAB_D (vec_unpacks_hi_optab, "vec_unpacks_hi_$a")
|
||||
OPTAB_D (vec_unpacks_lo_optab, "vec_unpacks_lo_$a")
|
||||
OPTAB_D (vec_unpacku_float_hi_optab, "vec_unpacku_float_hi_$a")
|
||||
OPTAB_D (vec_unpacku_float_lo_optab, "vec_unpacku_float_lo_$a")
|
||||
OPTAB_D (vec_unpacku_hi_optab, "vec_unpacku_hi_$a")
|
||||
OPTAB_D (vec_unpacku_lo_optab, "vec_unpacku_lo_$a")
|
||||
OPTAB_D (vec_widen_smult_even_optab, "vec_widen_smult_even_$a")
|
||||
OPTAB_D (vec_widen_smult_hi_optab, "vec_widen_smult_hi_$a")
|
||||
OPTAB_D (vec_widen_smult_lo_optab, "vec_widen_smult_lo_$a")
|
||||
OPTAB_D (vec_widen_smult_odd_optab, "vec_widen_smult_odd_$a")
|
||||
OPTAB_D (vec_widen_sshiftl_hi_optab, "vec_widen_sshiftl_hi_$a")
|
||||
OPTAB_D (vec_widen_sshiftl_lo_optab, "vec_widen_sshiftl_lo_$a")
|
||||
OPTAB_D (vec_widen_umult_even_optab, "vec_widen_umult_even_$a")
|
||||
OPTAB_D (vec_widen_umult_hi_optab, "vec_widen_umult_hi_$a")
|
||||
OPTAB_D (vec_widen_umult_lo_optab, "vec_widen_umult_lo_$a")
|
||||
OPTAB_D (vec_widen_umult_odd_optab, "vec_widen_umult_odd_$a")
|
||||
OPTAB_D (vec_widen_ushiftl_hi_optab, "vec_widen_ushiftl_hi_$a")
|
||||
OPTAB_D (vec_widen_ushiftl_lo_optab, "vec_widen_ushiftl_lo_$a")
|
||||
|
||||
OPTAB_D (sync_add_optab, "sync_add$I$a")
|
||||
OPTAB_D (sync_and_optab, "sync_and$I$a")
|
||||
OPTAB_D (sync_ior_optab, "sync_ior$I$a")
|
||||
OPTAB_D (sync_lock_release_optab, "sync_lock_release$I$a")
|
||||
OPTAB_D (sync_nand_optab, "sync_nand$I$a")
|
||||
OPTAB_D (sync_sub_optab, "sync_sub$I$a")
|
||||
OPTAB_D (sync_xor_optab, "sync_xor$I$a")
|
||||
|
||||
OPTAB_D (atomic_add_fetch_optab, "atomic_add_fetch$I$a")
|
||||
OPTAB_D (atomic_add_optab, "atomic_add$I$a")
|
||||
OPTAB_D (atomic_and_fetch_optab, "atomic_and_fetch$I$a")
|
||||
OPTAB_D (atomic_and_optab, "atomic_and$I$a")
|
||||
OPTAB_D (atomic_compare_and_swap_optab, "atomic_compare_and_swap$I$a")
|
||||
OPTAB_D (atomic_exchange_optab, "atomic_exchange$I$a")
|
||||
OPTAB_D (atomic_fetch_add_optab, "atomic_fetch_add$I$a")
|
||||
OPTAB_D (atomic_fetch_and_optab, "atomic_fetch_and$I$a")
|
||||
OPTAB_D (atomic_fetch_nand_optab, "atomic_fetch_nand$I$a")
|
||||
OPTAB_D (atomic_fetch_or_optab, "atomic_fetch_or$I$a")
|
||||
OPTAB_D (atomic_fetch_sub_optab, "atomic_fetch_sub$I$a")
|
||||
OPTAB_D (atomic_fetch_xor_optab, "atomic_fetch_xor$I$a")
|
||||
OPTAB_D (atomic_load_optab, "atomic_load$I$a")
|
||||
OPTAB_D (atomic_nand_fetch_optab, "atomic_nand_fetch$I$a")
|
||||
OPTAB_D (atomic_nand_optab, "atomic_nand$I$a")
|
||||
OPTAB_D (atomic_or_fetch_optab, "atomic_or_fetch$I$a")
|
||||
OPTAB_D (atomic_or_optab, "atomic_or$I$a")
|
||||
OPTAB_D (atomic_store_optab, "atomic_store$I$a")
|
||||
OPTAB_D (atomic_sub_fetch_optab, "atomic_sub_fetch$I$a")
|
||||
OPTAB_D (atomic_sub_optab, "atomic_sub$I$a")
|
||||
OPTAB_D (atomic_xor_fetch_optab, "atomic_xor_fetch$I$a")
|
||||
OPTAB_D (atomic_xor_optab, "atomic_xor$I$a")
|
||||
960
gcc/optabs.h
960
gcc/optabs.h
File diff suppressed because it is too large
Load Diff
|
|
@ -55,8 +55,13 @@ enum rtx_code {
|
|||
NUM_RTX_CODE.
|
||||
Assumes default enum value assignment. */
|
||||
|
||||
/* The cast here, saves many elsewhere. */
|
||||
#define NUM_RTX_CODE ((int) LAST_AND_UNUSED_RTX_CODE)
|
||||
/* The cast here, saves many elsewhere. */
|
||||
|
||||
/* Similar, but since generator files get more entries... */
|
||||
#ifdef GENERATOR_FILE
|
||||
# define NON_GENERATOR_NUM_RTX_CODE ((int) MATCH_OPERAND)
|
||||
#endif
|
||||
|
||||
/* Register Transfer Language EXPRESSIONS CODE CLASSES */
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue