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