![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to rtl.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* Manage RTL for C-Compiler ! 2: Copyright (C) 1987, 1988 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* This file contains the low level primitives for allocating, ! 23: printing and reading rtl expressions and vectors. ! 24: It also contains some functions for semantic analysis ! 25: on rtl expressions. */ ! 26: ! 27: #include "config.h" ! 28: #include <ctype.h> ! 29: #include <stdio.h> ! 30: #include "rtl.h" ! 31: ! 32: #include "obstack.h" ! 33: #define obstack_chunk_alloc xmalloc ! 34: #define obstack_chunk_free free ! 35: extern int xmalloc (); ! 36: extern void free (); ! 37: ! 38: /* Obstack used for allocating RTL objects. ! 39: Between functions, this is the permanent_obstack. ! 40: While parsing and expanding a function, this is maybepermanent_obstack ! 41: so we can save it if it is an inline function. ! 42: During optimization and output, this is temporary_obstack. */ ! 43: ! 44: extern struct obstack *rtl_obstack; ! 45: ! 46: #define MIN(x,y) ((x < y) ? x : y) ! 47: ! 48: extern long ftell(); ! 49: ! 50: /* Indexed by rtx code, gives number of operands for an rtx with that code. ! 51: Does NOT include rtx header data (code and links). ! 52: This array is initialized in init_rtx. */ ! 53: ! 54: int rtx_length[NUM_RTX_CODE + 1]; ! 55: ! 56: /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */ ! 57: ! 58: #define DEF_RTL_EXPR(ENUM, NAME, FORMAT) NAME , ! 59: ! 60: char *rtx_name[] = { ! 61: #include "rtl.def" /* rtl expressions are documented here */ ! 62: }; ! 63: ! 64: #undef DEF_RTL_EXPR ! 65: ! 66: /* Indexed by machine mode, gives the name of that machine mode. ! 67: This name does not include the letters "mode". */ ! 68: ! 69: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT) NAME, ! 70: ! 71: char *mode_name[] = { ! 72: #include "machmode.def" ! 73: }; ! 74: ! 75: #undef DEF_MACHMODE ! 76: ! 77: /* Indexed by machine mode, gives the length of the mode, in bytes. ! 78: GET_MODE_CLASS uses this. */ ! 79: ! 80: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT) CLASS, ! 81: ! 82: enum mode_class mode_class[] = { ! 83: #include "machmode.def" ! 84: }; ! 85: ! 86: #undef DEF_MACHMODE ! 87: ! 88: /* Indexed by machine mode, gives the length of the mode, in bytes. ! 89: GET_MODE_SIZE uses this. */ ! 90: ! 91: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT) SIZE, ! 92: ! 93: int mode_size[] = { ! 94: #include "machmode.def" ! 95: }; ! 96: ! 97: #undef DEF_MACHMODE ! 98: ! 99: /* Indexed by machine mode, gives the length of the mode's subunit. ! 100: GET_MODE_UNIT_SIZE uses this. */ ! 101: ! 102: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT) UNIT, ! 103: ! 104: int mode_unit_size[] = { ! 105: #include "machmode.def" /* machine modes are documented here */ ! 106: }; ! 107: ! 108: #undef DEF_MACHMODE ! 109: ! 110: /* Indexed by rtx code, gives a sequence of operand-types for ! 111: rtx's of that code. The sequence is a C string in which ! 112: each charcter describes one operand. */ ! 113: ! 114: char *rtx_format[] = { ! 115: /* "*" undefined. ! 116: can cause a warning message ! 117: "0" field is unused (or used in a phase-dependent manner) ! 118: prints nothing ! 119: "i" an integer ! 120: prints the integer ! 121: "s" a pointer to a string ! 122: prints the string ! 123: "e" a pointer to an rtl expression ! 124: prints the expression ! 125: "E" a pointer to a vector that points to a number of rtl expressions ! 126: prints a list of the rtl expressions ! 127: "u" a pointer to another insn ! 128: prints the uid of the insn. */ ! 129: ! 130: #define DEF_RTL_EXPR(ENUM, NAME, FORMAT) FORMAT , ! 131: #include "rtl.def" /* rtl expressions are defined here */ ! 132: #undef DEF_RTL_EXPR ! 133: }; ! 134: ! 135: /* Allocate an rtx vector of N elements. ! 136: Store the length, and initialize all elements to zero. */ ! 137: ! 138: rtvec ! 139: rtvec_alloc (n) ! 140: int n; ! 141: { ! 142: rtvec rt; ! 143: int i; ! 144: ! 145: rt = (rtvec) obstack_alloc (rtl_obstack, ! 146: sizeof (struct rtvec_def) ! 147: + (( n - 1) * sizeof (rtunion))); ! 148: ! 149: /* clear out the vector */ ! 150: PUT_NUM_ELEM(rt, n); ! 151: for (i=0; i < n; i++) ! 152: rt->elem[i].rtvec = NULL; /* @@ not portable due to rtunion */ ! 153: ! 154: return rt; ! 155: } ! 156: ! 157: /* Allocate an rtx of code CODE. The CODE is stored in the rtx; ! 158: all the rest is initialized to zero. */ ! 159: ! 160: rtx ! 161: rtx_alloc (code) ! 162: RTX_CODE code; ! 163: { ! 164: rtx rt; ! 165: register int nelts = GET_RTX_LENGTH (code); ! 166: register int length = sizeof (struct rtx_def) ! 167: + (nelts - 1) * sizeof (rtunion); ! 168: ! 169: rt = (rtx) obstack_alloc (rtl_obstack, length); ! 170: ! 171: * (int *) rt = 0; ! 172: PUT_CODE (rt, code); ! 173: ! 174: return rt; ! 175: } ! 176: ! 177: /* Create a new copy of an rtx. ! 178: Recursively copies the operands of the rtx, ! 179: except for those few rtx codes that are sharable. */ ! 180: ! 181: rtx ! 182: copy_rtx (orig) ! 183: register rtx orig; ! 184: { ! 185: register rtx copy; ! 186: register int i, j; ! 187: register RTX_CODE code; ! 188: register char *format_ptr; ! 189: ! 190: code = GET_CODE (orig); ! 191: ! 192: switch (code) ! 193: { ! 194: case REG: ! 195: case QUEUED: ! 196: case CONST_INT: ! 197: case CONST_DOUBLE: ! 198: case SYMBOL_REF: ! 199: case CODE_LABEL: ! 200: case PC: ! 201: case CC0: ! 202: return orig; ! 203: } ! 204: ! 205: copy = rtx_alloc (code); ! 206: PUT_MODE (copy, GET_MODE (orig)); ! 207: copy->in_struct = orig->in_struct; ! 208: copy->volatil = orig->volatil; ! 209: copy->unchanging = orig->unchanging; ! 210: copy->integrated = orig->integrated; ! 211: ! 212: format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); ! 213: ! 214: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) ! 215: { ! 216: switch (*format_ptr++) ! 217: { ! 218: case 'e': ! 219: XEXP (copy, i) = copy_rtx (XEXP (orig, i)); ! 220: break; ! 221: ! 222: case 'E': ! 223: XVEC (copy, i) = XVEC (orig, i); ! 224: if (XVEC (orig, i) != NULL) ! 225: { ! 226: XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); ! 227: for (j = 0; j < XVECLEN (copy, i); j++) ! 228: XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); ! 229: } ! 230: break; ! 231: ! 232: default: ! 233: XINT (copy, i) = XINT (orig, i); ! 234: break; ! 235: } ! 236: } ! 237: return copy; ! 238: } ! 239: ! 240: /* Return 1 if the value of X is unstable ! 241: (would be different at a different point in the program). ! 242: The frame pointer, arg pointer, etc. are considered stable ! 243: (within one function) and so is anything marked `unchanging'. */ ! 244: ! 245: int ! 246: rtx_unstable_p (x) ! 247: rtx x; ! 248: { ! 249: register RTX_CODE code = GET_CODE (x); ! 250: register int i; ! 251: register char *fmt; ! 252: ! 253: if (code == MEM) ! 254: return ! x->unchanging; ! 255: ! 256: if (code == QUEUED) ! 257: return 1; ! 258: ! 259: if (code == CONST || code == CONST_INT) ! 260: return 0; ! 261: ! 262: if (code == REG) ! 263: return ! (REGNO (x) == FRAME_POINTER_REGNUM ! 264: || REGNO (x) == ARG_POINTER_REGNUM ! 265: || x->unchanging); ! 266: ! 267: fmt = GET_RTX_FORMAT (code); ! 268: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) ! 269: if (fmt[i] == 'e') ! 270: if (rtx_unstable_p (XEXP (x, i))) ! 271: return 1; ! 272: return 0; ! 273: } ! 274: ! 275: /* Return 1 if X has a value that can vary even between two ! 276: executions of the program. 0 means X can be compared reliably ! 277: against certain constants or near-constants. ! 278: The frame pointer and the arg pointer are considered constant. */ ! 279: ! 280: int ! 281: rtx_varies_p (x) ! 282: rtx x; ! 283: { ! 284: register RTX_CODE code = GET_CODE (x); ! 285: register int i; ! 286: register char *fmt; ! 287: ! 288: if (code == MEM) ! 289: return 1; ! 290: ! 291: if (code == QUEUED) ! 292: return 1; ! 293: ! 294: if (code == CONST || code == CONST_INT) ! 295: return 0; ! 296: ! 297: if (code == REG) ! 298: return ! (REGNO (x) == FRAME_POINTER_REGNUM ! 299: || REGNO (x) == ARG_POINTER_REGNUM); ! 300: ! 301: fmt = GET_RTX_FORMAT (code); ! 302: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) ! 303: if (fmt[i] == 'e') ! 304: if (rtx_varies_p (XEXP (x, i))) ! 305: return 1; ! 306: return 0; ! 307: } ! 308: ! 309: /* Return 1 if X refers to a memory location whose address ! 310: cannot be compared reliably with constant addresses, ! 311: or if X refers to a BLKmode memory object. */ ! 312: ! 313: int ! 314: rtx_addr_varies_p (x) ! 315: rtx x; ! 316: { ! 317: register RTX_CODE code = GET_CODE (x); ! 318: register int i; ! 319: register char *fmt; ! 320: ! 321: if (code == MEM) ! 322: return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0)); ! 323: ! 324: fmt = GET_RTX_FORMAT (code); ! 325: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) ! 326: if (fmt[i] == 'e') ! 327: if (rtx_addr_varies_p (XEXP (x, i))) ! 328: return 1; ! 329: return 0; ! 330: } ! 331: ! 332: /* Nonzero if register REG appears somewhere within IN. ! 333: Also works if REG is not a register; in this case it checks ! 334: for a subexpression of IN that is Lisp "equal" to REG. */ ! 335: ! 336: int ! 337: reg_mentioned_p (reg, in) ! 338: register rtx reg, in; ! 339: { ! 340: register char *fmt; ! 341: register int i; ! 342: register enum rtx_code code; ! 343: ! 344: if (in == 0) ! 345: return 0; ! 346: ! 347: if (reg == in) ! 348: return 1; ! 349: ! 350: code = GET_CODE (in); ! 351: ! 352: switch (code) ! 353: { ! 354: /* Compare registers by number. */ ! 355: case REG: ! 356: return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg); ! 357: ! 358: /* These codes have no constituent expressions ! 359: and are unique. */ ! 360: case CC0: ! 361: case PC: ! 362: case CONST_INT: ! 363: case CONST: ! 364: case CONST_DOUBLE: ! 365: case LABEL_REF: ! 366: case SYMBOL_REF: ! 367: return 0; ! 368: } ! 369: ! 370: if (GET_CODE (reg) == code && rtx_equal_p (reg, in)) ! 371: return 1; ! 372: ! 373: fmt = GET_RTX_FORMAT (code); ! 374: ! 375: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) ! 376: { ! 377: if (fmt[i] == 'E') ! 378: { ! 379: register int j; ! 380: for (j = XVECLEN (in, i) - 1; j >= 0; j--) ! 381: if (reg_mentioned_p (reg, XVECEXP (in, i, j))) ! 382: return 1; ! 383: } ! 384: else if (fmt[i] == 'e' ! 385: && reg_mentioned_p (reg, XEXP (in, i))) ! 386: return 1; ! 387: } ! 388: return 0; ! 389: } ! 390: ! 391: /* Nonzero if register REG is used in an insn between ! 392: FROM_INSN and TO_INSN (exclusive of those two). */ ! 393: ! 394: int ! 395: reg_used_between_p (reg, from_insn, to_insn) ! 396: rtx reg, from_insn, to_insn; ! 397: { ! 398: register rtx insn; ! 399: register RTX_CODE code; ! 400: for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn)) ! 401: if (((code = GET_CODE (insn)) == INSN ! 402: || code == JUMP_INSN || code == CALL_INSN) ! 403: && reg_mentioned_p (reg, PATTERN (insn))) ! 404: return 1; ! 405: return 0; ! 406: } ! 407: ! 408: /* Return 1 if X and Y are identical-looking rtx's. ! 409: This is the Lisp function EQUAL for rtx arguments. */ ! 410: ! 411: int ! 412: rtx_equal_p (x, y) ! 413: rtx x, y; ! 414: { ! 415: register int i; ! 416: register int hash = 0; ! 417: register RTX_CODE code = GET_CODE (x); ! 418: register char *fmt; ! 419: ! 420: if (x == y) ! 421: return 1; ! 422: ! 423: /* Rtx's of different codes cannot be equal. */ ! 424: if (code != GET_CODE (y)) ! 425: return 0; ! 426: ! 427: /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. ! 428: (REG:SI x) and (REG:HI x) are NOT equivalent. */ ! 429: ! 430: if (GET_MODE (x) != GET_MODE (y)) ! 431: return 0; ! 432: ! 433: /* These three types of rtx's can be compared nonrecursively. */ ! 434: if (code == REG) ! 435: return (REGNO (x) == REGNO (y)); ! 436: if (code == LABEL_REF) ! 437: return XEXP (x, 0) == XEXP (y, 0); ! 438: if (code == SYMBOL_REF) ! 439: return XSTR (x, 0) == XSTR (y, 0); ! 440: ! 441: /* Compare the elements. If any pair of corresponding elements ! 442: fail to match, return 0 for the whole things. */ ! 443: ! 444: fmt = GET_RTX_FORMAT (code); ! 445: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) ! 446: { ! 447: switch (fmt[i]) ! 448: { ! 449: case 'i': ! 450: if (XINT (x, i) != XINT (y, i)) ! 451: return 0; ! 452: break; ! 453: ! 454: case 'e': ! 455: if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0) ! 456: return 0; ! 457: break; ! 458: ! 459: case 's': ! 460: if (strcmp (XSTR (x, i), XSTR (y, i))) ! 461: return 0; ! 462: break; ! 463: ! 464: case '0': ! 465: break; ! 466: ! 467: /* It is believed that rtx's at this level will never ! 468: contain anything but integers and other rtx's, ! 469: except for within LABEL_REFs and SYMBOL_REFs. */ ! 470: default: ! 471: abort (); ! 472: } ! 473: } ! 474: return 1; ! 475: } ! 476: ! 477: /* Call FUN on each register or MEM that is stored into or clobbered by X. ! 478: (X would be the pattern of an insn). ! 479: FUN receives two arguments: ! 480: the REG, MEM, CC0 or PC being stored in or clobbered, ! 481: the SET or CLOBBER rtx that does the store. */ ! 482: ! 483: void ! 484: note_stores (x, fun) ! 485: register rtx x; ! 486: void (*fun) (); ! 487: { ! 488: if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)) ! 489: { ! 490: register rtx dest = SET_DEST (x); ! 491: while (GET_CODE (dest) == SUBREG ! 492: || GET_CODE (dest) == ZERO_EXTRACT ! 493: || GET_CODE (dest) == SIGN_EXTRACT ! 494: || GET_CODE (dest) == STRICT_LOW_PART) ! 495: dest = XEXP (dest, 0); ! 496: (*fun) (dest, GET_CODE (x) == CLOBBER); ! 497: } ! 498: else if (GET_CODE (x) == PARALLEL) ! 499: { ! 500: register int i; ! 501: for (i = XVECLEN (x, 0) - 1; i >= 0; i--) ! 502: { ! 503: register rtx y = XVECEXP (x, 0, i); ! 504: if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER) ! 505: { ! 506: register rtx dest = SET_DEST (y); ! 507: while (GET_CODE (dest) == SUBREG ! 508: || GET_CODE (dest) == ZERO_EXTRACT ! 509: || GET_CODE (dest) == SIGN_EXTRACT ! 510: || GET_CODE (dest) == STRICT_LOW_PART) ! 511: dest = XEXP (dest, 0); ! 512: (*fun) (dest, GET_CODE (y) == CLOBBER); ! 513: } ! 514: } ! 515: } ! 516: } ! 517: ! 518: /* Return nonzero if register REG's old contents don't survive after INSN. ! 519: This can be because REG dies in INSN or because INSN entirely sets REG. ! 520: ! 521: "Entirely set" means set directly and not through a SUBREG, ! 522: ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains. ! 523: ! 524: REG may be a hard or pseudo reg. Renumbering is not taken into account, ! 525: but for this use that makes no difference, since regs don't overlap ! 526: during their lifetimes. Therefore, this function may be used ! 527: at any time after deaths have been computed (in flow.c). */ ! 528: ! 529: int ! 530: dead_or_set_p (insn, reg) ! 531: rtx insn; ! 532: rtx reg; ! 533: { ! 534: register rtx link; ! 535: register int regno = REGNO (reg); ! 536: ! 537: for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) ! 538: if ((REG_NOTE_KIND (link) == REG_DEAD ! 539: || REG_NOTE_KIND (link) == REG_INC) ! 540: && REGNO (XEXP (link, 0)) == regno) ! 541: return 1; ! 542: ! 543: if (GET_CODE (PATTERN (insn)) == SET) ! 544: return SET_DEST (PATTERN (insn)) == reg; ! 545: else if (GET_CODE (PATTERN (insn)) == PARALLEL) ! 546: { ! 547: register int i; ! 548: for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) ! 549: { ! 550: if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET ! 551: && SET_DEST (XVECEXP (PATTERN (insn), 0, i)) == reg) ! 552: return 1; ! 553: } ! 554: } ! 555: return 0; ! 556: } ! 557: ! 558: /* Return the reg-note of kind KIND in insn INSN, if there is one. ! 559: If DATUM is nonzero, look for one whose datum is DATUM. */ ! 560: ! 561: rtx ! 562: find_reg_note (insn, kind, datum) ! 563: rtx insn; ! 564: enum reg_note kind; ! 565: rtx datum; ! 566: { ! 567: register rtx link; ! 568: ! 569: for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) ! 570: if (REG_NOTE_KIND (link) == kind ! 571: && (datum == 0 || datum == XEXP (link, 0))) ! 572: return link; ! 573: return 0; ! 574: } ! 575: ! 576: /* Return the reg-note of kind KIND in insn INSN which applies to register ! 577: number REGNO, if any. Return 0 if there is no such reg-note. */ ! 578: ! 579: rtx ! 580: find_regno_note (insn, kind, regno) ! 581: rtx insn; ! 582: enum reg_note kind; ! 583: int regno; ! 584: { ! 585: register rtx link; ! 586: ! 587: for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) ! 588: if (REG_NOTE_KIND (link) == kind ! 589: && REGNO (XEXP (link, 0)) == regno) ! 590: return link; ! 591: return 0; ! 592: } ! 593: ! 594: /* Printing rtl for debugging dumps. */ ! 595: ! 596: static FILE *outfile; ! 597: ! 598: char spaces[] = " "; ! 599: ! 600: static int sawclose = 0; ! 601: ! 602: /* Print IN_RTX onto OUTFILE. This is the recursive part of printing. */ ! 603: ! 604: static void ! 605: print_rtx (in_rtx) ! 606: register rtx in_rtx; ! 607: { ! 608: static int indent; ! 609: register int i, j; ! 610: register char *format_ptr; ! 611: ! 612: if (sawclose) ! 613: { ! 614: fprintf (outfile, "\n%s", ! 615: (spaces + (sizeof spaces - indent * 2))); ! 616: sawclose = 0; ! 617: } ! 618: ! 619: if (in_rtx == 0) ! 620: { ! 621: fprintf (outfile, "(nil)"); ! 622: sawclose = 1; ! 623: return; ! 624: } ! 625: ! 626: /* print name of expression code */ ! 627: fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx))); ! 628: ! 629: if (in_rtx->in_struct) ! 630: fprintf (outfile, "/s"); ! 631: ! 632: if (in_rtx->volatil) ! 633: fprintf (outfile, "/v"); ! 634: ! 635: if (in_rtx->unchanging) ! 636: fprintf (outfile, "/u"); ! 637: ! 638: if (in_rtx->integrated) ! 639: fprintf (outfile, "/i"); ! 640: ! 641: if (GET_MODE (in_rtx) != VOIDmode) ! 642: fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx))); ! 643: ! 644: format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)); ! 645: ! 646: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++) ! 647: switch (*format_ptr++) ! 648: { ! 649: case 's': ! 650: if (XSTR (in_rtx, i) == 0) ! 651: fprintf (outfile, " \"\""); ! 652: else ! 653: fprintf (outfile, " (\"%s\")", XSTR (in_rtx, i)); ! 654: sawclose = 1; ! 655: break; ! 656: ! 657: /* 0 indicates a field for internal use that should not be printed. */ ! 658: case '0': ! 659: break; ! 660: ! 661: case 'e': ! 662: indent += 2; ! 663: if (!sawclose) ! 664: fprintf (outfile, " "); ! 665: print_rtx (XEXP (in_rtx, i)); ! 666: indent -= 2; ! 667: break; ! 668: ! 669: case 'E': ! 670: indent += 2; ! 671: if (sawclose) ! 672: { ! 673: fprintf (outfile, "\n%s", ! 674: (spaces + (sizeof spaces - indent * 2))); ! 675: sawclose = 0; ! 676: } ! 677: fprintf (outfile, "[ "); ! 678: if (NULL != XVEC (in_rtx, i)) ! 679: { ! 680: indent += 2; ! 681: if (XVECLEN (in_rtx, i)) ! 682: sawclose = 1; ! 683: ! 684: for (j = 0; j < XVECLEN (in_rtx, i); j++) ! 685: print_rtx (XVECEXP (in_rtx, i, j)); ! 686: ! 687: indent -= 2; ! 688: } ! 689: if (sawclose) ! 690: fprintf (outfile, "\n%s", ! 691: (spaces + (sizeof spaces - indent * 2))); ! 692: ! 693: fprintf (outfile, "] "); ! 694: sawclose = 1; ! 695: indent -= 2; ! 696: break; ! 697: ! 698: case 'i': ! 699: fprintf (outfile, " %d", XINT (in_rtx, i)); ! 700: sawclose = 0; ! 701: break; ! 702: ! 703: case 'u': ! 704: if (XEXP (in_rtx, i) != NULL) ! 705: fprintf(outfile, " %d", INSN_UID (XEXP (in_rtx, i))); ! 706: else ! 707: fprintf(outfile, " 0"); ! 708: sawclose = 0; ! 709: break; ! 710: ! 711: default: ! 712: fprintf (stderr, ! 713: "switch format wrong in rtl.print_rtx(). format was: %c.\n", ! 714: format_ptr[-1]); ! 715: abort (); ! 716: } ! 717: ! 718: fprintf (outfile, ")"); ! 719: sawclose = 1; ! 720: } ! 721: ! 722: /* Call this function from the debugger to see what X looks like. */ ! 723: ! 724: void ! 725: debug_rtx (x) ! 726: rtx x; ! 727: { ! 728: outfile = stderr; ! 729: print_rtx (x); ! 730: fprintf (stderr, "\n"); ! 731: } ! 732: ! 733: /* External entry point for printing a chain of INSNs ! 734: starting with RTX_FIRST onto file OUTF. */ ! 735: ! 736: void ! 737: print_rtl (outf, rtx_first) ! 738: FILE *outf; ! 739: rtx rtx_first; ! 740: { ! 741: register rtx tmp_rtx; ! 742: ! 743: outfile = outf; ! 744: sawclose = 0; ! 745: ! 746: for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx)) ! 747: { ! 748: print_rtx (tmp_rtx); ! 749: fprintf (outfile, "\n"); ! 750: } ! 751: } ! 752: ! 753: /* Subroutines of read_rtx. */ ! 754: ! 755: /* Dump code after printing a message. Used when read_rtx finds ! 756: invalid data. */ ! 757: ! 758: static void ! 759: dump_and_abort (expected_c, actual_c, infile) ! 760: int expected_c, actual_c; ! 761: FILE *infile; ! 762: { ! 763: int c, i; ! 764: ! 765: fprintf (stderr, ! 766: "Expected character %c. Read character %c. At file position: %ld\n", ! 767: expected_c, actual_c, ftell (infile)); ! 768: fprintf (stderr, "Following characters are:\n\t"); ! 769: for (i = 0; i < 200; i++) ! 770: { ! 771: c = getc (infile); ! 772: if (EOF == c) break; ! 773: putc (c, stderr); ! 774: } ! 775: fprintf (stderr, "Aborting.\n"); ! 776: abort (); ! 777: } ! 778: ! 779: /* Read chars from INFILE until a non-whitespace char ! 780: and return that. Comments, both Lisp style and C style, ! 781: are treated as whitespace. ! 782: Tools such as genflags use this function. */ ! 783: ! 784: int ! 785: read_skip_spaces (infile) ! 786: FILE *infile; ! 787: { ! 788: register int c; ! 789: while (c = getc (infile)) ! 790: { ! 791: if (c == ' ' || c == '\n' || c == '\t' || c == '\f') ! 792: ; ! 793: else if (c == ';') ! 794: { ! 795: while ((c = getc (infile)) && c != '\n') ; ! 796: } ! 797: else if (c == '/') ! 798: { ! 799: register int prevc; ! 800: c = getc (infile); ! 801: if (c != '*') ! 802: dump_and_abort ('*', c, infile); ! 803: ! 804: prevc = 0; ! 805: while (c = getc (infile)) ! 806: { ! 807: if (prevc == '*' && c == '/') ! 808: break; ! 809: prevc = c; ! 810: } ! 811: } ! 812: else break; ! 813: } ! 814: return c; ! 815: } ! 816: ! 817: /* Read an rtx code name into the buffer STR[]. ! 818: It is terminated by any of the punctuation chars of rtx printed syntax. */ ! 819: ! 820: static void ! 821: read_name (str, infile) ! 822: char *str; ! 823: FILE *infile; ! 824: { ! 825: register char *p; ! 826: register int c; ! 827: ! 828: c = read_skip_spaces(infile); ! 829: ! 830: p = str; ! 831: while (1) ! 832: { ! 833: if (c == ' ' || c == '\n' || c == '\t' || c == '\f') ! 834: break; ! 835: if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/' ! 836: || c == '(' || c == '[') ! 837: { ! 838: ungetc (c, infile); ! 839: break; ! 840: } ! 841: *p++ = c; ! 842: c = getc (infile); ! 843: } ! 844: *p = NULL; ! 845: } ! 846: ! 847: /* Read an rtx in printed representation from INFILE ! 848: and return an actual rtx in core constructed accordingly. ! 849: read_rtx is not used in the compiler proper, but rather in ! 850: the utilities gen*.c that construct C code from machine descriptions. */ ! 851: ! 852: rtx ! 853: read_rtx (infile) ! 854: FILE *infile; ! 855: { ! 856: register int i, j, list_counter; ! 857: RTX_CODE tmp_code; ! 858: register char *format_ptr; ! 859: /* tmp_char is a buffer used for reading decimal integers ! 860: and names of rtx types and machine modes. ! 861: Therefore, 256 must be enough. */ ! 862: char tmp_char[256]; ! 863: rtx return_rtx; ! 864: register int c; ! 865: int tmp_int; ! 866: ! 867: /* Linked list structure for making RTXs: */ ! 868: struct rtx_list ! 869: { ! 870: struct rtx_list *next; ! 871: rtx value; /* Value of this node... */ ! 872: }; ! 873: ! 874: c = read_skip_spaces (infile); /* Should be open paren. */ ! 875: if (c != '(') ! 876: dump_and_abort ('(', c, infile); ! 877: ! 878: read_name (tmp_char, infile); ! 879: ! 880: tmp_code = UNKNOWN; ! 881: ! 882: for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */ ! 883: { ! 884: if (!(strcmp (tmp_char, GET_RTX_NAME (i)))) ! 885: { ! 886: tmp_code = (RTX_CODE) i; /* get value for name */ ! 887: break; ! 888: } ! 889: } ! 890: if (tmp_code == UNKNOWN) ! 891: { ! 892: fprintf (stderr, ! 893: "Unknown rtx read in rtl.read_rtx(). Code name was %s .", ! 894: tmp_char); ! 895: } ! 896: /* (NIL) stands for an expression that isn't there. */ ! 897: if (tmp_code == NIL) ! 898: { ! 899: /* Discard the closeparen. */ ! 900: while ((c = getc (infile)) && c != ')'); ! 901: return 0; ! 902: } ! 903: ! 904: return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression ! 905: then we free this space below. */ ! 906: format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx)); ! 907: ! 908: /* If what follows is `: mode ', read it and ! 909: store the mode in the rtx. */ ! 910: ! 911: i = read_skip_spaces (infile); ! 912: if (i == ':') ! 913: { ! 914: register int k; ! 915: read_name (tmp_char, infile); ! 916: for (k = 0; k < NUM_MACHINE_MODES; k++) ! 917: if (!strcmp (GET_MODE_NAME (k), tmp_char)) ! 918: break; ! 919: ! 920: PUT_MODE (return_rtx, (enum machine_mode) k ); ! 921: } ! 922: else ! 923: ungetc (i, infile); ! 924: ! 925: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++) ! 926: switch (*format_ptr++) ! 927: { ! 928: /* 0 means a field for internal use only. ! 929: Don't expect it to be present in the input. */ ! 930: case '0': ! 931: break; ! 932: ! 933: case 'e': ! 934: case 'u': ! 935: XEXP (return_rtx, i) = read_rtx (infile); ! 936: break; ! 937: ! 938: case 'E': ! 939: { ! 940: register struct rtx_list *next_rtx, *rtx_list_link; ! 941: struct rtx_list *list_rtx; ! 942: ! 943: c = read_skip_spaces (infile); ! 944: if (c != '[') ! 945: dump_and_abort ('[', c, infile); ! 946: ! 947: /* add expressions to a list, while keeping a count */ ! 948: next_rtx = NULL; ! 949: list_counter = 0; ! 950: while ((c = read_skip_spaces (infile)) && c != ']') ! 951: { ! 952: ungetc (c, infile); ! 953: list_counter++; ! 954: rtx_list_link = (struct rtx_list *) ! 955: alloca (sizeof (struct rtx_list)); ! 956: rtx_list_link->value = read_rtx (infile); ! 957: if (next_rtx == 0) ! 958: list_rtx = rtx_list_link; ! 959: else ! 960: next_rtx->next = rtx_list_link; ! 961: next_rtx = rtx_list_link; ! 962: rtx_list_link->next = 0; ! 963: } ! 964: /* get vector length and allocate it */ ! 965: XVEC (return_rtx, i) = (list_counter ! 966: ? rtvec_alloc (list_counter) ! 967: : NULL); ! 968: if (list_counter > 0) ! 969: { ! 970: next_rtx = list_rtx; ! 971: for (j = 0; j < list_counter; j++, ! 972: next_rtx = next_rtx->next) ! 973: XVECEXP (return_rtx, i, j) = next_rtx->value; ! 974: } ! 975: /* close bracket gotten */ ! 976: } ! 977: break; ! 978: ! 979: case 's': ! 980: { ! 981: int saw_paren = 0; ! 982: register char *stringbuf; ! 983: int stringbufsize; ! 984: ! 985: c = read_skip_spaces (infile); ! 986: if (c == '(') ! 987: { ! 988: saw_paren = 1; ! 989: c = read_skip_spaces (infile); ! 990: } ! 991: if (c != '"') ! 992: dump_and_abort ('"', c, infile); ! 993: j = 0; ! 994: stringbufsize = 10; ! 995: stringbuf = (char *) xmalloc (stringbufsize + 1); ! 996: ! 997: while (1) ! 998: { ! 999: if (j >= stringbufsize - 4) ! 1000: { ! 1001: stringbufsize *= 2; ! 1002: stringbuf = (char *) xrealloc (stringbuf, stringbufsize + 1); ! 1003: } ! 1004: stringbuf[j] = getc (infile); /* Read the string */ ! 1005: if (stringbuf[j] == '\\') ! 1006: { ! 1007: stringbuf[j] = getc (infile); /* Read the string */ ! 1008: /* \; makes stuff for a C string constant containing ! 1009: newline and tab. */ ! 1010: if (stringbuf[j] == ';') ! 1011: { ! 1012: strcpy (&stringbuf[j], "\\n\\t"); ! 1013: j += 3; ! 1014: } ! 1015: } ! 1016: else if (stringbuf[j] == '"') ! 1017: break; ! 1018: j++; ! 1019: } ! 1020: ! 1021: stringbuf[j] = 0; /* NUL terminate the string */ ! 1022: stringbuf = (char *) xrealloc (stringbuf, j + 1); ! 1023: ! 1024: if (saw_paren) ! 1025: { ! 1026: c = read_skip_spaces (infile); ! 1027: if (c != ')') ! 1028: dump_and_abort (')', c, infile); ! 1029: } ! 1030: XSTR (return_rtx, i) = stringbuf; ! 1031: } ! 1032: break; ! 1033: ! 1034: case 'i': ! 1035: read_name (tmp_char, infile); ! 1036: tmp_int = atoi (tmp_char); ! 1037: XINT (return_rtx, i) = tmp_int; ! 1038: break; ! 1039: ! 1040: default: ! 1041: fprintf (stderr, ! 1042: "switch format wrong in rtl.read_rtx(). format was: %c.\n", ! 1043: format_ptr[-1]); ! 1044: fprintf (stderr, "\tfile position: %ld\n", ftell (infile)); ! 1045: abort (); ! 1046: } ! 1047: ! 1048: c = read_skip_spaces (infile); ! 1049: if (c != ')') ! 1050: dump_and_abort (')', c, infile); ! 1051: ! 1052: return return_rtx; ! 1053: } ! 1054: ! 1055: /* This is called once per compilation, before any rtx's are constructed. ! 1056: It initializes the vector `rtx_length'. */ ! 1057: ! 1058: void ! 1059: init_rtl () ! 1060: { ! 1061: int i; ! 1062: ! 1063: for (i = 0; i < NUM_RTX_CODE; i++) ! 1064: rtx_length[i] = strlen (rtx_format[i]); ! 1065: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.