X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Foptabs.h;h=1e97b57034d8d77621fc1b04bea495cc3abf393d;hb=bf9d249992807cb206c30ef4f576df87d090fe46;hp=22e2422ccd1e906996ecf132fa6b7033b1320985;hpb=8ed073f5481b02f3c347aaca2946ad3c4ee835fd;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/optabs.h b/gcc/optabs.h index 22e2422ccd1..1e97b57034d 100644 --- a/gcc/optabs.h +++ b/gcc/optabs.h @@ -1,11 +1,12 @@ /* Definitions for code generation pass of GNU compiler. - Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 + 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 2, or (at your option) +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, @@ -14,9 +15,8 @@ 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 COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #ifndef GCC_OPTABS_H #define GCC_OPTABS_H @@ -26,6 +26,7 @@ Boston, MA 02111-1307, USA. */ /* Optabs are tables saying how to generate insn bodies for various machine modes and numbers of operands. Each optab applies to one operation. + For example, add_optab applies to addition. The insn_code slot is the enum insn_code that says how to @@ -38,19 +39,32 @@ Boston, MA 02111-1307, USA. */ A few optabs, such as move_optab and cmp_optab, are used by special code. */ +struct optab_handlers GTY(()) +{ + enum insn_code insn_code; + rtx libfunc; +}; + struct optab GTY(()) { enum rtx_code code; - struct optab_handlers { - enum insn_code insn_code; - rtx libfunc; - } handlers [NUM_MACHINE_MODES]; + struct optab_handlers handlers[NUM_MACHINE_MODES]; }; typedef struct optab * optab; +/* A convert_optab is for some sort of conversion operation between + modes. The first array index is the destination mode, the second + is the source mode. */ +struct convert_optab GTY(()) +{ + enum rtx_code code; + struct optab_handlers handlers[NUM_MACHINE_MODES][NUM_MACHINE_MODES]; +}; +typedef struct convert_optab *convert_optab; + /* Given an enum insn_code, access the function to construct the body of that kind of insn. */ -#define GEN_FCN(CODE) (*insn_data[(int) (CODE)].genfun) +#define GEN_FCN(CODE) (insn_data[CODE].genfun) /* Enumeration of valid indexes into optab_table. */ enum optab_index @@ -69,6 +83,20 @@ enum optab_index /* Signed multiply with result one machine mode wider than args */ OTI_smul_widen, OTI_umul_widen, + /* Widening multiply of one unsigned and one signed operand. */ + OTI_usmul_widen, + /* Signed multiply and add with the result and addend one machine mode + wider than the multiplicand and multiplier. */ + OTI_smadd_widen, + /* Unsigned multiply and add with the result and addend one machine mode + wider than the multiplicand and multiplier. */ + OTI_umadd_widen, + /* Signed multiply and subtract the result and minuend one machine mode + wider than the multiplicand and multiplier. */ + OTI_smsub_widen, + /* Unsigned multiply and subtract the result and minuend one machine mode + wider than the multiplicand and multiplier. */ + OTI_umsub_widen, /* Signed divide */ OTI_sdiv, @@ -80,6 +108,9 @@ enum optab_index /* Signed remainder */ OTI_smod, OTI_umod, + /* Floating point remainder functions */ + OTI_fmod, + OTI_remainder, /* Convert float to integer in float fmt */ OTI_ftrunc, @@ -93,7 +124,7 @@ enum optab_index /* Arithmetic shift left */ OTI_ashl, /* Logical shift right */ - OTI_lshr, + OTI_lshr, /* Arithmetic shift right */ OTI_ashr, /* Rotate left */ @@ -117,6 +148,10 @@ enum optab_index OTI_mov, /* Move, preserving high part of register. */ OTI_movstrict, + /* Move, with a misaligned memory. */ + OTI_movmisalign, + /* Nontemporal store. */ + OTI_storent, /* Unary operations */ /* Negation */ @@ -125,6 +160,8 @@ enum optab_index /* Abs value */ OTI_abs, OTI_absv, + /* Byteswap */ + OTI_bswap, /* Bitwise not */ OTI_one_cmpl, /* Bit scanning and counting */ @@ -135,20 +172,56 @@ enum optab_index OTI_parity, /* Square root */ OTI_sqrt, + /* Sine-Cosine */ + OTI_sincos, /* Sine */ OTI_sin, + /* Inverse sine */ + OTI_asin, /* Cosine */ OTI_cos, + /* Inverse cosine */ + OTI_acos, /* Exponential */ OTI_exp, + /* Base-10 Exponential */ + OTI_exp10, + /* Base-2 Exponential */ + OTI_exp2, + /* Exponential - 1*/ + OTI_expm1, + /* Load exponent of a floating point number */ + OTI_ldexp, + /* Multiply floating-point number by integral power of radix */ + OTI_scalb, + /* Radix-independent exponent */ + OTI_logb, + OTI_ilogb, /* Natural Logarithm */ OTI_log, + /* Base-10 Logarithm */ + OTI_log10, + /* Base-2 Logarithm */ + OTI_log2, + /* logarithm of 1 plus argument */ + OTI_log1p, /* Rounding functions */ OTI_floor, OTI_ceil, - OTI_trunc, + OTI_btrunc, OTI_round, OTI_nearbyint, + OTI_rint, + /* Tangent */ + OTI_tan, + /* Inverse tangent */ + OTI_atan, + /* Copy sign */ + OTI_copysign, + /* Signbit */ + OTI_signbit, + /* Test for infinite value */ + OTI_isinf, /* Compare insn; two operands. */ OTI_cmp, @@ -157,6 +230,15 @@ enum optab_index /* tst insn; compare one operand against 0 */ OTI_tst, + /* Floating point comparison optabs - used primarily for libfuncs */ + OTI_eq, + OTI_ne, + OTI_gt, + OTI_ge, + OTI_lt, + OTI_le, + OTI_unord, + /* String length */ OTI_strlen, @@ -164,13 +246,81 @@ enum optab_index OTI_cbranch, OTI_cmov, OTI_cstore, - + /* Push instruction. */ OTI_push, /* Conditional add instruction. */ OTI_addcc, + /* Reduction operations on a vector operand. */ + OTI_reduc_smax, + OTI_reduc_umax, + OTI_reduc_smin, + OTI_reduc_umin, + OTI_reduc_splus, + OTI_reduc_uplus, + + /* Summation, with result machine mode one or more wider than args. */ + OTI_ssum_widen, + OTI_usum_widen, + + /* Dot product, with result machine mode one or more wider than args. */ + OTI_sdot_prod, + OTI_udot_prod, + + /* Set specified field of vector operand. */ + OTI_vec_set, + /* Extract specified field of vector operand. */ + OTI_vec_extract, + /* Extract even/odd fields of vector operands. */ + OTI_vec_extract_even, + OTI_vec_extract_odd, + /* Interleave fields of vector operands. */ + OTI_vec_interleave_high, + OTI_vec_interleave_low, + /* Initialize vector operand. */ + OTI_vec_init, + /* Whole vector shift. The shift amount is in bits. */ + OTI_vec_shl, + OTI_vec_shr, + /* Extract specified elements from vectors, for vector load. */ + OTI_vec_realign_load, + /* Widening multiplication. + The high/low part of the resulting vector of products is returned. */ + OTI_vec_widen_umult_hi, + OTI_vec_widen_umult_lo, + OTI_vec_widen_smult_hi, + OTI_vec_widen_smult_lo, + /* Extract and widen the high/low part of a vector of signed or + floating point elements. */ + OTI_vec_unpacks_hi, + OTI_vec_unpacks_lo, + /* Extract and widen the high/low part of a vector of unsigned + elements. */ + OTI_vec_unpacku_hi, + OTI_vec_unpacku_lo, + + /* Extract, convert to floating point and widen the high/low part of + a vector of signed or unsigned integer elements. */ + OTI_vec_unpacks_float_hi, + OTI_vec_unpacks_float_lo, + OTI_vec_unpacku_float_hi, + OTI_vec_unpacku_float_lo, + + /* Narrow (demote) and merge the elements of two vectors. */ + OTI_vec_pack_trunc, + OTI_vec_pack_usat, + OTI_vec_pack_ssat, + + /* Convert to signed/unsigned integer, narrow and merge elements + of two vectors of floating point elements. */ + OTI_vec_pack_sfix_trunc, + OTI_vec_pack_ufix_trunc, + + /* Perform a raise to the power of integer. */ + OTI_powi, + OTI_MAX }; @@ -185,6 +335,11 @@ extern GTY(()) optab optab_table[OTI_MAX]; #define umul_highpart_optab (optab_table[OTI_umul_highpart]) #define smul_widen_optab (optab_table[OTI_smul_widen]) #define umul_widen_optab (optab_table[OTI_umul_widen]) +#define usmul_widen_optab (optab_table[OTI_usmul_widen]) +#define smadd_widen_optab (optab_table[OTI_smadd_widen]) +#define umadd_widen_optab (optab_table[OTI_umadd_widen]) +#define smsub_widen_optab (optab_table[OTI_smsub_widen]) +#define umsub_widen_optab (optab_table[OTI_umsub_widen]) #define sdiv_optab (optab_table[OTI_sdiv]) #define smulv_optab (optab_table[OTI_smulv]) #define sdivv_optab (optab_table[OTI_sdivv]) @@ -193,6 +348,8 @@ extern GTY(()) optab optab_table[OTI_MAX]; #define udivmod_optab (optab_table[OTI_udivmod]) #define smod_optab (optab_table[OTI_smod]) #define umod_optab (optab_table[OTI_umod]) +#define fmod_optab (optab_table[OTI_fmod]) +#define remainder_optab (optab_table[OTI_remainder]) #define ftrunc_optab (optab_table[OTI_ftrunc]) #define and_optab (optab_table[OTI_and]) #define ior_optab (optab_table[OTI_ior]) @@ -211,32 +368,62 @@ extern GTY(()) optab optab_table[OTI_MAX]; #define mov_optab (optab_table[OTI_mov]) #define movstrict_optab (optab_table[OTI_movstrict]) +#define movmisalign_optab (optab_table[OTI_movmisalign]) +#define storent_optab (optab_table[OTI_storent]) #define neg_optab (optab_table[OTI_neg]) #define negv_optab (optab_table[OTI_negv]) #define abs_optab (optab_table[OTI_abs]) #define absv_optab (optab_table[OTI_absv]) #define one_cmpl_optab (optab_table[OTI_one_cmpl]) +#define bswap_optab (optab_table[OTI_bswap]) #define ffs_optab (optab_table[OTI_ffs]) #define clz_optab (optab_table[OTI_clz]) #define ctz_optab (optab_table[OTI_ctz]) #define popcount_optab (optab_table[OTI_popcount]) #define parity_optab (optab_table[OTI_parity]) #define sqrt_optab (optab_table[OTI_sqrt]) +#define sincos_optab (optab_table[OTI_sincos]) #define sin_optab (optab_table[OTI_sin]) +#define asin_optab (optab_table[OTI_asin]) #define cos_optab (optab_table[OTI_cos]) +#define acos_optab (optab_table[OTI_acos]) #define exp_optab (optab_table[OTI_exp]) +#define exp10_optab (optab_table[OTI_exp10]) +#define exp2_optab (optab_table[OTI_exp2]) +#define expm1_optab (optab_table[OTI_expm1]) +#define ldexp_optab (optab_table[OTI_ldexp]) +#define scalb_optab (optab_table[OTI_scalb]) +#define logb_optab (optab_table[OTI_logb]) +#define ilogb_optab (optab_table[OTI_ilogb]) #define log_optab (optab_table[OTI_log]) +#define log10_optab (optab_table[OTI_log10]) +#define log2_optab (optab_table[OTI_log2]) +#define log1p_optab (optab_table[OTI_log1p]) #define floor_optab (optab_table[OTI_floor]) #define ceil_optab (optab_table[OTI_ceil]) -#define trunc_optab (optab_table[OTI_trunc]) +#define btrunc_optab (optab_table[OTI_btrunc]) #define round_optab (optab_table[OTI_round]) #define nearbyint_optab (optab_table[OTI_nearbyint]) +#define rint_optab (optab_table[OTI_rint]) +#define tan_optab (optab_table[OTI_tan]) +#define atan_optab (optab_table[OTI_atan]) +#define copysign_optab (optab_table[OTI_copysign]) +#define signbit_optab (optab_table[OTI_signbit]) +#define isinf_optab (optab_table[OTI_isinf]) #define cmp_optab (optab_table[OTI_cmp]) #define ucmp_optab (optab_table[OTI_ucmp]) #define tst_optab (optab_table[OTI_tst]) +#define eq_optab (optab_table[OTI_eq]) +#define ne_optab (optab_table[OTI_ne]) +#define gt_optab (optab_table[OTI_gt]) +#define ge_optab (optab_table[OTI_ge]) +#define lt_optab (optab_table[OTI_lt]) +#define le_optab (optab_table[OTI_le]) +#define unord_optab (optab_table[OTI_unord]) + #define strlen_optab (optab_table[OTI_strlen]) #define cbranch_optab (optab_table[OTI_cbranch]) @@ -245,13 +432,87 @@ extern GTY(()) optab optab_table[OTI_MAX]; #define push_optab (optab_table[OTI_push]) #define addcc_optab (optab_table[OTI_addcc]) -/* Tables of patterns for extending one integer mode to another. */ -extern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2]; +#define reduc_smax_optab (optab_table[OTI_reduc_smax]) +#define reduc_umax_optab (optab_table[OTI_reduc_umax]) +#define reduc_smin_optab (optab_table[OTI_reduc_smin]) +#define reduc_umin_optab (optab_table[OTI_reduc_umin]) +#define reduc_splus_optab (optab_table[OTI_reduc_splus]) +#define reduc_uplus_optab (optab_table[OTI_reduc_uplus]) + +#define ssum_widen_optab (optab_table[OTI_ssum_widen]) +#define usum_widen_optab (optab_table[OTI_usum_widen]) +#define sdot_prod_optab (optab_table[OTI_sdot_prod]) +#define udot_prod_optab (optab_table[OTI_udot_prod]) + +#define vec_set_optab (optab_table[OTI_vec_set]) +#define vec_extract_optab (optab_table[OTI_vec_extract]) +#define vec_extract_even_optab (optab_table[OTI_vec_extract_even]) +#define vec_extract_odd_optab (optab_table[OTI_vec_extract_odd]) +#define vec_interleave_high_optab (optab_table[OTI_vec_interleave_high]) +#define vec_interleave_low_optab (optab_table[OTI_vec_interleave_low]) +#define vec_init_optab (optab_table[OTI_vec_init]) +#define vec_shl_optab (optab_table[OTI_vec_shl]) +#define vec_shr_optab (optab_table[OTI_vec_shr]) +#define vec_realign_load_optab (optab_table[OTI_vec_realign_load]) +#define vec_widen_umult_hi_optab (optab_table[OTI_vec_widen_umult_hi]) +#define vec_widen_umult_lo_optab (optab_table[OTI_vec_widen_umult_lo]) +#define vec_widen_smult_hi_optab (optab_table[OTI_vec_widen_smult_hi]) +#define vec_widen_smult_lo_optab (optab_table[OTI_vec_widen_smult_lo]) +#define vec_unpacks_hi_optab (optab_table[OTI_vec_unpacks_hi]) +#define vec_unpacks_lo_optab (optab_table[OTI_vec_unpacks_lo]) +#define vec_unpacku_hi_optab (optab_table[OTI_vec_unpacku_hi]) +#define vec_unpacku_lo_optab (optab_table[OTI_vec_unpacku_lo]) +#define vec_unpacks_float_hi_optab (optab_table[OTI_vec_unpacks_float_hi]) +#define vec_unpacks_float_lo_optab (optab_table[OTI_vec_unpacks_float_lo]) +#define vec_unpacku_float_hi_optab (optab_table[OTI_vec_unpacku_float_hi]) +#define vec_unpacku_float_lo_optab (optab_table[OTI_vec_unpacku_float_lo]) +#define vec_pack_trunc_optab (optab_table[OTI_vec_pack_trunc]) +#define vec_pack_ssat_optab (optab_table[OTI_vec_pack_ssat]) +#define vec_pack_usat_optab (optab_table[OTI_vec_pack_usat]) +#define vec_pack_sfix_trunc_optab (optab_table[OTI_vec_pack_sfix_trunc]) +#define vec_pack_ufix_trunc_optab (optab_table[OTI_vec_pack_ufix_trunc]) + +#define powi_optab (optab_table[OTI_powi]) + +/* Conversion optabs have their own table and indexes. */ +enum convert_optab_index +{ + COI_sext, + COI_zext, + COI_trunc, + + COI_sfix, + COI_ufix, + + COI_sfixtrunc, + COI_ufixtrunc, + + COI_sfloat, + COI_ufloat, + + COI_lrint, + COI_lround, + COI_lfloor, + COI_lceil, + + COI_MAX +}; -/* Tables of patterns for converting between fixed and floating point. */ -extern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; -extern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; -extern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; +extern GTY(()) convert_optab convert_optab_table[COI_MAX]; + +#define sext_optab (convert_optab_table[COI_sext]) +#define zext_optab (convert_optab_table[COI_zext]) +#define trunc_optab (convert_optab_table[COI_trunc]) +#define sfix_optab (convert_optab_table[COI_sfix]) +#define ufix_optab (convert_optab_table[COI_ufix]) +#define sfixtrunc_optab (convert_optab_table[COI_sfixtrunc]) +#define ufixtrunc_optab (convert_optab_table[COI_ufixtrunc]) +#define sfloat_optab (convert_optab_table[COI_sfloat]) +#define ufloat_optab (convert_optab_table[COI_ufloat]) +#define lrint_optab (convert_optab_table[COI_lrint]) +#define lround_optab (convert_optab_table[COI_lround]) +#define lfloor_optab (convert_optab_table[COI_lfloor]) +#define lceil_optab (convert_optab_table[COI_lceil]) /* These arrays record the insn_code of insns that may be needed to perform input and output reloads of special objects. They provide a @@ -263,14 +524,14 @@ extern enum insn_code reload_out_optab[NUM_MACHINE_MODES]; extern GTY(()) optab code_to_optab[NUM_RTX_CODE + 1]; -typedef rtx (*rtxfun) PARAMS ((rtx)); +typedef rtx (*rtxfun) (rtx); -/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) +/* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...) gives the gen_function to make a branch to test that condition. */ extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; -/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) +/* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...) gives the insn code to make a store-condition insn to test that condition. */ @@ -283,52 +544,117 @@ extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES]; #endif -/* This array records the insn_code of insns to perform block moves. */ -extern enum insn_code movstr_optab[NUM_MACHINE_MODES]; +/* Indexed by the machine mode, gives the insn code for vector conditional + operation. */ -/* This array records the insn_code of insns to perform block clears. */ -extern enum insn_code clrstr_optab[NUM_MACHINE_MODES]; +extern enum insn_code vcond_gen_code[NUM_MACHINE_MODES]; +extern enum insn_code vcondu_gen_code[NUM_MACHINE_MODES]; + +/* This array records the insn_code of insns to perform block moves. */ +extern enum insn_code movmem_optab[NUM_MACHINE_MODES]; + +/* This array records the insn_code of insns to perform block sets. */ +extern enum insn_code setmem_optab[NUM_MACHINE_MODES]; + +/* These arrays record the insn_code of two different kinds of insns + to perform block compares. */ +extern enum insn_code cmpstr_optab[NUM_MACHINE_MODES]; +extern enum insn_code cmpstrn_optab[NUM_MACHINE_MODES]; +extern enum insn_code cmpmem_optab[NUM_MACHINE_MODES]; + +/* Synchronization primitives. This first set is atomic operation for + which we don't care about the resulting value. */ +extern enum insn_code sync_add_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_sub_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_ior_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_and_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_xor_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_nand_optab[NUM_MACHINE_MODES]; + +/* This second set is atomic operations in which we return the value + that existed in memory before the operation. */ +extern enum insn_code sync_old_add_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_old_sub_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_old_ior_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_old_and_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_old_xor_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_old_nand_optab[NUM_MACHINE_MODES]; + +/* This third set is atomic operations in which we return the value + that resulted after performing the operation. */ +extern enum insn_code sync_new_add_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_new_sub_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_new_ior_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_new_and_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_new_xor_optab[NUM_MACHINE_MODES]; +extern enum insn_code sync_new_nand_optab[NUM_MACHINE_MODES]; + +/* Atomic compare and swap. */ +extern enum insn_code sync_compare_and_swap[NUM_MACHINE_MODES]; +extern enum insn_code sync_compare_and_swap_cc[NUM_MACHINE_MODES]; + +/* Atomic exchange with acquire semantics. */ +extern enum insn_code sync_lock_test_and_set[NUM_MACHINE_MODES]; + +/* Atomic clear with release semantics. */ +extern enum insn_code sync_lock_release[NUM_MACHINE_MODES]; /* Define functions given in optabs.c. */ +extern rtx expand_widen_pattern_expr (tree exp, rtx op0, rtx op1, rtx wide_op, + rtx target, int unsignedp); + +extern rtx expand_ternary_op (enum machine_mode mode, optab ternary_optab, + rtx op0, rtx op1, rtx op2, rtx target, + int unsignedp); + /* Expand a binary operation given optab and rtx operands. */ -extern rtx expand_binop PARAMS ((enum machine_mode, optab, rtx, rtx, rtx, - int, enum optab_methods)); +extern rtx expand_binop (enum machine_mode, optab, rtx, rtx, rtx, int, + enum optab_methods); + +extern bool force_expand_binop (enum machine_mode, optab, rtx, rtx, rtx, int, + enum optab_methods); /* Expand a binary operation with both signed and unsigned forms. */ -extern rtx sign_expand_binop PARAMS ((enum machine_mode, optab, optab, rtx, - rtx, rtx, int, enum optab_methods)); +extern rtx sign_expand_binop (enum machine_mode, optab, optab, rtx, rtx, + rtx, int, enum optab_methods); + +/* Generate code to perform an operation on one operand with two results. */ +extern int expand_twoval_unop (optab, rtx, rtx, rtx, int); /* Generate code to perform an operation on two operands with two results. */ -extern int expand_twoval_binop PARAMS ((optab, rtx, rtx, rtx, rtx, int)); +extern int expand_twoval_binop (optab, rtx, rtx, rtx, rtx, int); + +/* Generate code to perform an operation on two operands with two + results, using a library function. */ +extern bool expand_twoval_binop_libfunc (optab, rtx, rtx, rtx, rtx, + enum rtx_code); /* Expand a unary arithmetic operation given optab rtx operand. */ -extern rtx expand_unop PARAMS ((enum machine_mode, optab, rtx, rtx, int)); +extern rtx expand_unop (enum machine_mode, optab, rtx, rtx, int); /* Expand the absolute value operation. */ -extern rtx expand_abs_nojump PARAMS ((enum machine_mode, rtx, rtx, int)); -extern rtx expand_abs PARAMS ((enum machine_mode, rtx, rtx, int, int)); +extern rtx expand_abs_nojump (enum machine_mode, rtx, rtx, int); +extern rtx expand_abs (enum machine_mode, rtx, rtx, int, int); -/* Expand the complex absolute value operation. */ -extern rtx expand_complex_abs PARAMS ((enum machine_mode, rtx, rtx, int)); +/* Expand the copysign operation. */ +extern rtx expand_copysign (rtx, rtx, rtx); /* Generate an instruction with a given INSN_CODE with an output and an input. */ -extern void emit_unop_insn PARAMS ((int, rtx, rtx, enum rtx_code)); +extern void emit_unop_insn (int, rtx, rtx, enum rtx_code); + +/* Excapsulate the block in REG_LIBCALL, and REG_RETVAL reg notes and add + REG_LIBCALL_ID notes to all insns in block. */ +extern void maybe_encapsulate_block (rtx, rtx, rtx); /* Emit code to perform a series of operations on a multi-word quantity, one word at a time. */ -extern rtx emit_no_conflict_block PARAMS ((rtx, rtx, rtx, rtx, rtx)); - -/* Emit one rtl instruction to store zero in specified rtx. */ -extern void emit_clr_insn PARAMS ((rtx)); - -/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ -extern void emit_0_to_1_insn PARAMS ((rtx)); +extern rtx emit_no_conflict_block (rtx, rtx, rtx, rtx, rtx); /* Emit one rtl insn to compare two rtx's. */ -extern void emit_cmp_insn PARAMS ((rtx, rtx, enum rtx_code, rtx, - enum machine_mode, int)); +extern void emit_cmp_insn (rtx, rtx, enum rtx_code, rtx, enum machine_mode, + int); /* The various uses that a comparison can have; used by can_compare_p: jumps, conditional moves, store flag operations. */ @@ -339,32 +665,44 @@ enum can_compare_purpose ccp_store_flag }; +/* Return the optab used for computing the given operation on the type + given by the second argument. */ +extern optab optab_for_tree_code (enum tree_code, tree); + /* Nonzero if a compare of mode MODE can be done straightforwardly (without splitting it into pieces). */ -extern int can_compare_p PARAMS ((enum rtx_code, enum machine_mode, - enum can_compare_purpose)); - -extern rtx prepare_operand PARAMS ((int, rtx, int, enum machine_mode, - enum machine_mode, int)); +extern int can_compare_p (enum rtx_code, enum machine_mode, + enum can_compare_purpose); /* Return the INSN_CODE to use for an extend operation. */ -extern enum insn_code can_extend_p PARAMS ((enum machine_mode, - enum machine_mode, int)); +extern enum insn_code can_extend_p (enum machine_mode, enum machine_mode, int); /* Generate the body of an insn to extend Y (with mode MFROM) into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ -extern rtx gen_extend_insn PARAMS ((rtx, rtx, enum machine_mode, - enum machine_mode, int)); +extern rtx gen_extend_insn (rtx, rtx, enum machine_mode, + enum machine_mode, int); -/* Initialize the tables that control conversion between fixed and - floating values. */ -extern void init_fixtab PARAMS ((void)); -extern void init_floattab PARAMS ((void)); +/* Call this to reset the function entry for one optab. */ +extern void set_optab_libfunc (optab, enum machine_mode, const char *); +extern void set_conv_libfunc (convert_optab, enum machine_mode, + enum machine_mode, const char *); /* Generate code for a FLOAT_EXPR. */ -extern void expand_float PARAMS ((rtx, rtx, int)); +extern void expand_float (rtx, rtx, int); /* Generate code for a FIX_EXPR. */ -extern void expand_fix PARAMS ((rtx, rtx, int)); +extern void expand_fix (rtx, rtx, int); + +/* Generate code for float to integral conversion. */ +extern bool expand_sfix_optab (rtx, rtx, convert_optab); + +/* Return tree if target supports vector operations for COND_EXPR. */ +bool expand_vec_cond_expr_p (tree, enum machine_mode); + +/* Generate code for VEC_COND_EXPR. */ +extern rtx expand_vec_cond_expr (tree, rtx); + +/* Generate code for VEC_LSHIFT_EXPR and VEC_RSHIFT_EXPR. */ +extern rtx expand_vec_shift_expr (tree, rtx); #endif /* GCC_OPTABS_H */