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