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, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, 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   "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   "clrmem_optab[$A] = CODE_FOR_$(clrmem$a$)",
 172   "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)",
 173   "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)",
 174   "sync_add_optab[$A] = CODE_FOR_$(sync_add$I$a$)",
 175   "sync_sub_optab[$A] = CODE_FOR_$(sync_sub$I$a$)",
 176   "sync_ior_optab[$A] = CODE_FOR_$(sync_ior$I$a$)",
 177   "sync_and_optab[$A] = CODE_FOR_$(sync_and$I$a$)",
 178   "sync_xor_optab[$A] = CODE_FOR_$(sync_xor$I$a$)",
 179   "sync_nand_optab[$A] = CODE_FOR_$(sync_nand$I$a$)",
 180   "sync_old_add_optab[$A] = CODE_FOR_$(sync_old_add$I$a$)",
 181   "sync_old_sub_optab[$A] = CODE_FOR_$(sync_old_sub$I$a$)",
 182   "sync_old_ior_optab[$A] = CODE_FOR_$(sync_old_ior$I$a$)",
 183   "sync_old_and_optab[$A] = CODE_FOR_$(sync_old_and$I$a$)",
 184   "sync_old_xor_optab[$A] = CODE_FOR_$(sync_old_xor$I$a$)",
 185   "sync_old_nand_optab[$A] = CODE_FOR_$(sync_old_nand$I$a$)",
 186   "sync_new_add_optab[$A] = CODE_FOR_$(sync_new_add$I$a$)",
 187   "sync_new_sub_optab[$A] = CODE_FOR_$(sync_new_sub$I$a$)",
 188   "sync_new_ior_optab[$A] = CODE_FOR_$(sync_new_ior$I$a$)",
 189   "sync_new_and_optab[$A] = CODE_FOR_$(sync_new_and$I$a$)",
 190   "sync_new_xor_optab[$A] = CODE_FOR_$(sync_new_xor$I$a$)",
 191   "sync_new_nand_optab[$A] = CODE_FOR_$(sync_new_nand$I$a$)",
 192   "sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)",
 193   "sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
 194   "sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
 195   "sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
 196   "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
 197   "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
 198   "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)",
 199   "vec_shl_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shl_$a$)",
 200   "vec_shr_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shr_$a$)",
 201   "vec_realign_load_optab->handlers[$A].insn_code = CODE_FOR_$(vec_realign_load_$a$)",
 202   "vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
 203   "vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
 204   "reduc_smax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smax_$a$)",
 205   "reduc_umax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umax_$a$)",
 206   "reduc_smin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smin_$a$)",
 207   "reduc_umin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umin_$a$)",
 208   "reduc_splus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
 209   "reduc_uplus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_uplus_$a$)"
 210 };
 211
 212 static void gen_insn (rtx);
 213
 214 static void
 215 gen_insn (rtx insn)
 216 {
 217   const char *name = XSTR (insn, 0);
 218   int m1 = 0, m2 = 0, op = 0;
 219   size_t pindex;
 220   int i;
 221   const char *np, *pp, *p, *q;
 222
 223   /* Don't mention instructions whose names are the null string.
 224      They are in the machine description just to be recognized.  */
 225   if (*name == 0)
 226     return;
 227
 228   /* See if NAME matches one of the patterns we have for the optabs we know
 229      about.  */
 230
 231   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 232     {
 233       int force_float = 0, force_int = 0, force_partial_int = 0;
 234       int force_consec = 0;
 235       int matches = 1;
 236
 237       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 238         ;
 239
 240       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 241            pp++)
 242         {
 243           if (*pp != '$')
 244             {
 245               if (*pp != *np++)
 246                 break;
 247             }
 248           else
 249             switch (*++pp)
 250               {
 251               case 'N':
 252                 force_consec = 1;
 253                 break;
 254               case 'I':
 255                 force_int = 1;
 256                 break;
 257               case 'P':
 258                 force_partial_int = 1;
 259                 break;
 260               case 'F':
 261                 force_float = 1;
 262                 break;
 263               case 'V':
 264                 break;
 265               case 'c':
 266                 for (op = 0; op < NUM_RTX_CODE; op++)
 267                   {
 268                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 269                       if (*p != *q)
 270                         break;
 271
 272                     /* We have to be concerned about matching "gt" and
 273                        missing "gtu", e.g., so verify we have reached the
 274                        end of thing we are to match.  */
 275                     if (*p == 0 && *q == 0
 276                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 277                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 278                       break;
 279                   }
 280
 281                 if (op == NUM_RTX_CODE)
 282                   matches = 0;
 283                 else
 284                   np += strlen (GET_RTX_NAME(op));
 285                 break;
 286               case 'a':
 287               case 'b':
 288                 /* This loop will stop at the first prefix match, so
 289                    look through the modes in reverse order, in case
 290                    there are extra CC modes and CC is a prefix of the
 291                    CC modes (as it should be).  */
 292                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 293                   {
 294                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 295                       if (TOLOWER (*p) != *q)
 296                         break;
 297
 298                     if (*p == 0
 299                         && (! force_int || mode_class[i] == MODE_INT
 300                             || mode_class[i] == MODE_VECTOR_INT)
 301                         && (! force_partial_int
 302                             || mode_class[i] == MODE_INT
 303                             || mode_class[i] == MODE_PARTIAL_INT
 304                             || mode_class[i] == MODE_VECTOR_INT)
 305                         && (! force_float || mode_class[i] == MODE_FLOAT
 306                             || mode_class[i] == MODE_COMPLEX_FLOAT
 307                             || mode_class[i] == MODE_VECTOR_FLOAT))
 308                       break;
 309                   }
 310
 311                 if (i < 0)
 312                   matches = 0;
 313                 else if (*pp == 'a')
 314                   m1 = i, np += strlen (GET_MODE_NAME(i));
 315                 else
 316                   m2 = i, np += strlen (GET_MODE_NAME(i));
 317
 318                 force_int = force_partial_int = force_float = 0;
 319                 break;
 320
 321               default:
 322                 gcc_unreachable ();
 323               }
 324         }
 325
 326       if (matches && pp[0] == '$' && pp[1] == ')'
 327           && *np == 0
 328           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 329         break;
 330     }
 331
 332   if (pindex == ARRAY_SIZE (optabs))
 333     return;
 334
 335   /* We found a match.  If this pattern is only conditionally present,
 336      write out the "if" and two extra blanks.  */
 337
 338   if (*XSTR (insn, 2) != 0)
 339     printf ("  if (HAVE_%s)\n  ", name);
 340
 341   printf ("  ");
 342
 343   /* Now write out the initialization, making all required substitutions.  */
 344   for (pp = optabs[pindex]; *pp; pp++)
 345     {
 346       if (*pp != '$')
 347         putchar (*pp);
 348       else
 349         switch (*++pp)
 350           {
 351           case '(':  case ')':
 352           case 'I':  case 'F':  case 'N':
 353             break;
 354           case 'V':
 355             if (GET_MODE_CLASS (m1) == MODE_FLOAT)
 356               printf ("v");
 357             break;
 358           case 'a':
 359             for (np = GET_MODE_NAME(m1); *np; np++)
 360               putchar (TOLOWER (*np));
 361             break;
 362           case 'b':
 363             for (np = GET_MODE_NAME(m2); *np; np++)
 364               putchar (TOLOWER (*np));
 365             break;
 366           case 'A':
 367             printf ("%smode", GET_MODE_NAME(m1));
 368             break;
 369           case 'B':
 370             printf ("%smode", GET_MODE_NAME(m2));
 371             break;
 372           case 'c':
 373             printf ("%s", GET_RTX_NAME(op));
 374             break;
 375           case 'C':
 376             for (np = GET_RTX_NAME(op); *np; np++)
 377               putchar (TOUPPER (*np));
 378             break;
 379           }
 380     }
 381
 382   printf (";\n");
 383 }
 384
 385 extern int main (int, char **);
 386
 387 int
 388 main (int argc, char **argv)
 389 {
 390   rtx desc;
 391
 392   progname = "genopinit";
 393
 394   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 395     return (FATAL_EXIT_CODE);
 396
 397   printf ("/* Generated automatically by the program `genopinit'\n\
 398 from the machine description file `md'.  */\n\n");
 399
 400   printf ("#include \"config.h\"\n");
 401   printf ("#include \"system.h\"\n");
 402   printf ("#include \"coretypes.h\"\n");
 403   printf ("#include \"tm.h\"\n");
 404   printf ("#include \"rtl.h\"\n");
 405   printf ("#include \"flags.h\"\n");
 406   printf ("#include \"insn-config.h\"\n");
 407   printf ("#include \"recog.h\"\n");
 408   printf ("#include \"expr.h\"\n");
 409   printf ("#include \"optabs.h\"\n");
 410   printf ("#include \"reload.h\"\n\n");
 411
 412   printf ("void\ninit_all_optabs (void)\n{\n");
 413
 414   puts ("\
 415 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 416   int i, j;\n\
 417 #endif\n");
 418
 419   /* Read the machine description.  */
 420
 421   while (1)
 422     {
 423       int line_no, insn_code_number = 0;
 424
 425       desc = read_md_rtx (&line_no, &insn_code_number);
 426       if (desc == NULL)
 427         break;
 428
 429       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 430         gen_insn (desc);
 431     }
 432
 433   puts ("\
 434 \n\
 435 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 436   /* This flag says the same insns that convert to a signed fixnum\n\
 437      also convert validly to an unsigned one.  */\n\
 438   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 439     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 440       ufixtrunc_optab->handlers[i][j].insn_code\n\
 441       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 442 #endif\n\
 443 }");
 444
 445   fflush (stdout);
 446   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 447 }
 448
 449 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 450 const char *
 451 get_insn_name (int code ATTRIBUTE_UNUSED)
 452 {
 453   return NULL;
 454 }