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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  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
  55    $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
  56
  57    For some optabs, we store the operation by RTL codes.  These are only
  58    used for comparisons.  In that case, $c and $C are the lower-case and
  59    upper-case forms of the comparison, respectively.  */
  60
  61 static const char * const optabs[] =
  62 { "sext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(extend$a$b2$)",
  63   "zext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(zero_extend$a$b2$)",
  64   "sfix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
  65   "ufix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
  66   "sfixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
  67   "ufixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
  68   "sfloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(float$I$a$F$b2$)",
  69   "ufloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
  70   "trunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(trunc$a$b2$)",
  71   "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$P$a3$)",
  72   "addv_optab->handlers[$A].insn_code =\n\
  73     add_optab->handlers[$A].insn_code = CODE_FOR_$(add$F$a3$)",
  74   "addv_optab->handlers[$A].insn_code = CODE_FOR_$(addv$I$a3$)",
  75   "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$P$a3$)",
  76   "subv_optab->handlers[$A].insn_code =\n\
  77     sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$F$a3$)",
  78   "subv_optab->handlers[$A].insn_code = CODE_FOR_$(subv$I$a3$)",
  79   "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$P$a3$)",
  80   "smulv_optab->handlers[$A].insn_code =\n\
  81     smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$F$a3$)",
  82   "smulv_optab->handlers[$A].insn_code = CODE_FOR_$(mulv$I$a3$)",
  83   "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
  84   "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
  85   "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
  86   "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
  87   "usmul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(usmul$a$b3$)$N",
  88   "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$a3$)",
  89   "sdivv_optab->handlers[$A].insn_code = CODE_FOR_$(div$V$I$a3$)",
  90   "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
  91   "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
  92   "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
  93   "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
  94   "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
  95   "fmod_optab->handlers[$A].insn_code = CODE_FOR_$(fmod$a3$)",
  96   "remainder_optab->handlers[$A].insn_code = CODE_FOR_$(remainder$a3$)",
  97   "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
  98   "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
  99   "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
 100   "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
 101   "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
 102   "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
 103   "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
 104   "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
 105   "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
 106   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$a3$)",
 107   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$a3$)",
 108   "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
 109   "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
 110   "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
 111   "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
 112   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 113   "negv_optab->handlers[$A].insn_code =\n\
 114     neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$F$a2$)",
 115   "negv_optab->handlers[$A].insn_code = CODE_FOR_$(negv$I$a2$)",
 116   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
 117   "absv_optab->handlers[$A].insn_code =\n\
 118     abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$F$a2$)",
 119   "absv_optab->handlers[$A].insn_code = CODE_FOR_$(absv$I$a2$)",
 120   "copysign_optab->handlers[$A].insn_code = CODE_FOR_$(copysign$F$a3$)",
 121   "isinf_optab->handlers[$A].insn_code = CODE_FOR_$(isinf$a2$)",
 122   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 123   "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
 124   "lfloor_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lfloor$F$a$I$b2$)",
 125   "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
 126   "lceil_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lceil$F$a$I$b2$)",
 127   "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
 128   "btrunc_optab->handlers[$A].insn_code = CODE_FOR_$(btrunc$a2$)",
 129   "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
 130   "rint_optab->handlers[$A].insn_code = CODE_FOR_$(rint$a2$)",
 131   "lrint_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lrint$F$a$I$b2$)",
 132   "lround_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lround$F$a$I$b2$)",
 133   "sincos_optab->handlers[$A].insn_code = CODE_FOR_$(sincos$a3$)",
 134   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 135   "asin_optab->handlers[$A].insn_code = CODE_FOR_$(asin$a2$)",
 136   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 137   "acos_optab->handlers[$A].insn_code = CODE_FOR_$(acos$a2$)",
 138   "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
 139   "exp10_optab->handlers[$A].insn_code = CODE_FOR_$(exp10$a2$)",
 140   "exp2_optab->handlers[$A].insn_code = CODE_FOR_$(exp2$a2$)",
 141   "expm1_optab->handlers[$A].insn_code = CODE_FOR_$(expm1$a2$)",
 142   "ldexp_optab->handlers[$A].insn_code = CODE_FOR_$(ldexp$a3$)",
 143   "logb_optab->handlers[$A].insn_code = CODE_FOR_$(logb$a2$)",
 144   "ilogb_optab->handlers[$A].insn_code = CODE_FOR_$(ilogb$a2$)",
 145   "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
 146   "log10_optab->handlers[$A].insn_code = CODE_FOR_$(log10$a2$)",
 147   "log2_optab->handlers[$A].insn_code = CODE_FOR_$(log2$a2$)",
 148   "log1p_optab->handlers[$A].insn_code = CODE_FOR_$(log1p$a2$)",
 149   "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
 150   "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
 151   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 152   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 153   "bswap_optab->handlers[$A].insn_code = CODE_FOR_$(bswap$a2$)",
 154   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 155   "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
 156   "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
 157   "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
 158   "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
 159   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 160   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 161   "movmisalign_optab->handlers[$A].insn_code = CODE_FOR_$(movmisalign$a$)",
 162   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 163   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 164   "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
 165   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 166   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 167   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 168   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 169   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 170   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 171   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 172   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 173   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 174   "movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
 175   "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)",
 176   "cmpstrn_optab[$A] = CODE_FOR_$(cmpstrn$a$)",
 177   "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)",
 178   "setmem_optab[$A] = CODE_FOR_$(setmem$a$)",
 179   "sync_add_optab[$A] = CODE_FOR_$(sync_add$I$a$)",
 180   "sync_sub_optab[$A] = CODE_FOR_$(sync_sub$I$a$)",
 181   "sync_ior_optab[$A] = CODE_FOR_$(sync_ior$I$a$)",
 182   "sync_and_optab[$A] = CODE_FOR_$(sync_and$I$a$)",
 183   "sync_xor_optab[$A] = CODE_FOR_$(sync_xor$I$a$)",
 184   "sync_nand_optab[$A] = CODE_FOR_$(sync_nand$I$a$)",
 185   "sync_old_add_optab[$A] = CODE_FOR_$(sync_old_add$I$a$)",
 186   "sync_old_sub_optab[$A] = CODE_FOR_$(sync_old_sub$I$a$)",
 187   "sync_old_ior_optab[$A] = CODE_FOR_$(sync_old_ior$I$a$)",
 188   "sync_old_and_optab[$A] = CODE_FOR_$(sync_old_and$I$a$)",
 189   "sync_old_xor_optab[$A] = CODE_FOR_$(sync_old_xor$I$a$)",
 190   "sync_old_nand_optab[$A] = CODE_FOR_$(sync_old_nand$I$a$)",
 191   "sync_new_add_optab[$A] = CODE_FOR_$(sync_new_add$I$a$)",
 192   "sync_new_sub_optab[$A] = CODE_FOR_$(sync_new_sub$I$a$)",
 193   "sync_new_ior_optab[$A] = CODE_FOR_$(sync_new_ior$I$a$)",
 194   "sync_new_and_optab[$A] = CODE_FOR_$(sync_new_and$I$a$)",
 195   "sync_new_xor_optab[$A] = CODE_FOR_$(sync_new_xor$I$a$)",
 196   "sync_new_nand_optab[$A] = CODE_FOR_$(sync_new_nand$I$a$)",
 197   "sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)",
 198   "sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
 199   "sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
 200   "sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
 201   "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
 202   "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
 203   "vec_extract_even_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract_even$a$)",
 204   "vec_extract_odd_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract_odd$a$)",
 205   "vec_interleave_high_optab->handlers[$A].insn_code = CODE_FOR_$(vec_interleave_high$a$)",
 206   "vec_interleave_low_optab->handlers[$A].insn_code = CODE_FOR_$(vec_interleave_low$a$)",
 207   "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)",
 208   "vec_shl_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shl_$a$)",
 209   "vec_shr_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shr_$a$)",
 210   "vec_realign_load_optab->handlers[$A].insn_code = CODE_FOR_$(vec_realign_load_$a$)",
 211   "vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
 212   "vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
 213   "ssum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_ssum$I$a3$)",
 214   "usum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_usum$I$a3$)",
 215   "udot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(udot_prod$I$a$)",
 216   "sdot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(sdot_prod$I$a$)",
 217   "reduc_smax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smax_$a$)",
 218   "reduc_umax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umax_$a$)",
 219   "reduc_smin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smin_$a$)",
 220   "reduc_umin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umin_$a$)",
 221   "reduc_splus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
 222   "reduc_uplus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_uplus_$a$)",
 223   "vec_widen_umult_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_umult_hi_$a$)",
 224   "vec_widen_umult_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_umult_lo_$a$)",
 225   "vec_widen_smult_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_smult_hi_$a$)",
 226   "vec_widen_smult_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_smult_lo_$a$)",
 227   "vec_unpacks_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_hi_$a$)",
 228   "vec_unpacks_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_lo_$a$)",
 229   "vec_unpacku_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_hi_$a$)",
 230   "vec_unpacku_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_lo_$a$)",
 231   "vec_pack_mod_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_mod_$a$)",
 232   "vec_pack_ssat_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_ssat_$a$)",  "vec_pack_usat_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_usat_$a$)"
 233 };
 234
 235 static void gen_insn (rtx);
 236
 237 static void
 238 gen_insn (rtx insn)
 239 {
 240   const char *name = XSTR (insn, 0);
 241   int m1 = 0, m2 = 0, op = 0;
 242   size_t pindex;
 243   int i;
 244   const char *np, *pp, *p, *q;
 245
 246   /* Don't mention instructions whose names are the null string.
 247      They are in the machine description just to be recognized.  */
 248   if (*name == 0)
 249     return;
 250
 251   /* See if NAME matches one of the patterns we have for the optabs we know
 252      about.  */
 253
 254   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 255     {
 256       int force_float = 0, force_int = 0, force_partial_int = 0;
 257       int force_consec = 0;
 258       int matches = 1;
 259
 260       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 261         ;
 262
 263       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 264            pp++)
 265         {
 266           if (*pp != '$')
 267             {
 268               if (*pp != *np++)
 269                 break;
 270             }
 271           else
 272             switch (*++pp)
 273               {
 274               case 'N':
 275                 force_consec = 1;
 276                 break;
 277               case 'I':
 278                 force_int = 1;
 279                 break;
 280               case 'P':
 281                 force_partial_int = 1;
 282                 break;
 283               case 'F':
 284                 force_float = 1;
 285                 break;
 286               case 'V':
 287                 break;
 288               case 'c':
 289                 for (op = 0; op < NUM_RTX_CODE; op++)
 290                   {
 291                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 292                       if (*p != *q)
 293                         break;
 294
 295                     /* We have to be concerned about matching "gt" and
 296                        missing "gtu", e.g., so verify we have reached the
 297                        end of thing we are to match.  */
 298                     if (*p == 0 && *q == 0
 299                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 300                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 301                       break;
 302                   }
 303
 304                 if (op == NUM_RTX_CODE)
 305                   matches = 0;
 306                 else
 307                   np += strlen (GET_RTX_NAME(op));
 308                 break;
 309               case 'a':
 310               case 'b':
 311                 /* This loop will stop at the first prefix match, so
 312                    look through the modes in reverse order, in case
 313                    there are extra CC modes and CC is a prefix of the
 314                    CC modes (as it should be).  */
 315                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 316                   {
 317                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 318                       if (TOLOWER (*p) != *q)
 319                         break;
 320
 321                     if (*p == 0
 322                         && (! force_int || mode_class[i] == MODE_INT
 323                             || mode_class[i] == MODE_VECTOR_INT)
 324                         && (! force_partial_int
 325                             || mode_class[i] == MODE_INT
 326                             || mode_class[i] == MODE_PARTIAL_INT
 327                             || mode_class[i] == MODE_VECTOR_INT)
 328                         && (! force_float
 329                             || mode_class[i] == MODE_FLOAT
 330                             || mode_class[i] == MODE_DECIMAL_FLOAT
 331                             || mode_class[i] == MODE_COMPLEX_FLOAT
 332                             || mode_class[i] == MODE_VECTOR_FLOAT))
 333                       break;
 334                   }
 335
 336                 if (i < 0)
 337                   matches = 0;
 338                 else if (*pp == 'a')
 339                   m1 = i, np += strlen (GET_MODE_NAME(i));
 340                 else
 341                   m2 = i, np += strlen (GET_MODE_NAME(i));
 342
 343                 force_int = force_partial_int = force_float = 0;
 344                 break;
 345
 346               default:
 347                 gcc_unreachable ();
 348               }
 349         }
 350
 351       if (matches && pp[0] == '$' && pp[1] == ')'
 352           && *np == 0
 353           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 354         break;
 355     }
 356
 357   if (pindex == ARRAY_SIZE (optabs))
 358     return;
 359
 360   /* We found a match.  If this pattern is only conditionally present,
 361      write out the "if" and two extra blanks.  */
 362
 363   if (*XSTR (insn, 2) != 0)
 364     printf ("  if (HAVE_%s)\n  ", name);
 365
 366   printf ("  ");
 367
 368   /* Now write out the initialization, making all required substitutions.  */
 369   for (pp = optabs[pindex]; *pp; pp++)
 370     {
 371       if (*pp != '$')
 372         putchar (*pp);
 373       else
 374         switch (*++pp)
 375           {
 376           case '(':  case ')':
 377           case 'I':  case 'F':  case 'N':
 378             break;
 379           case 'V':
 380             if (SCALAR_FLOAT_MODE_P (m1))
 381               printf ("v");
 382             break;
 383           case 'a':
 384             for (np = GET_MODE_NAME(m1); *np; np++)
 385               putchar (TOLOWER (*np));
 386             break;
 387           case 'b':
 388             for (np = GET_MODE_NAME(m2); *np; np++)
 389               putchar (TOLOWER (*np));
 390             break;
 391           case 'A':
 392             printf ("%smode", GET_MODE_NAME(m1));
 393             break;
 394           case 'B':
 395             printf ("%smode", GET_MODE_NAME(m2));
 396             break;
 397           case 'c':
 398             printf ("%s", GET_RTX_NAME(op));
 399             break;
 400           case 'C':
 401             for (np = GET_RTX_NAME(op); *np; np++)
 402               putchar (TOUPPER (*np));
 403             break;
 404           }
 405     }
 406
 407   printf (";\n");
 408 }
 409
 410 extern int main (int, char **);
 411
 412 int
 413 main (int argc, char **argv)
 414 {
 415   rtx desc;
 416
 417   progname = "genopinit";
 418
 419   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 420     return (FATAL_EXIT_CODE);
 421
 422   printf ("/* Generated automatically by the program `genopinit'\n\
 423 from the machine description file `md'.  */\n\n");
 424
 425   printf ("#include \"config.h\"\n");
 426   printf ("#include \"system.h\"\n");
 427   printf ("#include \"coretypes.h\"\n");
 428   printf ("#include \"tm.h\"\n");
 429   printf ("#include \"rtl.h\"\n");
 430   printf ("#include \"flags.h\"\n");
 431   printf ("#include \"insn-config.h\"\n");
 432   printf ("#include \"recog.h\"\n");
 433   printf ("#include \"expr.h\"\n");
 434   printf ("#include \"optabs.h\"\n");
 435   printf ("#include \"reload.h\"\n\n");
 436
 437   printf ("void\ninit_all_optabs (void)\n{\n");
 438
 439   puts ("\
 440 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 441   int i, j;\n\
 442 #endif\n");
 443
 444   /* Read the machine description.  */
 445
 446   while (1)
 447     {
 448       int line_no, insn_code_number = 0;
 449
 450       desc = read_md_rtx (&line_no, &insn_code_number);
 451       if (desc == NULL)
 452         break;
 453
 454       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 455         gen_insn (desc);
 456     }
 457
 458   puts ("\
 459 \n\
 460 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 461   /* This flag says the same insns that convert to a signed fixnum\n\
 462      also convert validly to an unsigned one.  */\n\
 463   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 464     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 465       ufixtrunc_optab->handlers[i][j].insn_code\n\
 466       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 467 #endif\n\
 468 }");
 469
 470   fflush (stdout);
 471   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 472 }