rtl.c revision 52284
1/* Allocate and read RTL for GNU C Compiler. 2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998 Free Software Foundation, Inc. 3 4This file is part of GNU CC. 5 6GNU CC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2, or (at your option) 9any later version. 10 11GNU CC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GNU CC; see the file COPYING. If not, write to 18the Free Software Foundation, 59 Temple Place - Suite 330, 19Boston, MA 02111-1307, USA. */ 20 21 22#include "config.h" 23#include "system.h" 24#include "rtl.h" 25#include "real.h" 26#include "bitmap.h" 27 28#include "obstack.h" 29#define obstack_chunk_alloc xmalloc 30#define obstack_chunk_free free 31 32/* Obstack used for allocating RTL objects. 33 Between functions, this is the permanent_obstack. 34 While parsing and expanding a function, this is maybepermanent_obstack 35 so we can save it if it is an inline function. 36 During optimization and output, this is function_obstack. */ 37 38extern struct obstack *rtl_obstack; 39 40/* Indexed by rtx code, gives number of operands for an rtx with that code. 41 Does NOT include rtx header data (code and links). 42 This array is initialized in init_rtl. */ 43 44int rtx_length[NUM_RTX_CODE + 1]; 45 46/* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */ 47 48#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME , 49 50char *rtx_name[] = { 51#include "rtl.def" /* rtl expressions are documented here */ 52}; 53 54#undef DEF_RTL_EXPR 55 56/* Indexed by machine mode, gives the name of that machine mode. 57 This name does not include the letters "mode". */ 58 59#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME, 60 61char *mode_name[(int) MAX_MACHINE_MODE + 1] = { 62#include "machmode.def" 63 64#ifdef EXTRA_CC_MODES 65 EXTRA_CC_NAMES, 66#endif 67 /* Add an extra field to avoid a core dump if someone tries to convert 68 MAX_MACHINE_MODE to a string. */ 69 "" 70}; 71 72#undef DEF_MACHMODE 73 74/* Indexed by machine mode, gives the length of the mode, in bytes. 75 GET_MODE_CLASS uses this. */ 76 77#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS, 78 79enum mode_class mode_class[(int) MAX_MACHINE_MODE] = { 80#include "machmode.def" 81}; 82 83#undef DEF_MACHMODE 84 85/* Indexed by machine mode, gives the length of the mode, in bytes. 86 GET_MODE_SIZE uses this. */ 87 88#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE, 89 90int mode_size[(int) MAX_MACHINE_MODE] = { 91#include "machmode.def" 92}; 93 94#undef DEF_MACHMODE 95 96/* Indexed by machine mode, gives the length of the mode's subunit. 97 GET_MODE_UNIT_SIZE uses this. */ 98 99#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT, 100 101int mode_unit_size[(int) MAX_MACHINE_MODE] = { 102#include "machmode.def" /* machine modes are documented here */ 103}; 104 105#undef DEF_MACHMODE 106 107/* Indexed by machine mode, gives next wider natural mode 108 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions 109 use this. */ 110 111#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \ 112 (unsigned char) WIDER, 113 114unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = { 115#include "machmode.def" /* machine modes are documented here */ 116}; 117 118#undef DEF_MACHMODE 119 120#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \ 121 ((SIZE) * BITS_PER_UNIT >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (SIZE) * BITS_PER_UNIT) - 1, 122 123/* Indexed by machine mode, gives mask of significant bits in mode. */ 124 125unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = { 126#include "machmode.def" 127}; 128 129/* Indexed by mode class, gives the narrowest mode for each class. */ 130 131enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS]; 132 133/* Indexed by rtx code, gives a sequence of operand-types for 134 rtx's of that code. The sequence is a C string in which 135 each character describes one operand. */ 136 137char *rtx_format[] = { 138 /* "*" undefined. 139 can cause a warning message 140 "0" field is unused (or used in a phase-dependent manner) 141 prints nothing 142 "i" an integer 143 prints the integer 144 "n" like "i", but prints entries from `note_insn_name' 145 "w" an integer of width HOST_BITS_PER_WIDE_INT 146 prints the integer 147 "s" a pointer to a string 148 prints the string 149 "S" like "s", but optional: 150 the containing rtx may end before this operand 151 "e" a pointer to an rtl expression 152 prints the expression 153 "E" a pointer to a vector that points to a number of rtl expressions 154 prints a list of the rtl expressions 155 "V" like "E", but optional: 156 the containing rtx may end before this operand 157 "u" a pointer to another insn 158 prints the uid of the insn. 159 "b" is a pointer to a bitmap header. 160 "t" is a tree pointer. */ 161 162#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , 163#include "rtl.def" /* rtl expressions are defined here */ 164#undef DEF_RTL_EXPR 165}; 166 167/* Indexed by rtx code, gives a character representing the "class" of 168 that rtx code. See rtl.def for documentation on the defined classes. */ 169 170char rtx_class[] = { 171#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS, 172#include "rtl.def" /* rtl expressions are defined here */ 173#undef DEF_RTL_EXPR 174}; 175 176/* Names for kinds of NOTEs and REG_NOTEs. */ 177 178char *note_insn_name[] = { 0 , "NOTE_INSN_DELETED", 179 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END", 180 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END", 181 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP", 182 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP", 183 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG", 184 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG", 185 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END", 186 "NOTE_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_START", 187 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE", 188 "NOTE_INSN_BASIC_BLOCK" }; 189 190char *reg_note_name[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0", 191 "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL", 192 "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED", 193 "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL", 194 "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB", 195 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", 196 "REG_BR_PRED", "REG_EH_CONTEXT", 197 "REG_FRAME_RELATED_EXPR", "REG_EH_REGION", 198 "REG_EH_RETHROW" }; 199 200static void dump_and_abort PROTO((int, int, FILE *)) ATTRIBUTE_NORETURN; 201static void read_name PROTO((char *, FILE *)); 202 203/* Allocate an rtx vector of N elements. 204 Store the length, and initialize all elements to zero. */ 205 206rtvec 207rtvec_alloc (n) 208 int n; 209{ 210 rtvec rt; 211 int i; 212 213 rt = (rtvec) obstack_alloc (rtl_obstack, 214 sizeof (struct rtvec_def) 215 + (( n - 1) * sizeof (rtunion))); 216 217 /* clear out the vector */ 218 PUT_NUM_ELEM (rt, n); 219 220 for (i = 0; i < n; i++) 221 rt->elem[i].rtwint = 0; 222 223 return rt; 224} 225 226/* Allocate an rtx of code CODE. The CODE is stored in the rtx; 227 all the rest is initialized to zero. */ 228 229rtx 230rtx_alloc (code) 231 RTX_CODE code; 232{ 233 rtx rt; 234 register struct obstack *ob = rtl_obstack; 235 register int nelts = GET_RTX_LENGTH (code); 236 register int length = sizeof (struct rtx_def) 237 + (nelts - 1) * sizeof (rtunion); 238 239 /* This function is called more than any other in GCC, 240 so we manipulate the obstack directly. 241 242 Even though rtx objects are word aligned, we may be sharing an obstack 243 with tree nodes, which may have to be double-word aligned. So align 244 our length to the alignment mask in the obstack. */ 245 246 length = (length + ob->alignment_mask) & ~ ob->alignment_mask; 247 248 if (ob->chunk_limit - ob->next_free < length) 249 _obstack_newchunk (ob, length); 250 rt = (rtx)ob->object_base; 251 ob->next_free += length; 252 ob->object_base = ob->next_free; 253 254 /* We want to clear everything up to the FLD array. Normally, this is 255 one int, but we don't want to assume that and it isn't very portable 256 anyway; this is. */ 257 258 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion)); 259 260 PUT_CODE (rt, code); 261 262 return rt; 263} 264 265/* Free the rtx X and all RTL allocated since X. */ 266 267void 268rtx_free (x) 269 rtx x; 270{ 271 obstack_free (rtl_obstack, x); 272} 273 274/* Create a new copy of an rtx. 275 Recursively copies the operands of the rtx, 276 except for those few rtx codes that are sharable. */ 277 278rtx 279copy_rtx (orig) 280 register rtx orig; 281{ 282 register rtx copy; 283 register int i, j; 284 register RTX_CODE code; 285 register char *format_ptr; 286 287 code = GET_CODE (orig); 288 289 switch (code) 290 { 291 case REG: 292 case QUEUED: 293 case CONST_INT: 294 case CONST_DOUBLE: 295 case SYMBOL_REF: 296 case CODE_LABEL: 297 case PC: 298 case CC0: 299 case SCRATCH: 300 /* SCRATCH must be shared because they represent distinct values. */ 301 case ADDRESSOF: 302 return orig; 303 304 case CONST: 305 /* CONST can be shared if it contains a SYMBOL_REF. If it contains 306 a LABEL_REF, it isn't sharable. */ 307 if (GET_CODE (XEXP (orig, 0)) == PLUS 308 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF 309 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT) 310 return orig; 311 break; 312 313 /* A MEM with a constant address is not sharable. The problem is that 314 the constant address may need to be reloaded. If the mem is shared, 315 then reloading one copy of this mem will cause all copies to appear 316 to have been reloaded. */ 317 318 default: 319 break; 320 } 321 322 copy = rtx_alloc (code); 323 324 /* Copy the various flags, and other information. We assume that 325 all fields need copying, and then clear the fields that should 326 not be copied. That is the sensible default behavior, and forces 327 us to explicitly document why we are *not* copying a flag. */ 328 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion)); 329 330 /* We do not copy the USED flag, which is used as a mark bit during 331 walks over the RTL. */ 332 copy->used = 0; 333 334 /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */ 335 if (GET_RTX_CLASS (code) == 'i') 336 { 337 copy->jump = 0; 338 copy->call = 0; 339 copy->frame_related = 0; 340 } 341 342 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 343 344 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 345 { 346 switch (*format_ptr++) 347 { 348 case 'e': 349 XEXP (copy, i) = XEXP (orig, i); 350 if (XEXP (orig, i) != NULL) 351 XEXP (copy, i) = copy_rtx (XEXP (orig, i)); 352 break; 353 354 case '0': 355 case 'u': 356 XEXP (copy, i) = XEXP (orig, i); 357 break; 358 359 case 'E': 360 case 'V': 361 XVEC (copy, i) = XVEC (orig, i); 362 if (XVEC (orig, i) != NULL) 363 { 364 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 365 for (j = 0; j < XVECLEN (copy, i); j++) 366 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); 367 } 368 break; 369 370 case 'b': 371 { 372 bitmap new_bits = BITMAP_OBSTACK_ALLOC (rtl_obstack); 373 bitmap_copy (new_bits, XBITMAP (orig, i)); 374 XBITMAP (copy, i) = new_bits; 375 break; 376 } 377 378 case 't': 379 XTREE (copy, i) = XTREE (orig, i); 380 break; 381 382 case 'w': 383 XWINT (copy, i) = XWINT (orig, i); 384 break; 385 386 case 'i': 387 XINT (copy, i) = XINT (orig, i); 388 break; 389 390 case 's': 391 case 'S': 392 XSTR (copy, i) = XSTR (orig, i); 393 break; 394 395 default: 396 abort (); 397 } 398 } 399 return copy; 400} 401 402/* Similar to `copy_rtx' except that if MAY_SHARE is present, it is 403 placed in the result directly, rather than being copied. */ 404 405rtx 406copy_most_rtx (orig, may_share) 407 register rtx orig; 408 register rtx may_share; 409{ 410 register rtx copy; 411 register int i, j; 412 register RTX_CODE code; 413 register char *format_ptr; 414 415 if (orig == may_share) 416 return orig; 417 418 code = GET_CODE (orig); 419 420 switch (code) 421 { 422 case REG: 423 case QUEUED: 424 case CONST_INT: 425 case CONST_DOUBLE: 426 case SYMBOL_REF: 427 case CODE_LABEL: 428 case PC: 429 case CC0: 430 return orig; 431 default: 432 break; 433 } 434 435 copy = rtx_alloc (code); 436 PUT_MODE (copy, GET_MODE (orig)); 437 copy->in_struct = orig->in_struct; 438 copy->volatil = orig->volatil; 439 copy->unchanging = orig->unchanging; 440 copy->integrated = orig->integrated; 441 442 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 443 444 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 445 { 446 switch (*format_ptr++) 447 { 448 case 'e': 449 XEXP (copy, i) = XEXP (orig, i); 450 if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share) 451 XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share); 452 break; 453 454 case '0': 455 case 'u': 456 XEXP (copy, i) = XEXP (orig, i); 457 break; 458 459 case 'E': 460 case 'V': 461 XVEC (copy, i) = XVEC (orig, i); 462 if (XVEC (orig, i) != NULL) 463 { 464 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 465 for (j = 0; j < XVECLEN (copy, i); j++) 466 XVECEXP (copy, i, j) 467 = copy_most_rtx (XVECEXP (orig, i, j), may_share); 468 } 469 break; 470 471 case 'w': 472 XWINT (copy, i) = XWINT (orig, i); 473 break; 474 475 case 'n': 476 case 'i': 477 XINT (copy, i) = XINT (orig, i); 478 break; 479 480 case 's': 481 case 'S': 482 XSTR (copy, i) = XSTR (orig, i); 483 break; 484 485 default: 486 abort (); 487 } 488 } 489 return copy; 490} 491 492/* Create a new copy of an rtx. Only copy just one level. */ 493rtx 494shallow_copy_rtx (orig) 495 rtx orig; 496{ 497 register int i; 498 register char *format_ptr; 499 register RTX_CODE code = GET_CODE (orig); 500 register rtx copy = rtx_alloc (code); 501 502 PUT_MODE (copy, GET_MODE (orig)); 503 copy->in_struct = orig->in_struct; 504 copy->volatil = orig->volatil; 505 copy->unchanging = orig->unchanging; 506 copy->integrated = orig->integrated; 507 508 for (i = 0; i < GET_RTX_LENGTH (code); i++) 509 copy->fld[i] = orig->fld[i]; 510 511 return copy; 512} 513 514/* Subroutines of read_rtx. */ 515 516/* Dump code after printing a message. Used when read_rtx finds 517 invalid data. */ 518 519static void 520dump_and_abort (expected_c, actual_c, infile) 521 int expected_c, actual_c; 522 FILE *infile; 523{ 524 int c, i; 525 526 if (expected_c >= 0) 527 fprintf (stderr, 528 "Expected character %c. Found character %c.", 529 expected_c, actual_c); 530 fprintf (stderr, " At file position: %ld\n", ftell (infile)); 531 fprintf (stderr, "Following characters are:\n\t"); 532 for (i = 0; i < 200; i++) 533 { 534 c = getc (infile); 535 if (EOF == c) break; 536 putc (c, stderr); 537 } 538 fprintf (stderr, "Aborting.\n"); 539 abort (); 540} 541 542/* Read chars from INFILE until a non-whitespace char 543 and return that. Comments, both Lisp style and C style, 544 are treated as whitespace. 545 Tools such as genflags use this function. */ 546 547int 548read_skip_spaces (infile) 549 FILE *infile; 550{ 551 register int c; 552 while ((c = getc (infile))) 553 { 554 if (c == ' ' || c == '\n' || c == '\t' || c == '\f') 555 ; 556 else if (c == ';') 557 { 558 while ((c = getc (infile)) && c != '\n' && c != EOF) 559 ; 560 } 561 else if (c == '/') 562 { 563 register int prevc; 564 c = getc (infile); 565 if (c != '*') 566 dump_and_abort ('*', c, infile); 567 568 prevc = 0; 569 while ((c = getc (infile)) && c != EOF) 570 { 571 if (prevc == '*' && c == '/') 572 break; 573 prevc = c; 574 } 575 } 576 else break; 577 } 578 return c; 579} 580 581/* Read an rtx code name into the buffer STR[]. 582 It is terminated by any of the punctuation chars of rtx printed syntax. */ 583 584static void 585read_name (str, infile) 586 char *str; 587 FILE *infile; 588{ 589 register char *p; 590 register int c; 591 592 c = read_skip_spaces(infile); 593 594 p = str; 595 while (1) 596 { 597 if (c == ' ' || c == '\n' || c == '\t' || c == '\f') 598 break; 599 if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/' 600 || c == '(' || c == '[') 601 { 602 ungetc (c, infile); 603 break; 604 } 605 *p++ = c; 606 c = getc (infile); 607 } 608 if (p == str) 609 { 610 fprintf (stderr, "missing name or number"); 611 dump_and_abort (-1, -1, infile); 612 } 613 614 *p = 0; 615} 616 617/* Provide a version of a function to read a long long if the system does 618 not provide one. */ 619#if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ) 620HOST_WIDE_INT 621atoll(p) 622 const char *p; 623{ 624 int neg = 0; 625 HOST_WIDE_INT tmp_wide; 626 627 while (ISSPACE(*p)) 628 p++; 629 if (*p == '-') 630 neg = 1, p++; 631 else if (*p == '+') 632 p++; 633 634 tmp_wide = 0; 635 while (ISDIGIT(*p)) 636 { 637 HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0'); 638 if (new_wide < tmp_wide) 639 { 640 /* Return INT_MAX equiv on overflow. */ 641 tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1; 642 break; 643 } 644 tmp_wide = new_wide; 645 p++; 646 } 647 648 if (neg) 649 tmp_wide = -tmp_wide; 650 return tmp_wide; 651} 652#endif 653 654/* Read an rtx in printed representation from INFILE 655 and return an actual rtx in core constructed accordingly. 656 read_rtx is not used in the compiler proper, but rather in 657 the utilities gen*.c that construct C code from machine descriptions. */ 658 659rtx 660read_rtx (infile) 661 FILE *infile; 662{ 663 register int i, j, list_counter; 664 RTX_CODE tmp_code; 665 register char *format_ptr; 666 /* tmp_char is a buffer used for reading decimal integers 667 and names of rtx types and machine modes. 668 Therefore, 256 must be enough. */ 669 char tmp_char[256]; 670 rtx return_rtx; 671 register int c; 672 int tmp_int; 673 HOST_WIDE_INT tmp_wide; 674 675 /* Linked list structure for making RTXs: */ 676 struct rtx_list 677 { 678 struct rtx_list *next; 679 rtx value; /* Value of this node... */ 680 }; 681 682 c = read_skip_spaces (infile); /* Should be open paren. */ 683 if (c != '(') 684 dump_and_abort ('(', c, infile); 685 686 read_name (tmp_char, infile); 687 688 tmp_code = UNKNOWN; 689 690 for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */ 691 { 692 if (!(strcmp (tmp_char, GET_RTX_NAME (i)))) 693 { 694 tmp_code = (RTX_CODE) i; /* get value for name */ 695 break; 696 } 697 } 698 if (tmp_code == UNKNOWN) 699 { 700 fprintf (stderr, 701 "Unknown rtx read in rtl.read_rtx(). Code name was %s .", 702 tmp_char); 703 } 704 /* (NIL) stands for an expression that isn't there. */ 705 if (tmp_code == NIL) 706 { 707 /* Discard the closeparen. */ 708 while ((c = getc (infile)) && c != ')'); 709 return 0; 710 } 711 712 return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression 713 then we free this space below. */ 714 format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx)); 715 716 /* If what follows is `: mode ', read it and 717 store the mode in the rtx. */ 718 719 i = read_skip_spaces (infile); 720 if (i == ':') 721 { 722 register int k; 723 read_name (tmp_char, infile); 724 for (k = 0; k < NUM_MACHINE_MODES; k++) 725 if (!strcmp (GET_MODE_NAME (k), tmp_char)) 726 break; 727 728 PUT_MODE (return_rtx, (enum machine_mode) k ); 729 } 730 else 731 ungetc (i, infile); 732 733 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++) 734 switch (*format_ptr++) 735 { 736 /* 0 means a field for internal use only. 737 Don't expect it to be present in the input. */ 738 case '0': 739 break; 740 741 case 'e': 742 case 'u': 743 XEXP (return_rtx, i) = read_rtx (infile); 744 break; 745 746 case 'V': 747 /* 'V' is an optional vector: if a closeparen follows, 748 just store NULL for this element. */ 749 c = read_skip_spaces (infile); 750 ungetc (c, infile); 751 if (c == ')') 752 { 753 XVEC (return_rtx, i) = 0; 754 break; 755 } 756 /* Now process the vector. */ 757 758 case 'E': 759 { 760 register struct rtx_list *next_rtx, *rtx_list_link; 761 struct rtx_list *list_rtx = NULL; 762 763 c = read_skip_spaces (infile); 764 if (c != '[') 765 dump_and_abort ('[', c, infile); 766 767 /* add expressions to a list, while keeping a count */ 768 next_rtx = NULL; 769 list_counter = 0; 770 while ((c = read_skip_spaces (infile)) && c != ']') 771 { 772 ungetc (c, infile); 773 list_counter++; 774 rtx_list_link = (struct rtx_list *) 775 alloca (sizeof (struct rtx_list)); 776 rtx_list_link->value = read_rtx (infile); 777 if (next_rtx == 0) 778 list_rtx = rtx_list_link; 779 else 780 next_rtx->next = rtx_list_link; 781 next_rtx = rtx_list_link; 782 rtx_list_link->next = 0; 783 } 784 /* get vector length and allocate it */ 785 XVEC (return_rtx, i) = (list_counter 786 ? rtvec_alloc (list_counter) : NULL_RTVEC); 787 if (list_counter > 0) 788 { 789 next_rtx = list_rtx; 790 for (j = 0; j < list_counter; j++, 791 next_rtx = next_rtx->next) 792 XVECEXP (return_rtx, i, j) = next_rtx->value; 793 } 794 /* close bracket gotten */ 795 } 796 break; 797 798 case 'S': 799 /* 'S' is an optional string: if a closeparen follows, 800 just store NULL for this element. */ 801 c = read_skip_spaces (infile); 802 ungetc (c, infile); 803 if (c == ')') 804 { 805 XSTR (return_rtx, i) = 0; 806 break; 807 } 808 809 case 's': 810 { 811 int saw_paren = 0; 812 register char *stringbuf; 813 814 c = read_skip_spaces (infile); 815 if (c == '(') 816 { 817 saw_paren = 1; 818 c = read_skip_spaces (infile); 819 } 820 if (c != '"') 821 dump_and_abort ('"', c, infile); 822 823 while (1) 824 { 825 c = getc (infile); /* Read the string */ 826 if (c == '\\') 827 { 828 c = getc (infile); /* Read the string */ 829 /* \; makes stuff for a C string constant containing 830 newline and tab. */ 831 if (c == ';') 832 { 833 obstack_grow (rtl_obstack, "\\n\\t", 4); 834 continue; 835 } 836 } 837 else if (c == '"') 838 break; 839 840 obstack_1grow (rtl_obstack, c); 841 } 842 843 obstack_1grow (rtl_obstack, 0); 844 stringbuf = (char *) obstack_finish (rtl_obstack); 845 846 if (saw_paren) 847 { 848 c = read_skip_spaces (infile); 849 if (c != ')') 850 dump_and_abort (')', c, infile); 851 } 852 XSTR (return_rtx, i) = stringbuf; 853 } 854 break; 855 856 case 'w': 857 read_name (tmp_char, infile); 858#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT 859 tmp_wide = atoi (tmp_char); 860#else 861#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG 862 tmp_wide = atol (tmp_char); 863#else 864 /* Prefer atoll over atoq, since the former is in the ISO C9X draft. 865 But prefer not to use our hand-rolled function above either. */ 866#if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ) 867 tmp_wide = atoll (tmp_char); 868#else 869 tmp_wide = atoq (tmp_char); 870#endif 871#endif 872#endif 873 XWINT (return_rtx, i) = tmp_wide; 874 break; 875 876 case 'i': 877 case 'n': 878 read_name (tmp_char, infile); 879 tmp_int = atoi (tmp_char); 880 XINT (return_rtx, i) = tmp_int; 881 break; 882 883 default: 884 fprintf (stderr, 885 "switch format wrong in rtl.read_rtx(). format was: %c.\n", 886 format_ptr[-1]); 887 fprintf (stderr, "\tfile position: %ld\n", ftell (infile)); 888 abort (); 889 } 890 891 c = read_skip_spaces (infile); 892 if (c != ')') 893 dump_and_abort (')', c, infile); 894 895 return return_rtx; 896} 897 898/* This is called once per compilation, before any rtx's are constructed. 899 It initializes the vector `rtx_length', the extra CC modes, if any, 900 and computes certain commonly-used modes. */ 901 902void 903init_rtl () 904{ 905 int min_class_size[(int) MAX_MODE_CLASS]; 906 enum machine_mode mode; 907 int i; 908 909 for (i = 0; i < NUM_RTX_CODE; i++) 910 rtx_length[i] = strlen (rtx_format[i]); 911 912 /* Make CONST_DOUBLE bigger, if real values are bigger than 913 it normally expects to have room for. 914 Note that REAL_VALUE_TYPE is not defined by default, 915 since tree.h is not included. But the default dfn as `double' 916 would do no harm. */ 917#ifdef REAL_VALUE_TYPE 918 i = sizeof (REAL_VALUE_TYPE) / sizeof (rtunion) + 2; 919 if (rtx_length[(int) CONST_DOUBLE] < i) 920 { 921 char *s = (char *) xmalloc (i + 1); 922 rtx_length[(int) CONST_DOUBLE] = i; 923 rtx_format[(int) CONST_DOUBLE] = s; 924 *s++ = 'e'; 925 *s++ = '0'; 926 /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string 927 of as many `w's as we now have elements. Subtract two from 928 the size to account for the 'e' and the '0'. */ 929 for (i = 2; i < rtx_length[(int) CONST_DOUBLE]; i++) 930 *s++ = 'w'; 931 *s++ = 0; 932 } 933#endif 934 935#ifdef EXTRA_CC_MODES 936 for (i = (int) CCmode + 1; i < (int) MAX_MACHINE_MODE; i++) 937 { 938 mode_class[i] = MODE_CC; 939 mode_mask_array[i] = mode_mask_array[(int) CCmode]; 940 mode_size[i] = mode_size[(int) CCmode]; 941 mode_unit_size[i] = mode_unit_size[(int) CCmode]; 942 mode_wider_mode[i - 1] = i; 943 mode_wider_mode[i] = (unsigned char)VOIDmode; 944 } 945#endif 946 947 /* Find the narrowest mode for each class. */ 948 949 for (i = 0; i < (int) MAX_MODE_CLASS; i++) 950 min_class_size[i] = 1000; 951 952 for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE; 953 mode = (enum machine_mode) ((int) mode + 1)) 954 { 955 if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)]) 956 { 957 class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode; 958 min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode); 959 } 960 } 961} 962