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