1/* Generate code from to output assembler insns as recognized from rtl. 2 Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 3 2003, 2004, 2005 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22 23/* This program reads the machine description for the compiler target machine 24 and produces a file containing these things: 25 26 1. An array of `struct insn_data', which is indexed by insn code number, 27 which contains: 28 29 a. `name' is the name for that pattern. Nameless patterns are 30 given a name. 31 32 b. `output' hold either the output template, an array of output 33 templates, or an output function. 34 35 c. `genfun' is the function to generate a body for that pattern, 36 given operands as arguments. 37 38 d. `n_operands' is the number of distinct operands in the pattern 39 for that insn, 40 41 e. `n_dups' is the number of match_dup's that appear in the insn's 42 pattern. This says how many elements of `recog_data.dup_loc' are 43 significant after an insn has been recognized. 44 45 f. `n_alternatives' is the number of alternatives in the constraints 46 of each pattern. 47 48 g. `output_format' tells what type of thing `output' is. 49 50 h. `operand' is the base of an array of operand data for the insn. 51 52 2. An array of `struct insn_operand data', used by `operand' above. 53 54 a. `predicate', an int-valued function, is the match_operand predicate 55 for this operand. 56 57 b. `constraint' is the constraint for this operand. 58 59 c. `address_p' indicates that the operand appears within ADDRESS 60 rtx's. 61 62 d. `mode' is the machine mode that that operand is supposed to have. 63 64 e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART. 65 66 f. `eliminable', is nonzero for operands that are matched normally by 67 MATCH_OPERAND; it is zero for operands that should not be changed during 68 register elimination such as MATCH_OPERATORs. 69 70 The code number of an insn is simply its position in the machine 71 description; code numbers are assigned sequentially to entries in 72 the description, starting with code number 0. 73 74 Thus, the following entry in the machine description 75 76 (define_insn "clrdf" 77 [(set (match_operand:DF 0 "general_operand" "") 78 (const_int 0))] 79 "" 80 "clrd %0") 81 82 assuming it is the 25th entry present, would cause 83 insn_data[24].template to be "clrd %0", and 84 insn_data[24].n_operands to be 1. */ 85 86#include "bconfig.h" 87#include "system.h" 88#include "coretypes.h" 89#include "tm.h" 90#include "rtl.h" 91#include "errors.h" 92#include "gensupport.h" 93 94/* No instruction can have more operands than this. Sorry for this 95 arbitrary limit, but what machine will have an instruction with 96 this many operands? */ 97 98#define MAX_MAX_OPERANDS 40 99 100static int n_occurrences (int, const char *); 101static const char *strip_whitespace (const char *); 102 103/* insns in the machine description are assigned sequential code numbers 104 that are used by insn-recog.c (produced by genrecog) to communicate 105 to insn-output.c (produced by this program). */ 106 107static int next_code_number; 108 109/* This counts all definitions in the md file, 110 for the sake of error messages. */ 111 112static int next_index_number; 113 114/* This counts all operands used in the md file. The first is null. */ 115 116static int next_operand_number = 1; 117 118/* Record in this chain all information about the operands we will output. */ 119 120struct operand_data 121{ 122 struct operand_data *next; 123 int index; 124 const char *predicate; 125 const char *constraint; 126 enum machine_mode mode; 127 unsigned char n_alternatives; 128 char address_p; 129 char strict_low; 130 char eliminable; 131 char seen; 132}; 133 134/* Begin with a null operand at index 0. */ 135 136static struct operand_data null_operand = 137{ 138 0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0 139}; 140 141static struct operand_data *odata = &null_operand; 142static struct operand_data **odata_end = &null_operand.next; 143 144/* Must match the constants in recog.h. */ 145 146#define INSN_OUTPUT_FORMAT_NONE 0 /* abort */ 147#define INSN_OUTPUT_FORMAT_SINGLE 1 /* const char * */ 148#define INSN_OUTPUT_FORMAT_MULTI 2 /* const char * const * */ 149#define INSN_OUTPUT_FORMAT_FUNCTION 3 /* const char * (*)(...) */ 150 151/* Record in this chain all information that we will output, 152 associated with the code number of the insn. */ 153 154struct data 155{ 156 struct data *next; 157 const char *name; 158 const char *template; 159 int code_number; 160 int index_number; 161 const char *filename; 162 int lineno; 163 int n_operands; /* Number of operands this insn recognizes */ 164 int n_dups; /* Number times match_dup appears in pattern */ 165 int n_alternatives; /* Number of alternatives in each constraint */ 166 int operand_number; /* Operand index in the big array. */ 167 int output_format; /* INSN_OUTPUT_FORMAT_*. */ 168 struct operand_data operand[MAX_MAX_OPERANDS]; 169}; 170 171/* This variable points to the first link in the insn chain. */ 172 173static struct data *idata, **idata_end = &idata; 174 175static void output_prologue (void); 176static void output_operand_data (void); 177static void output_insn_data (void); 178static void output_get_insn_name (void); 179static void scan_operands (struct data *, rtx, int, int); 180static int compare_operands (struct operand_data *, 181 struct operand_data *); 182static void place_operands (struct data *); 183static void process_template (struct data *, const char *); 184static void validate_insn_alternatives (struct data *); 185static void validate_insn_operands (struct data *); 186static void gen_insn (rtx, int); 187static void gen_peephole (rtx, int); 188static void gen_expand (rtx, int); 189static void gen_split (rtx, int); 190 191#ifdef USE_MD_CONSTRAINTS 192 193struct constraint_data 194{ 195 struct constraint_data *next_this_letter; 196 int lineno; 197 unsigned int namelen; 198 const char name[1]; 199}; 200 201/* This is a complete list (unlike the one in genpreds.c) of constraint 202 letters and modifiers with machine-independent meaning. The only 203 omission is digits, as these are handled specially. */ 204static const char indep_constraints[] = ",=+%*?!#&<>EFVXgimnoprs"; 205 206static struct constraint_data * 207constraints_by_letter_table[1 << CHAR_BIT]; 208 209static int mdep_constraint_len (const char *, int, int); 210static void note_constraint (rtx, int); 211 212#else /* !USE_MD_CONSTRAINTS */ 213 214static void check_constraint_len (void); 215static int constraint_len (const char *, int); 216 217#endif /* !USE_MD_CONSTRAINTS */ 218 219 220static void 221output_prologue (void) 222{ 223 printf ("/* Generated automatically by the program `genoutput'\n\ 224 from the machine description file `md'. */\n\n"); 225 226 printf ("#include \"config.h\"\n"); 227 printf ("#include \"system.h\"\n"); 228 printf ("#include \"coretypes.h\"\n"); 229 printf ("#include \"tm.h\"\n"); 230 printf ("#include \"flags.h\"\n"); 231 printf ("#include \"ggc.h\"\n"); 232 printf ("#include \"rtl.h\"\n"); 233 printf ("#include \"expr.h\"\n"); 234 printf ("#include \"insn-codes.h\"\n"); 235 printf ("#include \"tm_p.h\"\n"); 236 printf ("#include \"function.h\"\n"); 237 printf ("#include \"regs.h\"\n"); 238 printf ("#include \"hard-reg-set.h\"\n"); 239 printf ("#include \"real.h\"\n"); 240 printf ("#include \"insn-config.h\"\n\n"); 241 printf ("#include \"conditions.h\"\n"); 242 printf ("#include \"insn-attr.h\"\n\n"); 243 printf ("#include \"recog.h\"\n\n"); 244 printf ("#include \"toplev.h\"\n"); 245 printf ("#include \"output.h\"\n"); 246 printf ("#include \"target.h\"\n"); 247 printf ("#include \"tm-constrs.h\"\n"); 248} 249 250static void 251output_operand_data (void) 252{ 253 struct operand_data *d; 254 255 printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n"); 256 257 for (d = odata; d; d = d->next) 258 { 259 printf (" {\n"); 260 261 printf (" %s,\n", 262 d->predicate && d->predicate[0] ? d->predicate : "0"); 263 264 printf (" \"%s\",\n", d->constraint ? d->constraint : ""); 265 266 printf (" %smode,\n", GET_MODE_NAME (d->mode)); 267 268 printf (" %d,\n", d->strict_low); 269 270 printf (" %d\n", d->eliminable); 271 272 printf(" },\n"); 273 } 274 printf("};\n\n\n"); 275} 276 277static void 278output_insn_data (void) 279{ 280 struct data *d; 281 int name_offset = 0; 282 int next_name_offset; 283 const char * last_name = 0; 284 const char * next_name = 0; 285 struct data *n; 286 287 for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++) 288 if (n->name) 289 { 290 next_name = n->name; 291 break; 292 } 293 294 printf ("#if GCC_VERSION >= 2007\n__extension__\n#endif\n"); 295 printf ("\nconst struct insn_data insn_data[] = \n{\n"); 296 297 for (d = idata; d; d = d->next) 298 { 299 printf (" /* %s:%d */\n", d->filename, d->lineno); 300 printf (" {\n"); 301 302 if (d->name) 303 { 304 printf (" \"%s\",\n", d->name); 305 name_offset = 0; 306 last_name = d->name; 307 next_name = 0; 308 for (n = d->next, next_name_offset = 1; n; 309 n = n->next, next_name_offset++) 310 { 311 if (n->name) 312 { 313 next_name = n->name; 314 break; 315 } 316 } 317 } 318 else 319 { 320 name_offset++; 321 if (next_name && (last_name == 0 322 || name_offset > next_name_offset / 2)) 323 printf (" \"%s-%d\",\n", next_name, 324 next_name_offset - name_offset); 325 else 326 printf (" \"%s+%d\",\n", last_name, name_offset); 327 } 328 329 switch (d->output_format) 330 { 331 case INSN_OUTPUT_FORMAT_NONE: 332 printf ("#if HAVE_DESIGNATED_INITIALIZERS\n"); 333 printf (" { 0 },\n"); 334 printf ("#else\n"); 335 printf (" { 0, 0, 0 },\n"); 336 printf ("#endif\n"); 337 break; 338 case INSN_OUTPUT_FORMAT_SINGLE: 339 { 340 const char *p = d->template; 341 char prev = 0; 342 343 printf ("#if HAVE_DESIGNATED_INITIALIZERS\n"); 344 printf (" { .single =\n"); 345 printf ("#else\n"); 346 printf (" {\n"); 347 printf ("#endif\n"); 348 printf (" \""); 349 while (*p) 350 { 351 if (IS_VSPACE (*p) && prev != '\\') 352 { 353 /* Preserve two consecutive \n's or \r's, but treat \r\n 354 as a single newline. */ 355 if (*p == '\n' && prev != '\r') 356 printf ("\\n\\\n"); 357 } 358 else 359 putchar (*p); 360 prev = *p; 361 ++p; 362 } 363 printf ("\",\n"); 364 printf ("#if HAVE_DESIGNATED_INITIALIZERS\n"); 365 printf (" },\n"); 366 printf ("#else\n"); 367 printf (" 0, 0 },\n"); 368 printf ("#endif\n"); 369 } 370 break; 371 case INSN_OUTPUT_FORMAT_MULTI: 372 printf ("#if HAVE_DESIGNATED_INITIALIZERS\n"); 373 printf (" { .multi = output_%d },\n", d->code_number); 374 printf ("#else\n"); 375 printf (" { 0, output_%d, 0 },\n", d->code_number); 376 printf ("#endif\n"); 377 break; 378 case INSN_OUTPUT_FORMAT_FUNCTION: 379 printf ("#if HAVE_DESIGNATED_INITIALIZERS\n"); 380 printf (" { .function = output_%d },\n", d->code_number); 381 printf ("#else\n"); 382 printf (" { 0, 0, output_%d },\n", d->code_number); 383 printf ("#endif\n"); 384 break; 385 default: 386 gcc_unreachable (); 387 } 388 389 if (d->name && d->name[0] != '*') 390 printf (" (insn_gen_fn) gen_%s,\n", d->name); 391 else 392 printf (" 0,\n"); 393 394 printf (" &operand_data[%d],\n", d->operand_number); 395 printf (" %d,\n", d->n_operands); 396 printf (" %d,\n", d->n_dups); 397 printf (" %d,\n", d->n_alternatives); 398 printf (" %d\n", d->output_format); 399 400 printf(" },\n"); 401 } 402 printf ("};\n\n\n"); 403} 404 405static void 406output_get_insn_name (void) 407{ 408 printf ("const char *\n"); 409 printf ("get_insn_name (int code)\n"); 410 printf ("{\n"); 411 printf (" if (code == NOOP_MOVE_INSN_CODE)\n"); 412 printf (" return \"NOOP_MOVE\";\n"); 413 printf (" else\n"); 414 printf (" return insn_data[code].name;\n"); 415 printf ("}\n"); 416} 417 418 419/* Stores in max_opno the largest operand number present in `part', if 420 that is larger than the previous value of max_opno, and the rest of 421 the operand data into `d->operand[i]'. 422 423 THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS. 424 THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */ 425 426static int max_opno; 427static int num_dups; 428 429static void 430scan_operands (struct data *d, rtx part, int this_address_p, 431 int this_strict_low) 432{ 433 int i, j; 434 const char *format_ptr; 435 int opno; 436 437 if (part == 0) 438 return; 439 440 switch (GET_CODE (part)) 441 { 442 case MATCH_OPERAND: 443 opno = XINT (part, 0); 444 if (opno > max_opno) 445 max_opno = opno; 446 if (max_opno >= MAX_MAX_OPERANDS) 447 { 448 message_with_line (d->lineno, 449 "maximum number of operands exceeded"); 450 have_error = 1; 451 return; 452 } 453 if (d->operand[opno].seen) 454 { 455 message_with_line (d->lineno, 456 "repeated operand number %d\n", opno); 457 have_error = 1; 458 } 459 460 d->operand[opno].seen = 1; 461 d->operand[opno].mode = GET_MODE (part); 462 d->operand[opno].strict_low = this_strict_low; 463 d->operand[opno].predicate = XSTR (part, 1); 464 d->operand[opno].constraint = strip_whitespace (XSTR (part, 2)); 465 d->operand[opno].n_alternatives 466 = n_occurrences (',', d->operand[opno].constraint) + 1; 467 d->operand[opno].address_p = this_address_p; 468 d->operand[opno].eliminable = 1; 469 return; 470 471 case MATCH_SCRATCH: 472 opno = XINT (part, 0); 473 if (opno > max_opno) 474 max_opno = opno; 475 if (max_opno >= MAX_MAX_OPERANDS) 476 { 477 message_with_line (d->lineno, 478 "maximum number of operands exceeded"); 479 have_error = 1; 480 return; 481 } 482 if (d->operand[opno].seen) 483 { 484 message_with_line (d->lineno, 485 "repeated operand number %d\n", opno); 486 have_error = 1; 487 } 488 489 d->operand[opno].seen = 1; 490 d->operand[opno].mode = GET_MODE (part); 491 d->operand[opno].strict_low = 0; 492 d->operand[opno].predicate = "scratch_operand"; 493 d->operand[opno].constraint = strip_whitespace (XSTR (part, 1)); 494 d->operand[opno].n_alternatives 495 = n_occurrences (',', d->operand[opno].constraint) + 1; 496 d->operand[opno].address_p = 0; 497 d->operand[opno].eliminable = 0; 498 return; 499 500 case MATCH_OPERATOR: 501 case MATCH_PARALLEL: 502 opno = XINT (part, 0); 503 if (opno > max_opno) 504 max_opno = opno; 505 if (max_opno >= MAX_MAX_OPERANDS) 506 { 507 message_with_line (d->lineno, 508 "maximum number of operands exceeded"); 509 have_error = 1; 510 return; 511 } 512 if (d->operand[opno].seen) 513 { 514 message_with_line (d->lineno, 515 "repeated operand number %d\n", opno); 516 have_error = 1; 517 } 518 519 d->operand[opno].seen = 1; 520 d->operand[opno].mode = GET_MODE (part); 521 d->operand[opno].strict_low = 0; 522 d->operand[opno].predicate = XSTR (part, 1); 523 d->operand[opno].constraint = 0; 524 d->operand[opno].address_p = 0; 525 d->operand[opno].eliminable = 0; 526 for (i = 0; i < XVECLEN (part, 2); i++) 527 scan_operands (d, XVECEXP (part, 2, i), 0, 0); 528 return; 529 530 case MATCH_DUP: 531 case MATCH_OP_DUP: 532 case MATCH_PAR_DUP: 533 ++num_dups; 534 break; 535 536 case ADDRESS: 537 scan_operands (d, XEXP (part, 0), 1, 0); 538 return; 539 540 case STRICT_LOW_PART: 541 scan_operands (d, XEXP (part, 0), 0, 1); 542 return; 543 544 default: 545 break; 546 } 547 548 format_ptr = GET_RTX_FORMAT (GET_CODE (part)); 549 550 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++) 551 switch (*format_ptr++) 552 { 553 case 'e': 554 case 'u': 555 scan_operands (d, XEXP (part, i), 0, 0); 556 break; 557 case 'E': 558 if (XVEC (part, i) != NULL) 559 for (j = 0; j < XVECLEN (part, i); j++) 560 scan_operands (d, XVECEXP (part, i, j), 0, 0); 561 break; 562 } 563} 564 565/* Compare two operands for content equality. */ 566 567static int 568compare_operands (struct operand_data *d0, struct operand_data *d1) 569{ 570 const char *p0, *p1; 571 572 p0 = d0->predicate; 573 if (!p0) 574 p0 = ""; 575 p1 = d1->predicate; 576 if (!p1) 577 p1 = ""; 578 if (strcmp (p0, p1) != 0) 579 return 0; 580 581 p0 = d0->constraint; 582 if (!p0) 583 p0 = ""; 584 p1 = d1->constraint; 585 if (!p1) 586 p1 = ""; 587 if (strcmp (p0, p1) != 0) 588 return 0; 589 590 if (d0->mode != d1->mode) 591 return 0; 592 593 if (d0->strict_low != d1->strict_low) 594 return 0; 595 596 if (d0->eliminable != d1->eliminable) 597 return 0; 598 599 return 1; 600} 601 602/* Scan the list of operands we've already committed to output and either 603 find a subsequence that is the same, or allocate a new one at the end. */ 604 605static void 606place_operands (struct data *d) 607{ 608 struct operand_data *od, *od2; 609 int i; 610 611 if (d->n_operands == 0) 612 { 613 d->operand_number = 0; 614 return; 615 } 616 617 /* Brute force substring search. */ 618 for (od = odata, i = 0; od; od = od->next, i = 0) 619 if (compare_operands (od, &d->operand[0])) 620 { 621 od2 = od->next; 622 i = 1; 623 while (1) 624 { 625 if (i == d->n_operands) 626 goto full_match; 627 if (od2 == NULL) 628 goto partial_match; 629 if (! compare_operands (od2, &d->operand[i])) 630 break; 631 ++i, od2 = od2->next; 632 } 633 } 634 635 /* Either partial match at the end of the list, or no match. In either 636 case, we tack on what operands are remaining to the end of the list. */ 637 partial_match: 638 d->operand_number = next_operand_number - i; 639 for (; i < d->n_operands; ++i) 640 { 641 od2 = &d->operand[i]; 642 *odata_end = od2; 643 odata_end = &od2->next; 644 od2->index = next_operand_number++; 645 } 646 *odata_end = NULL; 647 return; 648 649 full_match: 650 d->operand_number = od->index; 651 return; 652} 653 654 655/* Process an assembler template from a define_insn or a define_peephole. 656 It is either the assembler code template, a list of assembler code 657 templates, or C code to generate the assembler code template. */ 658 659static void 660process_template (struct data *d, const char *template) 661{ 662 const char *cp; 663 int i; 664 665 /* Templates starting with * contain straight code to be run. */ 666 if (template[0] == '*') 667 { 668 d->template = 0; 669 d->output_format = INSN_OUTPUT_FORMAT_FUNCTION; 670 671 puts ("\nstatic const char *"); 672 printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n", 673 d->code_number); 674 puts ("{"); 675 print_rtx_ptr_loc (template); 676 puts (template + 1); 677 puts ("}"); 678 } 679 680 /* If the assembler code template starts with a @ it is a newline-separated 681 list of assembler code templates, one for each alternative. */ 682 else if (template[0] == '@') 683 { 684 d->template = 0; 685 d->output_format = INSN_OUTPUT_FORMAT_MULTI; 686 687 printf ("\nstatic const char * const output_%d[] = {\n", d->code_number); 688 689 for (i = 0, cp = &template[1]; *cp; ) 690 { 691 const char *ep, *sp; 692 693 while (ISSPACE (*cp)) 694 cp++; 695 696 printf (" \""); 697 698 for (ep = sp = cp; !IS_VSPACE (*ep) && *ep != '\0'; ++ep) 699 if (!ISSPACE (*ep)) 700 sp = ep + 1; 701 702 if (sp != ep) 703 message_with_line (d->lineno, 704 "trailing whitespace in output template"); 705 706 while (cp < sp) 707 { 708 putchar (*cp); 709 cp++; 710 } 711 712 printf ("\",\n"); 713 i++; 714 } 715 if (i == 1) 716 message_with_line (d->lineno, 717 "'@' is redundant for output template with single alternative"); 718 if (i != d->n_alternatives) 719 { 720 message_with_line (d->lineno, 721 "wrong number of alternatives in the output template"); 722 have_error = 1; 723 } 724 725 printf ("};\n"); 726 } 727 else 728 { 729 d->template = template; 730 d->output_format = INSN_OUTPUT_FORMAT_SINGLE; 731 } 732} 733 734/* Check insn D for consistency in number of constraint alternatives. */ 735 736static void 737validate_insn_alternatives (struct data *d) 738{ 739 int n = 0, start; 740 741 /* Make sure all the operands have the same number of alternatives 742 in their constraints. Let N be that number. */ 743 for (start = 0; start < d->n_operands; start++) 744 if (d->operand[start].n_alternatives > 0) 745 { 746 int len, i; 747 const char *p; 748 char c; 749 int which_alternative = 0; 750 int alternative_count_unsure = 0; 751 752 for (p = d->operand[start].constraint; (c = *p); p += len) 753 { 754#ifdef USE_MD_CONSTRAINTS 755 if (ISSPACE (c) || strchr (indep_constraints, c)) 756 len = 1; 757 else if (ISDIGIT (c)) 758 { 759 const char *q = p; 760 do 761 q++; 762 while (ISDIGIT (*q)); 763 len = q - p; 764 } 765 else 766 len = mdep_constraint_len (p, d->lineno, start); 767#else 768 len = CONSTRAINT_LEN (c, p); 769 770 if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c))) 771 { 772 message_with_line (d->lineno, 773 "invalid length %d for char '%c' in alternative %d of operand %d", 774 len, c, which_alternative, start); 775 len = 1; 776 have_error = 1; 777 } 778#endif 779 780 if (c == ',') 781 { 782 which_alternative++; 783 continue; 784 } 785 786 for (i = 1; i < len; i++) 787 if (p[i] == '\0') 788 { 789 message_with_line (d->lineno, 790 "NUL in alternative %d of operand %d", 791 which_alternative, start); 792 alternative_count_unsure = 1; 793 break; 794 } 795 else if (strchr (",#*", p[i])) 796 { 797 message_with_line (d->lineno, 798 "'%c' in alternative %d of operand %d", 799 p[i], which_alternative, start); 800 alternative_count_unsure = 1; 801 } 802 } 803 if (alternative_count_unsure) 804 have_error = 1; 805 else if (n == 0) 806 n = d->operand[start].n_alternatives; 807 else if (n != d->operand[start].n_alternatives) 808 { 809 message_with_line (d->lineno, 810 "wrong number of alternatives in operand %d", 811 start); 812 have_error = 1; 813 } 814 } 815 816 /* Record the insn's overall number of alternatives. */ 817 d->n_alternatives = n; 818} 819 820/* Verify that there are no gaps in operand numbers for INSNs. */ 821 822static void 823validate_insn_operands (struct data *d) 824{ 825 int i; 826 827 for (i = 0; i < d->n_operands; ++i) 828 if (d->operand[i].seen == 0) 829 { 830 message_with_line (d->lineno, "missing operand %d", i); 831 have_error = 1; 832 } 833} 834 835/* Look at a define_insn just read. Assign its code number. Record 836 on idata the template and the number of arguments. If the insn has 837 a hairy output action, output a function for now. */ 838 839static void 840gen_insn (rtx insn, int lineno) 841{ 842 struct data *d = XNEW (struct data); 843 int i; 844 845 d->code_number = next_code_number; 846 d->index_number = next_index_number; 847 d->filename = read_rtx_filename; 848 d->lineno = lineno; 849 if (XSTR (insn, 0)[0]) 850 d->name = XSTR (insn, 0); 851 else 852 d->name = 0; 853 854 /* Build up the list in the same order as the insns are seen 855 in the machine description. */ 856 d->next = 0; 857 *idata_end = d; 858 idata_end = &d->next; 859 860 max_opno = -1; 861 num_dups = 0; 862 memset (d->operand, 0, sizeof (d->operand)); 863 864 for (i = 0; i < XVECLEN (insn, 1); i++) 865 scan_operands (d, XVECEXP (insn, 1, i), 0, 0); 866 867 d->n_operands = max_opno + 1; 868 d->n_dups = num_dups; 869 870#ifndef USE_MD_CONSTRAINTS 871 check_constraint_len (); 872#endif 873 validate_insn_operands (d); 874 validate_insn_alternatives (d); 875 place_operands (d); 876 process_template (d, XTMPL (insn, 3)); 877} 878 879/* Look at a define_peephole just read. Assign its code number. 880 Record on idata the template and the number of arguments. 881 If the insn has a hairy output action, output it now. */ 882 883static void 884gen_peephole (rtx peep, int lineno) 885{ 886 struct data *d = XNEW (struct data); 887 int i; 888 889 d->code_number = next_code_number; 890 d->index_number = next_index_number; 891 d->filename = read_rtx_filename; 892 d->lineno = lineno; 893 d->name = 0; 894 895 /* Build up the list in the same order as the insns are seen 896 in the machine description. */ 897 d->next = 0; 898 *idata_end = d; 899 idata_end = &d->next; 900 901 max_opno = -1; 902 num_dups = 0; 903 memset (d->operand, 0, sizeof (d->operand)); 904 905 /* Get the number of operands by scanning all the patterns of the 906 peephole optimizer. But ignore all the rest of the information 907 thus obtained. */ 908 for (i = 0; i < XVECLEN (peep, 0); i++) 909 scan_operands (d, XVECEXP (peep, 0, i), 0, 0); 910 911 d->n_operands = max_opno + 1; 912 d->n_dups = 0; 913 914 validate_insn_alternatives (d); 915 place_operands (d); 916 process_template (d, XTMPL (peep, 2)); 917} 918 919/* Process a define_expand just read. Assign its code number, 920 only for the purposes of `insn_gen_function'. */ 921 922static void 923gen_expand (rtx insn, int lineno) 924{ 925 struct data *d = XNEW (struct data); 926 int i; 927 928 d->code_number = next_code_number; 929 d->index_number = next_index_number; 930 d->filename = read_rtx_filename; 931 d->lineno = lineno; 932 if (XSTR (insn, 0)[0]) 933 d->name = XSTR (insn, 0); 934 else 935 d->name = 0; 936 937 /* Build up the list in the same order as the insns are seen 938 in the machine description. */ 939 d->next = 0; 940 *idata_end = d; 941 idata_end = &d->next; 942 943 max_opno = -1; 944 num_dups = 0; 945 memset (d->operand, 0, sizeof (d->operand)); 946 947 /* Scan the operands to get the specified predicates and modes, 948 since expand_binop needs to know them. */ 949 950 if (XVEC (insn, 1)) 951 for (i = 0; i < XVECLEN (insn, 1); i++) 952 scan_operands (d, XVECEXP (insn, 1, i), 0, 0); 953 954 d->n_operands = max_opno + 1; 955 d->n_dups = num_dups; 956 d->template = 0; 957 d->output_format = INSN_OUTPUT_FORMAT_NONE; 958 959 validate_insn_alternatives (d); 960 place_operands (d); 961} 962 963/* Process a define_split just read. Assign its code number, 964 only for reasons of consistency and to simplify genrecog. */ 965 966static void 967gen_split (rtx split, int lineno) 968{ 969 struct data *d = XNEW (struct data); 970 int i; 971 972 d->code_number = next_code_number; 973 d->index_number = next_index_number; 974 d->filename = read_rtx_filename; 975 d->lineno = lineno; 976 d->name = 0; 977 978 /* Build up the list in the same order as the insns are seen 979 in the machine description. */ 980 d->next = 0; 981 *idata_end = d; 982 idata_end = &d->next; 983 984 max_opno = -1; 985 num_dups = 0; 986 memset (d->operand, 0, sizeof (d->operand)); 987 988 /* Get the number of operands by scanning all the patterns of the 989 split patterns. But ignore all the rest of the information thus 990 obtained. */ 991 for (i = 0; i < XVECLEN (split, 0); i++) 992 scan_operands (d, XVECEXP (split, 0, i), 0, 0); 993 994 d->n_operands = max_opno + 1; 995 d->n_dups = 0; 996 d->n_alternatives = 0; 997 d->template = 0; 998 d->output_format = INSN_OUTPUT_FORMAT_NONE; 999 1000 place_operands (d); 1001} 1002 1003extern int main (int, char **); 1004 1005int 1006main (int argc, char **argv) 1007{ 1008 rtx desc; 1009 1010 progname = "genoutput"; 1011 1012 if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE) 1013 return (FATAL_EXIT_CODE); 1014 1015 output_prologue (); 1016 next_code_number = 0; 1017 next_index_number = 0; 1018 1019 /* Read the machine description. */ 1020 1021 while (1) 1022 { 1023 int line_no; 1024 1025 desc = read_md_rtx (&line_no, &next_code_number); 1026 if (desc == NULL) 1027 break; 1028 1029 switch (GET_CODE (desc)) 1030 { 1031 case DEFINE_INSN: 1032 gen_insn (desc, line_no); 1033 break; 1034 1035 case DEFINE_PEEPHOLE: 1036 gen_peephole (desc, line_no); 1037 break; 1038 1039 case DEFINE_EXPAND: 1040 gen_expand (desc, line_no); 1041 break; 1042 1043 case DEFINE_SPLIT: 1044 case DEFINE_PEEPHOLE2: 1045 gen_split (desc, line_no); 1046 break; 1047 1048#ifdef USE_MD_CONSTRAINTS 1049 case DEFINE_CONSTRAINT: 1050 case DEFINE_REGISTER_CONSTRAINT: 1051 case DEFINE_ADDRESS_CONSTRAINT: 1052 case DEFINE_MEMORY_CONSTRAINT: 1053 note_constraint (desc, line_no); 1054 break; 1055#endif 1056 1057 default: 1058 break; 1059 } 1060 next_index_number++; 1061 } 1062 1063 printf("\n\n"); 1064 output_operand_data (); 1065 output_insn_data (); 1066 output_get_insn_name (); 1067 1068 fflush (stdout); 1069 return (ferror (stdout) != 0 || have_error 1070 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); 1071} 1072 1073/* Return the number of occurrences of character C in string S or 1074 -1 if S is the null string. */ 1075 1076static int 1077n_occurrences (int c, const char *s) 1078{ 1079 int n = 0; 1080 1081 if (s == 0 || *s == '\0') 1082 return -1; 1083 1084 while (*s) 1085 n += (*s++ == c); 1086 1087 return n; 1088} 1089 1090/* Remove whitespace in `s' by moving up characters until the end. 1091 Return a new string. */ 1092 1093static const char * 1094strip_whitespace (const char *s) 1095{ 1096 char *p, *q; 1097 char ch; 1098 1099 if (s == 0) 1100 return 0; 1101 1102 p = q = XNEWVEC (char, strlen (s) + 1); 1103 while ((ch = *s++) != '\0') 1104 if (! ISSPACE (ch)) 1105 *p++ = ch; 1106 1107 *p = '\0'; 1108 return q; 1109} 1110 1111#ifdef USE_MD_CONSTRAINTS 1112 1113/* Record just enough information about a constraint to allow checking 1114 of operand constraint strings above, in validate_insn_alternatives. 1115 Does not validate most properties of the constraint itself; does 1116 enforce no duplicate names, no overlap with MI constraints, and no 1117 prefixes. EXP is the define_*constraint form, LINENO the line number 1118 reported by the reader. */ 1119static void 1120note_constraint (rtx exp, int lineno) 1121{ 1122 const char *name = XSTR (exp, 0); 1123 unsigned int namelen = strlen (name); 1124 struct constraint_data **iter, **slot, *new; 1125 1126 if (strchr (indep_constraints, name[0])) 1127 { 1128 if (name[1] == '\0') 1129 message_with_line (lineno, "constraint letter '%s' cannot be " 1130 "redefined by the machine description", name); 1131 else 1132 message_with_line (lineno, "constraint name '%s' cannot be defined by " 1133 "the machine description, as it begins with '%c'", 1134 name, name[0]); 1135 have_error = 1; 1136 return; 1137 } 1138 1139 slot = &constraints_by_letter_table[(unsigned int)name[0]]; 1140 for (iter = slot; *iter; iter = &(*iter)->next_this_letter) 1141 { 1142 /* This causes slot to end up pointing to the 1143 next_this_letter field of the last constraint with a name 1144 of equal or greater length than the new constraint; hence 1145 the new constraint will be inserted after all previous 1146 constraints with names of the same length. */ 1147 if ((*iter)->namelen >= namelen) 1148 slot = iter; 1149 1150 if (!strcmp ((*iter)->name, name)) 1151 { 1152 message_with_line (lineno, "redefinition of constraint '%s'", name); 1153 message_with_line ((*iter)->lineno, "previous definition is here"); 1154 have_error = 1; 1155 return; 1156 } 1157 else if (!strncmp ((*iter)->name, name, (*iter)->namelen)) 1158 { 1159 message_with_line (lineno, "defining constraint '%s' here", name); 1160 message_with_line ((*iter)->lineno, "renders constraint '%s' " 1161 "(defined here) a prefix", (*iter)->name); 1162 have_error = 1; 1163 return; 1164 } 1165 else if (!strncmp ((*iter)->name, name, namelen)) 1166 { 1167 message_with_line (lineno, "constraint '%s' is a prefix", name); 1168 message_with_line ((*iter)->lineno, "of constraint '%s' " 1169 "(defined here)", (*iter)->name); 1170 have_error = 1; 1171 return; 1172 } 1173 } 1174 new = xmalloc (sizeof (struct constraint_data) + namelen); 1175 strcpy ((char *)new + offsetof(struct constraint_data, name), name); 1176 new->namelen = namelen; 1177 new->lineno = lineno; 1178 new->next_this_letter = *slot; 1179 *slot = new; 1180} 1181 1182/* Return the length of the constraint name beginning at position S 1183 of an operand constraint string, or issue an error message if there 1184 is no such constraint. Does not expect to be called for generic 1185 constraints. */ 1186static int 1187mdep_constraint_len (const char *s, int lineno, int opno) 1188{ 1189 struct constraint_data *p; 1190 1191 p = constraints_by_letter_table[(unsigned int)s[0]]; 1192 1193 if (p) 1194 for (; p; p = p->next_this_letter) 1195 if (!strncmp (s, p->name, p->namelen)) 1196 return p->namelen; 1197 1198 message_with_line (lineno, 1199 "error: undefined machine-specific constraint " 1200 "at this point: \"%s\"", s); 1201 message_with_line (lineno, "note: in operand %d", opno); 1202 have_error = 1; 1203 return 1; /* safe */ 1204} 1205 1206#else 1207/* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not 1208 tampered with. This isn't bullet-proof, but it should catch 1209 most genuine mistakes. */ 1210static void 1211check_constraint_len (void) 1212{ 1213 const char *p; 1214 int d; 1215 1216 for (p = ",#*+=&%!1234567890"; *p; p++) 1217 for (d = -9; d < 9; d++) 1218 gcc_assert (constraint_len (p, d) == d); 1219} 1220 1221static int 1222constraint_len (const char *p, int genoutput_default_constraint_len) 1223{ 1224 /* Check that we still match defaults.h . First we do a generation-time 1225 check that fails if the value is not the expected one... */ 1226 gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1); 1227 /* And now a compile-time check that should give a diagnostic if the 1228 definition doesn't exactly match. */ 1229#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 1230 /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is 1231 being used. */ 1232#undef DEFAULT_CONSTRAINT_LEN 1233#define DEFAULT_CONSTRAINT_LEN(C,STR) \ 1234 ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len) 1235 return CONSTRAINT_LEN (*p, p); 1236 /* And set it back. */ 1237#undef DEFAULT_CONSTRAINT_LEN 1238#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 1239} 1240#endif 1241