gcc/genemit.c

   1 /* Generate code from machine description to emit insns as rtl.
   2    Copyright (C) 1987-2019 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include "bconfig.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "rtl.h"
  26 #include "errors.h"
  27 #include "read-md.h"
  28 #include "gensupport.h"
  29
  30
  31 /* Data structure for recording the patterns of insns that have CLOBBERs.
  32    We use this to output a function that adds these CLOBBERs to a
  33    previously-allocated PARALLEL expression.  */
  34
  35 struct clobber_pat
  36 {
  37   struct clobber_ent *insns;
  38   rtx pattern;
  39   int first_clobber;
  40   struct clobber_pat *next;
  41   int has_hard_reg;
  42 } *clobber_list;
  43
  44 /* Records one insn that uses the clobber list.  */
  45
  46 struct clobber_ent
  47 {
  48   int code_number;              /* Counts only insns.  */
  49   struct clobber_ent *next;
  50 };
  51
  52 static void output_peephole2_scratches  (rtx);
  53
  54 /* True for <X>_optab if that optab isn't allowed to fail.  */
  55 static bool nofail_optabs[NUM_OPTABS];
  56 \f
  57 static void
  58 print_code (RTX_CODE code)
  59 {
  60   const char *p1;
  61   for (p1 = GET_RTX_NAME (code); *p1; p1++)
  62     putchar (TOUPPER (*p1));
  63 }
  64
  65 static void
  66 gen_rtx_scratch (rtx x, enum rtx_code subroutine_type)
  67 {
  68   if (subroutine_type == DEFINE_PEEPHOLE2)
  69     {
  70       printf ("operand%d", XINT (x, 0));
  71     }
  72   else
  73     {
  74       printf ("gen_rtx_SCRATCH (%smode)", GET_MODE_NAME (GET_MODE (x)));
  75     }
  76 }
  77
  78 /* Print a C expression to construct an RTX just like X,
  79    substituting any operand references appearing within.  */
  80
  81 static void
  82 gen_exp (rtx x, enum rtx_code subroutine_type, char *used, md_rtx_info *info)
  83 {
  84   RTX_CODE code;
  85   int i;
  86   int len;
  87   const char *fmt;
  88   const char *sep = "";
  89
  90   if (x == 0)
  91     {
  92       printf ("NULL_RTX");
  93       return;
  94     }
  95
  96   code = GET_CODE (x);
  97
  98   switch (code)
  99     {
 100     case MATCH_OPERAND:
 101     case MATCH_DUP:
 102       if (used)
 103         {
 104           if (used[XINT (x, 0)])
 105             {
 106               printf ("copy_rtx (operand%d)", XINT (x, 0));
 107               return;
 108             }
 109           used[XINT (x, 0)] = 1;
 110         }
 111       printf ("operand%d", XINT (x, 0));
 112       return;
 113
 114     case MATCH_OP_DUP:
 115       printf ("gen_rtx_fmt_");
 116       for (i = 0; i < XVECLEN (x, 1); i++)
 117         printf ("e");
 118       printf (" (GET_CODE (operand%d), ", XINT (x, 0));
 119       if (GET_MODE (x) == VOIDmode)
 120         printf ("GET_MODE (operand%d)", XINT (x, 0));
 121       else
 122         printf ("%smode", GET_MODE_NAME (GET_MODE (x)));
 123       for (i = 0; i < XVECLEN (x, 1); i++)
 124         {
 125           printf (",\n\t\t");
 126           gen_exp (XVECEXP (x, 1, i), subroutine_type, used, info);
 127         }
 128       printf (")");
 129       return;
 130
 131     case MATCH_OPERATOR:
 132       printf ("gen_rtx_fmt_");
 133       for (i = 0; i < XVECLEN (x, 2); i++)
 134         printf ("e");
 135       printf (" (GET_CODE (operand%d)", XINT (x, 0));
 136       printf (", %smode", GET_MODE_NAME (GET_MODE (x)));
 137       for (i = 0; i < XVECLEN (x, 2); i++)
 138         {
 139           printf (",\n\t\t");
 140           gen_exp (XVECEXP (x, 2, i), subroutine_type, used, info);
 141         }
 142       printf (")");
 143       return;
 144
 145     case MATCH_PARALLEL:
 146     case MATCH_PAR_DUP:
 147       printf ("operand%d", XINT (x, 0));
 148       return;
 149
 150     case MATCH_SCRATCH:
 151       gen_rtx_scratch (x, subroutine_type);
 152       return;
 153
 154     case PC:
 155       printf ("pc_rtx");
 156       return;
 157     case RETURN:
 158       printf ("ret_rtx");
 159       return;
 160     case SIMPLE_RETURN:
 161       printf ("simple_return_rtx");
 162       return;
 163     case CLOBBER:
 164       if (REG_P (XEXP (x, 0)))
 165         {
 166           printf ("gen_hard_reg_clobber (%smode, %i)",
 167                   GET_MODE_NAME (GET_MODE (XEXP (x, 0))),
 168                   REGNO (XEXP (x, 0)));
 169           return;
 170         }
 171       break;
 172     case CLOBBER_HIGH:
 173       if (!REG_P (XEXP (x, 0)))
 174         error ("CLOBBER_HIGH argument is not a register expr, at %s:%d",
 175                info->loc.filename, info->loc.lineno);
 176       printf ("gen_hard_reg_clobber_high (%smode, %i)",
 177               GET_MODE_NAME (GET_MODE (XEXP (x, 0))),
 178               REGNO (XEXP (x, 0)));
 179       return;
 180       break;
 181     case CC0:
 182       printf ("cc0_rtx");
 183       return;
 184
 185     case CONST_INT:
 186       if (INTVAL (x) == 0)
 187         printf ("const0_rtx");
 188       else if (INTVAL (x) == 1)
 189         printf ("const1_rtx");
 190       else if (INTVAL (x) == -1)
 191         printf ("constm1_rtx");
 192       else if (-MAX_SAVED_CONST_INT <= INTVAL (x)
 193                && INTVAL (x) <= MAX_SAVED_CONST_INT)
 194         printf ("const_int_rtx[MAX_SAVED_CONST_INT + (%d)]",
 195                 (int) INTVAL (x));
 196       else if (INTVAL (x) == STORE_FLAG_VALUE)
 197         printf ("const_true_rtx");
 198       else
 199         {
 200           printf ("GEN_INT (");
 201           printf (HOST_WIDE_INT_PRINT_DEC_C, INTVAL (x));
 202           printf (")");
 203         }
 204       return;
 205
 206     case CONST_DOUBLE:
 207     case CONST_FIXED:
 208     case CONST_WIDE_INT:
 209       /* These shouldn't be written in MD files.  Instead, the appropriate
 210          routines in varasm.c should be called.  */
 211       gcc_unreachable ();
 212
 213     default:
 214       break;
 215     }
 216
 217   printf ("gen_rtx_");
 218   print_code (code);
 219   printf (" (");
 220   if (!always_void_p (code))
 221     {
 222       printf ("%smode", GET_MODE_NAME (GET_MODE (x)));
 223       sep = ",\n\t";
 224     }
 225
 226   fmt = GET_RTX_FORMAT (code);
 227   len = GET_RTX_LENGTH (code);
 228   for (i = 0; i < len; i++)
 229     {
 230       if (fmt[i] == '0')
 231         break;
 232       fputs (sep, stdout);
 233       switch (fmt[i])
 234         {
 235         case 'e': case 'u':
 236           gen_exp (XEXP (x, i), subroutine_type, used, info);
 237           break;
 238
 239         case 'i':
 240           printf ("%u", XINT (x, i));
 241           break;
 242
 243         case 'r':
 244           printf ("%u", REGNO (x));
 245           break;
 246
 247         case 'p':
 248           /* We don't have a way of parsing polynomial offsets yet,
 249              and hopefully never will.  */
 250           printf ("%d", SUBREG_BYTE (x).to_constant ());
 251           break;
 252
 253         case 's':
 254           printf ("\"%s\"", XSTR (x, i));
 255           break;
 256
 257         case 'E':
 258           {
 259             int j;
 260             printf ("gen_rtvec (%d", XVECLEN (x, i));
 261             for (j = 0; j < XVECLEN (x, i); j++)
 262               {
 263                 printf (",\n\t\t");
 264                 gen_exp (XVECEXP (x, i, j), subroutine_type, used, info);
 265               }
 266             printf (")");
 267             break;
 268           }
 269
 270         default:
 271           gcc_unreachable ();
 272         }
 273       sep = ",\n\t";
 274     }
 275   printf (")");
 276 }
 277
 278 /* Output code to emit the instruction patterns in VEC, with each element
 279    becoming a separate instruction.  USED is as for gen_exp.  */
 280
 281 static void
 282 gen_emit_seq (rtvec vec, char *used, md_rtx_info *info)
 283 {
 284   for (int i = 0, len = GET_NUM_ELEM (vec); i < len; ++i)
 285     {
 286       bool last_p = (i == len - 1);
 287       rtx next = RTVEC_ELT (vec, i);
 288       if (const char *name = get_emit_function (next))
 289         {
 290           printf ("  %s (", name);
 291           gen_exp (next, DEFINE_EXPAND, used, info);
 292           printf (");\n");
 293           if (!last_p && needs_barrier_p (next))
 294             printf ("  emit_barrier ();");
 295         }
 296       else
 297         {
 298           printf ("  emit (");
 299           gen_exp (next, DEFINE_EXPAND, used, info);
 300           printf (", %s);\n", last_p ? "false" : "true");
 301         }
 302     }
 303 }
 304 \f
 305 /* Emit the given C code to the output file.  The code is allowed to
 306    fail if CAN_FAIL_P.  NAME describes what we're generating,
 307    for use in error messages.  */
 308
 309 static void
 310 emit_c_code (const char *code, bool can_fail_p, const char *name)
 311 {
 312   if (can_fail_p)
 313     printf ("#define FAIL return (end_sequence (), _val)\n");
 314   else
 315     printf ("#define FAIL _Pragma (\"GCC error \\\"%s cannot FAIL\\\"\")"
 316             " (void)0\n", name);
 317   printf ("#define DONE return (_val = get_insns (),"
 318           "end_sequence (), _val)\n");
 319
 320   rtx_reader_ptr->print_md_ptr_loc (code);
 321   printf ("%s\n", code);
 322
 323   printf ("#undef DONE\n");
 324   printf ("#undef FAIL\n");
 325 }
 326 \f
 327 /* Generate the `gen_...' function for a DEFINE_INSN.  */
 328
 329 static void
 330 gen_insn (md_rtx_info *info)
 331 {
 332   struct pattern_stats stats;
 333   int i;
 334
 335   /* See if the pattern for this insn ends with a group of CLOBBERs of (hard)
 336      registers or MATCH_SCRATCHes.  If so, store away the information for
 337      later.  */
 338
 339   rtx insn = info->def;
 340   if (XVEC (insn, 1))
 341     {
 342       int has_hard_reg = 0;
 343
 344       for (i = XVECLEN (insn, 1) - 1; i > 0; i--)
 345         {
 346           if (GET_CODE (XVECEXP (insn, 1, i)) != CLOBBER
 347               && GET_CODE (XVECEXP (insn, 1, i)) != CLOBBER_HIGH)
 348             break;
 349
 350           if (REG_P (XEXP (XVECEXP (insn, 1, i), 0)))
 351             has_hard_reg = 1;
 352           else if (GET_CODE (XEXP (XVECEXP (insn, 1, i), 0)) != MATCH_SCRATCH)
 353             break;
 354         }
 355
 356       if (i != XVECLEN (insn, 1) - 1)
 357         {
 358           struct clobber_pat *p;
 359           struct clobber_ent *link = XNEW (struct clobber_ent);
 360           int j;
 361
 362           link->code_number = info->index;
 363
 364           /* See if any previous CLOBBER_LIST entry is the same as this
 365              one.  */
 366
 367           for (p = clobber_list; p; p = p->next)
 368             {
 369               if (p->first_clobber != i + 1
 370                   || XVECLEN (p->pattern, 1) != XVECLEN (insn, 1))
 371                 continue;
 372
 373               for (j = i + 1; j < XVECLEN (insn, 1); j++)
 374                 {
 375                   rtx old_rtx = XEXP (XVECEXP (p->pattern, 1, j), 0);
 376                   rtx new_rtx = XEXP (XVECEXP (insn, 1, j), 0);
 377
 378                   /* OLD and NEW_INSN are the same if both are to be a SCRATCH
 379                      of the same mode,
 380                      or if both are registers of the same mode and number.  */
 381                   if (! (GET_CODE (old_rtx) == GET_CODE (new_rtx)
 382                          && GET_MODE (old_rtx) == GET_MODE (new_rtx)
 383                          && ((GET_CODE (old_rtx) == MATCH_SCRATCH
 384                               && GET_CODE (new_rtx) == MATCH_SCRATCH)
 385                              || (REG_P (old_rtx) && REG_P (new_rtx)
 386                                  && REGNO (old_rtx) == REGNO (new_rtx)))))
 387                     break;
 388                 }
 389
 390               if (j == XVECLEN (insn, 1))
 391                 break;
 392             }
 393
 394           if (p == 0)
 395             {
 396               p = XNEW (struct clobber_pat);
 397
 398               p->insns = 0;
 399               p->pattern = insn;
 400               p->first_clobber = i + 1;
 401               p->next = clobber_list;
 402               p->has_hard_reg = has_hard_reg;
 403               clobber_list = p;
 404             }
 405
 406           link->next = p->insns;
 407           p->insns = link;
 408         }
 409     }
 410
 411   /* Don't mention instructions whose names are the null string
 412      or begin with '*'.  They are in the machine description just
 413      to be recognized.  */
 414   if (XSTR (insn, 0)[0] == 0 || XSTR (insn, 0)[0] == '*')
 415     return;
 416
 417   printf ("/* %s:%d */\n", info->loc.filename, info->loc.lineno);
 418
 419   /* Find out how many operands this function has.  */
 420   get_pattern_stats (&stats, XVEC (insn, 1));
 421   if (stats.max_dup_opno > stats.max_opno)
 422     fatal_at (info->loc, "match_dup operand number has no match_operand");
 423
 424   /* Output the function name and argument declarations.  */
 425   printf ("rtx\ngen_%s (", XSTR (insn, 0));
 426   if (stats.num_generator_args)
 427     for (i = 0; i < stats.num_generator_args; i++)
 428       if (i)
 429         printf (",\n\trtx operand%d ATTRIBUTE_UNUSED", i);
 430       else
 431         printf ("rtx operand%d ATTRIBUTE_UNUSED", i);
 432   else
 433     printf ("void");
 434   printf (")\n");
 435   printf ("{\n");
 436
 437   /* Output code to construct and return the rtl for the instruction body.  */
 438
 439   rtx pattern = add_implicit_parallel (XVEC (insn, 1));
 440   /* ??? This is the traditional behavior, but seems suspect.  */
 441   char *used = (XVECLEN (insn, 1) == 1
 442                 ? NULL
 443                 : XCNEWVEC (char, stats.num_generator_args));
 444   printf ("  return ");
 445   gen_exp (pattern, DEFINE_INSN, used, info);
 446   printf (";\n}\n\n");
 447   XDELETEVEC (used);
 448 }
 449 \f
 450 /* Generate the `gen_...' function for a DEFINE_EXPAND.  */
 451
 452 static void
 453 gen_expand (md_rtx_info *info)
 454 {
 455   struct pattern_stats stats;
 456   int i;
 457   char *used;
 458
 459   rtx expand = info->def;
 460   if (strlen (XSTR (expand, 0)) == 0)
 461     fatal_at (info->loc, "define_expand lacks a name");
 462   if (XVEC (expand, 1) == 0)
 463     fatal_at (info->loc, "define_expand for %s lacks a pattern",
 464               XSTR (expand, 0));
 465
 466   /* Find out how many operands this function has.  */
 467   get_pattern_stats (&stats, XVEC (expand, 1));
 468   if (stats.min_scratch_opno != -1
 469       && stats.min_scratch_opno <= MAX (stats.max_opno, stats.max_dup_opno))
 470     fatal_at (info->loc, "define_expand for %s needs to have match_scratch "
 471                          "numbers above all other operands", XSTR (expand, 0));
 472
 473   /* Output the function name and argument declarations.  */
 474   printf ("rtx\ngen_%s (", XSTR (expand, 0));
 475   if (stats.num_generator_args)
 476     for (i = 0; i < stats.num_generator_args; i++)
 477       if (i)
 478         printf (",\n\trtx operand%d", i);
 479       else
 480         printf ("rtx operand%d", i);
 481   else
 482     printf ("void");
 483   printf (")\n");
 484   printf ("{\n");
 485
 486   /* If we don't have any C code to write, only one insn is being written,
 487      and no MATCH_DUPs are present, we can just return the desired insn
 488      like we do for a DEFINE_INSN.  This saves memory.  */
 489   if ((XSTR (expand, 3) == 0 || *XSTR (expand, 3) == '\0')
 490       && stats.max_opno >= stats.max_dup_opno
 491       && XVECLEN (expand, 1) == 1)
 492     {
 493       printf ("  return ");
 494       gen_exp (XVECEXP (expand, 1, 0), DEFINE_EXPAND, NULL, info);
 495       printf (";\n}\n\n");
 496       return;
 497     }
 498
 499   /* For each operand referred to only with MATCH_DUPs,
 500      make a local variable.  */
 501   for (i = stats.num_generator_args; i <= stats.max_dup_opno; i++)
 502     printf ("  rtx operand%d;\n", i);
 503   printf ("  rtx_insn *_val = 0;\n");
 504   printf ("  start_sequence ();\n");
 505
 506   /* The fourth operand of DEFINE_EXPAND is some code to be executed
 507      before the actual construction.
 508      This code expects to refer to `operands'
 509      just as the output-code in a DEFINE_INSN does,
 510      but here `operands' is an automatic array.
 511      So copy the operand values there before executing it.  */
 512   if (XSTR (expand, 3) && *XSTR (expand, 3))
 513     {
 514       printf ("  {\n");
 515       if (stats.num_operand_vars > 0)
 516         printf ("    rtx operands[%d];\n", stats.num_operand_vars);
 517
 518       /* Output code to copy the arguments into `operands'.  */
 519       for (i = 0; i < stats.num_generator_args; i++)
 520         printf ("    operands[%d] = operand%d;\n", i, i);
 521
 522       /* Output the special code to be executed before the sequence
 523          is generated.  */
 524       optab_pattern p;
 525       bool can_fail_p = true;
 526       if (find_optab (&p, XSTR (expand, 0)))
 527         {
 528           gcc_assert (p.op < NUM_OPTABS);
 529           if (nofail_optabs[p.op])
 530             can_fail_p = false;
 531         }
 532       emit_c_code (XSTR (expand, 3), can_fail_p, XSTR (expand, 0));
 533
 534       /* Output code to copy the arguments back out of `operands'
 535          (unless we aren't going to use them at all).  */
 536       if (XVEC (expand, 1) != 0)
 537         {
 538           for (i = 0; i <= MAX (stats.max_opno, stats.max_dup_opno); i++)
 539             {
 540               printf ("    operand%d = operands[%d];\n", i, i);
 541               printf ("    (void) operand%d;\n", i);
 542             }
 543         }
 544       printf ("  }\n");
 545     }
 546
 547   used = XCNEWVEC (char, stats.num_operand_vars);
 548   gen_emit_seq (XVEC (expand, 1), used, info);
 549   XDELETEVEC (used);
 550
 551   /* Call `get_insns' to extract the list of all the
 552      insns emitted within this gen_... function.  */
 553
 554   printf ("  _val = get_insns ();\n");
 555   printf ("  end_sequence ();\n");
 556   printf ("  return _val;\n}\n\n");
 557 }
 558
 559 /* Like gen_expand, but generates insns resulting from splitting SPLIT.  */
 560
 561 static void
 562 gen_split (md_rtx_info *info)
 563 {
 564   struct pattern_stats stats;
 565   int i;
 566   rtx split = info->def;
 567   const char *const name =
 568     ((GET_CODE (split) == DEFINE_PEEPHOLE2) ? "peephole2" : "split");
 569   const char *unused;
 570   char *used;
 571
 572   if (XVEC (split, 0) == 0)
 573     fatal_at (info->loc, "%s lacks a pattern",
 574               GET_RTX_NAME (GET_CODE (split)));
 575   else if (XVEC (split, 2) == 0)
 576     fatal_at (info->loc, "%s lacks a replacement pattern",
 577               GET_RTX_NAME (GET_CODE (split)));
 578
 579   /* Find out how many operands this function has.  */
 580
 581   get_pattern_stats (&stats, XVEC (split, 2));
 582   unused = (stats.num_operand_vars == 0 ? " ATTRIBUTE_UNUSED" : "");
 583   used = XCNEWVEC (char, stats.num_operand_vars);
 584
 585   /* Output the prototype, function name and argument declarations.  */
 586   if (GET_CODE (split) == DEFINE_PEEPHOLE2)
 587     {
 588       printf ("extern rtx_insn *gen_%s_%d (rtx_insn *, rtx *);\n",
 589               name, info->index);
 590       printf ("rtx_insn *\ngen_%s_%d (rtx_insn *curr_insn ATTRIBUTE_UNUSED,"
 591               " rtx *operands%s)\n",
 592               name, info->index, unused);
 593     }
 594   else
 595     {
 596       printf ("extern rtx_insn *gen_split_%d (rtx_insn *, rtx *);\n",
 597               info->index);
 598       printf ("rtx_insn *\ngen_split_%d "
 599               "(rtx_insn *curr_insn ATTRIBUTE_UNUSED, rtx *operands%s)\n",
 600               info->index, unused);
 601     }
 602   printf ("{\n");
 603
 604   /* Declare all local variables.  */
 605   for (i = 0; i < stats.num_operand_vars; i++)
 606     printf ("  rtx operand%d;\n", i);
 607   printf ("  rtx_insn *_val = NULL;\n");
 608
 609   if (GET_CODE (split) == DEFINE_PEEPHOLE2)
 610     output_peephole2_scratches (split);
 611
 612   const char *fn = info->loc.filename;
 613   for (const char *p = fn; *p; p++)
 614     if (*p == '/')
 615       fn = p + 1;
 616
 617   printf ("  if (dump_file)\n");
 618   printf ("    fprintf (dump_file, \"Splitting with gen_%s_%d (%s:%d)\\n\");\n",
 619           name, info->index, fn, info->loc.lineno);
 620
 621   printf ("  start_sequence ();\n");
 622
 623   /* The fourth operand of DEFINE_SPLIT is some code to be executed
 624      before the actual construction.  */
 625
 626   if (XSTR (split, 3))
 627     emit_c_code (XSTR (split, 3), true, name);
 628
 629   /* Output code to copy the arguments back out of `operands'  */
 630   for (i = 0; i < stats.num_operand_vars; i++)
 631     {
 632       printf ("  operand%d = operands[%d];\n", i, i);
 633       printf ("  (void) operand%d;\n", i);
 634     }
 635
 636   gen_emit_seq (XVEC (split, 2), used, info);
 637
 638   /* Call `get_insns' to make a list of all the
 639      insns emitted within this gen_... function.  */
 640
 641   printf ("  _val = get_insns ();\n");
 642   printf ("  end_sequence ();\n");
 643   printf ("  return _val;\n}\n\n");
 644
 645   free (used);
 646 }
 647 \f
 648 /* Write a function, `add_clobbers', that is given a PARALLEL of sufficient
 649    size for the insn and an INSN_CODE, and inserts the required CLOBBERs at
 650    the end of the vector.  */
 651
 652 static void
 653 output_add_clobbers (md_rtx_info *info)
 654 {
 655   struct clobber_pat *clobber;
 656   struct clobber_ent *ent;
 657   int i;
 658
 659   printf ("\n\nvoid\nadd_clobbers (rtx pattern ATTRIBUTE_UNUSED, int insn_code_number)\n");
 660   printf ("{\n");
 661   printf ("  switch (insn_code_number)\n");
 662   printf ("    {\n");
 663
 664   for (clobber = clobber_list; clobber; clobber = clobber->next)
 665     {
 666       for (ent = clobber->insns; ent; ent = ent->next)
 667         printf ("    case %d:\n", ent->code_number);
 668
 669       for (i = clobber->first_clobber; i < XVECLEN (clobber->pattern, 1); i++)
 670         {
 671           printf ("      XVECEXP (pattern, 0, %d) = ", i);
 672           gen_exp (XVECEXP (clobber->pattern, 1, i),
 673                    GET_CODE (clobber->pattern), NULL, info);
 674           printf (";\n");
 675         }
 676
 677       printf ("      break;\n\n");
 678     }
 679
 680   printf ("    default:\n");
 681   printf ("      gcc_unreachable ();\n");
 682   printf ("    }\n");
 683   printf ("}\n");
 684 }
 685 \f
 686 /* Write a function, `added_clobbers_hard_reg_p' that is given an insn_code
 687    number that will have clobbers added (as indicated by `recog') and returns
 688    1 if those include a clobber of a hard reg or 0 if all of them just clobber
 689    SCRATCH.  */
 690
 691 static void
 692 output_added_clobbers_hard_reg_p (void)
 693 {
 694   struct clobber_pat *clobber;
 695   struct clobber_ent *ent;
 696   int clobber_p, used;
 697
 698   printf ("\n\nint\nadded_clobbers_hard_reg_p (int insn_code_number)\n");
 699   printf ("{\n");
 700   printf ("  switch (insn_code_number)\n");
 701   printf ("    {\n");
 702
 703   for (clobber_p = 0; clobber_p <= 1; clobber_p++)
 704     {
 705       used = 0;
 706       for (clobber = clobber_list; clobber; clobber = clobber->next)
 707         if (clobber->has_hard_reg == clobber_p)
 708           for (ent = clobber->insns; ent; ent = ent->next)
 709             {
 710               printf ("    case %d:\n", ent->code_number);
 711               used++;
 712             }
 713
 714       if (used)
 715         printf ("      return %d;\n\n", clobber_p);
 716     }
 717
 718   printf ("    default:\n");
 719   printf ("      gcc_unreachable ();\n");
 720   printf ("    }\n");
 721   printf ("}\n");
 722 }
 723 \f
 724 /* Generate code to invoke find_free_register () as needed for the
 725    scratch registers used by the peephole2 pattern in SPLIT.  */
 726
 727 static void
 728 output_peephole2_scratches (rtx split)
 729 {
 730   int i;
 731   int insn_nr = 0;
 732   bool first = true;
 733
 734   for (i = 0; i < XVECLEN (split, 0); i++)
 735     {
 736       rtx elt = XVECEXP (split, 0, i);
 737       if (GET_CODE (elt) == MATCH_SCRATCH)
 738         {
 739           int last_insn_nr = insn_nr;
 740           int cur_insn_nr = insn_nr;
 741           int j;
 742           for (j = i + 1; j < XVECLEN (split, 0); j++)
 743             if (GET_CODE (XVECEXP (split, 0, j)) == MATCH_DUP)
 744               {
 745                 if (XINT (XVECEXP (split, 0, j), 0) == XINT (elt, 0))
 746                   last_insn_nr = cur_insn_nr;
 747               }
 748             else if (GET_CODE (XVECEXP (split, 0, j)) != MATCH_SCRATCH)
 749               cur_insn_nr++;
 750
 751           if (first)
 752             {
 753               printf ("  HARD_REG_SET _regs_allocated;\n");
 754               printf ("  CLEAR_HARD_REG_SET (_regs_allocated);\n");
 755               first = false;
 756             }
 757
 758           printf ("  if ((operands[%d] = peep2_find_free_register (%d, %d, \"%s\", %smode, &_regs_allocated)) == NULL_RTX)\n\
 759     return NULL;\n",
 760                   XINT (elt, 0),
 761                   insn_nr, last_insn_nr,
 762                   XSTR (elt, 1),
 763                   GET_MODE_NAME (GET_MODE (elt)));
 764
 765         }
 766       else if (GET_CODE (elt) != MATCH_DUP)
 767         insn_nr++;
 768     }
 769 }
 770
 771 /* Print "arg<N>" parameter declarations for each argument N of ONAME.  */
 772
 773 static void
 774 print_overload_arguments (overloaded_name *oname)
 775 {
 776   for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
 777     printf ("%s%s arg%d", i == 0 ? "" : ", ", oname->arg_types[i], i);
 778 }
 779
 780 /* Print code to test whether INSTANCE should be chosen, given that
 781    argument N of the overload is available as "arg<N>".  */
 782
 783 static void
 784 print_overload_test (overloaded_instance *instance)
 785 {
 786   for (unsigned int i = 0; i < instance->arg_values.length (); ++i)
 787     printf ("%sarg%d == %s", i == 0 ? "  if (" : "\n      && ",
 788             i, instance->arg_values[i]);
 789   printf (")\n");
 790 }
 791
 792 /* Emit a maybe_code_for_* function for ONAME.  */
 793
 794 static void
 795 handle_overloaded_code_for (overloaded_name *oname)
 796 {
 797   /* Print the function prototype.  */
 798   printf ("\ninsn_code\nmaybe_code_for_%s (", oname->name);
 799   print_overload_arguments (oname);
 800   printf (")\n{\n");
 801
 802   /* Use a sequence of "if" statements for each instance.  */
 803   for (overloaded_instance *instance = oname->first_instance;
 804        instance; instance = instance->next)
 805     {
 806       print_overload_test (instance);
 807       printf ("    return CODE_FOR_%s;\n", instance->name);
 808     }
 809
 810   /* Return null if no match was found.  */
 811   printf ("  return CODE_FOR_nothing;\n}\n");
 812 }
 813
 814 /* Emit a maybe_gen_* function for ONAME.  */
 815
 816 static void
 817 handle_overloaded_gen (overloaded_name *oname)
 818 {
 819   unsigned HOST_WIDE_INT seen = 0;
 820   /* All patterns must have the same number of operands.  */
 821   for (overloaded_instance *instance = oname->first_instance->next;
 822        instance; instance = instance->next)
 823     {
 824       pattern_stats stats;
 825       get_pattern_stats (&stats, XVEC (instance->insn, 1));
 826       unsigned HOST_WIDE_INT mask
 827         = HOST_WIDE_INT_1U << stats.num_generator_args;
 828       if (seen & mask)
 829         continue;
 830
 831       seen |= mask;
 832
 833       /* Print the function prototype.  */
 834       printf ("\nrtx\nmaybe_gen_%s (", oname->name);
 835       print_overload_arguments (oname);
 836       for (int i = 0; i < stats.num_generator_args; ++i)
 837         printf (", rtx x%d", i);
 838       printf (")\n{\n");
 839
 840       /* Use maybe_code_for_*, instead of duplicating the selection
 841          logic here.  */
 842       printf ("  insn_code code = maybe_code_for_%s (", oname->name);
 843       for (unsigned int i = 0; i < oname->arg_types.length (); ++i)
 844         printf ("%sarg%d", i == 0 ? "" : ", ", i);
 845       printf (");\n"
 846               "  if (code != CODE_FOR_nothing)\n"
 847               "    {\n"
 848               "      gcc_assert (insn_data[code].n_generator_args == %d);\n"
 849               "      return GEN_FCN (code) (", stats.num_generator_args);
 850       for (int i = 0; i < stats.num_generator_args; ++i)
 851         printf ("%sx%d", i == 0 ? "" : ", ", i);
 852       printf (");\n"
 853               "    }\n"
 854               "  else\n"
 855               "    return NULL_RTX;\n"
 856               "}\n");
 857     }
 858 }
 859
 860 int
 861 main (int argc, const char **argv)
 862 {
 863   progname = "genemit";
 864
 865   if (!init_rtx_reader_args (argc, argv))
 866     return (FATAL_EXIT_CODE);
 867
 868 #define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE) \
 869   nofail_optabs[OPTAB##_optab] = true;
 870 #include "internal-fn.def"
 871
 872   /* Assign sequential codes to all entries in the machine description
 873      in parallel with the tables in insn-output.c.  */
 874
 875   printf ("/* Generated automatically by the program `genemit'\n\
 876 from the machine description file `md'.  */\n\n");
 877
 878   printf ("#define IN_TARGET_CODE 1\n");
 879   printf ("#include \"config.h\"\n");
 880   printf ("#include \"system.h\"\n");
 881   printf ("#include \"coretypes.h\"\n");
 882   printf ("#include \"backend.h\"\n");
 883   printf ("#include \"predict.h\"\n");
 884   printf ("#include \"tree.h\"\n");
 885   printf ("#include \"rtl.h\"\n");
 886   printf ("#include \"alias.h\"\n");
 887   printf ("#include \"varasm.h\"\n");
 888   printf ("#include \"stor-layout.h\"\n");
 889   printf ("#include \"calls.h\"\n");
 890   printf ("#include \"memmodel.h\"\n");
 891   printf ("#include \"tm_p.h\"\n");
 892   printf ("#include \"flags.h\"\n");
 893   printf ("#include \"insn-config.h\"\n");
 894   printf ("#include \"expmed.h\"\n");
 895   printf ("#include \"dojump.h\"\n");
 896   printf ("#include \"explow.h\"\n");
 897   printf ("#include \"emit-rtl.h\"\n");
 898   printf ("#include \"stmt.h\"\n");
 899   printf ("#include \"expr.h\"\n");
 900   printf ("#include \"insn-codes.h\"\n");
 901   printf ("#include \"optabs.h\"\n");
 902   printf ("#include \"dfp.h\"\n");
 903   printf ("#include \"output.h\"\n");
 904   printf ("#include \"recog.h\"\n");
 905   printf ("#include \"df.h\"\n");
 906   printf ("#include \"resource.h\"\n");
 907   printf ("#include \"reload.h\"\n");
 908   printf ("#include \"diagnostic-core.h\"\n");
 909   printf ("#include \"regs.h\"\n");
 910   printf ("#include \"tm-constrs.h\"\n");
 911   printf ("#include \"ggc.h\"\n");
 912   printf ("#include \"target.h\"\n\n");
 913
 914   /* Read the machine description.  */
 915
 916   md_rtx_info info;
 917   while (read_md_rtx (&info))
 918     switch (GET_CODE (info.def))
 919       {
 920       case DEFINE_INSN:
 921         gen_insn (&info);
 922         break;
 923
 924       case DEFINE_EXPAND:
 925         printf ("/* %s:%d */\n", info.loc.filename, info.loc.lineno);
 926         gen_expand (&info);
 927         break;
 928
 929       case DEFINE_SPLIT:
 930         printf ("/* %s:%d */\n", info.loc.filename, info.loc.lineno);
 931         gen_split (&info);
 932         break;
 933
 934       case DEFINE_PEEPHOLE2:
 935         printf ("/* %s:%d */\n", info.loc.filename, info.loc.lineno);
 936         gen_split (&info);
 937         break;
 938
 939       default:
 940         break;
 941       }
 942
 943   /* Write out the routines to add CLOBBERs to a pattern and say whether they
 944      clobber a hard reg.  */
 945   output_add_clobbers (&info);
 946   output_added_clobbers_hard_reg_p ();
 947
 948   for (overloaded_name *oname = rtx_reader_ptr->get_overloads ();
 949        oname; oname = oname->next)
 950     {
 951       handle_overloaded_code_for (oname);
 952       handle_overloaded_gen (oname);
 953     }
 954
 955   fflush (stdout);
 956   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 957 }