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 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   "drem_optab->handlers[$A].insn_code = CODE_FOR_$(drem$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   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 122   "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
 123   "lfloor_optab->handlers[$A].insn_code = CODE_FOR_$(lfloor$a2$)",
 124   "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
 125   "lceil_optab->handlers[$A].insn_code = CODE_FOR_$(lceil$a2$)",
 126   "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
 127   "btrunc_optab->handlers[$A].insn_code = CODE_FOR_$(btrunc$a2$)",
 128   "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
 129   "rint_optab->handlers[$A].insn_code = CODE_FOR_$(rint$a2$)",
 130   "lrint_optab->handlers[$A].insn_code = CODE_FOR_$(lrint$a2$)",
 131   "sincos_optab->handlers[$A].insn_code = CODE_FOR_$(sincos$a3$)",
 132   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 133   "asin_optab->handlers[$A].insn_code = CODE_FOR_$(asin$a2$)",
 134   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 135   "acos_optab->handlers[$A].insn_code = CODE_FOR_$(acos$a2$)",
 136   "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
 137   "exp10_optab->handlers[$A].insn_code = CODE_FOR_$(exp10$a2$)",
 138   "exp2_optab->handlers[$A].insn_code = CODE_FOR_$(exp2$a2$)",
 139   "expm1_optab->handlers[$A].insn_code = CODE_FOR_$(expm1$a2$)",
 140   "ldexp_optab->handlers[$A].insn_code = CODE_FOR_$(ldexp$a3$)",
 141   "logb_optab->handlers[$A].insn_code = CODE_FOR_$(logb$a2$)",
 142   "ilogb_optab->handlers[$A].insn_code = CODE_FOR_$(ilogb$a2$)",
 143   "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
 144   "log10_optab->handlers[$A].insn_code = CODE_FOR_$(log10$a2$)",
 145   "log2_optab->handlers[$A].insn_code = CODE_FOR_$(log2$a2$)",
 146   "log1p_optab->handlers[$A].insn_code = CODE_FOR_$(log1p$a2$)",
 147   "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
 148   "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
 149   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 150   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 151   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 152   "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
 153   "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
 154   "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
 155   "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
 156   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 157   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 158   "movmisalign_optab->handlers[$A].insn_code = CODE_FOR_$(movmisalign$a$)",
 159   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 160   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 161   "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
 162   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 163   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 164   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 165   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 166   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 167   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 168   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 169   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 170   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 171   "movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
 172   "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)",
 173   "cmpstrn_optab[$A] = CODE_FOR_$(cmpstrn$a$)",
 174   "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)",
 175   "setmem_optab[$A] = CODE_FOR_$(setmem$a$)",
 176   "sync_add_optab[$A] = CODE_FOR_$(sync_add$I$a$)",
 177   "sync_sub_optab[$A] = CODE_FOR_$(sync_sub$I$a$)",
 178   "sync_ior_optab[$A] = CODE_FOR_$(sync_ior$I$a$)",
 179   "sync_and_optab[$A] = CODE_FOR_$(sync_and$I$a$)",
 180   "sync_xor_optab[$A] = CODE_FOR_$(sync_xor$I$a$)",
 181   "sync_nand_optab[$A] = CODE_FOR_$(sync_nand$I$a$)",
 182   "sync_old_add_optab[$A] = CODE_FOR_$(sync_old_add$I$a$)",
 183   "sync_old_sub_optab[$A] = CODE_FOR_$(sync_old_sub$I$a$)",
 184   "sync_old_ior_optab[$A] = CODE_FOR_$(sync_old_ior$I$a$)",
 185   "sync_old_and_optab[$A] = CODE_FOR_$(sync_old_and$I$a$)",
 186   "sync_old_xor_optab[$A] = CODE_FOR_$(sync_old_xor$I$a$)",
 187   "sync_old_nand_optab[$A] = CODE_FOR_$(sync_old_nand$I$a$)",
 188   "sync_new_add_optab[$A] = CODE_FOR_$(sync_new_add$I$a$)",
 189   "sync_new_sub_optab[$A] = CODE_FOR_$(sync_new_sub$I$a$)",
 190   "sync_new_ior_optab[$A] = CODE_FOR_$(sync_new_ior$I$a$)",
 191   "sync_new_and_optab[$A] = CODE_FOR_$(sync_new_and$I$a$)",
 192   "sync_new_xor_optab[$A] = CODE_FOR_$(sync_new_xor$I$a$)",
 193   "sync_new_nand_optab[$A] = CODE_FOR_$(sync_new_nand$I$a$)",
 194   "sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)",
 195   "sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
 196   "sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
 197   "sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
 198   "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
 199   "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
 200   "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)",
 201   "vec_shl_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shl_$a$)",
 202   "vec_shr_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shr_$a$)",
 203   "vec_realign_load_optab->handlers[$A].insn_code = CODE_FOR_$(vec_realign_load_$a$)",
 204   "vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
 205   "vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
 206   "reduc_smax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smax_$a$)",
 207   "reduc_umax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umax_$a$)",
 208   "reduc_smin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smin_$a$)",
 209   "reduc_umin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umin_$a$)",
 210   "reduc_splus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
 211   "reduc_uplus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_uplus_$a$)"
 212 };
 213
 214 static void gen_insn (rtx);
 215
 216 static void
 217 gen_insn (rtx insn)
 218 {
 219   const char *name = XSTR (insn, 0);
 220   int m1 = 0, m2 = 0, op = 0;
 221   size_t pindex;
 222   int i;
 223   const char *np, *pp, *p, *q;
 224
 225   /* Don't mention instructions whose names are the null string.
 226      They are in the machine description just to be recognized.  */
 227   if (*name == 0)
 228     return;
 229
 230   /* See if NAME matches one of the patterns we have for the optabs we know
 231      about.  */
 232
 233   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 234     {
 235       int force_float = 0, force_int = 0, force_partial_int = 0;
 236       int force_consec = 0;
 237       int matches = 1;
 238
 239       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 240         ;
 241
 242       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 243            pp++)
 244         {
 245           if (*pp != '$')
 246             {
 247               if (*pp != *np++)
 248                 break;
 249             }
 250           else
 251             switch (*++pp)
 252               {
 253               case 'N':
 254                 force_consec = 1;
 255                 break;
 256               case 'I':
 257                 force_int = 1;
 258                 break;
 259               case 'P':
 260                 force_partial_int = 1;
 261                 break;
 262               case 'F':
 263                 force_float = 1;
 264                 break;
 265               case 'V':
 266                 break;
 267               case 'c':
 268                 for (op = 0; op < NUM_RTX_CODE; op++)
 269                   {
 270                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 271                       if (*p != *q)
 272                         break;
 273
 274                     /* We have to be concerned about matching "gt" and
 275                        missing "gtu", e.g., so verify we have reached the
 276                        end of thing we are to match.  */
 277                     if (*p == 0 && *q == 0
 278                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 279                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 280                       break;
 281                   }
 282
 283                 if (op == NUM_RTX_CODE)
 284                   matches = 0;
 285                 else
 286                   np += strlen (GET_RTX_NAME(op));
 287                 break;
 288               case 'a':
 289               case 'b':
 290                 /* This loop will stop at the first prefix match, so
 291                    look through the modes in reverse order, in case
 292                    there are extra CC modes and CC is a prefix of the
 293                    CC modes (as it should be).  */
 294                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 295                   {
 296                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 297                       if (TOLOWER (*p) != *q)
 298                         break;
 299
 300                     if (*p == 0
 301                         && (! force_int || mode_class[i] == MODE_INT
 302                             || mode_class[i] == MODE_VECTOR_INT)
 303                         && (! force_partial_int
 304                             || mode_class[i] == MODE_INT
 305                             || mode_class[i] == MODE_PARTIAL_INT
 306                             || mode_class[i] == MODE_VECTOR_INT)
 307                         && (! force_float
 308                             || mode_class[i] == MODE_FLOAT
 309                             || mode_class[i] == MODE_DECIMAL_FLOAT
 310                             || mode_class[i] == MODE_COMPLEX_FLOAT
 311                             || mode_class[i] == MODE_VECTOR_FLOAT))
 312                       break;
 313                   }
 314
 315                 if (i < 0)
 316                   matches = 0;
 317                 else if (*pp == 'a')
 318                   m1 = i, np += strlen (GET_MODE_NAME(i));
 319                 else
 320                   m2 = i, np += strlen (GET_MODE_NAME(i));
 321
 322                 force_int = force_partial_int = force_float = 0;
 323                 break;
 324
 325               default:
 326                 gcc_unreachable ();
 327               }
 328         }
 329
 330       if (matches && pp[0] == '$' && pp[1] == ')'
 331           && *np == 0
 332           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 333         break;
 334     }
 335
 336   if (pindex == ARRAY_SIZE (optabs))
 337     return;
 338
 339   /* We found a match.  If this pattern is only conditionally present,
 340      write out the "if" and two extra blanks.  */
 341
 342   if (*XSTR (insn, 2) != 0)
 343     printf ("  if (HAVE_%s)\n  ", name);
 344
 345   printf ("  ");
 346
 347   /* Now write out the initialization, making all required substitutions.  */
 348   for (pp = optabs[pindex]; *pp; pp++)
 349     {
 350       if (*pp != '$')
 351         putchar (*pp);
 352       else
 353         switch (*++pp)
 354           {
 355           case '(':  case ')':
 356           case 'I':  case 'F':  case 'N':
 357             break;
 358           case 'V':
 359             if (SCALAR_FLOAT_MODE_P (m1))
 360               printf ("v");
 361             break;
 362           case 'a':
 363             for (np = GET_MODE_NAME(m1); *np; np++)
 364               putchar (TOLOWER (*np));
 365             break;
 366           case 'b':
 367             for (np = GET_MODE_NAME(m2); *np; np++)
 368               putchar (TOLOWER (*np));
 369             break;
 370           case 'A':
 371             printf ("%smode", GET_MODE_NAME(m1));
 372             break;
 373           case 'B':
 374             printf ("%smode", GET_MODE_NAME(m2));
 375             break;
 376           case 'c':
 377             printf ("%s", GET_RTX_NAME(op));
 378             break;
 379           case 'C':
 380             for (np = GET_RTX_NAME(op); *np; np++)
 381               putchar (TOUPPER (*np));
 382             break;
 383           }
 384     }
 385
 386   printf (";\n");
 387 }
 388
 389 extern int main (int, char **);
 390
 391 int
 392 main (int argc, char **argv)
 393 {
 394   rtx desc;
 395
 396   progname = "genopinit";
 397
 398   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 399     return (FATAL_EXIT_CODE);
 400
 401   printf ("/* Generated automatically by the program `genopinit'\n\
 402 from the machine description file `md'.  */\n\n");
 403
 404   printf ("#include \"config.h\"\n");
 405   printf ("#include \"system.h\"\n");
 406   printf ("#include \"coretypes.h\"\n");
 407   printf ("#include \"tm.h\"\n");
 408   printf ("#include \"rtl.h\"\n");
 409   printf ("#include \"flags.h\"\n");
 410   printf ("#include \"insn-config.h\"\n");
 411   printf ("#include \"recog.h\"\n");
 412   printf ("#include \"expr.h\"\n");
 413   printf ("#include \"optabs.h\"\n");
 414   printf ("#include \"reload.h\"\n\n");
 415
 416   printf ("void\ninit_all_optabs (void)\n{\n");
 417
 418   puts ("\
 419 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 420   int i, j;\n\
 421 #endif\n");
 422
 423   /* Read the machine description.  */
 424
 425   while (1)
 426     {
 427       int line_no, insn_code_number = 0;
 428
 429       desc = read_md_rtx (&line_no, &insn_code_number);
 430       if (desc == NULL)
 431         break;
 432
 433       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 434         gen_insn (desc);
 435     }
 436
 437   puts ("\
 438 \n\
 439 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 440   /* This flag says the same insns that convert to a signed fixnum\n\
 441      also convert validly to an unsigned one.  */\n\
 442   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 443     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 444       ufixtrunc_optab->handlers[i][j].insn_code\n\
 445       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 446 #endif\n\
 447 }");
 448
 449   fflush (stdout);
 450   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 451 }
 452
 453 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 454 const char *
 455 get_insn_name (int code ATTRIBUTE_UNUSED)
 456 {
 457   return NULL;
 458 }