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 || mode_class[i] == MODE_FLOAT
 308                             || mode_class[i] == MODE_COMPLEX_FLOAT
 309                             || mode_class[i] == MODE_VECTOR_FLOAT))
 310                       break;
 311                   }
 312
 313                 if (i < 0)
 314                   matches = 0;
 315                 else if (*pp == 'a')
 316                   m1 = i, np += strlen (GET_MODE_NAME(i));
 317                 else
 318                   m2 = i, np += strlen (GET_MODE_NAME(i));
 319
 320                 force_int = force_partial_int = force_float = 0;
 321                 break;
 322
 323               default:
 324                 gcc_unreachable ();
 325               }
 326         }
 327
 328       if (matches && pp[0] == '$' && pp[1] == ')'
 329           && *np == 0
 330           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 331         break;
 332     }
 333
 334   if (pindex == ARRAY_SIZE (optabs))
 335     return;
 336
 337   /* We found a match.  If this pattern is only conditionally present,
 338      write out the "if" and two extra blanks.  */
 339
 340   if (*XSTR (insn, 2) != 0)
 341     printf ("  if (HAVE_%s)\n  ", name);
 342
 343   printf ("  ");
 344
 345   /* Now write out the initialization, making all required substitutions.  */
 346   for (pp = optabs[pindex]; *pp; pp++)
 347     {
 348       if (*pp != '$')
 349         putchar (*pp);
 350       else
 351         switch (*++pp)
 352           {
 353           case '(':  case ')':
 354           case 'I':  case 'F':  case 'N':
 355             break;
 356           case 'V':
 357             if (SCALAR_FLOAT_MODE_P (m1))
 358               printf ("v");
 359             break;
 360           case 'a':
 361             for (np = GET_MODE_NAME(m1); *np; np++)
 362               putchar (TOLOWER (*np));
 363             break;
 364           case 'b':
 365             for (np = GET_MODE_NAME(m2); *np; np++)
 366               putchar (TOLOWER (*np));
 367             break;
 368           case 'A':
 369             printf ("%smode", GET_MODE_NAME(m1));
 370             break;
 371           case 'B':
 372             printf ("%smode", GET_MODE_NAME(m2));
 373             break;
 374           case 'c':
 375             printf ("%s", GET_RTX_NAME(op));
 376             break;
 377           case 'C':
 378             for (np = GET_RTX_NAME(op); *np; np++)
 379               putchar (TOUPPER (*np));
 380             break;
 381           }
 382     }
 383
 384   printf (";\n");
 385 }
 386
 387 extern int main (int, char **);
 388
 389 int
 390 main (int argc, char **argv)
 391 {
 392   rtx desc;
 393
 394   progname = "genopinit";
 395
 396   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 397     return (FATAL_EXIT_CODE);
 398
 399   printf ("/* Generated automatically by the program `genopinit'\n\
 400 from the machine description file `md'.  */\n\n");
 401
 402   printf ("#include \"config.h\"\n");
 403   printf ("#include \"system.h\"\n");
 404   printf ("#include \"coretypes.h\"\n");
 405   printf ("#include \"tm.h\"\n");
 406   printf ("#include \"rtl.h\"\n");
 407   printf ("#include \"flags.h\"\n");
 408   printf ("#include \"insn-config.h\"\n");
 409   printf ("#include \"recog.h\"\n");
 410   printf ("#include \"expr.h\"\n");
 411   printf ("#include \"optabs.h\"\n");
 412   printf ("#include \"reload.h\"\n\n");
 413
 414   printf ("void\ninit_all_optabs (void)\n{\n");
 415
 416   puts ("\
 417 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 418   int i, j;\n\
 419 #endif\n");
 420
 421   /* Read the machine description.  */
 422
 423   while (1)
 424     {
 425       int line_no, insn_code_number = 0;
 426
 427       desc = read_md_rtx (&line_no, &insn_code_number);
 428       if (desc == NULL)
 429         break;
 430
 431       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 432         gen_insn (desc);
 433     }
 434
 435   puts ("\
 436 \n\
 437 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 438   /* This flag says the same insns that convert to a signed fixnum\n\
 439      also convert validly to an unsigned one.  */\n\
 440   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 441     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 442       ufixtrunc_optab->handlers[i][j].insn_code\n\
 443       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 444 #endif\n\
 445 }");
 446
 447   fflush (stdout);
 448   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 449 }
 450
 451 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 452 const char *
 453 get_insn_name (int code ATTRIBUTE_UNUSED)
 454 {
 455   return NULL;
 456 }