gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "bconfig.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "errors.h"
  29 #include "gensupport.h"
  30
  31
  32 /* Many parts of GCC use arrays that are indexed by machine mode and
  33    contain the insn codes for pattern in the MD file that perform a given
  34    operation on operands of that mode.
  35
  36    These patterns are present in the MD file with names that contain
  37    the mode(s) used and the name of the operation.  This program
  38    writes a function `init_all_optabs' that initializes the optabs with
  39    all the insn codes of the relevant patterns present in the MD file.
  40
  41    This array contains a list of optabs that need to be initialized.  Within
  42    each string, the name of the pattern to be matched against is delimited
  43    with $( and $).  In the string, $a and $b are used to match a short mode
  44    name (the part of the mode name not including `mode' and converted to
  45    lower-case).  When writing out the initializer, the entire string is
  46    used.  $A and $B are replaced with the full name of the mode; $a and $b
  47    are replaced with the short form of the name, as above.
  48
  49    If $N is present in the pattern, it means the two modes must be consecutive
  50    widths in the same mode class (e.g, QImode and HImode).  $I means that
  51    only full integer modes should be considered for the next mode, and $F
  52    means that only float modes should be considered.
  53    $P means that both full and partial integer modes should be considered.
  54    $Q means that only fixed-point modes should be considered.
  55
  56    $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
  57
  58    For some optabs, we store the operation by RTL codes.  These are only
  59    used for comparisons.  In that case, $c and $C are the lower-case and
  60    upper-case forms of the comparison, respectively.  */
  61
  62 static const char * const optabs[] =
  63 { "set_convert_optab_handler (sext_optab, $B, $A, CODE_FOR_$(extend$a$b2$))",
  64   "set_convert_optab_handler (zext_optab, $B, $A, CODE_FOR_$(zero_extend$a$b2$))",
  65   "set_convert_optab_handler (sfix_optab, $B, $A, CODE_FOR_$(fix$F$a$I$b2$))",
  66   "set_convert_optab_handler (ufix_optab, $B, $A, CODE_FOR_$(fixuns$F$a$b2$))",
  67   "set_convert_optab_handler (sfixtrunc_optab, $B, $A, CODE_FOR_$(fix_trunc$F$a$I$b2$))",
  68   "set_convert_optab_handler (ufixtrunc_optab, $B, $A, CODE_FOR_$(fixuns_trunc$F$a$I$b2$))",
  69   "set_convert_optab_handler (sfloat_optab, $B, $A, CODE_FOR_$(float$I$a$F$b2$))",
  70   "set_convert_optab_handler (ufloat_optab, $B, $A, CODE_FOR_$(floatuns$I$a$F$b2$))",
  71   "set_convert_optab_handler (trunc_optab, $B, $A, CODE_FOR_$(trunc$a$b2$))",
  72   "set_convert_optab_handler (fract_optab, $B, $A, CODE_FOR_$(fract$a$b2$))",
  73   "set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$I$a$Q$b2$))",
  74   "set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$Q$a$I$b2$))",
  75   "set_convert_optab_handler (satfract_optab, $B, $A, CODE_FOR_$(satfract$a$Q$b2$))",
  76   "set_convert_optab_handler (satfractuns_optab, $B, $A, CODE_FOR_$(satfractuns$I$a$Q$b2$))",
  77   "set_convert_optab_handler (vec_load_lanes_optab, $A, $B, CODE_FOR_$(vec_load_lanes$a$b$))",
  78   "set_convert_optab_handler (vec_store_lanes_optab, $A, $B, CODE_FOR_$(vec_store_lanes$a$b$))",
  79   "set_optab_handler (add_optab, $A, CODE_FOR_$(add$P$a3$))",
  80   "set_optab_handler (addv_optab, $A, CODE_FOR_$(add$F$a3$)),\n\
  81     set_optab_handler (add_optab, $A, CODE_FOR_$(add$F$a3$))",
  82   "set_optab_handler (addv_optab, $A, CODE_FOR_$(addv$I$a3$))",
  83   "set_optab_handler (add_optab, $A, CODE_FOR_$(add$Q$a3$))",
  84   "set_optab_handler (ssadd_optab, $A, CODE_FOR_$(ssadd$Q$a3$))",
  85   "set_optab_handler (usadd_optab, $A, CODE_FOR_$(usadd$Q$a3$))",
  86   "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$P$a3$))",
  87   "set_optab_handler (subv_optab, $A, CODE_FOR_$(sub$F$a3$)),\n\
  88     set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$F$a3$))",
  89   "set_optab_handler (subv_optab, $A, CODE_FOR_$(subv$I$a3$))",
  90   "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$Q$a3$))",
  91   "set_optab_handler (sssub_optab, $A, CODE_FOR_$(sssub$Q$a3$))",
  92   "set_optab_handler (ussub_optab, $A, CODE_FOR_$(ussub$Q$a3$))",
  93   "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$Q$a3$))",
  94   "set_optab_handler (ssmul_optab, $A, CODE_FOR_$(ssmul$Q$a3$))",
  95   "set_optab_handler (usmul_optab, $A, CODE_FOR_$(usmul$Q$a3$))",
  96   "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$P$a3$))",
  97   "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mul$F$a3$)),\n\
  98     set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$F$a3$))",
  99   "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mulv$I$a3$))",
 100   "set_optab_handler (umul_highpart_optab, $A, CODE_FOR_$(umul$a3_highpart$))",
 101   "set_optab_handler (smul_highpart_optab, $A, CODE_FOR_$(smul$a3_highpart$))",
 102   "set_optab_handler (smul_widen_optab, $B, CODE_FOR_$(mul$a$b3$)$N)",
 103   "set_optab_handler (umul_widen_optab, $B, CODE_FOR_$(umul$a$b3$)$N)",
 104   "set_optab_handler (usmul_widen_optab, $B, CODE_FOR_$(usmul$a$b3$)$N)",
 105   "set_optab_handler (smadd_widen_optab, $B, CODE_FOR_$(madd$a$b4$)$N)",
 106   "set_optab_handler (umadd_widen_optab, $B, CODE_FOR_$(umadd$a$b4$)$N)",
 107   "set_optab_handler (ssmadd_widen_optab, $B, CODE_FOR_$(ssmadd$a$b4$)$N)",
 108   "set_optab_handler (usmadd_widen_optab, $B, CODE_FOR_$(usmadd$a$b4$)$N)",
 109   "set_optab_handler (smsub_widen_optab, $B, CODE_FOR_$(msub$a$b4$)$N)",
 110   "set_optab_handler (umsub_widen_optab, $B, CODE_FOR_$(umsub$a$b4$)$N)",
 111   "set_optab_handler (ssmsub_widen_optab, $B, CODE_FOR_$(ssmsub$a$b4$)$N)",
 112   "set_optab_handler (usmsub_widen_optab, $B, CODE_FOR_$(usmsub$a$b4$)$N)",
 113   "set_optab_handler (sdiv_optab, $A, CODE_FOR_$(div$a3$))",
 114   "set_optab_handler (ssdiv_optab, $A, CODE_FOR_$(ssdiv$Q$a3$))",
 115   "set_optab_handler (sdivv_optab, $A, CODE_FOR_$(div$V$I$a3$))",
 116   "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$I$a3$))",
 117   "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$Q$a3$))",
 118   "set_optab_handler (usdiv_optab, $A, CODE_FOR_$(usdiv$Q$a3$))",
 119   "set_optab_handler (sdivmod_optab, $A, CODE_FOR_$(divmod$a4$))",
 120   "set_optab_handler (udivmod_optab, $A, CODE_FOR_$(udivmod$a4$))",
 121   "set_optab_handler (smod_optab, $A, CODE_FOR_$(mod$a3$))",
 122   "set_optab_handler (umod_optab, $A, CODE_FOR_$(umod$a3$))",
 123   "set_optab_handler (fmod_optab, $A, CODE_FOR_$(fmod$a3$))",
 124   "set_optab_handler (remainder_optab, $A, CODE_FOR_$(remainder$a3$))",
 125   "set_optab_handler (ftrunc_optab, $A, CODE_FOR_$(ftrunc$F$a2$))",
 126   "set_optab_handler (and_optab, $A, CODE_FOR_$(and$a3$))",
 127   "set_optab_handler (ior_optab, $A, CODE_FOR_$(ior$a3$))",
 128   "set_optab_handler (xor_optab, $A, CODE_FOR_$(xor$a3$))",
 129   "set_optab_handler (ashl_optab, $A, CODE_FOR_$(ashl$a3$))",
 130   "set_optab_handler (ssashl_optab, $A, CODE_FOR_$(ssashl$Q$a3$))",
 131   "set_optab_handler (usashl_optab, $A, CODE_FOR_$(usashl$Q$a3$))",
 132   "set_optab_handler (ashr_optab, $A, CODE_FOR_$(ashr$a3$))",
 133   "set_optab_handler (lshr_optab, $A, CODE_FOR_$(lshr$a3$))",
 134   "set_optab_handler (rotl_optab, $A, CODE_FOR_$(rotl$a3$))",
 135   "set_optab_handler (rotr_optab, $A, CODE_FOR_$(rotr$a3$))",
 136   "set_optab_handler (vashr_optab, $A, CODE_FOR_$(vashr$a3$))",
 137   "set_optab_handler (vlshr_optab, $A, CODE_FOR_$(vlshr$a3$))",
 138   "set_optab_handler (vashl_optab, $A, CODE_FOR_$(vashl$a3$))",
 139   "set_optab_handler (vrotl_optab, $A, CODE_FOR_$(vrotl$a3$))",
 140   "set_optab_handler (vrotr_optab, $A, CODE_FOR_$(vrotr$a3$))",
 141   "set_optab_handler (smin_optab, $A, CODE_FOR_$(smin$a3$))",
 142   "set_optab_handler (smax_optab, $A, CODE_FOR_$(smax$a3$))",
 143   "set_optab_handler (umin_optab, $A, CODE_FOR_$(umin$I$a3$))",
 144   "set_optab_handler (umax_optab, $A, CODE_FOR_$(umax$I$a3$))",
 145   "set_optab_handler (pow_optab, $A, CODE_FOR_$(pow$a3$))",
 146   "set_optab_handler (atan2_optab, $A, CODE_FOR_$(atan2$a3$))",
 147   "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$P$a2$))",
 148   "set_optab_handler (negv_optab, $A, CODE_FOR_$(neg$F$a2$)),\n\
 149     set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$F$a2$))",
 150   "set_optab_handler (negv_optab, $A, CODE_FOR_$(negv$I$a2$))",
 151   "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$Q$a2$))",
 152   "set_optab_handler (ssneg_optab, $A, CODE_FOR_$(ssneg$Q$a2$))",
 153   "set_optab_handler (usneg_optab, $A, CODE_FOR_$(usneg$Q$a2$))",
 154   "set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$P$a2$))",
 155   "set_optab_handler (absv_optab, $A, CODE_FOR_$(abs$F$a2$)),\n\
 156     set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$F$a2$))",
 157   "set_optab_handler (absv_optab, $A, CODE_FOR_$(absv$I$a2$))",
 158   "set_optab_handler (copysign_optab, $A, CODE_FOR_$(copysign$F$a3$))",
 159   "set_optab_handler (signbit_optab, $A, CODE_FOR_$(signbit$F$a2$))",
 160   "set_optab_handler (isinf_optab, $A, CODE_FOR_$(isinf$a2$))",
 161   "set_optab_handler (sqrt_optab, $A, CODE_FOR_$(sqrt$a2$))",
 162   "set_optab_handler (floor_optab, $A, CODE_FOR_$(floor$a2$))",
 163   "set_convert_optab_handler (lfloor_optab, $B, $A, CODE_FOR_$(lfloor$F$a$I$b2$))",
 164   "set_optab_handler (fma_optab, $A, CODE_FOR_$(fma$a4$))",
 165   "set_optab_handler (fms_optab, $A, CODE_FOR_$(fms$a4$))",
 166   "set_optab_handler (fnma_optab, $A, CODE_FOR_$(fnma$a4$))",
 167   "set_optab_handler (fnms_optab, $A, CODE_FOR_$(fnms$a4$))",
 168   "set_optab_handler (ceil_optab, $A, CODE_FOR_$(ceil$a2$))",
 169   "set_convert_optab_handler (lceil_optab, $B, $A, CODE_FOR_$(lceil$F$a$I$b2$))",
 170   "set_optab_handler (round_optab, $A, CODE_FOR_$(round$a2$))",
 171   "set_optab_handler (btrunc_optab, $A, CODE_FOR_$(btrunc$a2$))",
 172   "set_optab_handler (nearbyint_optab, $A, CODE_FOR_$(nearbyint$a2$))",
 173   "set_optab_handler (rint_optab, $A, CODE_FOR_$(rint$a2$))",
 174   "set_convert_optab_handler (lrint_optab, $B, $A, CODE_FOR_$(lrint$F$a$I$b2$))",
 175   "set_convert_optab_handler (lround_optab, $B, $A, CODE_FOR_$(lround$F$a$I$b2$))",
 176   "set_optab_handler (sincos_optab, $A, CODE_FOR_$(sincos$a3$))",
 177   "set_optab_handler (sin_optab, $A, CODE_FOR_$(sin$a2$))",
 178   "set_optab_handler (asin_optab, $A, CODE_FOR_$(asin$a2$))",
 179   "set_optab_handler (cos_optab, $A, CODE_FOR_$(cos$a2$))",
 180   "set_optab_handler (acos_optab, $A, CODE_FOR_$(acos$a2$))",
 181   "set_optab_handler (exp_optab, $A, CODE_FOR_$(exp$a2$))",
 182   "set_optab_handler (exp10_optab, $A, CODE_FOR_$(exp10$a2$))",
 183   "set_optab_handler (exp2_optab, $A, CODE_FOR_$(exp2$a2$))",
 184   "set_optab_handler (expm1_optab, $A, CODE_FOR_$(expm1$a2$))",
 185   "set_optab_handler (ldexp_optab, $A, CODE_FOR_$(ldexp$a3$))",
 186   "set_optab_handler (scalb_optab, $A, CODE_FOR_$(scalb$a3$))",
 187   "set_optab_handler (significand_optab, $A, CODE_FOR_$(significand$a2$))",
 188   "set_optab_handler (logb_optab, $A, CODE_FOR_$(logb$a2$))",
 189   "set_optab_handler (ilogb_optab, $A, CODE_FOR_$(ilogb$a2$))",
 190   "set_optab_handler (log_optab, $A, CODE_FOR_$(log$a2$))",
 191   "set_optab_handler (log10_optab, $A, CODE_FOR_$(log10$a2$))",
 192   "set_optab_handler (log2_optab, $A, CODE_FOR_$(log2$a2$))",
 193   "set_optab_handler (log1p_optab, $A, CODE_FOR_$(log1p$a2$))",
 194   "set_optab_handler (tan_optab, $A, CODE_FOR_$(tan$a2$))",
 195   "set_optab_handler (atan_optab, $A, CODE_FOR_$(atan$a2$))",
 196   "set_optab_handler (strlen_optab, $A, CODE_FOR_$(strlen$a$))",
 197   "set_optab_handler (one_cmpl_optab, $A, CODE_FOR_$(one_cmpl$a2$))",
 198   "set_optab_handler (bswap_optab, $A, CODE_FOR_$(bswap$a2$))",
 199   "set_optab_handler (ffs_optab, $A, CODE_FOR_$(ffs$a2$))",
 200   "set_optab_handler (clz_optab, $A, CODE_FOR_$(clz$a2$))",
 201   "set_optab_handler (ctz_optab, $A, CODE_FOR_$(ctz$a2$))",
 202   "set_optab_handler (clrsb_optab, $A, CODE_FOR_$(clrsb$a2$))",
 203   "set_optab_handler (popcount_optab, $A, CODE_FOR_$(popcount$a2$))",
 204   "set_optab_handler (parity_optab, $A, CODE_FOR_$(parity$a2$))",
 205   "set_optab_handler (mov_optab, $A, CODE_FOR_$(mov$a$))",
 206   "set_optab_handler (movstrict_optab, $A, CODE_FOR_$(movstrict$a$))",
 207   "set_optab_handler (movmisalign_optab, $A, CODE_FOR_$(movmisalign$a$))",
 208   "set_optab_handler (storent_optab, $A, CODE_FOR_$(storent$a$))",
 209   "set_optab_handler (addcc_optab, $A, CODE_FOR_$(add$acc$))",
 210   "set_direct_optab_handler (movcc_optab, $A, CODE_FOR_$(mov$acc$))",
 211   "set_optab_handler (cbranch_optab, $A, CODE_FOR_$(cbranch$a4$))",
 212   "set_optab_handler (cmov_optab, $A, CODE_FOR_$(cmov$a6$))",
 213   "set_optab_handler (cstore_optab, $A, CODE_FOR_$(cstore$a4$))",
 214   "set_optab_handler (ctrap_optab, $A, CODE_FOR_$(ctrap$a4$))",
 215   "set_optab_handler (push_optab, $A, CODE_FOR_$(push$a1$))",
 216   "set_direct_optab_handler (reload_in_optab, $A, CODE_FOR_$(reload_in$a$))",
 217   "set_direct_optab_handler (reload_out_optab, $A, CODE_FOR_$(reload_out$a$))",
 218   "set_direct_optab_handler (movmem_optab, $A, CODE_FOR_$(movmem$a$))",
 219   "set_direct_optab_handler (cmpstr_optab, $A, CODE_FOR_$(cmpstr$a$))",
 220   "set_direct_optab_handler (cmpstrn_optab, $A, CODE_FOR_$(cmpstrn$a$))",
 221   "set_direct_optab_handler (cmpmem_optab, $A, CODE_FOR_$(cmpmem$a$))",
 222   "set_direct_optab_handler (setmem_optab, $A, CODE_FOR_$(setmem$a$))",
 223   "set_direct_optab_handler (sync_add_optab, $A, CODE_FOR_$(sync_add$I$a$))",
 224   "set_direct_optab_handler (sync_sub_optab, $A, CODE_FOR_$(sync_sub$I$a$))",
 225   "set_direct_optab_handler (sync_ior_optab, $A, CODE_FOR_$(sync_ior$I$a$))",
 226   "set_direct_optab_handler (sync_and_optab, $A, CODE_FOR_$(sync_and$I$a$))",
 227   "set_direct_optab_handler (sync_xor_optab, $A, CODE_FOR_$(sync_xor$I$a$))",
 228   "set_direct_optab_handler (sync_nand_optab, $A, CODE_FOR_$(sync_nand$I$a$))",
 229   "set_direct_optab_handler (sync_old_add_optab, $A, CODE_FOR_$(sync_old_add$I$a$))",
 230   "set_direct_optab_handler (sync_old_sub_optab, $A, CODE_FOR_$(sync_old_sub$I$a$))",
 231   "set_direct_optab_handler (sync_old_ior_optab, $A, CODE_FOR_$(sync_old_ior$I$a$))",
 232   "set_direct_optab_handler (sync_old_and_optab, $A, CODE_FOR_$(sync_old_and$I$a$))",
 233   "set_direct_optab_handler (sync_old_xor_optab, $A, CODE_FOR_$(sync_old_xor$I$a$))",
 234   "set_direct_optab_handler (sync_old_nand_optab, $A, CODE_FOR_$(sync_old_nand$I$a$))",
 235   "set_direct_optab_handler (sync_new_add_optab, $A, CODE_FOR_$(sync_new_add$I$a$))",
 236   "set_direct_optab_handler (sync_new_sub_optab, $A, CODE_FOR_$(sync_new_sub$I$a$))",
 237   "set_direct_optab_handler (sync_new_ior_optab, $A, CODE_FOR_$(sync_new_ior$I$a$))",
 238   "set_direct_optab_handler (sync_new_and_optab, $A, CODE_FOR_$(sync_new_and$I$a$))",
 239   "set_direct_optab_handler (sync_new_xor_optab, $A, CODE_FOR_$(sync_new_xor$I$a$))",
 240   "set_direct_optab_handler (sync_new_nand_optab, $A, CODE_FOR_$(sync_new_nand$I$a$))",
 241   "set_direct_optab_handler (sync_compare_and_swap_optab, $A, CODE_FOR_$(sync_compare_and_swap$I$a$))",
 242   "set_direct_optab_handler (sync_lock_test_and_set_optab, $A, CODE_FOR_$(sync_lock_test_and_set$I$a$))",
 243   "set_direct_optab_handler (sync_lock_release_optab, $A, CODE_FOR_$(sync_lock_release$I$a$))",
 244   "set_optab_handler (vec_set_optab, $A, CODE_FOR_$(vec_set$a$))",
 245   "set_optab_handler (vec_extract_optab, $A, CODE_FOR_$(vec_extract$a$))",
 246   "set_optab_handler (vec_extract_even_optab, $A, CODE_FOR_$(vec_extract_even$a$))",
 247   "set_optab_handler (vec_extract_odd_optab, $A, CODE_FOR_$(vec_extract_odd$a$))",
 248   "set_optab_handler (vec_interleave_high_optab, $A, CODE_FOR_$(vec_interleave_high$a$))",
 249   "set_optab_handler (vec_interleave_low_optab, $A, CODE_FOR_$(vec_interleave_low$a$))",
 250   "set_optab_handler (vec_init_optab, $A, CODE_FOR_$(vec_init$a$))",
 251   "set_optab_handler (vec_shl_optab, $A, CODE_FOR_$(vec_shl_$a$))",
 252   "set_optab_handler (vec_shr_optab, $A, CODE_FOR_$(vec_shr_$a$))",
 253   "set_optab_handler (vec_realign_load_optab, $A, CODE_FOR_$(vec_realign_load_$a$))",
 254   "set_direct_optab_handler (vcond_optab, $A, CODE_FOR_$(vcond$a$))",
 255   "set_direct_optab_handler (vcondu_optab, $A, CODE_FOR_$(vcondu$a$))",
 256   "set_optab_handler (ssum_widen_optab, $A, CODE_FOR_$(widen_ssum$I$a3$))",
 257   "set_optab_handler (usum_widen_optab, $A, CODE_FOR_$(widen_usum$I$a3$))",
 258   "set_optab_handler (udot_prod_optab, $A, CODE_FOR_$(udot_prod$I$a$))",
 259   "set_optab_handler (sdot_prod_optab, $A, CODE_FOR_$(sdot_prod$I$a$))",
 260   "set_optab_handler (reduc_smax_optab, $A, CODE_FOR_$(reduc_smax_$a$))",
 261   "set_optab_handler (reduc_umax_optab, $A, CODE_FOR_$(reduc_umax_$a$))",
 262   "set_optab_handler (reduc_smin_optab, $A, CODE_FOR_$(reduc_smin_$a$))",
 263   "set_optab_handler (reduc_umin_optab, $A, CODE_FOR_$(reduc_umin_$a$))",
 264   "set_optab_handler (reduc_splus_optab, $A, CODE_FOR_$(reduc_splus_$a$))" ,
 265   "set_optab_handler (reduc_uplus_optab, $A, CODE_FOR_$(reduc_uplus_$a$))",
 266   "set_optab_handler (vec_widen_umult_hi_optab, $A, CODE_FOR_$(vec_widen_umult_hi_$a$))",
 267   "set_optab_handler (vec_widen_umult_lo_optab, $A, CODE_FOR_$(vec_widen_umult_lo_$a$))",
 268   "set_optab_handler (vec_widen_smult_hi_optab, $A, CODE_FOR_$(vec_widen_smult_hi_$a$))",
 269   "set_optab_handler (vec_widen_smult_lo_optab, $A, CODE_FOR_$(vec_widen_smult_lo_$a$))",
 270   "set_optab_handler (vec_unpacks_hi_optab, $A, CODE_FOR_$(vec_unpacks_hi_$a$))",
 271   "set_optab_handler (vec_unpacks_lo_optab, $A, CODE_FOR_$(vec_unpacks_lo_$a$))",
 272   "set_optab_handler (vec_unpacku_hi_optab, $A, CODE_FOR_$(vec_unpacku_hi_$a$))",
 273   "set_optab_handler (vec_unpacku_lo_optab, $A, CODE_FOR_$(vec_unpacku_lo_$a$))",
 274   "set_optab_handler (vec_unpacks_float_hi_optab, $A, CODE_FOR_$(vec_unpacks_float_hi_$a$))",
 275   "set_optab_handler (vec_unpacks_float_lo_optab, $A, CODE_FOR_$(vec_unpacks_float_lo_$a$))",
 276   "set_optab_handler (vec_unpacku_float_hi_optab, $A, CODE_FOR_$(vec_unpacku_float_hi_$a$))",
 277   "set_optab_handler (vec_unpacku_float_lo_optab, $A, CODE_FOR_$(vec_unpacku_float_lo_$a$))",
 278   "set_optab_handler (vec_pack_trunc_optab, $A, CODE_FOR_$(vec_pack_trunc_$a$))",
 279   "set_optab_handler (vec_pack_ssat_optab, $A, CODE_FOR_$(vec_pack_ssat_$a$))",
 280   "set_optab_handler (vec_pack_usat_optab, $A, CODE_FOR_$(vec_pack_usat_$a$))",
 281   "set_optab_handler (vec_pack_sfix_trunc_optab, $A, CODE_FOR_$(vec_pack_sfix_trunc_$a$))",
 282   "set_optab_handler (vec_pack_ufix_trunc_optab, $A, CODE_FOR_$(vec_pack_ufix_trunc_$a$))"
 283 };
 284
 285 static void gen_insn (rtx);
 286
 287 static void
 288 gen_insn (rtx insn)
 289 {
 290   const char *name = XSTR (insn, 0);
 291   int m1 = 0, m2 = 0, op = 0;
 292   size_t pindex;
 293   int i;
 294   const char *np, *pp, *p, *q;
 295
 296   /* Don't mention instructions whose names are the null string.
 297      They are in the machine description just to be recognized.  */
 298   if (*name == 0)
 299     return;
 300
 301   /* See if NAME matches one of the patterns we have for the optabs we know
 302      about.  */
 303
 304   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 305     {
 306       int force_float = 0, force_int = 0, force_partial_int = 0;
 307       int force_fixed = 0;
 308       int force_consec = 0;
 309       int matches = 1;
 310
 311       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 312         ;
 313
 314       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 315            pp++)
 316         {
 317           if (*pp != '$')
 318             {
 319               if (*pp != *np++)
 320                 break;
 321             }
 322           else
 323             switch (*++pp)
 324               {
 325               case 'N':
 326                 force_consec = 1;
 327                 break;
 328               case 'I':
 329                 force_int = 1;
 330                 break;
 331               case 'P':
 332                 force_partial_int = 1;
 333                 break;
 334               case 'F':
 335                 force_float = 1;
 336                 break;
 337               case 'Q':
 338                 force_fixed = 1;
 339                 break;
 340               case 'V':
 341                 break;
 342               case 'c':
 343                 for (op = 0; op < NUM_RTX_CODE; op++)
 344                   {
 345                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 346                       if (*p != *q)
 347                         break;
 348
 349                     /* We have to be concerned about matching "gt" and
 350                        missing "gtu", e.g., so verify we have reached the
 351                        end of thing we are to match.  */
 352                     if (*p == 0 && *q == 0
 353                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 354                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 355                       break;
 356                   }
 357
 358                 if (op == NUM_RTX_CODE)
 359                   matches = 0;
 360                 else
 361                   np += strlen (GET_RTX_NAME(op));
 362                 break;
 363               case 'a':
 364               case 'b':
 365                 /* This loop will stop at the first prefix match, so
 366                    look through the modes in reverse order, in case
 367                    there are extra CC modes and CC is a prefix of the
 368                    CC modes (as it should be).  */
 369                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 370                   {
 371                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 372                       if (TOLOWER (*p) != *q)
 373                         break;
 374
 375                     if (*p == 0
 376                         && (! force_int || mode_class[i] == MODE_INT
 377                             || mode_class[i] == MODE_VECTOR_INT)
 378                         && (! force_partial_int
 379                             || mode_class[i] == MODE_INT
 380                             || mode_class[i] == MODE_PARTIAL_INT
 381                             || mode_class[i] == MODE_VECTOR_INT)
 382                         && (! force_float
 383                             || mode_class[i] == MODE_FLOAT
 384                             || mode_class[i] == MODE_DECIMAL_FLOAT
 385                             || mode_class[i] == MODE_COMPLEX_FLOAT
 386                             || mode_class[i] == MODE_VECTOR_FLOAT)
 387                         && (! force_fixed
 388                             || mode_class[i] == MODE_FRACT
 389                             || mode_class[i] == MODE_UFRACT
 390                             || mode_class[i] == MODE_ACCUM
 391                             || mode_class[i] == MODE_UACCUM
 392                             || mode_class[i] == MODE_VECTOR_FRACT
 393                             || mode_class[i] == MODE_VECTOR_UFRACT
 394                             || mode_class[i] == MODE_VECTOR_ACCUM
 395                             || mode_class[i] == MODE_VECTOR_UACCUM))
 396                       break;
 397                   }
 398
 399                 if (i < 0)
 400                   matches = 0;
 401                 else if (*pp == 'a')
 402                   m1 = i, np += strlen (GET_MODE_NAME(i));
 403                 else
 404                   m2 = i, np += strlen (GET_MODE_NAME(i));
 405
 406                 force_int = force_partial_int = force_float = force_fixed = 0;
 407                 break;
 408
 409               default:
 410                 gcc_unreachable ();
 411               }
 412         }
 413
 414       if (matches && pp[0] == '$' && pp[1] == ')'
 415           && *np == 0
 416           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 417         break;
 418     }
 419
 420   if (pindex == ARRAY_SIZE (optabs))
 421     return;
 422
 423   /* We found a match.  If this pattern is only conditionally present,
 424      write out the "if" and two extra blanks.  */
 425
 426   if (*XSTR (insn, 2) != 0)
 427     printf ("  if (HAVE_%s)\n  ", name);
 428
 429   printf ("  ");
 430
 431   /* Now write out the initialization, making all required substitutions.  */
 432   for (pp = optabs[pindex]; *pp; pp++)
 433     {
 434       if (*pp != '$')
 435         putchar (*pp);
 436       else
 437         switch (*++pp)
 438           {
 439           case '(':  case ')':
 440           case 'I':  case 'F':  case 'N':
 441             break;
 442           case 'V':
 443             if (SCALAR_FLOAT_MODE_P (m1))
 444               printf ("v");
 445             break;
 446           case 'a':
 447             for (np = GET_MODE_NAME(m1); *np; np++)
 448               putchar (TOLOWER (*np));
 449             break;
 450           case 'b':
 451             for (np = GET_MODE_NAME(m2); *np; np++)
 452               putchar (TOLOWER (*np));
 453             break;
 454           case 'A':
 455             printf ("%smode", GET_MODE_NAME(m1));
 456             break;
 457           case 'B':
 458             printf ("%smode", GET_MODE_NAME(m2));
 459             break;
 460           case 'c':
 461             printf ("%s", GET_RTX_NAME(op));
 462             break;
 463           case 'C':
 464             for (np = GET_RTX_NAME(op); *np; np++)
 465               putchar (TOUPPER (*np));
 466             break;
 467           }
 468     }
 469
 470   printf (";\n");
 471 }
 472
 473 extern int main (int, char **);
 474
 475 int
 476 main (int argc, char **argv)
 477 {
 478   rtx desc;
 479
 480   progname = "genopinit";
 481
 482   if (!init_rtx_reader_args (argc, argv))
 483     return (FATAL_EXIT_CODE);
 484
 485   printf ("/* Generated automatically by the program `genopinit'\n\
 486 from the machine description file `md'.  */\n\n");
 487
 488   printf ("#include \"config.h\"\n");
 489   printf ("#include \"system.h\"\n");
 490   printf ("#include \"coretypes.h\"\n");
 491   printf ("#include \"tm.h\"\n");
 492   printf ("#include \"rtl.h\"\n");
 493   printf ("#include \"tm_p.h\"\n");
 494   printf ("#include \"flags.h\"\n");
 495   printf ("#include \"insn-config.h\"\n");
 496   printf ("#include \"recog.h\"\n");
 497   printf ("#include \"expr.h\"\n");
 498   printf ("#include \"optabs.h\"\n");
 499   printf ("#include \"reload.h\"\n\n");
 500
 501   printf ("void\ninit_all_optabs (void)\n{\n");
 502
 503   puts ("\
 504 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 505   int i, j;\n\
 506 #endif\n");
 507
 508   /* Read the machine description.  */
 509
 510   while (1)
 511     {
 512       int line_no, insn_code_number = 0;
 513
 514       desc = read_md_rtx (&line_no, &insn_code_number);
 515       if (desc == NULL)
 516         break;
 517
 518       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 519         gen_insn (desc);
 520     }
 521
 522   puts ("\
 523 \n\
 524 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 525   /* This flag says the same insns that convert to a signed fixnum\n\
 526      also convert validly to an unsigned one.  */\n\
 527   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 528     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 529       set_convert_optab_handler\n\
 530         (ufixtrunc_optab, (enum machine_mode) i, (enum machine_mode) j,\n\
 531          convert_optab_handler (sfixtrunc_optab, (enum machine_mode) i,\n\
 532                                                  (enum machine_mode) j));\n\
 533 #endif\n\
 534 }");
 535
 536   fflush (stdout);
 537   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 538 }