1 /* Support routines for the various generation passes. 2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 3 2010, Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it 8 under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 15 License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "bconfig.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tm.h" 25 #include "rtl.h" 26 #include "obstack.h" 27 #include "errors.h" 28 #include "hashtab.h" 29 #include "gensupport.h" 30 31 32 /* In case some macros used by files we include need it, define this here. */ 33 int target_flags; 34 35 int insn_elision = 1; 36 37 const char *in_fname; 38 39 /* This callback will be invoked whenever an rtl include directive is 40 processed. To be used for creation of the dependency file. */ 41 void (*include_callback) (const char *); 42 43 static struct obstack obstack; 44 struct obstack *rtl_obstack = &obstack; 45 46 static int sequence_num; 47 static int errors; 48 49 static int predicable_default; 50 static const char *predicable_true; 51 static const char *predicable_false; 52 53 static htab_t condition_table; 54 55 static char *base_dir = NULL; 56 57 /* We initially queue all patterns, process the define_insn and 58 define_cond_exec patterns, then return them one at a time. */ 59 60 struct queue_elem 61 { 62 rtx data; 63 const char *filename; 64 int lineno; 65 struct queue_elem *next; 66 /* In a DEFINE_INSN that came from a DEFINE_INSN_AND_SPLIT, SPLIT 67 points to the generated DEFINE_SPLIT. */ 68 struct queue_elem *split; 69 }; 70 71 static struct queue_elem *define_attr_queue; 72 static struct queue_elem **define_attr_tail = &define_attr_queue; 73 static struct queue_elem *define_pred_queue; 74 static struct queue_elem **define_pred_tail = &define_pred_queue; 75 static struct queue_elem *define_insn_queue; 76 static struct queue_elem **define_insn_tail = &define_insn_queue; 77 static struct queue_elem *define_cond_exec_queue; 78 static struct queue_elem **define_cond_exec_tail = &define_cond_exec_queue; 79 static struct queue_elem *other_queue; 80 static struct queue_elem **other_tail = &other_queue; 81 82 static struct queue_elem *queue_pattern (rtx, struct queue_elem ***, 83 const char *, int); 84 85 /* Current maximum length of directory names in the search path 86 for include files. (Altered as we get more of them.) */ 87 88 size_t max_include_len; 89 90 struct file_name_list 91 { 92 struct file_name_list *next; 93 const char *fname; 94 }; 95 96 struct file_name_list *first_dir_md_include = 0; /* First dir to search */ 97 /* First dir to search for <file> */ 98 struct file_name_list *first_bracket_include = 0; 99 struct file_name_list *last_dir_md_include = 0; /* Last in chain */ 100 101 static void remove_constraints (rtx); 102 static void process_rtx (rtx, int); 103 104 static int is_predicable (struct queue_elem *); 105 static void identify_predicable_attribute (void); 106 static int n_alternatives (const char *); 107 static void collect_insn_data (rtx, int *, int *); 108 static rtx alter_predicate_for_insn (rtx, int, int, int); 109 static const char *alter_test_for_insn (struct queue_elem *, 110 struct queue_elem *); 111 static char *shift_output_template (char *, const char *, int); 112 static const char *alter_output_for_insn (struct queue_elem *, 113 struct queue_elem *, 114 int, int); 115 static void process_one_cond_exec (struct queue_elem *); 116 static void process_define_cond_exec (void); 117 static void process_include (rtx, int); 118 static char *save_string (const char *, int); 119 static void init_predicate_table (void); 120 static void record_insn_name (int, const char *); 121 122 void 123 message_with_line (int lineno, const char *msg, ...) 124 { 125 va_list ap; 126 127 va_start (ap, msg); 128 129 fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno); 130 vfprintf (stderr, msg, ap); 131 fputc ('\n', stderr); 132 133 va_end (ap); 134 } 135 136 /* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in 137 the gensupport programs. */ 138 139 rtx 140 gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED (mode), 141 HOST_WIDE_INT arg) 142 { 143 rtx rt = rtx_alloc (CONST_INT); 144 145 XWINT (rt, 0) = arg; 146 return rt; 147 } 148 149 /* Queue PATTERN on LIST_TAIL. Return the address of the new queue 150 element. */ 151 152 static struct queue_elem * 153 queue_pattern (rtx pattern, struct queue_elem ***list_tail, 154 const char *filename, int lineno) 155 { 156 struct queue_elem *e = XNEW(struct queue_elem); 157 e->data = pattern; 158 e->filename = filename; 159 e->lineno = lineno; 160 e->next = NULL; 161 e->split = NULL; 162 **list_tail = e; 163 *list_tail = &e->next; 164 return e; 165 } 166 167 /* Recursively remove constraints from an rtx. */ 168 169 static void 170 remove_constraints (rtx part) 171 { 172 int i, j; 173 const char *format_ptr; 174 175 if (part == 0) 176 return; 177 178 if (GET_CODE (part) == MATCH_OPERAND) 179 XSTR (part, 2) = ""; 180 else if (GET_CODE (part) == MATCH_SCRATCH) 181 XSTR (part, 1) = ""; 182 183 format_ptr = GET_RTX_FORMAT (GET_CODE (part)); 184 185 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++) 186 switch (*format_ptr++) 187 { 188 case 'e': 189 case 'u': 190 remove_constraints (XEXP (part, i)); 191 break; 192 case 'E': 193 if (XVEC (part, i) != NULL) 194 for (j = 0; j < XVECLEN (part, i); j++) 195 remove_constraints (XVECEXP (part, i, j)); 196 break; 197 } 198 } 199 200 /* Process an include file assuming that it lives in gcc/config/{target}/ 201 if the include looks like (include "file"). */ 202 203 static void 204 process_include (rtx desc, int lineno) 205 { 206 const char *filename = XSTR (desc, 0); 207 const char *old_filename; 208 int old_lineno; 209 char *pathname; 210 FILE *input_file; 211 212 /* If specified file name is absolute, skip the include stack. */ 213 if (! IS_ABSOLUTE_PATH (filename)) 214 { 215 struct file_name_list *stackp; 216 217 /* Search directory path, trying to open the file. */ 218 for (stackp = first_dir_md_include; stackp; stackp = stackp->next) 219 { 220 static const char sep[2] = { DIR_SEPARATOR, '\0' }; 221 222 pathname = concat (stackp->fname, sep, filename, NULL); 223 input_file = fopen (pathname, "r"); 224 if (input_file != NULL) 225 goto success; 226 free (pathname); 227 } 228 } 229 230 if (base_dir) 231 pathname = concat (base_dir, filename, NULL); 232 else 233 pathname = xstrdup (filename); 234 input_file = fopen (pathname, "r"); 235 if (input_file == NULL) 236 { 237 free (pathname); 238 message_with_line (lineno, "include file `%s' not found", filename); 239 errors = 1; 240 return; 241 } 242 success: 243 244 /* Save old cursor; setup new for the new file. Note that "lineno" the 245 argument to this function is the beginning of the include statement, 246 while read_rtx_lineno has already been advanced. */ 247 old_filename = read_rtx_filename; 248 old_lineno = read_rtx_lineno; 249 read_rtx_filename = pathname; 250 read_rtx_lineno = 1; 251 252 if (include_callback) 253 include_callback (pathname); 254 255 /* Read the entire file. */ 256 while (read_rtx (input_file, &desc, &lineno)) 257 process_rtx (desc, lineno); 258 259 /* Do not free pathname. It is attached to the various rtx queue 260 elements. */ 261 262 read_rtx_filename = old_filename; 263 read_rtx_lineno = old_lineno; 264 265 fclose (input_file); 266 } 267 268 /* Process a top level rtx in some way, queuing as appropriate. */ 269 270 static void 271 process_rtx (rtx desc, int lineno) 272 { 273 switch (GET_CODE (desc)) 274 { 275 case DEFINE_INSN: 276 queue_pattern (desc, &define_insn_tail, read_rtx_filename, lineno); 277 break; 278 279 case DEFINE_COND_EXEC: 280 queue_pattern (desc, &define_cond_exec_tail, read_rtx_filename, lineno); 281 break; 282 283 case DEFINE_ATTR: 284 queue_pattern (desc, &define_attr_tail, read_rtx_filename, lineno); 285 break; 286 287 case DEFINE_PREDICATE: 288 case DEFINE_SPECIAL_PREDICATE: 289 case DEFINE_CONSTRAINT: 290 case DEFINE_REGISTER_CONSTRAINT: 291 case DEFINE_MEMORY_CONSTRAINT: 292 case DEFINE_ADDRESS_CONSTRAINT: 293 queue_pattern (desc, &define_pred_tail, read_rtx_filename, lineno); 294 break; 295 296 case INCLUDE: 297 process_include (desc, lineno); 298 break; 299 300 case DEFINE_INSN_AND_SPLIT: 301 { 302 const char *split_cond; 303 rtx split; 304 rtvec attr; 305 int i; 306 struct queue_elem *insn_elem; 307 struct queue_elem *split_elem; 308 309 /* Create a split with values from the insn_and_split. */ 310 split = rtx_alloc (DEFINE_SPLIT); 311 312 i = XVECLEN (desc, 1); 313 XVEC (split, 0) = rtvec_alloc (i); 314 while (--i >= 0) 315 { 316 XVECEXP (split, 0, i) = copy_rtx (XVECEXP (desc, 1, i)); 317 remove_constraints (XVECEXP (split, 0, i)); 318 } 319 320 /* If the split condition starts with "&&", append it to the 321 insn condition to create the new split condition. */ 322 split_cond = XSTR (desc, 4); 323 if (split_cond[0] == '&' && split_cond[1] == '&') 324 { 325 copy_rtx_ptr_loc (split_cond + 2, split_cond); 326 split_cond = join_c_conditions (XSTR (desc, 2), split_cond + 2); 327 } 328 XSTR (split, 1) = split_cond; 329 XVEC (split, 2) = XVEC (desc, 5); 330 XSTR (split, 3) = XSTR (desc, 6); 331 332 /* Fix up the DEFINE_INSN. */ 333 attr = XVEC (desc, 7); 334 PUT_CODE (desc, DEFINE_INSN); 335 XVEC (desc, 4) = attr; 336 337 /* Queue them. */ 338 insn_elem 339 = queue_pattern (desc, &define_insn_tail, read_rtx_filename, 340 lineno); 341 split_elem 342 = queue_pattern (split, &other_tail, read_rtx_filename, lineno); 343 insn_elem->split = split_elem; 344 break; 345 } 346 347 default: 348 queue_pattern (desc, &other_tail, read_rtx_filename, lineno); 349 break; 350 } 351 } 352 353 /* Return true if attribute PREDICABLE is true for ELEM, which holds 354 a DEFINE_INSN. */ 355 356 static int 357 is_predicable (struct queue_elem *elem) 358 { 359 rtvec vec = XVEC (elem->data, 4); 360 const char *value; 361 int i; 362 363 if (! vec) 364 return predicable_default; 365 366 for (i = GET_NUM_ELEM (vec) - 1; i >= 0; --i) 367 { 368 rtx sub = RTVEC_ELT (vec, i); 369 switch (GET_CODE (sub)) 370 { 371 case SET_ATTR: 372 if (strcmp (XSTR (sub, 0), "predicable") == 0) 373 { 374 value = XSTR (sub, 1); 375 goto found; 376 } 377 break; 378 379 case SET_ATTR_ALTERNATIVE: 380 if (strcmp (XSTR (sub, 0), "predicable") == 0) 381 { 382 message_with_line (elem->lineno, 383 "multiple alternatives for `predicable'"); 384 errors = 1; 385 return 0; 386 } 387 break; 388 389 case SET: 390 if (GET_CODE (SET_DEST (sub)) != ATTR 391 || strcmp (XSTR (SET_DEST (sub), 0), "predicable") != 0) 392 break; 393 sub = SET_SRC (sub); 394 if (GET_CODE (sub) == CONST_STRING) 395 { 396 value = XSTR (sub, 0); 397 goto found; 398 } 399 400 /* ??? It would be possible to handle this if we really tried. 401 It's not easy though, and I'm not going to bother until it 402 really proves necessary. */ 403 message_with_line (elem->lineno, 404 "non-constant value for `predicable'"); 405 errors = 1; 406 return 0; 407 408 default: 409 gcc_unreachable (); 410 } 411 } 412 413 return predicable_default; 414 415 found: 416 /* Verify that predicability does not vary on the alternative. */ 417 /* ??? It should be possible to handle this by simply eliminating 418 the non-predicable alternatives from the insn. FRV would like 419 to do this. Delay this until we've got the basics solid. */ 420 if (strchr (value, ',') != NULL) 421 { 422 message_with_line (elem->lineno, 423 "multiple alternatives for `predicable'"); 424 errors = 1; 425 return 0; 426 } 427 428 /* Find out which value we're looking at. */ 429 if (strcmp (value, predicable_true) == 0) 430 return 1; 431 if (strcmp (value, predicable_false) == 0) 432 return 0; 433 434 message_with_line (elem->lineno, 435 "unknown value `%s' for `predicable' attribute", 436 value); 437 errors = 1; 438 return 0; 439 } 440 441 /* Examine the attribute "predicable"; discover its boolean values 442 and its default. */ 443 444 static void 445 identify_predicable_attribute (void) 446 { 447 struct queue_elem *elem; 448 char *p_true, *p_false; 449 const char *value; 450 451 /* Look for the DEFINE_ATTR for `predicable', which must exist. */ 452 for (elem = define_attr_queue; elem ; elem = elem->next) 453 if (strcmp (XSTR (elem->data, 0), "predicable") == 0) 454 goto found; 455 456 message_with_line (define_cond_exec_queue->lineno, 457 "attribute `predicable' not defined"); 458 errors = 1; 459 return; 460 461 found: 462 value = XSTR (elem->data, 1); 463 p_false = xstrdup (value); 464 p_true = strchr (p_false, ','); 465 if (p_true == NULL || strchr (++p_true, ',') != NULL) 466 { 467 message_with_line (elem->lineno, 468 "attribute `predicable' is not a boolean"); 469 errors = 1; 470 if (p_false) 471 free (p_false); 472 return; 473 } 474 p_true[-1] = '\0'; 475 476 predicable_true = p_true; 477 predicable_false = p_false; 478 479 switch (GET_CODE (XEXP (elem->data, 2))) 480 { 481 case CONST_STRING: 482 value = XSTR (XEXP (elem->data, 2), 0); 483 break; 484 485 case CONST: 486 message_with_line (elem->lineno, 487 "attribute `predicable' cannot be const"); 488 errors = 1; 489 if (p_false) 490 free (p_false); 491 return; 492 493 default: 494 message_with_line (elem->lineno, 495 "attribute `predicable' must have a constant default"); 496 errors = 1; 497 if (p_false) 498 free (p_false); 499 return; 500 } 501 502 if (strcmp (value, p_true) == 0) 503 predicable_default = 1; 504 else if (strcmp (value, p_false) == 0) 505 predicable_default = 0; 506 else 507 { 508 message_with_line (elem->lineno, 509 "unknown value `%s' for `predicable' attribute", 510 value); 511 errors = 1; 512 if (p_false) 513 free (p_false); 514 } 515 } 516 517 /* Return the number of alternatives in constraint S. */ 518 519 static int 520 n_alternatives (const char *s) 521 { 522 int n = 1; 523 524 if (s) 525 while (*s) 526 n += (*s++ == ','); 527 528 return n; 529 } 530 531 /* Determine how many alternatives there are in INSN, and how many 532 operands. */ 533 534 static void 535 collect_insn_data (rtx pattern, int *palt, int *pmax) 536 { 537 const char *fmt; 538 enum rtx_code code; 539 int i, j, len; 540 541 code = GET_CODE (pattern); 542 switch (code) 543 { 544 case MATCH_OPERAND: 545 i = n_alternatives (XSTR (pattern, 2)); 546 *palt = (i > *palt ? i : *palt); 547 /* Fall through. */ 548 549 case MATCH_OPERATOR: 550 case MATCH_SCRATCH: 551 case MATCH_PARALLEL: 552 i = XINT (pattern, 0); 553 if (i > *pmax) 554 *pmax = i; 555 break; 556 557 default: 558 break; 559 } 560 561 fmt = GET_RTX_FORMAT (code); 562 len = GET_RTX_LENGTH (code); 563 for (i = 0; i < len; i++) 564 { 565 switch (fmt[i]) 566 { 567 case 'e': case 'u': 568 collect_insn_data (XEXP (pattern, i), palt, pmax); 569 break; 570 571 case 'V': 572 if (XVEC (pattern, i) == NULL) 573 break; 574 /* Fall through. */ 575 case 'E': 576 for (j = XVECLEN (pattern, i) - 1; j >= 0; --j) 577 collect_insn_data (XVECEXP (pattern, i, j), palt, pmax); 578 break; 579 580 case 'i': case 'w': case '0': case 's': case 'S': case 'T': 581 break; 582 583 default: 584 gcc_unreachable (); 585 } 586 } 587 } 588 589 static rtx 590 alter_predicate_for_insn (rtx pattern, int alt, int max_op, int lineno) 591 { 592 const char *fmt; 593 enum rtx_code code; 594 int i, j, len; 595 596 code = GET_CODE (pattern); 597 switch (code) 598 { 599 case MATCH_OPERAND: 600 { 601 const char *c = XSTR (pattern, 2); 602 603 if (n_alternatives (c) != 1) 604 { 605 message_with_line (lineno, 606 "too many alternatives for operand %d", 607 XINT (pattern, 0)); 608 errors = 1; 609 return NULL; 610 } 611 612 /* Replicate C as needed to fill out ALT alternatives. */ 613 if (c && *c && alt > 1) 614 { 615 size_t c_len = strlen (c); 616 size_t len = alt * (c_len + 1); 617 char *new_c = XNEWVEC(char, len); 618 619 memcpy (new_c, c, c_len); 620 for (i = 1; i < alt; ++i) 621 { 622 new_c[i * (c_len + 1) - 1] = ','; 623 memcpy (&new_c[i * (c_len + 1)], c, c_len); 624 } 625 new_c[len - 1] = '\0'; 626 XSTR (pattern, 2) = new_c; 627 } 628 } 629 /* Fall through. */ 630 631 case MATCH_OPERATOR: 632 case MATCH_SCRATCH: 633 case MATCH_PARALLEL: 634 XINT (pattern, 0) += max_op; 635 break; 636 637 default: 638 break; 639 } 640 641 fmt = GET_RTX_FORMAT (code); 642 len = GET_RTX_LENGTH (code); 643 for (i = 0; i < len; i++) 644 { 645 rtx r; 646 647 switch (fmt[i]) 648 { 649 case 'e': case 'u': 650 r = alter_predicate_for_insn (XEXP (pattern, i), alt, 651 max_op, lineno); 652 if (r == NULL) 653 return r; 654 break; 655 656 case 'E': 657 for (j = XVECLEN (pattern, i) - 1; j >= 0; --j) 658 { 659 r = alter_predicate_for_insn (XVECEXP (pattern, i, j), 660 alt, max_op, lineno); 661 if (r == NULL) 662 return r; 663 } 664 break; 665 666 case 'i': case 'w': case '0': case 's': 667 break; 668 669 default: 670 gcc_unreachable (); 671 } 672 } 673 674 return pattern; 675 } 676 677 static const char * 678 alter_test_for_insn (struct queue_elem *ce_elem, 679 struct queue_elem *insn_elem) 680 { 681 return join_c_conditions (XSTR (ce_elem->data, 1), 682 XSTR (insn_elem->data, 2)); 683 } 684 685 /* Adjust all of the operand numbers in SRC to match the shift they'll 686 get from an operand displacement of DISP. Return a pointer after the 687 adjusted string. */ 688 689 static char * 690 shift_output_template (char *dest, const char *src, int disp) 691 { 692 while (*src) 693 { 694 char c = *src++; 695 *dest++ = c; 696 if (c == '%') 697 { 698 c = *src++; 699 if (ISDIGIT ((unsigned char) c)) 700 c += disp; 701 else if (ISALPHA (c)) 702 { 703 *dest++ = c; 704 c = *src++ + disp; 705 } 706 *dest++ = c; 707 } 708 } 709 710 return dest; 711 } 712 713 static const char * 714 alter_output_for_insn (struct queue_elem *ce_elem, 715 struct queue_elem *insn_elem, 716 int alt, int max_op) 717 { 718 const char *ce_out, *insn_out; 719 char *result, *p; 720 size_t len, ce_len, insn_len; 721 722 /* ??? Could coordinate with genoutput to not duplicate code here. */ 723 724 ce_out = XSTR (ce_elem->data, 2); 725 insn_out = XTMPL (insn_elem->data, 3); 726 if (!ce_out || *ce_out == '\0') 727 return insn_out; 728 729 ce_len = strlen (ce_out); 730 insn_len = strlen (insn_out); 731 732 if (*insn_out == '*') 733 /* You must take care of the predicate yourself. */ 734 return insn_out; 735 736 if (*insn_out == '@') 737 { 738 len = (ce_len + 1) * alt + insn_len + 1; 739 p = result = XNEWVEC(char, len); 740 741 do 742 { 743 do 744 *p++ = *insn_out++; 745 while (ISSPACE ((unsigned char) *insn_out)); 746 747 if (*insn_out != '#') 748 { 749 p = shift_output_template (p, ce_out, max_op); 750 *p++ = ' '; 751 } 752 753 do 754 *p++ = *insn_out++; 755 while (*insn_out && *insn_out != '\n'); 756 } 757 while (*insn_out); 758 *p = '\0'; 759 } 760 else 761 { 762 len = ce_len + 1 + insn_len + 1; 763 result = XNEWVEC (char, len); 764 765 p = shift_output_template (result, ce_out, max_op); 766 *p++ = ' '; 767 memcpy (p, insn_out, insn_len + 1); 768 } 769 770 return result; 771 } 772 773 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */ 774 775 static void 776 process_one_cond_exec (struct queue_elem *ce_elem) 777 { 778 struct queue_elem *insn_elem; 779 for (insn_elem = define_insn_queue; insn_elem ; insn_elem = insn_elem->next) 780 { 781 int alternatives, max_operand; 782 rtx pred, insn, pattern, split; 783 char *new_name; 784 int i; 785 786 if (! is_predicable (insn_elem)) 787 continue; 788 789 alternatives = 1; 790 max_operand = -1; 791 collect_insn_data (insn_elem->data, &alternatives, &max_operand); 792 max_operand += 1; 793 794 if (XVECLEN (ce_elem->data, 0) != 1) 795 { 796 message_with_line (ce_elem->lineno, 797 "too many patterns in predicate"); 798 errors = 1; 799 return; 800 } 801 802 pred = copy_rtx (XVECEXP (ce_elem->data, 0, 0)); 803 pred = alter_predicate_for_insn (pred, alternatives, max_operand, 804 ce_elem->lineno); 805 if (pred == NULL) 806 return; 807 808 /* Construct a new pattern for the new insn. */ 809 insn = copy_rtx (insn_elem->data); 810 new_name = XNEWVAR (char, strlen XSTR (insn_elem->data, 0) + 4); 811 sprintf (new_name, "*p %s", XSTR (insn_elem->data, 0)); 812 XSTR (insn, 0) = new_name; 813 pattern = rtx_alloc (COND_EXEC); 814 XEXP (pattern, 0) = pred; 815 if (XVECLEN (insn, 1) == 1) 816 { 817 XEXP (pattern, 1) = XVECEXP (insn, 1, 0); 818 XVECEXP (insn, 1, 0) = pattern; 819 PUT_NUM_ELEM (XVEC (insn, 1), 1); 820 } 821 else 822 { 823 XEXP (pattern, 1) = rtx_alloc (PARALLEL); 824 XVEC (XEXP (pattern, 1), 0) = XVEC (insn, 1); 825 XVEC (insn, 1) = rtvec_alloc (1); 826 XVECEXP (insn, 1, 0) = pattern; 827 } 828 829 XSTR (insn, 2) = alter_test_for_insn (ce_elem, insn_elem); 830 XTMPL (insn, 3) = alter_output_for_insn (ce_elem, insn_elem, 831 alternatives, max_operand); 832 833 /* ??? Set `predicable' to false. Not crucial since it's really 834 only used here, and we won't reprocess this new pattern. */ 835 836 /* Put the new pattern on the `other' list so that it 837 (a) is not reprocessed by other define_cond_exec patterns 838 (b) appears after all normal define_insn patterns. 839 840 ??? B is debatable. If one has normal insns that match 841 cond_exec patterns, they will be preferred over these 842 generated patterns. Whether this matters in practice, or if 843 it's a good thing, or whether we should thread these new 844 patterns into the define_insn chain just after their generator 845 is something we'll have to experiment with. */ 846 847 queue_pattern (insn, &other_tail, insn_elem->filename, 848 insn_elem->lineno); 849 850 if (!insn_elem->split) 851 continue; 852 853 /* If the original insn came from a define_insn_and_split, 854 generate a new split to handle the predicated insn. */ 855 split = copy_rtx (insn_elem->split->data); 856 /* Predicate the pattern matched by the split. */ 857 pattern = rtx_alloc (COND_EXEC); 858 XEXP (pattern, 0) = pred; 859 if (XVECLEN (split, 0) == 1) 860 { 861 XEXP (pattern, 1) = XVECEXP (split, 0, 0); 862 XVECEXP (split, 0, 0) = pattern; 863 PUT_NUM_ELEM (XVEC (split, 0), 1); 864 } 865 else 866 { 867 XEXP (pattern, 1) = rtx_alloc (PARALLEL); 868 XVEC (XEXP (pattern, 1), 0) = XVEC (split, 0); 869 XVEC (split, 0) = rtvec_alloc (1); 870 XVECEXP (split, 0, 0) = pattern; 871 } 872 /* Predicate all of the insns generated by the split. */ 873 for (i = 0; i < XVECLEN (split, 2); i++) 874 { 875 pattern = rtx_alloc (COND_EXEC); 876 XEXP (pattern, 0) = pred; 877 XEXP (pattern, 1) = XVECEXP (split, 2, i); 878 XVECEXP (split, 2, i) = pattern; 879 } 880 /* Add the new split to the queue. */ 881 queue_pattern (split, &other_tail, read_rtx_filename, 882 insn_elem->split->lineno); 883 } 884 } 885 886 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN 887 patterns appropriately. */ 888 889 static void 890 process_define_cond_exec (void) 891 { 892 struct queue_elem *elem; 893 894 identify_predicable_attribute (); 895 if (errors) 896 return; 897 898 for (elem = define_cond_exec_queue; elem ; elem = elem->next) 899 process_one_cond_exec (elem); 900 } 901 902 static char * 903 save_string (const char *s, int len) 904 { 905 char *result = XNEWVEC (char, len + 1); 906 907 memcpy (result, s, len); 908 result[len] = 0; 909 return result; 910 } 911 912 913 /* The entry point for initializing the reader. */ 914 915 int 916 init_md_reader_args_cb (int argc, char **argv, bool (*parse_opt)(const char *)) 917 { 918 FILE *input_file; 919 int c, i, lineno; 920 char *lastsl; 921 rtx desc; 922 bool no_more_options; 923 bool already_read_stdin; 924 925 /* Unlock the stdio streams. */ 926 unlock_std_streams (); 927 928 /* First we loop over all the options. */ 929 for (i = 1; i < argc; i++) 930 { 931 if (argv[i][0] != '-') 932 continue; 933 934 c = argv[i][1]; 935 switch (c) 936 { 937 case 'I': /* Add directory to path for includes. */ 938 { 939 struct file_name_list *dirtmp; 940 941 dirtmp = XNEW (struct file_name_list); 942 dirtmp->next = 0; /* New one goes on the end */ 943 if (first_dir_md_include == 0) 944 first_dir_md_include = dirtmp; 945 else 946 last_dir_md_include->next = dirtmp; 947 last_dir_md_include = dirtmp; /* Tail follows the last one */ 948 if (argv[i][1] == 'I' && argv[i][2] != 0) 949 dirtmp->fname = argv[i] + 2; 950 else if (i + 1 == argc) 951 fatal ("directory name missing after -I option"); 952 else 953 dirtmp->fname = argv[++i]; 954 if (strlen (dirtmp->fname) > max_include_len) 955 max_include_len = strlen (dirtmp->fname); 956 } 957 break; 958 959 case '\0': 960 /* An argument consisting of exactly one dash is a request to 961 read stdin. This will be handled in the second loop. */ 962 continue; 963 964 case '-': 965 /* An argument consisting of just two dashes causes option 966 parsing to cease. */ 967 if (argv[i][2] == '\0') 968 goto stop_parsing_options; 969 970 default: 971 /* The program may have provided a callback so it can 972 accept its own options. */ 973 if (parse_opt && parse_opt (argv[i])) 974 break; 975 976 fatal ("invalid option `%s'", argv[i]); 977 } 978 } 979 980 stop_parsing_options: 981 982 /* Prepare to read input. */ 983 condition_table = htab_create (500, hash_c_test, cmp_c_test, NULL); 984 init_predicate_table (); 985 obstack_init (rtl_obstack); 986 errors = 0; 987 sequence_num = 0; 988 no_more_options = false; 989 already_read_stdin = false; 990 991 992 /* Now loop over all input files. */ 993 for (i = 1; i < argc; i++) 994 { 995 if (argv[i][0] == '-') 996 { 997 if (argv[i][1] == '\0') 998 { 999 /* Read stdin. */ 1000 if (already_read_stdin) 1001 fatal ("cannot read standard input twice"); 1002 1003 base_dir = NULL; 1004 read_rtx_filename = in_fname = "<stdin>"; 1005 read_rtx_lineno = 1; 1006 input_file = stdin; 1007 already_read_stdin = true; 1008 1009 while (read_rtx (input_file, &desc, &lineno)) 1010 process_rtx (desc, lineno); 1011 fclose (input_file); 1012 continue; 1013 } 1014 else if (argv[i][1] == '-' && argv[i][2] == '\0') 1015 { 1016 /* No further arguments are to be treated as options. */ 1017 no_more_options = true; 1018 continue; 1019 } 1020 else if (!no_more_options) 1021 continue; 1022 } 1023 1024 /* If we get here we are looking at a non-option argument, i.e. 1025 a file to be processed. */ 1026 1027 in_fname = argv[i]; 1028 lastsl = strrchr (in_fname, '/'); 1029 if (lastsl != NULL) 1030 base_dir = save_string (in_fname, lastsl - in_fname + 1 ); 1031 else 1032 base_dir = NULL; 1033 1034 read_rtx_filename = in_fname; 1035 read_rtx_lineno = 1; 1036 input_file = fopen (in_fname, "r"); 1037 if (input_file == 0) 1038 { 1039 perror (in_fname); 1040 return FATAL_EXIT_CODE; 1041 } 1042 1043 while (read_rtx (input_file, &desc, &lineno)) 1044 process_rtx (desc, lineno); 1045 fclose (input_file); 1046 } 1047 1048 /* If we get to this point without having seen any files to process, 1049 read standard input now. */ 1050 if (!in_fname) 1051 { 1052 base_dir = NULL; 1053 read_rtx_filename = in_fname = "<stdin>"; 1054 read_rtx_lineno = 1; 1055 input_file = stdin; 1056 1057 while (read_rtx (input_file, &desc, &lineno)) 1058 process_rtx (desc, lineno); 1059 fclose (input_file); 1060 } 1061 1062 /* Process define_cond_exec patterns. */ 1063 if (define_cond_exec_queue != NULL) 1064 process_define_cond_exec (); 1065 1066 return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE; 1067 } 1068 1069 /* Programs that don't have their own options can use this entry point 1070 instead. */ 1071 int 1072 init_md_reader_args (int argc, char **argv) 1073 { 1074 return init_md_reader_args_cb (argc, argv, 0); 1075 } 1076 1077 /* The entry point for reading a single rtx from an md file. */ 1078 1079 rtx 1080 read_md_rtx (int *lineno, int *seqnr) 1081 { 1082 struct queue_elem **queue, *elem; 1083 rtx desc; 1084 1085 discard: 1086 1087 /* Read all patterns from a given queue before moving on to the next. */ 1088 if (define_attr_queue != NULL) 1089 queue = &define_attr_queue; 1090 else if (define_pred_queue != NULL) 1091 queue = &define_pred_queue; 1092 else if (define_insn_queue != NULL) 1093 queue = &define_insn_queue; 1094 else if (other_queue != NULL) 1095 queue = &other_queue; 1096 else 1097 return NULL_RTX; 1098 1099 elem = *queue; 1100 *queue = elem->next; 1101 desc = elem->data; 1102 read_rtx_filename = elem->filename; 1103 *lineno = elem->lineno; 1104 *seqnr = sequence_num; 1105 1106 free (elem); 1107 1108 /* Discard insn patterns which we know can never match (because 1109 their C test is provably always false). If insn_elision is 1110 false, our caller needs to see all the patterns. Note that the 1111 elided patterns are never counted by the sequence numbering; it 1112 it is the caller's responsibility, when insn_elision is false, not 1113 to use elided pattern numbers for anything. */ 1114 switch (GET_CODE (desc)) 1115 { 1116 case DEFINE_INSN: 1117 case DEFINE_EXPAND: 1118 if (maybe_eval_c_test (XSTR (desc, 2)) != 0) 1119 sequence_num++; 1120 else if (insn_elision) 1121 goto discard; 1122 1123 /* *seqnr is used here so the name table will match caller's 1124 idea of insn numbering, whether or not elision is active. */ 1125 record_insn_name (*seqnr, XSTR (desc, 0)); 1126 break; 1127 1128 case DEFINE_SPLIT: 1129 case DEFINE_PEEPHOLE: 1130 case DEFINE_PEEPHOLE2: 1131 if (maybe_eval_c_test (XSTR (desc, 1)) != 0) 1132 sequence_num++; 1133 else if (insn_elision) 1134 goto discard; 1135 break; 1136 1137 default: 1138 break; 1139 } 1140 1141 return desc; 1142 } 1143 1144 /* Helper functions for insn elision. */ 1145 1146 /* Compute a hash function of a c_test structure, which is keyed 1147 by its ->expr field. */ 1148 hashval_t 1149 hash_c_test (const void *x) 1150 { 1151 const struct c_test *a = (const struct c_test *) x; 1152 const unsigned char *base, *s = (const unsigned char *) a->expr; 1153 hashval_t hash; 1154 unsigned char c; 1155 unsigned int len; 1156 1157 base = s; 1158 hash = 0; 1159 1160 while ((c = *s++) != '\0') 1161 { 1162 hash += c + (c << 17); 1163 hash ^= hash >> 2; 1164 } 1165 1166 len = s - base; 1167 hash += len + (len << 17); 1168 hash ^= hash >> 2; 1169 1170 return hash; 1171 } 1172 1173 /* Compare two c_test expression structures. */ 1174 int 1175 cmp_c_test (const void *x, const void *y) 1176 { 1177 const struct c_test *a = (const struct c_test *) x; 1178 const struct c_test *b = (const struct c_test *) y; 1179 1180 return !strcmp (a->expr, b->expr); 1181 } 1182 1183 /* Given a string representing a C test expression, look it up in the 1184 condition_table and report whether or not its value is known 1185 at compile time. Returns a tristate: 1 for known true, 0 for 1186 known false, -1 for unknown. */ 1187 int 1188 maybe_eval_c_test (const char *expr) 1189 { 1190 const struct c_test *test; 1191 struct c_test dummy; 1192 1193 if (expr[0] == 0) 1194 return 1; 1195 1196 dummy.expr = expr; 1197 test = (const struct c_test *)htab_find (condition_table, &dummy); 1198 if (!test) 1199 return -1; 1200 return test->value; 1201 } 1202 1203 /* Record the C test expression EXPR in the condition_table, with 1204 value VAL. Duplicates clobber previous entries. */ 1205 1206 void 1207 add_c_test (const char *expr, int value) 1208 { 1209 struct c_test *test; 1210 1211 if (expr[0] == 0) 1212 return; 1213 1214 test = XNEW (struct c_test); 1215 test->expr = expr; 1216 test->value = value; 1217 1218 *(htab_find_slot (condition_table, test, INSERT)) = test; 1219 } 1220 1221 /* For every C test, call CALLBACK with two arguments: a pointer to 1222 the condition structure and INFO. Stops when CALLBACK returns zero. */ 1223 void 1224 traverse_c_tests (htab_trav callback, void *info) 1225 { 1226 if (condition_table) 1227 htab_traverse (condition_table, callback, info); 1228 } 1229 1230 1231 /* Given a string, return the number of comma-separated elements in it. 1232 Return 0 for the null string. */ 1233 int 1234 n_comma_elts (const char *s) 1235 { 1236 int n; 1237 1238 if (*s == '\0') 1239 return 0; 1240 1241 for (n = 1; *s; s++) 1242 if (*s == ',') 1243 n++; 1244 1245 return n; 1246 } 1247 1248 /* Given a pointer to a (char *), return a pointer to the beginning of the 1249 next comma-separated element in the string. Advance the pointer given 1250 to the end of that element. Return NULL if at end of string. Caller 1251 is responsible for copying the string if necessary. White space between 1252 a comma and an element is ignored. */ 1253 1254 const char * 1255 scan_comma_elt (const char **pstr) 1256 { 1257 const char *start; 1258 const char *p = *pstr; 1259 1260 if (*p == ',') 1261 p++; 1262 while (ISSPACE(*p)) 1263 p++; 1264 1265 if (*p == '\0') 1266 return NULL; 1267 1268 start = p; 1269 1270 while (*p != ',' && *p != '\0') 1271 p++; 1272 1273 *pstr = p; 1274 return start; 1275 } 1276 1277 /* Helper functions for define_predicate and define_special_predicate 1278 processing. Shared between genrecog.c and genpreds.c. */ 1279 1280 static htab_t predicate_table; 1281 struct pred_data *first_predicate; 1282 static struct pred_data **last_predicate = &first_predicate; 1283 1284 static hashval_t 1285 hash_struct_pred_data (const void *ptr) 1286 { 1287 return htab_hash_string (((const struct pred_data *)ptr)->name); 1288 } 1289 1290 static int 1291 eq_struct_pred_data (const void *a, const void *b) 1292 { 1293 return !strcmp (((const struct pred_data *)a)->name, 1294 ((const struct pred_data *)b)->name); 1295 } 1296 1297 struct pred_data * 1298 lookup_predicate (const char *name) 1299 { 1300 struct pred_data key; 1301 key.name = name; 1302 return (struct pred_data *) htab_find (predicate_table, &key); 1303 } 1304 1305 /* Record that predicate PRED can accept CODE. */ 1306 1307 void 1308 add_predicate_code (struct pred_data *pred, enum rtx_code code) 1309 { 1310 if (!pred->codes[code]) 1311 { 1312 pred->num_codes++; 1313 pred->codes[code] = true; 1314 1315 if (GET_RTX_CLASS (code) != RTX_CONST_OBJ) 1316 pred->allows_non_const = true; 1317 1318 if (code != REG 1319 && code != SUBREG 1320 && code != MEM 1321 && code != CONCAT 1322 && code != PARALLEL 1323 && code != STRICT_LOW_PART) 1324 pred->allows_non_lvalue = true; 1325 1326 if (pred->num_codes == 1) 1327 pred->singleton = code; 1328 else if (pred->num_codes == 2) 1329 pred->singleton = UNKNOWN; 1330 } 1331 } 1332 1333 void 1334 add_predicate (struct pred_data *pred) 1335 { 1336 void **slot = htab_find_slot (predicate_table, pred, INSERT); 1337 if (*slot) 1338 { 1339 error ("duplicate predicate definition for '%s'", pred->name); 1340 return; 1341 } 1342 *slot = pred; 1343 *last_predicate = pred; 1344 last_predicate = &pred->next; 1345 } 1346 1347 /* This array gives the initial content of the predicate table. It 1348 has entries for all predicates defined in recog.c. */ 1349 1350 struct std_pred_table 1351 { 1352 const char *name; 1353 bool special; 1354 bool allows_const_p; 1355 RTX_CODE codes[NUM_RTX_CODE]; 1356 }; 1357 1358 static const struct std_pred_table std_preds[] = { 1359 {"general_operand", false, true, {SUBREG, REG, MEM}}, 1360 {"address_operand", true, true, {SUBREG, REG, MEM, PLUS, MINUS, MULT}}, 1361 {"register_operand", false, false, {SUBREG, REG}}, 1362 {"pmode_register_operand", true, false, {SUBREG, REG}}, 1363 {"scratch_operand", false, false, {SCRATCH, REG}}, 1364 {"immediate_operand", false, true, {UNKNOWN}}, 1365 {"const_int_operand", false, false, {CONST_INT}}, 1366 {"const_double_operand", false, false, {CONST_INT, CONST_DOUBLE}}, 1367 {"nonimmediate_operand", false, false, {SUBREG, REG, MEM}}, 1368 {"nonmemory_operand", false, true, {SUBREG, REG}}, 1369 {"push_operand", false, false, {MEM}}, 1370 {"pop_operand", false, false, {MEM}}, 1371 {"memory_operand", false, false, {SUBREG, MEM}}, 1372 {"indirect_operand", false, false, {SUBREG, MEM}}, 1373 {"ordered_comparison_operator", false, false, {EQ, NE, 1374 LE, LT, GE, GT, 1375 LEU, LTU, GEU, GTU}}, 1376 {"comparison_operator", false, false, {EQ, NE, 1377 LE, LT, GE, GT, 1378 LEU, LTU, GEU, GTU, 1379 UNORDERED, ORDERED, 1380 UNEQ, UNGE, UNGT, 1381 UNLE, UNLT, LTGT}} 1382 }; 1383 #define NUM_KNOWN_STD_PREDS ARRAY_SIZE (std_preds) 1384 1385 /* Initialize the table of predicate definitions, starting with 1386 the information we have on generic predicates. */ 1387 1388 static void 1389 init_predicate_table (void) 1390 { 1391 size_t i, j; 1392 struct pred_data *pred; 1393 1394 predicate_table = htab_create_alloc (37, hash_struct_pred_data, 1395 eq_struct_pred_data, 0, 1396 xcalloc, free); 1397 1398 for (i = 0; i < NUM_KNOWN_STD_PREDS; i++) 1399 { 1400 pred = XCNEW (struct pred_data); 1401 pred->name = std_preds[i].name; 1402 pred->special = std_preds[i].special; 1403 1404 for (j = 0; std_preds[i].codes[j] != 0; j++) 1405 add_predicate_code (pred, std_preds[i].codes[j]); 1406 1407 if (std_preds[i].allows_const_p) 1408 for (j = 0; j < NUM_RTX_CODE; j++) 1409 if (GET_RTX_CLASS (j) == RTX_CONST_OBJ) 1410 add_predicate_code (pred, (enum rtx_code) j); 1411 1412 add_predicate (pred); 1413 } 1414 } 1415 1416 /* These functions allow linkage with print-rtl.c. Also, some generators 1417 like to annotate their output with insn names. */ 1418 1419 /* Holds an array of names indexed by insn_code_number. */ 1420 static char **insn_name_ptr = 0; 1421 static int insn_name_ptr_size = 0; 1422 1423 const char * 1424 get_insn_name (int code) 1425 { 1426 if (code < insn_name_ptr_size) 1427 return insn_name_ptr[code]; 1428 else 1429 return NULL; 1430 } 1431 1432 static void 1433 record_insn_name (int code, const char *name) 1434 { 1435 static const char *last_real_name = "insn"; 1436 static int last_real_code = 0; 1437 char *new_name; 1438 1439 if (insn_name_ptr_size <= code) 1440 { 1441 int new_size; 1442 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512); 1443 insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size); 1444 memset (insn_name_ptr + insn_name_ptr_size, 0, 1445 sizeof(char *) * (new_size - insn_name_ptr_size)); 1446 insn_name_ptr_size = new_size; 1447 } 1448 1449 if (!name || name[0] == '\0') 1450 { 1451 new_name = XNEWVAR (char, strlen (last_real_name) + 10); 1452 sprintf (new_name, "%s+%d", last_real_name, code - last_real_code); 1453 } 1454 else 1455 { 1456 last_real_name = new_name = xstrdup (name); 1457 last_real_code = code; 1458 } 1459 1460 insn_name_ptr[code] = new_name; 1461 } 1462