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-2020 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 ATTRIBUTE_UNUSED, 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 class constraint_data
 670 {
 671 public:
 672   class constraint_data *next_this_letter;
 673   class constraint_data *next_textual;
 674   const char *name;
 675   const char *c_name;    /* same as .name unless mangling is necessary */
 676   file_location loc;     /* location of definition */
 677   size_t namelen;
 678   const char *regclass;  /* for register constraints */
 679   rtx exp;               /* for other constraints */
 680   unsigned int is_register      : 1;
 681   unsigned int is_const_int     : 1;
 682   unsigned int is_const_dbl     : 1;
 683   unsigned int is_extra         : 1;
 684   unsigned int is_memory        : 1;
 685   unsigned int is_special_memory: 1;
 686   unsigned int is_address       : 1;
 687   unsigned int maybe_allows_reg : 1;
 688   unsigned int maybe_allows_mem : 1;
 689 };
 690
 691 /* Overview of all constraints beginning with a given letter.  */
 692
 693 static class constraint_data *
 694 constraints_by_letter_table[1<<CHAR_BIT];
 695
 696 /* For looking up all the constraints in the order that they appeared
 697    in the machine description.  */
 698 static class constraint_data *first_constraint;
 699 static class constraint_data **last_constraint_ptr = &first_constraint;
 700
 701 #define FOR_ALL_CONSTRAINTS(iter_) \
 702   for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
 703
 704 /* Contraint letters that have a special meaning and that cannot be used
 705    in define*_constraints.  */
 706 static const char generic_constraint_letters[] = "g";
 707
 708 /* Machine-independent code expects that constraints with these
 709    (initial) letters will allow only (a subset of all) CONST_INTs.  */
 710
 711 static const char const_int_constraints[] = "IJKLMNOP";
 712
 713 /* Machine-independent code expects that constraints with these
 714    (initial) letters will allow only (a subset of all) CONST_DOUBLEs.  */
 715
 716 static const char const_dbl_constraints[] = "GH";
 717
 718 /* Summary data used to decide whether to output various functions and
 719    macro definitions.  */
 720 static unsigned int constraint_max_namelen;
 721 static bool have_register_constraints;
 722 static bool have_memory_constraints;
 723 static bool have_special_memory_constraints;
 724 static bool have_address_constraints;
 725 static bool have_extra_constraints;
 726 static bool have_const_int_constraints;
 727 static unsigned int num_constraints;
 728
 729 static const constraint_data **enum_order;
 730 static unsigned int register_start, register_end;
 731 static unsigned int satisfied_start;
 732 static unsigned int const_int_start, const_int_end;
 733 static unsigned int memory_start, memory_end;
 734 static unsigned int special_memory_start, special_memory_end;
 735 static unsigned int address_start, address_end;
 736 static unsigned int maybe_allows_none_start, maybe_allows_none_end;
 737 static unsigned int maybe_allows_reg_start, maybe_allows_reg_end;
 738 static unsigned int maybe_allows_mem_start, maybe_allows_mem_end;
 739
 740 /* Convert NAME, which contains angle brackets and/or underscores, to
 741    a string that can be used as part of a C identifier.  The string
 742    comes from the rtl_obstack.  */
 743 static const char *
 744 mangle (const char *name)
 745 {
 746   for (; *name; name++)
 747     switch (*name)
 748       {
 749       case '_': obstack_grow (rtl_obstack, "__", 2); break;
 750       case '<': obstack_grow (rtl_obstack, "_l", 2); break;
 751       case '>': obstack_grow (rtl_obstack, "_g", 2); break;
 752       default: obstack_1grow (rtl_obstack, *name); break;
 753       }
 754
 755   obstack_1grow (rtl_obstack, '\0');
 756   return XOBFINISH (rtl_obstack, const char *);
 757 }
 758
 759 /* Add one constraint, of any sort, to the tables.  NAME is its name;
 760    REGCLASS is the register class, if any; EXP is the expression to
 761    test, if any; IS_MEMORY, IS_SPECIAL_MEMORY and IS_ADDRESS indicate
 762    memory, special memory, and address constraints, respectively; LOC
 763    is the .md file location.
 764
 765    Not all combinations of arguments are valid; most importantly,
 766    REGCLASS is mutually exclusive with EXP, and
 767    IS_MEMORY/IS_SPECIAL_MEMORY/IS_ADDRESS are only meaningful for
 768    constraints with EXP.
 769
 770    This function enforces all syntactic and semantic rules about what
 771    constraints can be defined.  */
 772
 773 static void
 774 add_constraint (const char *name, const char *regclass,
 775                 rtx exp, bool is_memory, bool is_special_memory,
 776                 bool is_address, file_location loc)
 777 {
 778   class constraint_data *c, **iter, **slot;
 779   const char *p;
 780   bool need_mangled_name = false;
 781   bool is_const_int;
 782   bool is_const_dbl;
 783   size_t namelen;
 784
 785   if (strcmp (name, "TARGET_MEM_CONSTRAINT") == 0)
 786     name = general_mem;
 787
 788   if (exp && validate_exp (exp, name, loc))
 789     return;
 790
 791   for (p = name; *p; p++)
 792     if (!ISALNUM (*p))
 793       {
 794         if (*p == '<' || *p == '>' || *p == '_')
 795           need_mangled_name = true;
 796         else
 797           {
 798             error_at (loc, "constraint name '%s' must be composed of letters,"
 799                       " digits, underscores, and angle brackets", name);
 800             return;
 801           }
 802       }
 803
 804   if (strchr (generic_constraint_letters, name[0]))
 805     {
 806       if (name[1] == '\0')
 807         error_at (loc, "constraint letter '%s' cannot be "
 808                   "redefined by the machine description", name);
 809       else
 810         error_at (loc, "constraint name '%s' cannot be defined by the machine"
 811                   " description, as it begins with '%c'", name, name[0]);
 812       return;
 813     }
 814
 815
 816   namelen = strlen (name);
 817   slot = &constraints_by_letter_table[(unsigned int)name[0]];
 818   for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
 819     {
 820       /* This causes slot to end up pointing to the
 821          next_this_letter field of the last constraint with a name
 822          of equal or greater length than the new constraint; hence
 823          the new constraint will be inserted after all previous
 824          constraints with names of the same length.  */
 825       if ((*iter)->namelen >= namelen)
 826         slot = iter;
 827
 828       if (!strcmp ((*iter)->name, name))
 829         {
 830           error_at (loc, "redefinition of constraint '%s'", name);
 831           message_at ((*iter)->loc, "previous definition is here");
 832           return;
 833         }
 834       else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
 835         {
 836           error_at (loc, "defining constraint '%s' here", name);
 837           message_at ((*iter)->loc, "renders constraint '%s' "
 838                       "(defined here) a prefix", (*iter)->name);
 839           return;
 840         }
 841       else if (!strncmp ((*iter)->name, name, namelen))
 842         {
 843           error_at (loc, "constraint '%s' is a prefix", name);
 844           message_at ((*iter)->loc, "of constraint '%s' (defined here)",
 845                       (*iter)->name);
 846           return;
 847         }
 848     }
 849
 850   is_const_int = strchr (const_int_constraints, name[0]) != 0;
 851   is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
 852
 853   if (is_const_int || is_const_dbl)
 854     {
 855       enum rtx_code appropriate_code
 856         = is_const_int ? CONST_INT : CONST_DOUBLE;
 857
 858       /* Consider relaxing this requirement in the future.  */
 859       if (regclass
 860           || GET_CODE (exp) != AND
 861           || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
 862           || strcmp (XSTR (XEXP (exp, 0), 0),
 863                      GET_RTX_NAME (appropriate_code)))
 864         {
 865           if (name[1] == '\0')
 866             error_at (loc, "constraint letter '%c' is reserved "
 867                       "for %s constraints", name[0],
 868                       GET_RTX_NAME (appropriate_code));
 869           else
 870             error_at (loc, "constraint names beginning with '%c' "
 871                       "(%s) are reserved for %s constraints",
 872                       name[0], name, GET_RTX_NAME (appropriate_code));
 873           return;
 874         }
 875
 876       if (is_memory)
 877         {
 878           if (name[1] == '\0')
 879             error_at (loc, "constraint letter '%c' cannot be a "
 880                       "memory constraint", name[0]);
 881           else
 882             error_at (loc, "constraint name '%s' begins with '%c', "
 883                       "and therefore cannot be a memory constraint",
 884                       name, name[0]);
 885           return;
 886         }
 887       else if (is_special_memory)
 888         {
 889           if (name[1] == '\0')
 890             error_at (loc, "constraint letter '%c' cannot be a "
 891                       "special memory constraint", name[0]);
 892           else
 893             error_at (loc, "constraint name '%s' begins with '%c', "
 894                       "and therefore cannot be a special memory constraint",
 895                       name, name[0]);
 896           return;
 897         }
 898       else if (is_address)
 899         {
 900           if (name[1] == '\0')
 901             error_at (loc, "constraint letter '%c' cannot be an "
 902                       "address constraint", name[0]);
 903           else
 904             error_at (loc, "constraint name '%s' begins with '%c', "
 905                       "and therefore cannot be an address constraint",
 906                       name, name[0]);
 907           return;
 908         }
 909     }
 910
 911
 912   c = XOBNEW (rtl_obstack, class constraint_data);
 913   c->name = name;
 914   c->c_name = need_mangled_name ? mangle (name) : name;
 915   c->loc = loc;
 916   c->namelen = namelen;
 917   c->regclass = regclass;
 918   c->exp = exp;
 919   c->is_register = regclass != 0;
 920   c->is_const_int = is_const_int;
 921   c->is_const_dbl = is_const_dbl;
 922   c->is_extra = !(regclass || is_const_int || is_const_dbl);
 923   c->is_memory = is_memory;
 924   c->is_special_memory = is_special_memory;
 925   c->is_address = is_address;
 926   c->maybe_allows_reg = true;
 927   c->maybe_allows_mem = true;
 928   if (exp)
 929     {
 930       char codes[NUM_RTX_CODE];
 931       compute_test_codes (exp, loc, codes);
 932       if (!codes[REG] && !codes[SUBREG])
 933         c->maybe_allows_reg = false;
 934       if (!codes[MEM])
 935         c->maybe_allows_mem = false;
 936     }
 937   c->next_this_letter = *slot;
 938   *slot = c;
 939
 940   /* Insert this constraint in the list of all constraints in textual
 941      order.  */
 942   c->next_textual = 0;
 943   *last_constraint_ptr = c;
 944   last_constraint_ptr = &c->next_textual;
 945
 946   constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
 947   have_register_constraints |= c->is_register;
 948   have_const_int_constraints |= c->is_const_int;
 949   have_extra_constraints |= c->is_extra;
 950   have_memory_constraints |= c->is_memory;
 951   have_special_memory_constraints |= c->is_special_memory;
 952   have_address_constraints |= c->is_address;
 953   num_constraints += 1;
 954 }
 955
 956 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT,
 957    DEFINE_SPECIAL_MEMORY_CONSTRAINT, or DEFINE_ADDRESS_CONSTRAINT
 958    expression, C.  */
 959 static void
 960 process_define_constraint (md_rtx_info *info)
 961 {
 962   add_constraint (XSTR (info->def, 0), 0, XEXP (info->def, 2),
 963                   GET_CODE (info->def) == DEFINE_MEMORY_CONSTRAINT,
 964                   GET_CODE (info->def) == DEFINE_SPECIAL_MEMORY_CONSTRAINT,
 965                   GET_CODE (info->def) == DEFINE_ADDRESS_CONSTRAINT,
 966                   info->loc);
 967 }
 968
 969 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C.  */
 970 static void
 971 process_define_register_constraint (md_rtx_info *info)
 972 {
 973   add_constraint (XSTR (info->def, 0), XSTR (info->def, 1),
 974                   0, false, false, false, info->loc);
 975 }
 976
 977 /* Put the constraints into enum order.  We want to keep constraints
 978    of the same type together so that query functions can be simple
 979    range checks.  */
 980 static void
 981 choose_enum_order (void)
 982 {
 983   class constraint_data *c;
 984
 985   enum_order = XNEWVEC (const constraint_data *, num_constraints);
 986   unsigned int next = 0;
 987
 988   register_start = next;
 989   FOR_ALL_CONSTRAINTS (c)
 990     if (c->is_register)
 991       enum_order[next++] = c;
 992   register_end = next;
 993
 994   satisfied_start = next;
 995
 996   const_int_start = next;
 997   FOR_ALL_CONSTRAINTS (c)
 998     if (c->is_const_int)
 999       enum_order[next++] = c;
1000   const_int_end = next;
1001
1002   memory_start = next;
1003   FOR_ALL_CONSTRAINTS (c)
1004     if (c->is_memory)
1005       enum_order[next++] = c;
1006   memory_end = next;
1007
1008   special_memory_start = next;
1009   FOR_ALL_CONSTRAINTS (c)
1010     if (c->is_special_memory)
1011       enum_order[next++] = c;
1012   special_memory_end = next;
1013
1014   address_start = next;
1015   FOR_ALL_CONSTRAINTS (c)
1016     if (c->is_address)
1017       enum_order[next++] = c;
1018   address_end = next;
1019
1020   maybe_allows_none_start = next;
1021   FOR_ALL_CONSTRAINTS (c)
1022     if (!c->is_register && !c->is_const_int && !c->is_memory
1023         && !c->is_special_memory && !c->is_address
1024         && !c->maybe_allows_reg && !c->maybe_allows_mem)
1025       enum_order[next++] = c;
1026   maybe_allows_none_end = next;
1027
1028   maybe_allows_reg_start = next;
1029   FOR_ALL_CONSTRAINTS (c)
1030     if (!c->is_register && !c->is_const_int && !c->is_memory
1031         && !c->is_special_memory && !c->is_address
1032         && c->maybe_allows_reg && !c->maybe_allows_mem)
1033       enum_order[next++] = c;
1034   maybe_allows_reg_end = next;
1035
1036   maybe_allows_mem_start = next;
1037   FOR_ALL_CONSTRAINTS (c)
1038     if (!c->is_register && !c->is_const_int && !c->is_memory
1039         && !c->is_special_memory && !c->is_address
1040         && !c->maybe_allows_reg && c->maybe_allows_mem)
1041       enum_order[next++] = c;
1042   maybe_allows_mem_end = next;
1043
1044   FOR_ALL_CONSTRAINTS (c)
1045     if (!c->is_register && !c->is_const_int && !c->is_memory
1046         && !c->is_special_memory && !c->is_address
1047         && c->maybe_allows_reg && c->maybe_allows_mem)
1048       enum_order[next++] = c;
1049   gcc_assert (next == num_constraints);
1050 }
1051
1052 /* Write out an enumeration with one entry per machine-specific
1053    constraint.  */
1054 static void
1055 write_enum_constraint_num (void)
1056 {
1057   fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout);
1058   fputs ("enum constraint_num\n"
1059          "{\n"
1060          "  CONSTRAINT__UNKNOWN = 0", stdout);
1061   for (unsigned int i = 0; i < num_constraints; ++i)
1062     printf (",\n  CONSTRAINT_%s", enum_order[i]->c_name);
1063   puts (",\n  CONSTRAINT__LIMIT\n};\n");
1064 }
1065
1066 /* Write out a function which looks at a string and determines what
1067    constraint name, if any, it begins with.  */
1068 static void
1069 write_lookup_constraint_1 (void)
1070 {
1071   unsigned int i;
1072   puts ("enum constraint_num\n"
1073         "lookup_constraint_1 (const char *str)\n"
1074         "{\n"
1075         "  switch (str[0])\n"
1076         "    {");
1077
1078   for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
1079     {
1080       class constraint_data *c = constraints_by_letter_table[i];
1081       if (!c)
1082         continue;
1083
1084       printf ("    case '%c':\n", i);
1085       if (c->namelen == 1)
1086         printf ("      return CONSTRAINT_%s;\n", c->c_name);
1087       else
1088         {
1089           do
1090             {
1091               printf ("      if (!strncmp (str + 1, \"%s\", %lu))\n"
1092                       "        return CONSTRAINT_%s;\n",
1093                       c->name + 1, (unsigned long int) c->namelen - 1,
1094                       c->c_name);
1095               c = c->next_this_letter;
1096             }
1097           while (c);
1098           puts ("      break;");
1099         }
1100     }
1101
1102   puts ("    default: break;\n"
1103         "    }\n"
1104         "  return CONSTRAINT__UNKNOWN;\n"
1105         "}\n");
1106 }
1107
1108 /* Write out an array that maps single-letter characters to their
1109    constraints (if that fits in a character) or 255 if lookup_constraint_1
1110    must be called.  */
1111 static void
1112 write_lookup_constraint_array (void)
1113 {
1114   unsigned int i;
1115   printf ("const unsigned char lookup_constraint_array[] = {\n  ");
1116   for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
1117     {
1118       if (i != 0)
1119         printf (",\n  ");
1120       class constraint_data *c = constraints_by_letter_table[i];
1121       if (!c)
1122         printf ("CONSTRAINT__UNKNOWN");
1123       else if (c->namelen == 1)
1124         printf ("MIN ((int) CONSTRAINT_%s, (int) UCHAR_MAX)", c->c_name);
1125       else
1126         printf ("UCHAR_MAX");
1127     }
1128   printf ("\n};\n\n");
1129 }
1130
1131 /* Write out a function which looks at a string and determines what
1132    the constraint name length is.  */
1133 static void
1134 write_insn_constraint_len (void)
1135 {
1136   unsigned int i;
1137
1138   puts ("static inline size_t\n"
1139         "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n"
1140         "{\n"
1141         "  switch (fc)\n"
1142         "    {");
1143
1144   for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
1145     {
1146       class constraint_data *c = constraints_by_letter_table[i];
1147
1148       if (!c
1149           || c->namelen == 1)
1150         continue;
1151
1152       /* Constraints with multiple characters should have the same
1153          length.  */
1154       {
1155         class constraint_data *c2 = c->next_this_letter;
1156         size_t len = c->namelen;
1157         while (c2)
1158           {
1159             if (c2->namelen != len)
1160               error ("Multi-letter constraints with first letter '%c' "
1161                      "should have same length", i);
1162             c2 = c2->next_this_letter;
1163           }
1164       }
1165
1166       printf ("    case '%c': return %lu;\n",
1167               i, (unsigned long int) c->namelen);
1168     }
1169
1170   puts ("    default: break;\n"
1171         "    }\n"
1172         "  return 1;\n"
1173         "}\n");
1174 }
1175
1176 /* Write out the function which computes the register class corresponding
1177    to a register constraint.  */
1178 static void
1179 write_reg_class_for_constraint_1 (void)
1180 {
1181   class constraint_data *c;
1182
1183   puts ("enum reg_class\n"
1184         "reg_class_for_constraint_1 (enum constraint_num c)\n"
1185         "{\n"
1186         "  switch (c)\n"
1187         "    {");
1188
1189   FOR_ALL_CONSTRAINTS (c)
1190     if (c->is_register)
1191       printf ("    case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
1192
1193   puts ("    default: break;\n"
1194         "    }\n"
1195         "  return NO_REGS;\n"
1196         "}\n");
1197 }
1198
1199 /* Write out the functions which compute whether a given value matches
1200    a given non-register constraint.  */
1201 static void
1202 write_tm_constrs_h (void)
1203 {
1204   class constraint_data *c;
1205
1206   printf ("\
1207 /* Generated automatically by the program '%s'\n\
1208    from the machine description file '%s'.  */\n\n", progname,
1209           md_reader_ptr->get_top_level_filename ());
1210
1211   puts ("\
1212 #ifndef GCC_TM_CONSTRS_H\n\
1213 #define GCC_TM_CONSTRS_H\n");
1214
1215   FOR_ALL_CONSTRAINTS (c)
1216     if (!c->is_register)
1217       {
1218         bool needs_ival = needs_variable (c->exp, "ival");
1219         bool needs_hval = needs_variable (c->exp, "hval");
1220         bool needs_lval = needs_variable (c->exp, "lval");
1221         bool needs_rval = needs_variable (c->exp, "rval");
1222         bool needs_mode = (needs_variable (c->exp, "mode")
1223                            || needs_hval || needs_lval || needs_rval);
1224         bool needs_op = (needs_variable (c->exp, "op")
1225                          || needs_ival || needs_mode);
1226
1227         printf ("static inline bool\n"
1228                 "satisfies_constraint_%s (rtx %s)\n"
1229                 "{\n", c->c_name,
1230                 needs_op ? "op" : "ARG_UNUSED (op)");
1231         if (needs_mode)
1232           puts ("  machine_mode mode = GET_MODE (op);");
1233         if (needs_ival)
1234           puts ("  HOST_WIDE_INT ival = 0;");
1235         if (needs_hval)
1236           puts ("  HOST_WIDE_INT hval = 0;");
1237         if (needs_lval)
1238           puts ("  unsigned HOST_WIDE_INT lval = 0;");
1239         if (needs_rval)
1240           puts ("  const REAL_VALUE_TYPE *rval = 0;");
1241
1242         if (needs_ival)
1243           puts ("  if (CONST_INT_P (op))\n"
1244                 "    ival = INTVAL (op);");
1245 #if TARGET_SUPPORTS_WIDE_INT
1246         if (needs_lval || needs_hval)
1247           error ("you can't use lval or hval");
1248 #else
1249         if (needs_hval)
1250           puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1251                 "    hval = CONST_DOUBLE_HIGH (op);");
1252         if (needs_lval)
1253           puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
1254                 "    lval = CONST_DOUBLE_LOW (op);");
1255 #endif
1256         if (needs_rval)
1257           puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
1258                 "    rval = CONST_DOUBLE_REAL_VALUE (op);");
1259
1260         write_predicate_stmts (c->exp);
1261         fputs ("}\n", stdout);
1262       }
1263   puts ("#endif /* tm-constrs.h */");
1264 }
1265
1266 /* Write out the wrapper function, constraint_satisfied_p, that maps
1267    a CONSTRAINT_xxx constant to one of the predicate functions generated
1268    above.  */
1269 static void
1270 write_constraint_satisfied_p_array (void)
1271 {
1272   if (satisfied_start == num_constraints)
1273     return;
1274
1275   printf ("bool (*constraint_satisfied_p_array[]) (rtx) = {\n  ");
1276   for (unsigned int i = satisfied_start; i < num_constraints; ++i)
1277     {
1278       if (i != satisfied_start)
1279         printf (",\n  ");
1280       printf ("satisfies_constraint_%s", enum_order[i]->c_name);
1281     }
1282   printf ("\n};\n\n");
1283 }
1284
1285 /* Write out the function which computes whether a given value matches
1286    a given CONST_INT constraint.  This doesn't just forward to
1287    constraint_satisfied_p because caller passes the INTVAL, not the RTX.  */
1288 static void
1289 write_insn_const_int_ok_for_constraint (void)
1290 {
1291   class constraint_data *c;
1292
1293   puts ("bool\n"
1294         "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
1295                                           "enum constraint_num c)\n"
1296         "{\n"
1297         "  switch (c)\n"
1298         "    {");
1299
1300   FOR_ALL_CONSTRAINTS (c)
1301     if (c->is_const_int)
1302       {
1303         printf ("    case CONSTRAINT_%s:\n      return ", c->c_name);
1304         /* c->exp is guaranteed to be (and (match_code "const_int") (...));
1305            we know at this point that we have a const_int, so we need not
1306            bother with that part of the test.  */
1307         write_predicate_expr (XEXP (c->exp, 1));
1308         fputs (";\n\n", stdout);
1309       }
1310
1311   puts ("    default: break;\n"
1312         "    }\n"
1313         "  return false;\n"
1314         "}\n");
1315 }
1316 \f
1317 /* Write a definition for a function NAME that returns true if a given
1318    constraint_num is in the range [START, END).  */
1319 static void
1320 write_range_function (const char *name, unsigned int start, unsigned int end)
1321 {
1322   printf ("static inline bool\n");
1323   if (start != end)
1324     printf ("%s (enum constraint_num c)\n"
1325             "{\n"
1326             "  return c >= CONSTRAINT_%s && c <= CONSTRAINT_%s;\n"
1327             "}\n\n",
1328             name, enum_order[start]->c_name, enum_order[end - 1]->c_name);
1329   else
1330     printf ("%s (enum constraint_num)\n"
1331             "{\n"
1332             "  return false;\n"
1333             "}\n\n", name);
1334 }
1335
1336 /* Write a definition for insn_extra_constraint_allows_reg_mem function.  */
1337 static void
1338 write_allows_reg_mem_function (void)
1339 {
1340   printf ("static inline void\n"
1341           "insn_extra_constraint_allows_reg_mem (enum constraint_num c,\n"
1342           "\t\t\t\t      bool *allows_reg, bool *allows_mem)\n"
1343           "{\n");
1344   if (maybe_allows_none_start != maybe_allows_none_end)
1345     printf ("  if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1346             "    return;\n",
1347             enum_order[maybe_allows_none_start]->c_name,
1348             enum_order[maybe_allows_none_end - 1]->c_name);
1349   if (maybe_allows_reg_start != maybe_allows_reg_end)
1350     printf ("  if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1351             "    {\n"
1352             "      *allows_reg = true;\n"
1353             "      return;\n"
1354             "    }\n",
1355             enum_order[maybe_allows_reg_start]->c_name,
1356             enum_order[maybe_allows_reg_end - 1]->c_name);
1357   if (maybe_allows_mem_start != maybe_allows_mem_end)
1358     printf ("  if (c >= CONSTRAINT_%s && c <= CONSTRAINT_%s)\n"
1359             "    {\n"
1360             "      *allows_mem = true;\n"
1361             "      return;\n"
1362             "    }\n",
1363             enum_order[maybe_allows_mem_start]->c_name,
1364             enum_order[maybe_allows_mem_end - 1]->c_name);
1365   printf ("  (void) c;\n"
1366           "  *allows_reg = true;\n"
1367           "  *allows_mem = true;\n"
1368           "}\n\n");
1369 }
1370
1371 /* VEC is a list of key/value pairs, with the keys being lower bounds
1372    of a range.  Output a decision tree that handles the keys covered by
1373    [VEC[START], VEC[END]), returning FALLBACK for keys lower then VEC[START]'s.
1374    INDENT is the number of spaces to indent the code.  */
1375 static void
1376 print_type_tree (const vec <std::pair <unsigned int, const char *> > &vec,
1377                  unsigned int start, unsigned int end, const char *fallback,
1378                  unsigned int indent)
1379 {
1380   while (start < end)
1381     {
1382       unsigned int mid = (start + end) / 2;
1383       printf ("%*sif (c >= CONSTRAINT_%s)\n",
1384               indent, "", enum_order[vec[mid].first]->c_name);
1385       if (mid + 1 == end)
1386         print_type_tree (vec, mid + 1, end, vec[mid].second, indent + 2);
1387       else
1388         {
1389           printf ("%*s{\n", indent + 2, "");
1390           print_type_tree (vec, mid + 1, end, vec[mid].second, indent + 4);
1391           printf ("%*s}\n", indent + 2, "");
1392         }
1393       end = mid;
1394     }
1395   printf ("%*sreturn %s;\n", indent, "", fallback);
1396 }
1397
1398 /* Write tm-preds.h.  Unfortunately, it is impossible to forward-declare
1399    an enumeration in portable C, so we have to condition all these
1400    prototypes on HAVE_MACHINE_MODES.  */
1401 static void
1402 write_tm_preds_h (void)
1403 {
1404   struct pred_data *p;
1405
1406   printf ("\
1407 /* Generated automatically by the program '%s'\n\
1408    from the machine description file '%s'.  */\n\n", progname,
1409           md_reader_ptr->get_top_level_filename ());
1410
1411   puts ("\
1412 #ifndef GCC_TM_PREDS_H\n\
1413 #define GCC_TM_PREDS_H\n\
1414 \n\
1415 #ifdef HAVE_MACHINE_MODES");
1416
1417   FOR_ALL_PREDICATES (p)
1418     printf ("extern int %s (rtx, machine_mode);\n", p->name);
1419
1420   puts ("#endif /* HAVE_MACHINE_MODES */\n");
1421
1422   if (constraint_max_namelen > 0)
1423     {
1424       write_enum_constraint_num ();
1425       puts ("extern enum constraint_num lookup_constraint_1 (const char *);\n"
1426             "extern const unsigned char lookup_constraint_array[];\n"
1427             "\n"
1428             "/* Return the constraint at the beginning of P, or"
1429             " CONSTRAINT__UNKNOWN if it\n"
1430             "   isn't recognized.  */\n"
1431             "\n"
1432             "static inline enum constraint_num\n"
1433             "lookup_constraint (const char *p)\n"
1434             "{\n"
1435             "  unsigned int index = lookup_constraint_array"
1436             "[(unsigned char) *p];\n"
1437             "  return (index == UCHAR_MAX\n"
1438             "          ? lookup_constraint_1 (p)\n"
1439             "          : (enum constraint_num) index);\n"
1440             "}\n");
1441       if (satisfied_start == num_constraints)
1442         puts ("/* Return true if X satisfies constraint C.  */\n"
1443               "\n"
1444               "static inline bool\n"
1445               "constraint_satisfied_p (rtx, enum constraint_num)\n"
1446               "{\n"
1447               "  return false;\n"
1448               "}\n");
1449       else
1450         printf ("extern bool (*constraint_satisfied_p_array[]) (rtx);\n"
1451                 "\n"
1452                 "/* Return true if X satisfies constraint C.  */\n"
1453                 "\n"
1454                 "static inline bool\n"
1455                 "constraint_satisfied_p (rtx x, enum constraint_num c)\n"
1456                 "{\n"
1457                 "  int i = (int) c - (int) CONSTRAINT_%s;\n"
1458                 "  return i >= 0 && constraint_satisfied_p_array[i] (x);\n"
1459                 "}\n"
1460                 "\n",
1461                 enum_order[satisfied_start]->name);
1462
1463       write_range_function ("insn_extra_register_constraint",
1464                             register_start, register_end);
1465       write_range_function ("insn_extra_memory_constraint",
1466                             memory_start, memory_end);
1467       write_range_function ("insn_extra_special_memory_constraint",
1468                             special_memory_start, special_memory_end);
1469       write_range_function ("insn_extra_address_constraint",
1470                             address_start, address_end);
1471       write_allows_reg_mem_function ();
1472
1473       if (constraint_max_namelen > 1)
1474         {
1475           write_insn_constraint_len ();
1476           puts ("#define CONSTRAINT_LEN(c_,s_) "
1477                 "insn_constraint_len (c_,s_)\n");
1478         }
1479       else
1480         puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
1481       if (have_register_constraints)
1482         puts ("extern enum reg_class reg_class_for_constraint_1 "
1483               "(enum constraint_num);\n"
1484               "\n"
1485               "static inline enum reg_class\n"
1486               "reg_class_for_constraint (enum constraint_num c)\n"
1487               "{\n"
1488               "  if (insn_extra_register_constraint (c))\n"
1489               "    return reg_class_for_constraint_1 (c);\n"
1490               "  return NO_REGS;\n"
1491               "}\n");
1492       else
1493         puts ("static inline enum reg_class\n"
1494               "reg_class_for_constraint (enum constraint_num)\n"
1495               "{\n"
1496               "  return NO_REGS;\n"
1497               "}\n");
1498       if (have_const_int_constraints)
1499         puts ("extern bool insn_const_int_ok_for_constraint "
1500               "(HOST_WIDE_INT, enum constraint_num);\n"
1501               "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
1502               "    insn_const_int_ok_for_constraint (v_, "
1503               "lookup_constraint (s_))\n");
1504       else
1505         puts ("static inline bool\n"
1506               "insn_const_int_ok_for_constraint (HOST_WIDE_INT,"
1507               " enum constraint_num)\n"
1508               "{\n"
1509               "  return false;\n"
1510               "}\n");
1511
1512       puts ("enum constraint_type\n"
1513             "{\n"
1514             "  CT_REGISTER,\n"
1515             "  CT_CONST_INT,\n"
1516             "  CT_MEMORY,\n"
1517             "  CT_SPECIAL_MEMORY,\n"
1518             "  CT_ADDRESS,\n"
1519             "  CT_FIXED_FORM\n"
1520             "};\n"
1521             "\n"
1522             "static inline enum constraint_type\n"
1523             "get_constraint_type (enum constraint_num c)\n"
1524             "{");
1525       auto_vec <std::pair <unsigned int, const char *>, 4> values;
1526       if (const_int_start != const_int_end)
1527         values.safe_push (std::make_pair (const_int_start, "CT_CONST_INT"));
1528       if (memory_start != memory_end)
1529         values.safe_push (std::make_pair (memory_start, "CT_MEMORY"));
1530       if (special_memory_start != special_memory_end)
1531         values.safe_push (std::make_pair (special_memory_start, "CT_SPECIAL_MEMORY"));
1532       if (address_start != address_end)
1533         values.safe_push (std::make_pair (address_start, "CT_ADDRESS"));
1534       if (address_end != num_constraints)
1535         values.safe_push (std::make_pair (address_end, "CT_FIXED_FORM"));
1536       print_type_tree (values, 0, values.length (), "CT_REGISTER", 2);
1537       puts ("}");
1538     }
1539
1540   puts ("#endif /* tm-preds.h */");
1541 }
1542
1543 /* Write insn-preds.c.
1544    N.B. the list of headers to include was copied from genrecog; it
1545    may not be ideal.
1546
1547    FUTURE: Write #line markers referring back to the machine
1548    description.  (Can't practically do this now since we don't know
1549    the line number of the C block - just the line number of the enclosing
1550    expression.)  */
1551 static void
1552 write_insn_preds_c (void)
1553 {
1554   struct pred_data *p;
1555
1556   printf ("\
1557 /* Generated automatically by the program '%s'\n\
1558    from the machine description file '%s'.  */\n\n", progname,
1559           md_reader_ptr->get_top_level_filename ());
1560
1561   puts ("\
1562 #define IN_TARGET_CODE 1\n\
1563 #include \"config.h\"\n\
1564 #include \"system.h\"\n\
1565 #include \"coretypes.h\"\n\
1566 #include \"backend.h\"\n\
1567 #include \"predict.h\"\n\
1568 #include \"tree.h\"\n\
1569 #include \"rtl.h\"\n\
1570 #include \"alias.h\"\n\
1571 #include \"varasm.h\"\n\
1572 #include \"stor-layout.h\"\n\
1573 #include \"calls.h\"\n\
1574 #include \"memmodel.h\"\n\
1575 #include \"tm_p.h\"\n\
1576 #include \"insn-config.h\"\n\
1577 #include \"recog.h\"\n\
1578 #include \"output.h\"\n\
1579 #include \"flags.h\"\n\
1580 #include \"df.h\"\n\
1581 #include \"resource.h\"\n\
1582 #include \"diagnostic-core.h\"\n\
1583 #include \"reload.h\"\n\
1584 #include \"regs.h\"\n\
1585 #include \"emit-rtl.h\"\n\
1586 #include \"tm-constrs.h\"\n\
1587 #include \"target.h\"\n");
1588
1589   FOR_ALL_PREDICATES (p)
1590     write_one_predicate_function (p);
1591
1592   if (constraint_max_namelen > 0)
1593     {
1594       write_lookup_constraint_1 ();
1595       write_lookup_constraint_array ();
1596       if (have_register_constraints)
1597         write_reg_class_for_constraint_1 ();
1598       write_constraint_satisfied_p_array ();
1599
1600       if (have_const_int_constraints)
1601         write_insn_const_int_ok_for_constraint ();
1602     }
1603 }
1604
1605 /* Argument parsing.  */
1606 static bool gen_header;
1607 static bool gen_constrs;
1608
1609 static bool
1610 parse_option (const char *opt)
1611 {
1612   if (!strcmp (opt, "-h"))
1613     {
1614       gen_header = true;
1615       return 1;
1616     }
1617   else if (!strcmp (opt, "-c"))
1618     {
1619       gen_constrs = true;
1620       return 1;
1621     }
1622   else
1623     return 0;
1624 }
1625
1626 /* Master control.  */
1627 int
1628 main (int argc, const char **argv)
1629 {
1630   progname = argv[0];
1631   if (argc <= 1)
1632     fatal ("no input file name");
1633   if (!init_rtx_reader_args_cb (argc, argv, parse_option))
1634     return FATAL_EXIT_CODE;
1635
1636   md_rtx_info info;
1637   while (read_md_rtx (&info))
1638     switch (GET_CODE (info.def))
1639       {
1640       case DEFINE_PREDICATE:
1641       case DEFINE_SPECIAL_PREDICATE:
1642         process_define_predicate (&info);
1643         break;
1644
1645       case DEFINE_CONSTRAINT:
1646       case DEFINE_MEMORY_CONSTRAINT:
1647       case DEFINE_SPECIAL_MEMORY_CONSTRAINT:
1648       case DEFINE_ADDRESS_CONSTRAINT:
1649         process_define_constraint (&info);
1650         break;
1651
1652       case DEFINE_REGISTER_CONSTRAINT:
1653         process_define_register_constraint (&info);
1654         break;
1655
1656       default:
1657         break;
1658       }
1659
1660   choose_enum_order ();
1661
1662   if (gen_header)
1663     write_tm_preds_h ();
1664   else if (gen_constrs)
1665     write_tm_constrs_h ();
1666   else
1667     write_insn_preds_c ();
1668
1669   if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
1670     return FATAL_EXIT_CODE;
1671
1672   return SUCCESS_EXIT_CODE;
1673 }