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