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