gcc/genpreds.c

   1 /* Generate from machine description:
   2    - prototype declarations for operand predicates (tm-preds.h)
   3    - function definitions of operand predicates, if defined new-style
   4      (insn-preds.c)
   5    Copyright (C) 2001-2013 Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  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 "obstack.h"
  30 #include "read-md.h"
  31 #include "gensupport.h"
  32
  33 /* Given a predicate expression EXP, from form NAME at line LINENO,
  34    verify that it does not contain any RTL constructs which are not
  35    valid in predicate definitions.  Returns true if EXP is
  36    INvalid; issues error messages, caller need not.  */
  37 static bool
  38 validate_exp (rtx exp, const char *name, int lineno)
  39 {
  40   if (exp == 0)
  41     {
  42       message_with_line (lineno, "%s: must give a predicate expression", name);
  43       return true;
  44     }
  45
  46   switch (GET_CODE (exp))
  47     {
  48       /* Ternary, binary, unary expressions: recurse into subexpressions.  */
  49     case IF_THEN_ELSE:
  50       if (validate_exp (XEXP (exp, 2), name, lineno))
  51         return true;
  52       /* else fall through */
  53     case AND:
  54     case IOR:
  55       if (validate_exp (XEXP (exp, 1), name, lineno))
  56         return true;
  57       /* else fall through */
  58     case NOT:
  59       return validate_exp (XEXP (exp, 0), name, lineno);
  60
  61       /* MATCH_CODE might have a syntax error in its path expression.  */
  62     case MATCH_CODE:
  63       {
  64         const char *p;
  65         for (p = XSTR (exp, 1); *p; p++)
  66           {
  67             if (!ISDIGIT (*p) && !ISLOWER (*p))
  68               {
  69                 error_with_line (lineno, "%s: invalid character in path "
  70                                  "string '%s'", name, XSTR (exp, 1));
  71                 return true;
  72               }
  73           }
  74       }
  75       /* fall through */
  76
  77       /* These need no special checking.  */
  78     case MATCH_OPERAND:
  79     case MATCH_TEST:
  80       return false;
  81
  82     default:
  83       error_with_line (lineno,
  84                        "%s: cannot use '%s' in a predicate expression",
  85                        name, GET_RTX_NAME (GET_CODE (exp)));
  86       return true;
  87     }
  88 }
  89
  90 /* Predicates are defined with (define_predicate) or
  91    (define_special_predicate) expressions in the machine description.  */
  92 static void
  93 process_define_predicate (rtx defn, int lineno)
  94 {
  95   validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno);
  96 }
  97
  98 /* Given a predicate, if it has an embedded C block, write the block
  99    out as a static inline subroutine, and augment the RTL test with a
 100    match_test that calls that subroutine.  For instance,
 101
 102        (define_predicate "basereg_operand"
 103          (match_operand 0 "register_operand")
 104        {
 105          if (GET_CODE (op) == SUBREG)
 106            op = SUBREG_REG (op);
 107          return REG_POINTER (op);
 108        })
 109
 110    becomes
 111
 112        static inline int basereg_operand_1(rtx op, enum machine_mode mode)
 113        {
 114          if (GET_CODE (op) == SUBREG)
 115            op = SUBREG_REG (op);
 116          return REG_POINTER (op);
 117        }
 118
 119        (define_predicate "basereg_operand"
 120          (and (match_operand 0 "register_operand")
 121               (match_test "basereg_operand_1 (op, mode)")))
 122
 123    The only wart is that there's no way to insist on a { } string in
 124    an RTL template, so we have to handle "" strings.  */
 125
 126
 127 static void
 128 write_predicate_subfunction (struct pred_data *p)
 129 {
 130   const char *match_test_str;
 131   rtx match_test_exp, and_exp;
 132
 133   if (p->c_block[0] == '\0')
 134     return;
 135
 136   /* Construct the function-call expression.  */
 137   obstack_grow (rtl_obstack, p->name, strlen (p->name));
 138   obstack_grow (rtl_obstack, "_1 (op, mode)",
 139                 sizeof "_1 (op, mode)");
 140   match_test_str = XOBFINISH (rtl_obstack, const char *);
 141
 142   /* Add the function-call expression to the complete expression to be
 143      evaluated.  */
 144   match_test_exp = rtx_alloc (MATCH_TEST);
 145   XSTR (match_test_exp, 0) = match_test_str;
 146
 147   and_exp = rtx_alloc (AND);
 148   XEXP (and_exp, 0) = p->exp;
 149   XEXP (and_exp, 1) = match_test_exp;
 150
 151   p->exp = and_exp;
 152
 153   printf ("static inline int\n"
 154           "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n",
 155           p->name);
 156   print_md_ptr_loc (p->c_block);
 157   if (p->c_block[0] == '{')
 158     fputs (p->c_block, stdout);
 159   else
 160     printf ("{\n  %s\n}", p->c_block);
 161   fputs ("\n\n", stdout);
 162 }
 163
 164 /* Given a predicate expression EXP, from form NAME, determine whether
 165    it refers to the variable given as VAR.  */
 166 static bool
 167 needs_variable (rtx exp, const char *var)
 168 {
 169   switch (GET_CODE (exp))
 170     {
 171       /* Ternary, binary, unary expressions need a variable if
 172          any of their subexpressions do.  */
 173     case IF_THEN_ELSE:
 174       if (needs_variable (XEXP (exp, 2), var))
 175         return true;
 176       /* else fall through */
 177     case AND:
 178     case IOR:
 179       if (needs_variable (XEXP (exp, 1), var))
 180         return true;
 181       /* else fall through */
 182     case NOT:
 183       return needs_variable (XEXP (exp, 0), var);
 184
 185       /* MATCH_CODE uses "op", but nothing else.  */
 186     case MATCH_CODE:
 187       return !strcmp (var, "op");
 188
 189       /* MATCH_OPERAND uses "op" and may use "mode".  */
 190     case MATCH_OPERAND:
 191       if (!strcmp (var, "op"))
 192         return true;
 193       if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
 194         return true;
 195       return false;
 196
 197       /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
 198     case MATCH_TEST:
 199       {
 200         const char *p = XSTR (exp, 0);
 201         const char *q = strstr (p, var);
 202         if (!q)
 203           return false;
 204         if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
 205           return false;
 206         q += strlen (var);
 207         if (ISALNUM (q[0]) || q[0] == '_')
 208           return false;
 209       }
 210       return true;
 211
 212     default:
 213       gcc_unreachable ();
 214     }
 215 }
 216
 217 /* Given an RTL expression EXP, find all subexpressions which we may
 218    assume to perform mode tests.  Normal MATCH_OPERAND does;
 219    MATCH_CODE does if it applies to the whole expression and accepts
 220    CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST
 221    does not.  These combine in almost-boolean fashion - the only
 222    exception is that (not X) must be assumed not to perform a mode
 223    test, whether or not X does.
 224
 225    The mark is the RTL /v flag, which is true for subexpressions which
 226    do *not* perform mode tests.
 227 */
 228 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil)
 229 static void
 230 mark_mode_tests (rtx exp)
 231 {
 232   switch (GET_CODE (exp))
 233     {
 234     case MATCH_OPERAND:
 235       {
 236         struct pred_data *p = lookup_predicate (XSTR (exp, 1));
 237         if (!p)
 238           error ("reference to undefined predicate '%s'", XSTR (exp, 1));
 239         else if (p->special || GET_MODE (exp) != VOIDmode)
 240           NO_MODE_TEST (exp) = 1;
 241       }
 242       break;
 243
 244     case MATCH_CODE:
 245       if (XSTR (exp, 1)[0] != '\0'
 246           || (!strstr (XSTR (exp, 0), "const_int")
 247               && !strstr (XSTR (exp, 0), "const_double")))
 248         NO_MODE_TEST (exp) = 1;
 249       break;
 250
 251     case MATCH_TEST:
 252     case NOT:
 253       NO_MODE_TEST (exp) = 1;
 254       break;
 255
 256     case AND:
 257       mark_mode_tests (XEXP (exp, 0));
 258       mark_mode_tests (XEXP (exp, 1));
 259
 260       NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
 261                             && NO_MODE_TEST (XEXP (exp, 1)));
 262       break;
 263
 264     case IOR:
 265       mark_mode_tests (XEXP (exp, 0));
 266       mark_mode_tests (XEXP (exp, 1));
 267
 268       NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0))
 269                             || NO_MODE_TEST (XEXP (exp, 1)));
 270       break;
 271
 272     case IF_THEN_ELSE:
 273       /* A ? B : C does a mode test if (one of A and B) does a mode
 274          test, and C does too.  */
 275       mark_mode_tests (XEXP (exp, 0));
 276       mark_mode_tests (XEXP (exp, 1));
 277       mark_mode_tests (XEXP (exp, 2));
 278
 279       NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0))
 280                              && NO_MODE_TEST (XEXP (exp, 1)))
 281                             || NO_MODE_TEST (XEXP (exp, 2)));
 282       break;
 283
 284     default:
 285       gcc_unreachable ();
 286     }
 287 }
 288
 289 /* Determine whether the expression EXP is a MATCH_CODE that should
 290    be written as a switch statement.  */
 291 static bool
 292 generate_switch_p (rtx exp)
 293 {
 294   return GET_CODE (exp) == MATCH_CODE
 295          && strchr (XSTR (exp, 0), ',');
 296 }
 297
 298 /* Given a predicate, work out where in its RTL expression to add
 299    tests for proper modes.  Special predicates do not get any such
 300    tests.  We try to avoid adding tests when we don't have to; in
 301    particular, other normal predicates can be counted on to do it for
 302    us.  */
 303
 304 static void
 305 add_mode_tests (struct pred_data *p)
 306 {
 307   rtx match_test_exp, and_exp;
 308   rtx *pos;
 309
 310   /* Don't touch special predicates.  */
 311   if (p->special)
 312     return;
 313
 314   mark_mode_tests (p->exp);
 315
 316   /* If the whole expression already tests the mode, we're done.  */
 317   if (!NO_MODE_TEST (p->exp))
 318     return;
 319
 320   match_test_exp = rtx_alloc (MATCH_TEST);
 321   XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode";
 322   and_exp = rtx_alloc (AND);
 323   XEXP (and_exp, 1) = match_test_exp;
 324
 325   /* It is always correct to rewrite p->exp as
 326
 327         (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode"))
 328
 329      but there are a couple forms where we can do better.  If the
 330      top-level pattern is an IOR, and one of the two branches does test
 331      the mode, we can wrap just the branch that doesn't.  Likewise, if
 332      we have an IF_THEN_ELSE, and one side of it tests the mode, we can
 333      wrap just the side that doesn't.  And, of course, we can repeat this
 334      descent as many times as it works.  */
 335
 336   pos = &p->exp;
 337   for (;;)
 338     {
 339       rtx subexp = *pos;
 340
 341       switch (GET_CODE (subexp))
 342         {
 343         case AND:
 344           /* The switch code generation in write_predicate_stmts prefers
 345              rtx code tests to be at the top of the expression tree.  So
 346              push this AND down into the second operand of an existing
 347              AND expression.  */
 348           if (generate_switch_p (XEXP (subexp, 0)))
 349             pos = &XEXP (subexp, 1);
 350           goto break_loop;
 351
 352         case IOR:
 353           {
 354             int test0 = NO_MODE_TEST (XEXP (subexp, 0));
 355             int test1 = NO_MODE_TEST (XEXP (subexp, 1));
 356
 357             gcc_assert (test0 || test1);
 358
 359             if (test0 && test1)
 360               goto break_loop;
 361             pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1);
 362           }
 363           break;
 364
 365         case IF_THEN_ELSE:
 366           {
 367             int test0 = NO_MODE_TEST (XEXP (subexp, 0));
 368             int test1 = NO_MODE_TEST (XEXP (subexp, 1));
 369             int test2 = NO_MODE_TEST (XEXP (subexp, 2));
 370
 371             gcc_assert ((test0 && test1) || test2);
 372
 373             if (test0 && test1 && test2)
 374               goto break_loop;
 375             if (test0 && test1)
 376               /* Must put it on the dependent clause, not the
 377                  controlling expression, or we change the meaning of
 378                  the test.  */
 379               pos = &XEXP (subexp, 1);
 380             else
 381               pos = &XEXP (subexp, 2);
 382           }
 383           break;
 384
 385         default:
 386           goto break_loop;
 387         }
 388     }
 389  break_loop:
 390   XEXP (and_exp, 0) = *pos;
 391   *pos = and_exp;
 392 }
 393
 394 /* PATH is a string describing a path from the root of an RTL
 395    expression to an inner subexpression to be tested.  Output
 396    code which computes the subexpression from the variable
 397    holding the root of the expression.  */
 398 static void
 399 write_extract_subexp (const char *path)
 400 {
 401   int len = strlen (path);
 402   int i;
 403
 404   /* We first write out the operations (XEXP or XVECEXP) in reverse
 405      order, then write "op", then the indices in forward order.  */
 406   for (i = len - 1; i >= 0; i--)
 407     {
 408       if (ISLOWER (path[i]))
 409         fputs ("XVECEXP (", stdout);
 410       else if (ISDIGIT (path[i]))
 411         fputs ("XEXP (", stdout);
 412       else
 413         gcc_unreachable ();
 414     }
 415
 416   fputs ("op", stdout);
 417
 418   for (i = 0; i < len; i++)
 419     {
 420       if (ISLOWER (path[i]))
 421         printf (", 0, %d)", path[i] - 'a');
 422       else if (ISDIGIT (path[i]))
 423         printf (", %d)", path[i] - '0');
 424       else
 425         gcc_unreachable ();
 426     }
 427 }
 428
 429 /* CODES is a list of RTX codes.  Write out an expression which
 430    determines whether the operand has one of those codes.  */
 431 static void
 432 write_match_code (const char *path, const char *codes)
 433 {
 434   const char *code;
 435
 436   while ((code = scan_comma_elt (&codes)) != 0)
 437     {
 438       fputs ("GET_CODE (", stdout);
 439       write_extract_subexp (path);
 440       fputs (") == ", stdout);
 441       while (code < codes)
 442         {
 443           putchar (TOUPPER (*code));
 444           code++;
 445         }
 446
 447       if (*codes == ',')
 448         fputs (" || ", stdout);
 449     }
 450 }
 451
 452 /* EXP is an RTL (sub)expression for a predicate.  Recursively
 453    descend the expression and write out an equivalent C expression.  */
 454 static void
 455 write_predicate_expr (rtx exp)
 456 {
 457   switch (GET_CODE (exp))
 458     {
 459     case AND:
 460       putchar ('(');
 461       write_predicate_expr (XEXP (exp, 0));
 462       fputs (") && (", stdout);
 463       write_predicate_expr (XEXP (exp, 1));
 464       putchar (')');
 465       break;
 466
 467     case IOR:
 468       putchar ('(');
 469       write_predicate_expr (XEXP (exp, 0));
 470       fputs (") || (", stdout);
 471       write_predicate_expr (XEXP (exp, 1));
 472       putchar (')');
 473       break;
 474
 475     case NOT:
 476       fputs ("!(", stdout);
 477       write_predicate_expr (XEXP (exp, 0));
 478       putchar (')');
 479       break;
 480
 481     case IF_THEN_ELSE:
 482       putchar ('(');
 483       write_predicate_expr (XEXP (exp, 0));
 484       fputs (") ? (", stdout);
 485       write_predicate_expr (XEXP (exp, 1));
 486       fputs (") : (", stdout);
 487       write_predicate_expr (XEXP (exp, 2));
 488       putchar (')');
 489       break;
 490
 491     case MATCH_OPERAND:
 492       if (GET_MODE (exp) == VOIDmode)
 493         printf ("%s (op, mode)", XSTR (exp, 1));
 494       else
 495         printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]);
 496       break;
 497
 498     case MATCH_CODE:
 499       write_match_code (XSTR (exp, 1), XSTR (exp, 0));
 500       break;
 501
 502     case MATCH_TEST:
 503       print_c_condition (XSTR (exp, 0));
 504       break;
 505
 506     default:
 507       gcc_unreachable ();
 508     }
 509 }
 510
 511 /* Write the MATCH_CODE expression EXP as a switch statement.  */
 512
 513 static void
 514 write_match_code_switch (rtx exp)
 515 {
 516   const char *codes = XSTR (exp, 0);
 517   const char *path = XSTR (exp, 1);
 518   const char *code;
 519
 520   fputs ("  switch (GET_CODE (", stdout);
 521   write_extract_subexp (path);
 522   fputs ("))\n    {\n", stdout);
 523
 524   while ((code = scan_comma_elt (&codes)) != 0)
 525     {
 526       fputs ("    case ", stdout);
 527       while (code < codes)
 528         {
 529           putchar (TOUPPER (*code));
 530           code++;
 531         }
 532       fputs(":\n", stdout);
 533     }
 534 }
 535
 536 /* Given a predicate expression EXP, write out a sequence of stmts
 537    to evaluate it.  This is similar to write_predicate_expr but can
 538    generate efficient switch statements.  */
 539
 540 static void
 541 write_predicate_stmts (rtx exp)
 542 {
 543   switch (GET_CODE (exp))
 544     {
 545     case MATCH_CODE:
 546       if (generate_switch_p (exp))
 547         {
 548           write_match_code_switch (exp);
 549           puts ("      return true;\n"
 550                 "    default:\n"
 551                 "      break;\n"
 552                 "    }\n"
 553                 "  return false;");
 554           return;
 555         }
 556       break;
 557
 558     case AND:
 559       if (generate_switch_p (XEXP (exp, 0)))
 560         {
 561           write_match_code_switch (XEXP (exp, 0));
 562           puts ("      break;\n"
 563                 "    default:\n"
 564                 "      return false;\n"
 565                 "    }");
 566           exp = XEXP (exp, 1);
 567         }
 568       break;
 569
 570     case IOR:
 571       if (generate_switch_p (XEXP (exp, 0)))
 572         {
 573           write_match_code_switch (XEXP (exp, 0));
 574           puts ("      return true;\n"
 575                 "    default:\n"
 576                 "      break;\n"
 577                 "    }");
 578           exp = XEXP (exp, 1);
 579         }
 580       break;
 581
 582     case NOT:
 583       if (generate_switch_p (XEXP (exp, 0)))
 584         {
 585           write_match_code_switch (XEXP (exp, 0));
 586           puts ("      return false;\n"
 587                 "    default:\n"
 588                 "      break;\n"
 589                 "    }\n"
 590                 "  return true;");
 591           return;
 592         }
 593       break;
 594
 595     default:
 596       break;
 597     }
 598
 599   fputs("  return ",stdout);
 600   write_predicate_expr (exp);
 601   fputs(";\n", stdout);
 602 }
 603
 604 /* Given a predicate, write out a complete C function to compute it.  */
 605 static void
 606 write_one_predicate_function (struct pred_data *p)
 607 {
 608   if (!p->exp)
 609     return;
 610
 611   write_predicate_subfunction (p);
 612   add_mode_tests (p);
 613
 614   /* A normal predicate can legitimately not look at enum machine_mode
 615      if it accepts only CONST_INTs and/or CONST_DOUBLEs.  */
 616   printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n",
 617           p->name);
 618   write_predicate_stmts (p->exp);
 619   fputs ("}\n\n", stdout);
 620 }
 621 \f
 622 /* Constraints fall into two categories: register constraints
 623    (define_register_constraint), and others (define_constraint,
 624    define_memory_constraint, define_address_constraint).  We
 625    work out automatically which of the various old-style macros
 626    they correspond to, and produce appropriate code.  They all
 627    go in the same hash table so we can verify that there are no
 628    duplicate names.  */
 629
 630 /* All data from one constraint definition.  */
 631 struct constraint_data
 632 {
 633   struct constraint_data *next_this_letter;
 634   struct constraint_data *next_textual;
 635   const char *name;
 636   const char *c_name;    /* same as .name unless mangling is necessary */
 637   size_t namelen;
 638   const char *regclass;  /* for register constraints */
 639   rtx exp;               /* for other constraints */
 640   unsigned int lineno;   /* line of definition */
 641   unsigned int is_register  : 1;
 642   unsigned int is_const_int : 1;
 643   unsigned int is_const_dbl : 1;
 644   unsigned int is_extra     : 1;
 645   unsigned int is_memory    : 1;
 646   unsigned int is_address   : 1;
 647 };
 648
 649 /* Overview of all constraints beginning with a given letter.  */
 650
 651 static struct constraint_data *
 652 constraints_by_letter_table[1<<CHAR_BIT];
 653
 654 /* For looking up all the constraints in the order that they appeared
 655    in the machine description.  */
 656 static struct constraint_data *first_constraint;
 657 static struct constraint_data **last_constraint_ptr = &first_constraint;
 658
 659 #define FOR_ALL_CONSTRAINTS(iter_) \
 660   for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
 661
 662 /* These letters, and all names beginning with them, are reserved for
 663    generic constraints.
 664    The 'm' constraint is not mentioned here since that constraint
 665    letter can be overridden by the back end by defining the
 666    TARGET_MEM_CONSTRAINT macro.  */
 667 static const char generic_constraint_letters[] = "EFVXginoprs";
 668
 669 /* Machine-independent code expects that constraints with these
 670    (initial) letters will allow only (a subset of all) CONST_INTs.  */
 671
 672 static const char const_int_constraints[] = "IJKLMNOP";
 673
 674 /* Machine-independent code expects that constraints with these
 675    (initial) letters will allow only (a subset of all) CONST_DOUBLEs.  */
 676
 677 static const char const_dbl_constraints[] = "GH";
 678
 679 /* Summary data used to decide whether to output various functions and
 680    macro definitions.  */
 681 static unsigned int constraint_max_namelen;
 682 static bool have_register_constraints;
 683 static bool have_memory_constraints;
 684 static bool have_address_constraints;
 685 static bool have_extra_constraints;
 686 static bool have_const_int_constraints;
 687 static bool have_const_dbl_constraints;
 688
 689 /* Convert NAME, which contains angle brackets and/or underscores, to
 690    a string that can be used as part of a C identifier.  The string
 691    comes from the rtl_obstack.  */
 692 static const char *
 693 mangle (const char *name)
 694 {
 695   for (; *name; name++)
 696     switch (*name)
 697       {
 698       case '_': obstack_grow (rtl_obstack, "__", 2); break;
 699       case '<': obstack_grow (rtl_obstack, "_l", 2); break;
 700       case '>': obstack_grow (rtl_obstack, "_g", 2); break;
 701       default: obstack_1grow (rtl_obstack, *name); break;
 702       }
 703
 704   obstack_1grow (rtl_obstack, '\0');
 705   return XOBFINISH (rtl_obstack, const char *);
 706 }
 707
 708 /* Add one constraint, of any sort, to the tables.  NAME is its name;
 709    REGCLASS is the register class, if any; EXP is the expression to
 710    test, if any;  IS_MEMORY and IS_ADDRESS indicate memory and address
 711    constraints, respectively; LINENO is the line number from the MD reader.
 712    Not all combinations of arguments are valid; most importantly, REGCLASS
 713    is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
 714    meaningful for constraints with EXP.
 715
 716    This function enforces all syntactic and semantic rules about what
 717    constraints can be defined.  */
 718
 719 static void
 720 add_constraint (const char *name, const char *regclass,
 721                 rtx exp, bool is_memory, bool is_address,
 722                 int lineno)
 723 {
 724   struct constraint_data *c, **iter, **slot;
 725   const char *p;
 726   bool need_mangled_name = false;
 727   bool is_const_int;
 728   bool is_const_dbl;
 729   size_t namelen;
 730
 731   if (exp && validate_exp (exp, name, lineno))
 732     return;
 733
 734   if (!ISALPHA (name[0]) && name[0] != '_')
 735     {
 736       if (name[1] == '\0')
 737         error_with_line (lineno, "constraint name '%s' is not "
 738                          "a letter or underscore", name);
 739       else
 740         error_with_line (lineno, "constraint name '%s' does not begin "
 741                          "with a letter or underscore", name);
 742       return;
 743     }
 744   for (p = name; *p; p++)
 745     if (!ISALNUM (*p))
 746       {
 747         if (*p == '<' || *p == '>' || *p == '_')
 748           need_mangled_name = true;
 749         else
 750           {
 751             error_with_line (lineno,
 752                              "constraint name '%s' must be composed of "
 753                              "letters, digits, underscores, and "
 754                              "angle brackets", name);
 755             return;
 756           }
 757       }
 758
 759   if (strchr (generic_constraint_letters, name[0]))
 760     {
 761       if (name[1] == '\0')
 762         error_with_line (lineno, "constraint letter '%s' cannot be "
 763                          "redefined by the machine description", name);
 764       else
 765         error_with_line (lineno, "constraint name '%s' cannot be defined by "
 766                          "the machine description, as it begins with '%c'",
 767                          name, name[0]);
 768       return;
 769     }
 770
 771
 772   namelen = strlen (name);
 773   slot = &constraints_by_letter_table[(unsigned int)name[0]];
 774   for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
 775     {
 776       /* This causes slot to end up pointing to the
 777          next_this_letter field of the last constraint with a name
 778          of equal or greater length than the new constraint; hence
 779          the new constraint will be inserted after all previous
 780          constraints with names of the same length.  */
 781       if ((*iter)->namelen >= namelen)
 782         slot = iter;
 783
 784       if (!strcmp ((*iter)->name, name))
 785         {
 786           error_with_line (lineno, "redefinition of constraint '%s'", name);
 787           message_with_line ((*iter)->lineno, "previous definition is here");
 788           return;
 789         }
 790       else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
 791         {
 792           error_with_line (lineno, "defining constraint '%s' here", name);
 793           message_with_line ((*iter)->lineno, "renders constraint '%s' "
 794                              "(defined here) a prefix", (*iter)->name);
 795           return;
 796         }
 797       else if (!strncmp ((*iter)->name, name, namelen))
 798         {
 799           error_with_line (lineno, "constraint '%s' is a prefix", name);
 800           message_with_line ((*iter)->lineno, "of constraint '%s' "
 801                              "(defined here)", (*iter)->name);
 802           return;
 803         }
 804     }
 805
 806   is_const_int = strchr (const_int_constraints, name[0]) != 0;
 807   is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
 808
 809   if (is_const_int || is_const_dbl)
 810     {
 811       enum rtx_code appropriate_code
 812         = is_const_int ? CONST_INT : CONST_DOUBLE;
 813
 814       /* Consider relaxing this requirement in the future.  */
 815       if (regclass
 816           || GET_CODE (exp) != AND
 817           || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
 818           || strcmp (XSTR (XEXP (exp, 0), 0),
 819                      GET_RTX_NAME (appropriate_code)))
 820         {
 821           if (name[1] == '\0')
 822             error_with_line (lineno, "constraint letter '%c' is reserved "
 823                              "for %s constraints",
 824                              name[0], GET_RTX_NAME (appropriate_code));
 825           else
 826             error_with_line (lineno, "constraint names beginning with '%c' "
 827                              "(%s) are reserved for %s constraints",
 828                              name[0], name, GET_RTX_NAME (appropriate_code));
 829           return;
 830         }
 831
 832       if (is_memory)
 833         {
 834           if (name[1] == '\0')
 835             error_with_line (lineno, "constraint letter '%c' cannot be a "
 836                              "memory constraint", name[0]);
 837           else
 838             error_with_line (lineno, "constraint name '%s' begins with '%c', "
 839                              "and therefore cannot be a memory constraint",
 840                              name, name[0]);
 841           return;
 842         }
 843       else if (is_address)
 844         {
 845           if (name[1] == '\0')
 846             error_with_line (lineno, "constraint letter '%c' cannot be a "
 847                              "memory constraint", name[0]);
 848           else
 849             error_with_line (lineno, "constraint name '%s' begins with '%c', "
 850                              "and therefore cannot be a memory constraint",
 851                              name, name[0]);
 852           return;
 853         }
 854     }
 855
 856
 857   c = XOBNEW (rtl_obstack, struct constraint_data);
 858   c->name = name;
 859   c->c_name = need_mangled_name ? mangle (name) : name;
 860   c->lineno = lineno;
 861   c->namelen = namelen;
 862   c->regclass = regclass;
 863   c->exp = exp;
 864   c->is_register = regclass != 0;
 865   c->is_const_int = is_const_int;
 866   c->is_const_dbl = is_const_dbl;
 867   c->is_extra = !(regclass || is_const_int || is_const_dbl);
 868   c->is_memory = is_memory;
 869   c->is_address = is_address;
 870
 871   c->next_this_letter = *slot;
 872   *slot = c;
 873
 874   /* Insert this constraint in the list of all constraints in textual
 875      order.  */
 876   c->next_textual = 0;
 877   *last_constraint_ptr = c;
 878   last_constraint_ptr = &c->next_textual;
 879
 880   constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
 881   have_register_constraints |= c->is_register;
 882   have_const_int_constraints |= c->is_const_int;
 883   have_const_dbl_constraints |= c->is_const_dbl;
 884   have_extra_constraints |= c->is_extra;
 885   have_memory_constraints |= c->is_memory;
 886   have_address_constraints |= c->is_address;
 887 }
 888
 889 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
 890    DEFINE_ADDRESS_CONSTRAINT expression, C.  */
 891 static void
 892 process_define_constraint (rtx c, int lineno)
 893 {
 894   add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
 895                   GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
 896                   GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
 897                   lineno);
 898 }
 899
 900 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C.  */
 901 static void
 902 process_define_register_constraint (rtx c, int lineno)
 903 {
 904   add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
 905 }
 906
 907 /* Write out an enumeration with one entry per machine-specific
 908    constraint.  */
 909 static void
 910 write_enum_constraint_num (void)
 911 {
 912   struct constraint_data *c;
 913
 914   fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
 915   fputs ("enum constraint_num\n"
 916          "{\n"
 917          "  CONSTRAINT__UNKNOWN = 0", stdout);
 918   FOR_ALL_CONSTRAINTS (c)
 919     printf (",\n  CONSTRAINT_%s", c->c_name);
 920   puts (",\n  CONSTRAINT__LIMIT\n};\n");
 921 }
 922
 923 /* Write out a function which looks at a string and determines what
 924    constraint name, if any, it begins with.  */
 925 static void
 926 write_lookup_constraint (void)
 927 {
 928   unsigned int i;
 929   puts ("enum constraint_num\n"
 930         "lookup_constraint (const char *str)\n"
 931         "{\n"
 932         "  switch (str[0])\n"
 933         "    {");
 934
 935   for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
 936     {
 937       struct constraint_data *c = constraints_by_letter_table[i];
 938       if (!c)
 939         continue;
 940
 941       printf ("    case '%c':\n", i);
 942       if (c->namelen == 1)
 943         printf ("      return CONSTRAINT_%s;\n", c->c_name);
 944       else
 945         {
 946           do
 947             {
 948               printf ("      if (!strncmp (str + 1, \"%s\", %lu))\n"
 949                       "        return CONSTRAINT_%s;\n",
 950                       c->name + 1, (unsigned long int) c->namelen - 1,
 951                       c->c_name);
 952               c = c->next_this_letter;
 953             }
 954           while (c);
 955           puts ("      break;");
 956         }
 957     }
 958
 959   puts ("    default: break;\n"
 960         "    }\n"
 961         "  return CONSTRAINT__UNKNOWN;\n"
 962         "}\n");
 963 }
 964
 965 /* Write out a function which looks at a string and determines what
 966    the constraint name length is.  */
 967 static void
 968 write_insn_constraint_len (void)
 969 {
 970   unsigned int i;
 971
 972   puts ("static inline size_t\n"
 973         "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
 974         "{\n"
 975         "  switch (fc)\n"
 976         "    {");
 977
 978   for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
 979     {
 980       struct constraint_data *c = constraints_by_letter_table[i];
 981
 982       if (!c
 983           || c->namelen == 1)
 984         continue;
 985
 986       /* Constraints with multiple characters should have the same
 987          length.  */
 988       {
 989         struct constraint_data *c2 = c->next_this_letter;
 990         size_t len = c->namelen;
 991         while (c2)
 992           {
 993             if (c2->namelen != len)
 994               error ("Multi-letter constraints with first letter '%c' "
 995                      "should have same length", i);
 996             c2 = c2->next_this_letter;
 997           }
 998       }
 999
1000       printf ("    case '%c': return %lu;\n",
1001               i, (unsigned long int) c->namelen);
1002     }
1003
1004   puts ("    default: break;\n"
1005         "    }\n"
1006         "  return 1;\n"
1007         "}\n");
1008 }
1009
1010 /* Write out the function which computes the register class corresponding
1011    to a register constraint.  */
1012 static void
1013 write_regclass_for_constraint (void)
1014 {
1015   struct constraint_data *c;
1016
1017   puts ("enum reg_class\n"
1018         "regclass_for_constraint (enum constraint_num c)\n"
1019         "{\n"
1020         "  switch (c)\n"
1021         "    {");
1022
1023   FOR_ALL_CONSTRAINTS (c)
1024     if (c->is_register)
1025       printf ("    case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1026
1027   puts ("    default: break;\n"
1028         "    }\n"
1029         "  return NO_REGS;\n"
1030         "}\n");
1031 }
1032
1033 /* Write out the functions which compute whether a given value matches
1034    a given non-register constraint.  */
1035 static void
1036 write_tm_constrs_h (void)
1037 {
1038   struct constraint_data *c;
1039
1040   printf ("\
1041 /* Generated automatically by the program '%s'\n\
1042    from the machine description file '%s'.  */\n\n", progname, in_fname);
1043
1044   puts ("\
1045 #ifndef GCC_TM_CONSTRS_H\n\
1046 #define GCC_TM_CONSTRS_H\n");
1047
1048   FOR_ALL_CONSTRAINTS (c)
1049     if (!c->is_register)
1050       {
1051         bool needs_ival = needs_variable (c->exp, "ival");
1052         bool needs_hval = needs_variable (c->exp, "hval");
1053         bool needs_lval = needs_variable (c->exp, "lval");
1054         bool needs_rval = needs_variable (c->exp, "rval");
1055         bool needs_mode = (needs_variable (c->exp, "mode")
1056                            || needs_hval || needs_lval || needs_rval);
1057         bool needs_op = (needs_variable (c->exp, "op")
1058                          || needs_ival || needs_mode);
1059
1060         printf ("static inline bool\n"
1061                 "satisfies_constraint_%s (rtx %s)\n"
1062                 "{\n", c->c_name,
1063                 needs_op ? "op" : "ARG_UNUSED (op)");
1064         if (needs_mode)
1065           puts ("  enum machine_mode mode = GET_MODE (op);");
1066         if (needs_ival)
1067           puts ("  HOST_WIDE_INT ival = 0;");
1068         if (needs_hval)
1069           puts ("  HOST_WIDE_INT hval = 0;");
1070         if (needs_lval)
1071           puts ("  unsigned HOST_WIDE_INT lval = 0;");
1072         if (needs_rval)
1073           puts ("  const REAL_VALUE_TYPE *rval = 0;");
1074
1075         if (needs_ival)
1076           puts ("  if (CONST_INT_P (op))\n"
1077                 "    ival = INTVAL (op);");
1078         if (needs_hval)
1079           puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1080                 "    hval = CONST_DOUBLE_HIGH (op);");
1081         if (needs_lval)
1082           puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1083                 "    lval = CONST_DOUBLE_LOW (op);");
1084         if (needs_rval)
1085           puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1086                 "    rval = CONST_DOUBLE_REAL_VALUE (op);");
1087
1088         write_predicate_stmts (c->exp);
1089         fputs ("}\n", stdout);
1090       }
1091   puts ("#endif /* tm-constrs.h */");
1092 }
1093
1094 /* Write out the wrapper function, constraint_satisfied_p, that maps
1095    a CONSTRAINT_xxx constant to one of the predicate functions generated
1096    above.  */
1097 static void
1098 write_constraint_satisfied_p (void)
1099 {
1100   struct constraint_data *c;
1101
1102   puts ("bool\n"
1103         "constraint_satisfied_p (rtx op, enum constraint_num c)\n"
1104         "{\n"
1105         "  switch (c)\n"
1106         "    {");
1107
1108   FOR_ALL_CONSTRAINTS (c)
1109     if (!c->is_register)
1110       printf ("    case CONSTRAINT_%s: "
1111               "return satisfies_constraint_%s (op);\n",
1112               c->c_name, c->c_name);
1113
1114   puts ("    default: break;\n"
1115         "    }\n"
1116         "  return false;\n"
1117         "}\n");
1118 }
1119
1120 /* Write out the function which computes whether a given value matches
1121    a given CONST_INT constraint.  This doesn't just forward to
1122    constraint_satisfied_p because caller passes the INTVAL, not the RTX.  */
1123 static void
1124 write_insn_const_int_ok_for_constraint (void)
1125 {
1126   struct constraint_data *c;
1127
1128   puts ("bool\n"
1129         "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1130                                           "enum constraint_num c)\n"
1131         "{\n"
1132         "  switch (c)\n"
1133         "    {");
1134
1135   FOR_ALL_CONSTRAINTS (c)
1136     if (c->is_const_int)
1137       {
1138         printf ("    case CONSTRAINT_%s:\n      return ", c->c_name);
1139         /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1140            we know at this point that we have a const_int, so we need not
1141            bother with that part of the test.  */
1142         write_predicate_expr (XEXP (c->exp, 1));
1143         fputs (";\n\n", stdout);
1144       }
1145
1146   puts ("    default: break;\n"
1147         "    }\n"
1148         "  return false;\n"
1149         "}\n");
1150 }
1151
1152
1153 /* Write out the function which computes whether a given constraint is
1154    a memory constraint.  */
1155 static void
1156 write_insn_extra_memory_constraint (void)
1157 {
1158   struct constraint_data *c;
1159
1160   puts ("bool\n"
1161         "insn_extra_memory_constraint (enum constraint_num c)\n"
1162         "{\n"
1163         "  switch (c)\n"
1164         "    {");
1165
1166   FOR_ALL_CONSTRAINTS (c)
1167     if (c->is_memory)
1168       printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
1169
1170   puts ("    default: break;\n"
1171         "    }\n"
1172         "  return false;\n"
1173         "}\n");
1174 }
1175
1176 /* Write out the function which computes whether a given constraint is
1177    an address constraint.  */
1178 static void
1179 write_insn_extra_address_constraint (void)
1180 {
1181   struct constraint_data *c;
1182
1183   puts ("bool\n"
1184         "insn_extra_address_constraint (enum constraint_num c)\n"
1185         "{\n"
1186         "  switch (c)\n"
1187         "    {");
1188
1189   FOR_ALL_CONSTRAINTS (c)
1190     if (c->is_address)
1191       printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
1192
1193   puts ("    default: break;\n"
1194         "    }\n"
1195         "  return false;\n"
1196         "}\n");
1197 }
1198
1199 \f
1200 /* Write tm-preds.h.  Unfortunately, it is impossible to forward-declare
1201    an enumeration in portable C, so we have to condition all these
1202    prototypes on HAVE_MACHINE_MODES.  */
1203 static void
1204 write_tm_preds_h (void)
1205 {
1206   struct pred_data *p;
1207
1208   printf ("\
1209 /* Generated automatically by the program '%s'\n\
1210    from the machine description file '%s'.  */\n\n", progname, in_fname);
1211
1212   puts ("\
1213 #ifndef GCC_TM_PREDS_H\n\
1214 #define GCC_TM_PREDS_H\n\
1215 \n\
1216 #ifdef HAVE_MACHINE_MODES");
1217
1218   FOR_ALL_PREDICATES (p)
1219     printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
1220
1221   puts ("#endif /* HAVE_MACHINE_MODES */\n");
1222
1223   if (constraint_max_namelen > 0)
1224     {
1225       write_enum_constraint_num ();
1226       puts ("extern enum constraint_num lookup_constraint (const char *);\n"
1227             "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
1228
1229       if (constraint_max_namelen > 1)
1230         {
1231           write_insn_constraint_len ();
1232           puts ("#define CONSTRAINT_LEN(c_,s_) "
1233                 "insn_constraint_len (c_,s_)\n");
1234         }
1235       else
1236         puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1237       if (have_register_constraints)
1238         puts ("extern enum reg_class regclass_for_constraint "
1239               "(enum constraint_num);\n"
1240               "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
1241               "    regclass_for_constraint (lookup_constraint (s_))\n"
1242               "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1243               "    regclass_for_constraint (x_)\n");
1244       else
1245         puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n"
1246               "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n"
1247               "    NO_REGS\n");
1248       if (have_const_int_constraints)
1249         puts ("extern bool insn_const_int_ok_for_constraint "
1250               "(HOST_WIDE_INT, enum constraint_num);\n"
1251               "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1252               "    insn_const_int_ok_for_constraint (v_, "
1253               "lookup_constraint (s_))\n");
1254       if (have_const_dbl_constraints)
1255         puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1256               "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1257       else
1258         puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
1259       if (have_extra_constraints)
1260         puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
1261               "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
1262       if (have_memory_constraints)
1263         puts ("extern bool "
1264               "insn_extra_memory_constraint (enum constraint_num);\n"
1265               "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
1266               "insn_extra_memory_constraint (lookup_constraint (s_))\n");
1267       else
1268         puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
1269       if (have_address_constraints)
1270         puts ("extern bool "
1271               "insn_extra_address_constraint (enum constraint_num);\n"
1272               "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
1273               "insn_extra_address_constraint (lookup_constraint (s_))\n");
1274       else
1275         puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
1276     }
1277
1278   puts ("#endif /* tm-preds.h */");
1279 }
1280
1281 /* Write insn-preds.c.
1282    N.B. the list of headers to include was copied from genrecog; it
1283    may not be ideal.
1284
1285    FUTURE: Write #line markers referring back to the machine
1286    description.  (Can't practically do this now since we don't know
1287    the line number of the C block - just the line number of the enclosing
1288    expression.)  */
1289 static void
1290 write_insn_preds_c (void)
1291 {
1292   struct pred_data *p;
1293
1294   printf ("\
1295 /* Generated automatically by the program '%s'\n\
1296    from the machine description file '%s'.  */\n\n", progname, in_fname);
1297
1298   puts ("\
1299 #include \"config.h\"\n\
1300 #include \"system.h\"\n\
1301 #include \"coretypes.h\"\n\
1302 #include \"tm.h\"\n\
1303 #include \"rtl.h\"\n\
1304 #include \"tree.h\"\n\
1305 #include \"tm_p.h\"\n\
1306 #include \"function.h\"\n\
1307 #include \"insn-config.h\"\n\
1308 #include \"recog.h\"\n\
1309 #include \"output.h\"\n\
1310 #include \"flags.h\"\n\
1311 #include \"hard-reg-set.h\"\n\
1312 #include \"resource.h\"\n\
1313 #include \"diagnostic-core.h\"\n\
1314 #include \"reload.h\"\n\
1315 #include \"regs.h\"\n\
1316 #include \"tm-constrs.h\"\n");
1317
1318   FOR_ALL_PREDICATES (p)
1319     write_one_predicate_function (p);
1320
1321   if (constraint_max_namelen > 0)
1322     {
1323       write_lookup_constraint ();
1324       if (have_register_constraints)
1325         write_regclass_for_constraint ();
1326       write_constraint_satisfied_p ();
1327
1328       if (have_const_int_constraints)
1329         write_insn_const_int_ok_for_constraint ();
1330
1331       if (have_memory_constraints)
1332         write_insn_extra_memory_constraint ();
1333       if (have_address_constraints)
1334         write_insn_extra_address_constraint ();
1335     }
1336 }
1337
1338 /* Argument parsing.  */
1339 static bool gen_header;
1340 static bool gen_constrs;
1341
1342 static bool
1343 parse_option (const char *opt)
1344 {
1345   if (!strcmp (opt, "-h"))
1346     {
1347       gen_header = true;
1348       return 1;
1349     }
1350   else if (!strcmp (opt, "-c"))
1351     {
1352       gen_constrs = true;
1353       return 1;
1354     }
1355   else
1356     return 0;
1357 }
1358
1359 /* Master control.  */
1360 int
1361 main (int argc, char **argv)
1362 {
1363   rtx defn;
1364   int pattern_lineno, next_insn_code = 0;
1365
1366   progname = argv[0];
1367   if (argc <= 1)
1368     fatal ("no input file name");
1369   if (!init_rtx_reader_args_cb (argc, argv, parse_option))
1370     return FATAL_EXIT_CODE;
1371
1372   while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
1373     switch (GET_CODE (defn))
1374       {
1375       case DEFINE_PREDICATE:
1376       case DEFINE_SPECIAL_PREDICATE:
1377         process_define_predicate (defn, pattern_lineno);
1378         break;
1379
1380       case DEFINE_CONSTRAINT:
1381       case DEFINE_MEMORY_CONSTRAINT:
1382       case DEFINE_ADDRESS_CONSTRAINT:
1383         process_define_constraint (defn, pattern_lineno);
1384         break;
1385
1386       case DEFINE_REGISTER_CONSTRAINT:
1387         process_define_register_constraint (defn, pattern_lineno);
1388         break;
1389
1390       default:
1391         break;
1392       }
1393
1394   if (gen_header)
1395     write_tm_preds_h ();
1396   else if (gen_constrs)
1397     write_tm_constrs_h ();
1398   else
1399     write_insn_preds_c ();
1400
1401   if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1402     return FATAL_EXIT_CODE;
1403
1404   return SUCCESS_EXIT_CODE;
1405 }