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
   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_optab_handler (add_optab, $A, CODE_FOR_$(add$P$a3$))",
  78   "set_optab_handler (addv_optab, $A, CODE_FOR_$(add$F$a3$)),\n\
  79     set_optab_handler (add_optab, $A, CODE_FOR_$(add$F$a3$))",
  80   "set_optab_handler (addv_optab, $A, CODE_FOR_$(addv$I$a3$))",
  81   "set_optab_handler (add_optab, $A, CODE_FOR_$(add$Q$a3$))",
  82   "set_optab_handler (ssadd_optab, $A, CODE_FOR_$(ssadd$Q$a3$))",
  83   "set_optab_handler (usadd_optab, $A, CODE_FOR_$(usadd$Q$a3$))",
  84   "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$P$a3$))",
  85   "set_optab_handler (subv_optab, $A, CODE_FOR_$(sub$F$a3$)),\n\
  86     set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$F$a3$))",
  87   "set_optab_handler (subv_optab, $A, CODE_FOR_$(subv$I$a3$))",
  88   "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$Q$a3$))",
  89   "set_optab_handler (sssub_optab, $A, CODE_FOR_$(sssub$Q$a3$))",
  90   "set_optab_handler (ussub_optab, $A, CODE_FOR_$(ussub$Q$a3$))",
  91   "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$Q$a3$))",
  92   "set_optab_handler (ssmul_optab, $A, CODE_FOR_$(ssmul$Q$a3$))",
  93   "set_optab_handler (usmul_optab, $A, CODE_FOR_$(usmul$Q$a3$))",
  94   "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$P$a3$))",
  95   "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mul$F$a3$)),\n\
  96     set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$F$a3$))",
  97   "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mulv$I$a3$))",
  98   "set_optab_handler (umul_highpart_optab, $A, CODE_FOR_$(umul$a3_highpart$))",
  99   "set_optab_handler (smul_highpart_optab, $A, CODE_FOR_$(smul$a3_highpart$))",
 100   "set_optab_handler (smul_widen_optab, $B, CODE_FOR_$(mul$a$b3$)$N)",
 101   "set_optab_handler (umul_widen_optab, $B, CODE_FOR_$(umul$a$b3$)$N)",
 102   "set_optab_handler (usmul_widen_optab, $B, CODE_FOR_$(usmul$a$b3$)$N)",
 103   "set_optab_handler (smadd_widen_optab, $B, CODE_FOR_$(madd$a$b4$)$N)",
 104   "set_optab_handler (umadd_widen_optab, $B, CODE_FOR_$(umadd$a$b4$)$N)",
 105   "set_optab_handler (ssmadd_widen_optab, $B, CODE_FOR_$(ssmadd$a$b4$)$N)",
 106   "set_optab_handler (usmadd_widen_optab, $B, CODE_FOR_$(usmadd$a$b4$)$N)",
 107   "set_optab_handler (smsub_widen_optab, $B, CODE_FOR_$(msub$a$b4$)$N)",
 108   "set_optab_handler (umsub_widen_optab, $B, CODE_FOR_$(umsub$a$b4$)$N)",
 109   "set_optab_handler (ssmsub_widen_optab, $B, CODE_FOR_$(ssmsub$a$b4$)$N)",
 110   "set_optab_handler (usmsub_widen_optab, $B, CODE_FOR_$(usmsub$a$b4$)$N)",
 111   "set_optab_handler (sdiv_optab, $A, CODE_FOR_$(div$a3$))",
 112   "set_optab_handler (ssdiv_optab, $A, CODE_FOR_$(ssdiv$Q$a3$))",
 113   "set_optab_handler (sdivv_optab, $A, CODE_FOR_$(div$V$I$a3$))",
 114   "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$I$a3$))",
 115   "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$Q$a3$))",
 116   "set_optab_handler (usdiv_optab, $A, CODE_FOR_$(usdiv$Q$a3$))",
 117   "set_optab_handler (sdivmod_optab, $A, CODE_FOR_$(divmod$a4$))",
 118   "set_optab_handler (udivmod_optab, $A, CODE_FOR_$(udivmod$a4$))",
 119   "set_optab_handler (smod_optab, $A, CODE_FOR_$(mod$a3$))",
 120   "set_optab_handler (umod_optab, $A, CODE_FOR_$(umod$a3$))",
 121   "set_optab_handler (fmod_optab, $A, CODE_FOR_$(fmod$a3$))",
 122   "set_optab_handler (remainder_optab, $A, CODE_FOR_$(remainder$a3$))",
 123   "set_optab_handler (ftrunc_optab, $A, CODE_FOR_$(ftrunc$F$a2$))",
 124   "set_optab_handler (and_optab, $A, CODE_FOR_$(and$a3$))",
 125   "set_optab_handler (ior_optab, $A, CODE_FOR_$(ior$a3$))",
 126   "set_optab_handler (xor_optab, $A, CODE_FOR_$(xor$a3$))",
 127   "set_optab_handler (ashl_optab, $A, CODE_FOR_$(ashl$a3$))",
 128   "set_optab_handler (ssashl_optab, $A, CODE_FOR_$(ssashl$Q$a3$))",
 129   "set_optab_handler (usashl_optab, $A, CODE_FOR_$(usashl$Q$a3$))",
 130   "set_optab_handler (ashr_optab, $A, CODE_FOR_$(ashr$a3$))",
 131   "set_optab_handler (lshr_optab, $A, CODE_FOR_$(lshr$a3$))",
 132   "set_optab_handler (rotl_optab, $A, CODE_FOR_$(rotl$a3$))",
 133   "set_optab_handler (rotr_optab, $A, CODE_FOR_$(rotr$a3$))",
 134   "set_optab_handler (vashr_optab, $A, CODE_FOR_$(vashr$a3$))",
 135   "set_optab_handler (vlshr_optab, $A, CODE_FOR_$(vlshr$a3$))",
 136   "set_optab_handler (vashl_optab, $A, CODE_FOR_$(vashl$a3$))",
 137   "set_optab_handler (vrotl_optab, $A, CODE_FOR_$(vrotl$a3$))",
 138   "set_optab_handler (vrotr_optab, $A, CODE_FOR_$(vrotr$a3$))",
 139   "set_optab_handler (smin_optab, $A, CODE_FOR_$(smin$a3$))",
 140   "set_optab_handler (smax_optab, $A, CODE_FOR_$(smax$a3$))",
 141   "set_optab_handler (umin_optab, $A, CODE_FOR_$(umin$I$a3$))",
 142   "set_optab_handler (umax_optab, $A, CODE_FOR_$(umax$I$a3$))",
 143   "set_optab_handler (pow_optab, $A, CODE_FOR_$(pow$a3$))",
 144   "set_optab_handler (atan2_optab, $A, CODE_FOR_$(atan2$a3$))",
 145   "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$P$a2$))",
 146   "set_optab_handler (negv_optab, $A, CODE_FOR_$(neg$F$a2$)),\n\
 147     set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$F$a2$))",
 148   "set_optab_handler (negv_optab, $A, CODE_FOR_$(negv$I$a2$))",
 149   "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$Q$a2$))",
 150   "set_optab_handler (ssneg_optab, $A, CODE_FOR_$(ssneg$Q$a2$))",
 151   "set_optab_handler (usneg_optab, $A, CODE_FOR_$(usneg$Q$a2$))",
 152   "set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$P$a2$))",
 153   "set_optab_handler (absv_optab, $A, CODE_FOR_$(abs$F$a2$)),\n\
 154     set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$F$a2$))",
 155   "set_optab_handler (absv_optab, $A, CODE_FOR_$(absv$I$a2$))",
 156   "set_optab_handler (copysign_optab, $A, CODE_FOR_$(copysign$F$a3$))",
 157   "set_optab_handler (signbit_optab, $A, CODE_FOR_$(signbit$F$a2$))",
 158   "set_optab_handler (isinf_optab, $A, CODE_FOR_$(isinf$a2$))",
 159   "set_optab_handler (sqrt_optab, $A, CODE_FOR_$(sqrt$a2$))",
 160   "set_optab_handler (floor_optab, $A, CODE_FOR_$(floor$a2$))",
 161   "set_convert_optab_handler (lfloor_optab, $B, $A, CODE_FOR_$(lfloor$F$a$I$b2$))",
 162   "set_optab_handler (fma_optab, $A, CODE_FOR_$(fma$a4$))",
 163   "set_optab_handler (ceil_optab, $A, CODE_FOR_$(ceil$a2$))",
 164   "set_convert_optab_handler (lceil_optab, $B, $A, CODE_FOR_$(lceil$F$a$I$b2$))",
 165   "set_optab_handler (round_optab, $A, CODE_FOR_$(round$a2$))",
 166   "set_optab_handler (btrunc_optab, $A, CODE_FOR_$(btrunc$a2$))",
 167   "set_optab_handler (nearbyint_optab, $A, CODE_FOR_$(nearbyint$a2$))",
 168   "set_optab_handler (rint_optab, $A, CODE_FOR_$(rint$a2$))",
 169   "set_convert_optab_handler (lrint_optab, $B, $A, CODE_FOR_$(lrint$F$a$I$b2$))",
 170   "set_convert_optab_handler (lround_optab, $B, $A, CODE_FOR_$(lround$F$a$I$b2$))",
 171   "set_optab_handler (sincos_optab, $A, CODE_FOR_$(sincos$a3$))",
 172   "set_optab_handler (sin_optab, $A, CODE_FOR_$(sin$a2$))",
 173   "set_optab_handler (asin_optab, $A, CODE_FOR_$(asin$a2$))",
 174   "set_optab_handler (cos_optab, $A, CODE_FOR_$(cos$a2$))",
 175   "set_optab_handler (acos_optab, $A, CODE_FOR_$(acos$a2$))",
 176   "set_optab_handler (exp_optab, $A, CODE_FOR_$(exp$a2$))",
 177   "set_optab_handler (exp10_optab, $A, CODE_FOR_$(exp10$a2$))",
 178   "set_optab_handler (exp2_optab, $A, CODE_FOR_$(exp2$a2$))",
 179   "set_optab_handler (expm1_optab, $A, CODE_FOR_$(expm1$a2$))",
 180   "set_optab_handler (ldexp_optab, $A, CODE_FOR_$(ldexp$a3$))",
 181   "set_optab_handler (scalb_optab, $A, CODE_FOR_$(scalb$a3$))",
 182   "set_optab_handler (significand_optab, $A, CODE_FOR_$(significand$a2$))",
 183   "set_optab_handler (logb_optab, $A, CODE_FOR_$(logb$a2$))",
 184   "set_optab_handler (ilogb_optab, $A, CODE_FOR_$(ilogb$a2$))",
 185   "set_optab_handler (log_optab, $A, CODE_FOR_$(log$a2$))",
 186   "set_optab_handler (log10_optab, $A, CODE_FOR_$(log10$a2$))",
 187   "set_optab_handler (log2_optab, $A, CODE_FOR_$(log2$a2$))",
 188   "set_optab_handler (log1p_optab, $A, CODE_FOR_$(log1p$a2$))",
 189   "set_optab_handler (tan_optab, $A, CODE_FOR_$(tan$a2$))",
 190   "set_optab_handler (atan_optab, $A, CODE_FOR_$(atan$a2$))",
 191   "set_optab_handler (strlen_optab, $A, CODE_FOR_$(strlen$a$))",
 192   "set_optab_handler (one_cmpl_optab, $A, CODE_FOR_$(one_cmpl$a2$))",
 193   "set_optab_handler (bswap_optab, $A, CODE_FOR_$(bswap$a2$))",
 194   "set_optab_handler (ffs_optab, $A, CODE_FOR_$(ffs$a2$))",
 195   "set_optab_handler (clz_optab, $A, CODE_FOR_$(clz$a2$))",
 196   "set_optab_handler (ctz_optab, $A, CODE_FOR_$(ctz$a2$))",
 197   "set_optab_handler (popcount_optab, $A, CODE_FOR_$(popcount$a2$))",
 198   "set_optab_handler (parity_optab, $A, CODE_FOR_$(parity$a2$))",
 199   "set_optab_handler (mov_optab, $A, CODE_FOR_$(mov$a$))",
 200   "set_optab_handler (movstrict_optab, $A, CODE_FOR_$(movstrict$a$))",
 201   "set_optab_handler (movmisalign_optab, $A, CODE_FOR_$(movmisalign$a$))",
 202   "set_optab_handler (storent_optab, $A, CODE_FOR_$(storent$a$))",
 203   "set_optab_handler (addcc_optab, $A, CODE_FOR_$(add$acc$))",
 204   "set_direct_optab_handler (movcc_optab, $A, CODE_FOR_$(mov$acc$))",
 205   "set_optab_handler (cbranch_optab, $A, CODE_FOR_$(cbranch$a4$))",
 206   "set_optab_handler (cmov_optab, $A, CODE_FOR_$(cmov$a6$))",
 207   "set_optab_handler (cstore_optab, $A, CODE_FOR_$(cstore$a4$))",
 208   "set_optab_handler (ctrap_optab, $A, CODE_FOR_$(ctrap$a4$))",
 209   "set_optab_handler (push_optab, $A, CODE_FOR_$(push$a1$))",
 210   "set_direct_optab_handler (reload_in_optab, $A, CODE_FOR_$(reload_in$a$))",
 211   "set_direct_optab_handler (reload_out_optab, $A, CODE_FOR_$(reload_out$a$))",
 212   "set_direct_optab_handler (movmem_optab, $A, CODE_FOR_$(movmem$a$))",
 213   "set_direct_optab_handler (cmpstr_optab, $A, CODE_FOR_$(cmpstr$a$))",
 214   "set_direct_optab_handler (cmpstrn_optab, $A, CODE_FOR_$(cmpstrn$a$))",
 215   "set_direct_optab_handler (cmpmem_optab, $A, CODE_FOR_$(cmpmem$a$))",
 216   "set_direct_optab_handler (setmem_optab, $A, CODE_FOR_$(setmem$a$))",
 217   "set_direct_optab_handler (sync_add_optab, $A, CODE_FOR_$(sync_add$I$a$))",
 218   "set_direct_optab_handler (sync_sub_optab, $A, CODE_FOR_$(sync_sub$I$a$))",
 219   "set_direct_optab_handler (sync_ior_optab, $A, CODE_FOR_$(sync_ior$I$a$))",
 220   "set_direct_optab_handler (sync_and_optab, $A, CODE_FOR_$(sync_and$I$a$))",
 221   "set_direct_optab_handler (sync_xor_optab, $A, CODE_FOR_$(sync_xor$I$a$))",
 222   "set_direct_optab_handler (sync_nand_optab, $A, CODE_FOR_$(sync_nand$I$a$))",
 223   "set_direct_optab_handler (sync_old_add_optab, $A, CODE_FOR_$(sync_old_add$I$a$))",
 224   "set_direct_optab_handler (sync_old_sub_optab, $A, CODE_FOR_$(sync_old_sub$I$a$))",
 225   "set_direct_optab_handler (sync_old_ior_optab, $A, CODE_FOR_$(sync_old_ior$I$a$))",
 226   "set_direct_optab_handler (sync_old_and_optab, $A, CODE_FOR_$(sync_old_and$I$a$))",
 227   "set_direct_optab_handler (sync_old_xor_optab, $A, CODE_FOR_$(sync_old_xor$I$a$))",
 228   "set_direct_optab_handler (sync_old_nand_optab, $A, CODE_FOR_$(sync_old_nand$I$a$))",
 229   "set_direct_optab_handler (sync_new_add_optab, $A, CODE_FOR_$(sync_new_add$I$a$))",
 230   "set_direct_optab_handler (sync_new_sub_optab, $A, CODE_FOR_$(sync_new_sub$I$a$))",
 231   "set_direct_optab_handler (sync_new_ior_optab, $A, CODE_FOR_$(sync_new_ior$I$a$))",
 232   "set_direct_optab_handler (sync_new_and_optab, $A, CODE_FOR_$(sync_new_and$I$a$))",
 233   "set_direct_optab_handler (sync_new_xor_optab, $A, CODE_FOR_$(sync_new_xor$I$a$))",
 234   "set_direct_optab_handler (sync_new_nand_optab, $A, CODE_FOR_$(sync_new_nand$I$a$))",
 235   "set_direct_optab_handler (sync_compare_and_swap_optab, $A, CODE_FOR_$(sync_compare_and_swap$I$a$))",
 236   "set_direct_optab_handler (sync_lock_test_and_set_optab, $A, CODE_FOR_$(sync_lock_test_and_set$I$a$))",
 237   "set_direct_optab_handler (sync_lock_release_optab, $A, CODE_FOR_$(sync_lock_release$I$a$))",
 238   "set_optab_handler (vec_set_optab, $A, CODE_FOR_$(vec_set$a$))",
 239   "set_optab_handler (vec_extract_optab, $A, CODE_FOR_$(vec_extract$a$))",
 240   "set_optab_handler (vec_extract_even_optab, $A, CODE_FOR_$(vec_extract_even$a$))",
 241   "set_optab_handler (vec_extract_odd_optab, $A, CODE_FOR_$(vec_extract_odd$a$))",
 242   "set_optab_handler (vec_interleave_high_optab, $A, CODE_FOR_$(vec_interleave_high$a$))",
 243   "set_optab_handler (vec_interleave_low_optab, $A, CODE_FOR_$(vec_interleave_low$a$))",
 244   "set_optab_handler (vec_init_optab, $A, CODE_FOR_$(vec_init$a$))",
 245   "set_optab_handler (vec_shl_optab, $A, CODE_FOR_$(vec_shl_$a$))",
 246   "set_optab_handler (vec_shr_optab, $A, CODE_FOR_$(vec_shr_$a$))",
 247   "set_optab_handler (vec_realign_load_optab, $A, CODE_FOR_$(vec_realign_load_$a$))",
 248   "set_direct_optab_handler (vcond_optab, $A, CODE_FOR_$(vcond$a$))",
 249   "set_direct_optab_handler (vcondu_optab, $A, CODE_FOR_$(vcondu$a$))",
 250   "set_optab_handler (ssum_widen_optab, $A, CODE_FOR_$(widen_ssum$I$a3$))",
 251   "set_optab_handler (usum_widen_optab, $A, CODE_FOR_$(widen_usum$I$a3$))",
 252   "set_optab_handler (udot_prod_optab, $A, CODE_FOR_$(udot_prod$I$a$))",
 253   "set_optab_handler (sdot_prod_optab, $A, CODE_FOR_$(sdot_prod$I$a$))",
 254   "set_optab_handler (reduc_smax_optab, $A, CODE_FOR_$(reduc_smax_$a$))",
 255   "set_optab_handler (reduc_umax_optab, $A, CODE_FOR_$(reduc_umax_$a$))",
 256   "set_optab_handler (reduc_smin_optab, $A, CODE_FOR_$(reduc_smin_$a$))",
 257   "set_optab_handler (reduc_umin_optab, $A, CODE_FOR_$(reduc_umin_$a$))",
 258   "set_optab_handler (reduc_splus_optab, $A, CODE_FOR_$(reduc_splus_$a$))" ,
 259   "set_optab_handler (reduc_uplus_optab, $A, CODE_FOR_$(reduc_uplus_$a$))",
 260   "set_optab_handler (vec_widen_umult_hi_optab, $A, CODE_FOR_$(vec_widen_umult_hi_$a$))",
 261   "set_optab_handler (vec_widen_umult_lo_optab, $A, CODE_FOR_$(vec_widen_umult_lo_$a$))",
 262   "set_optab_handler (vec_widen_smult_hi_optab, $A, CODE_FOR_$(vec_widen_smult_hi_$a$))",
 263   "set_optab_handler (vec_widen_smult_lo_optab, $A, CODE_FOR_$(vec_widen_smult_lo_$a$))",
 264   "set_optab_handler (vec_unpacks_hi_optab, $A, CODE_FOR_$(vec_unpacks_hi_$a$))",
 265   "set_optab_handler (vec_unpacks_lo_optab, $A, CODE_FOR_$(vec_unpacks_lo_$a$))",
 266   "set_optab_handler (vec_unpacku_hi_optab, $A, CODE_FOR_$(vec_unpacku_hi_$a$))",
 267   "set_optab_handler (vec_unpacku_lo_optab, $A, CODE_FOR_$(vec_unpacku_lo_$a$))",
 268   "set_optab_handler (vec_unpacks_float_hi_optab, $A, CODE_FOR_$(vec_unpacks_float_hi_$a$))",
 269   "set_optab_handler (vec_unpacks_float_lo_optab, $A, CODE_FOR_$(vec_unpacks_float_lo_$a$))",
 270   "set_optab_handler (vec_unpacku_float_hi_optab, $A, CODE_FOR_$(vec_unpacku_float_hi_$a$))",
 271   "set_optab_handler (vec_unpacku_float_lo_optab, $A, CODE_FOR_$(vec_unpacku_float_lo_$a$))",
 272   "set_optab_handler (vec_pack_trunc_optab, $A, CODE_FOR_$(vec_pack_trunc_$a$))",
 273   "set_optab_handler (vec_pack_ssat_optab, $A, CODE_FOR_$(vec_pack_ssat_$a$))",
 274   "set_optab_handler (vec_pack_usat_optab, $A, CODE_FOR_$(vec_pack_usat_$a$))",
 275   "set_optab_handler (vec_pack_sfix_trunc_optab, $A, CODE_FOR_$(vec_pack_sfix_trunc_$a$))",
 276   "set_optab_handler (vec_pack_ufix_trunc_optab, $A, CODE_FOR_$(vec_pack_ufix_trunc_$a$))"
 277 };
 278
 279 static void gen_insn (rtx);
 280
 281 static void
 282 gen_insn (rtx insn)
 283 {
 284   const char *name = XSTR (insn, 0);
 285   int m1 = 0, m2 = 0, op = 0;
 286   size_t pindex;
 287   int i;
 288   const char *np, *pp, *p, *q;
 289
 290   /* Don't mention instructions whose names are the null string.
 291      They are in the machine description just to be recognized.  */
 292   if (*name == 0)
 293     return;
 294
 295   /* See if NAME matches one of the patterns we have for the optabs we know
 296      about.  */
 297
 298   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 299     {
 300       int force_float = 0, force_int = 0, force_partial_int = 0;
 301       int force_fixed = 0;
 302       int force_consec = 0;
 303       int matches = 1;
 304
 305       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 306         ;
 307
 308       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 309            pp++)
 310         {
 311           if (*pp != '$')
 312             {
 313               if (*pp != *np++)
 314                 break;
 315             }
 316           else
 317             switch (*++pp)
 318               {
 319               case 'N':
 320                 force_consec = 1;
 321                 break;
 322               case 'I':
 323                 force_int = 1;
 324                 break;
 325               case 'P':
 326                 force_partial_int = 1;
 327                 break;
 328               case 'F':
 329                 force_float = 1;
 330                 break;
 331               case 'Q':
 332                 force_fixed = 1;
 333                 break;
 334               case 'V':
 335                 break;
 336               case 'c':
 337                 for (op = 0; op < NUM_RTX_CODE; op++)
 338                   {
 339                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 340                       if (*p != *q)
 341                         break;
 342
 343                     /* We have to be concerned about matching "gt" and
 344                        missing "gtu", e.g., so verify we have reached the
 345                        end of thing we are to match.  */
 346                     if (*p == 0 && *q == 0
 347                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 348                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 349                       break;
 350                   }
 351
 352                 if (op == NUM_RTX_CODE)
 353                   matches = 0;
 354                 else
 355                   np += strlen (GET_RTX_NAME(op));
 356                 break;
 357               case 'a':
 358               case 'b':
 359                 /* This loop will stop at the first prefix match, so
 360                    look through the modes in reverse order, in case
 361                    there are extra CC modes and CC is a prefix of the
 362                    CC modes (as it should be).  */
 363                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 364                   {
 365                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 366                       if (TOLOWER (*p) != *q)
 367                         break;
 368
 369                     if (*p == 0
 370                         && (! force_int || mode_class[i] == MODE_INT
 371                             || mode_class[i] == MODE_VECTOR_INT)
 372                         && (! force_partial_int
 373                             || mode_class[i] == MODE_INT
 374                             || mode_class[i] == MODE_PARTIAL_INT
 375                             || mode_class[i] == MODE_VECTOR_INT)
 376                         && (! force_float
 377                             || mode_class[i] == MODE_FLOAT
 378                             || mode_class[i] == MODE_DECIMAL_FLOAT
 379                             || mode_class[i] == MODE_COMPLEX_FLOAT
 380                             || mode_class[i] == MODE_VECTOR_FLOAT)
 381                         && (! force_fixed
 382                             || mode_class[i] == MODE_FRACT
 383                             || mode_class[i] == MODE_UFRACT
 384                             || mode_class[i] == MODE_ACCUM
 385                             || mode_class[i] == MODE_UACCUM
 386                             || mode_class[i] == MODE_VECTOR_FRACT
 387                             || mode_class[i] == MODE_VECTOR_UFRACT
 388                             || mode_class[i] == MODE_VECTOR_ACCUM
 389                             || mode_class[i] == MODE_VECTOR_UACCUM))
 390                       break;
 391                   }
 392
 393                 if (i < 0)
 394                   matches = 0;
 395                 else if (*pp == 'a')
 396                   m1 = i, np += strlen (GET_MODE_NAME(i));
 397                 else
 398                   m2 = i, np += strlen (GET_MODE_NAME(i));
 399
 400                 force_int = force_partial_int = force_float = force_fixed = 0;
 401                 break;
 402
 403               default:
 404                 gcc_unreachable ();
 405               }
 406         }
 407
 408       if (matches && pp[0] == '$' && pp[1] == ')'
 409           && *np == 0
 410           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 411         break;
 412     }
 413
 414   if (pindex == ARRAY_SIZE (optabs))
 415     return;
 416
 417   /* We found a match.  If this pattern is only conditionally present,
 418      write out the "if" and two extra blanks.  */
 419
 420   if (*XSTR (insn, 2) != 0)
 421     printf ("  if (HAVE_%s)\n  ", name);
 422
 423   printf ("  ");
 424
 425   /* Now write out the initialization, making all required substitutions.  */
 426   for (pp = optabs[pindex]; *pp; pp++)
 427     {
 428       if (*pp != '$')
 429         putchar (*pp);
 430       else
 431         switch (*++pp)
 432           {
 433           case '(':  case ')':
 434           case 'I':  case 'F':  case 'N':
 435             break;
 436           case 'V':
 437             if (SCALAR_FLOAT_MODE_P (m1))
 438               printf ("v");
 439             break;
 440           case 'a':
 441             for (np = GET_MODE_NAME(m1); *np; np++)
 442               putchar (TOLOWER (*np));
 443             break;
 444           case 'b':
 445             for (np = GET_MODE_NAME(m2); *np; np++)
 446               putchar (TOLOWER (*np));
 447             break;
 448           case 'A':
 449             printf ("%smode", GET_MODE_NAME(m1));
 450             break;
 451           case 'B':
 452             printf ("%smode", GET_MODE_NAME(m2));
 453             break;
 454           case 'c':
 455             printf ("%s", GET_RTX_NAME(op));
 456             break;
 457           case 'C':
 458             for (np = GET_RTX_NAME(op); *np; np++)
 459               putchar (TOUPPER (*np));
 460             break;
 461           }
 462     }
 463
 464   printf (";\n");
 465 }
 466
 467 extern int main (int, char **);
 468
 469 int
 470 main (int argc, char **argv)
 471 {
 472   rtx desc;
 473
 474   progname = "genopinit";
 475
 476   if (!init_rtx_reader_args (argc, argv))
 477     return (FATAL_EXIT_CODE);
 478
 479   printf ("/* Generated automatically by the program `genopinit'\n\
 480 from the machine description file `md'.  */\n\n");
 481
 482   printf ("#include \"config.h\"\n");
 483   printf ("#include \"system.h\"\n");
 484   printf ("#include \"coretypes.h\"\n");
 485   printf ("#include \"tm.h\"\n");
 486   printf ("#include \"rtl.h\"\n");
 487   printf ("#include \"tm_p.h\"\n");
 488   printf ("#include \"flags.h\"\n");
 489   printf ("#include \"insn-config.h\"\n");
 490   printf ("#include \"recog.h\"\n");
 491   printf ("#include \"expr.h\"\n");
 492   printf ("#include \"optabs.h\"\n");
 493   printf ("#include \"reload.h\"\n\n");
 494
 495   printf ("void\ninit_all_optabs (void)\n{\n");
 496
 497   puts ("\
 498 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 499   int i, j;\n\
 500 #endif\n");
 501
 502   /* Read the machine description.  */
 503
 504   while (1)
 505     {
 506       int line_no, insn_code_number = 0;
 507
 508       desc = read_md_rtx (&line_no, &insn_code_number);
 509       if (desc == NULL)
 510         break;
 511
 512       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 513         gen_insn (desc);
 514     }
 515
 516   puts ("\
 517 \n\
 518 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 519   /* This flag says the same insns that convert to a signed fixnum\n\
 520      also convert validly to an unsigned one.  */\n\
 521   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 522     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 523       set_convert_optab_handler\n\
 524         (ufixtrunc_optab, i, j,\n\
 525          convert_optab_handler (sfixtrunc_optab, i, j));\n\
 526 #endif\n\
 527 }");
 528
 529   fflush (stdout);
 530   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 531 }