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