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