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 7This file is part of GCC. 8 9GCC is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 3, or (at your option) 12any later version. 13 14GCC is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along 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 33static 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. */ 39static bool 40validate_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. */ 93static void 94process_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 128static void 129write_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. */ 167static bool 168needs_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) 230static void 231mark_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. */ 289static bool 290generate_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 302static void 303add_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. */ 436static void 437write_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. */ 469static void 470write_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. */ 492static void 493write_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 551static void 552write_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 578static void 579write_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. */ 643static void 644write_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 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. */ 669class constraint_data 670{ 671public: 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 693static class constraint_data * 694constraints_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. */ 698static class constraint_data *first_constraint; 699static 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. */ 706static 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 711static 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 716static const char const_dbl_constraints[] = "GH"; 717 718/* Summary data used to decide whether to output various functions and 719 macro definitions. */ 720static unsigned int constraint_max_namelen; 721static bool have_register_constraints; 722static bool have_memory_constraints; 723static bool have_special_memory_constraints; 724static bool have_address_constraints; 725static bool have_extra_constraints; 726static bool have_const_int_constraints; 727static unsigned int num_constraints; 728 729static const constraint_data **enum_order; 730static unsigned int register_start, register_end; 731static unsigned int satisfied_start; 732static unsigned int const_int_start, const_int_end; 733static unsigned int memory_start, memory_end; 734static unsigned int special_memory_start, special_memory_end; 735static unsigned int address_start, address_end; 736static unsigned int maybe_allows_none_start, maybe_allows_none_end; 737static unsigned int maybe_allows_reg_start, maybe_allows_reg_end; 738static 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. */ 743static const char * 744mangle (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 773static void 774add_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. */ 959static void 960process_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. */ 970static void 971process_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. */ 980static void 981choose_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. */ 1054static void 1055write_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. */ 1068static void 1069write_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. */ 1111static void 1112write_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. */ 1133static void 1134write_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. */ 1178static void 1179write_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. */ 1201static void 1202write_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. */ 1269static void 1270write_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. */ 1288static void 1289write_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 1317/* Write a definition for a function NAME that returns true if a given 1318 constraint_num is in the range [START, END). */ 1319static void 1320write_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. */ 1337static void 1338write_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. */ 1375static void 1376print_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. */ 1401static void 1402write_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.) */ 1551static void 1552write_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. */ 1606static bool gen_header; 1607static bool gen_constrs; 1608 1609static bool 1610parse_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. */ 1627int 1628main (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} 1674