![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to explow.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to explow.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Subroutines for manipulating rtx's in semantically interesting ways. ! 2: Copyright (C) 1987, 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 "rtl.h" ! 23: #include "tree.h" ! 24: #include "flags.h" ! 25: #include "expr.h" ! 26: #include "hard-reg-set.h" ! 27: #include "insn-config.h" ! 28: #include "recog.h" ! 29: #include "insn-flags.h" ! 30: #include "insn-codes.h" ! 31: ! 32: /* Return an rtx for the sum of X and the integer C. */ ! 33: ! 34: rtx ! 35: plus_constant (x, c) ! 36: register rtx x; ! 37: register int c; ! 38: { ! 39: register RTX_CODE code; ! 40: register enum machine_mode mode; ! 41: register rtx tem; ! 42: int all_constant = 0; ! 43: ! 44: if (c == 0) ! 45: return x; ! 46: ! 47: restart: ! 48: ! 49: code = GET_CODE (x); ! 50: mode = GET_MODE (x); ! 51: switch (code) ! 52: { ! 53: case CONST_INT: ! 54: return gen_rtx (CONST_INT, VOIDmode, (INTVAL (x) + c)); ! 55: ! 56: case CONST_DOUBLE: ! 57: { ! 58: int l1 = CONST_DOUBLE_LOW (x); ! 59: int h1 = CONST_DOUBLE_HIGH (x); ! 60: int l2 = c; ! 61: int h2 = c < 0 ? ~0 : 0; ! 62: int lv, hv; ! 63: ! 64: add_double (l1, h1, l2, h2, &lv, &hv); ! 65: ! 66: return immed_double_const (lv, hv, VOIDmode); ! 67: } ! 68: ! 69: case MEM: ! 70: /* If this is a reference to the constant pool, try replacing it with ! 71: a reference to a new constant. If the resulting address isn't ! 72: valid, don't return it because we have no way to validize it. */ ! 73: if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF ! 74: && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0))) ! 75: { ! 76: tem ! 77: = force_const_mem (GET_MODE (x), ! 78: plus_constant (get_pool_constant (XEXP (x, 0)), ! 79: c)); ! 80: if (memory_address_p (GET_MODE (tem), XEXP (tem, 0))) ! 81: return tem; ! 82: } ! 83: break; ! 84: ! 85: case CONST: ! 86: /* If adding to something entirely constant, set a flag ! 87: so that we can add a CONST around the result. */ ! 88: x = XEXP (x, 0); ! 89: all_constant = 1; ! 90: goto restart; ! 91: ! 92: case SYMBOL_REF: ! 93: case LABEL_REF: ! 94: all_constant = 1; ! 95: break; ! 96: ! 97: case PLUS: ! 98: /* The interesting case is adding the integer to a sum. ! 99: Look for constant term in the sum and combine ! 100: with C. For an integer constant term, we make a combined ! 101: integer. For a constant term that is not an explicit integer, ! 102: we cannot really combine, but group them together anyway. */ ! 103: if (GET_CODE (XEXP (x, 0)) == CONST_INT) ! 104: { ! 105: c += INTVAL (XEXP (x, 0)); ! 106: x = XEXP (x, 1); ! 107: } ! 108: else if (GET_CODE (XEXP (x, 1)) == CONST_INT) ! 109: { ! 110: c += INTVAL (XEXP (x, 1)); ! 111: x = XEXP (x, 0); ! 112: } ! 113: else if (CONSTANT_P (XEXP (x, 0))) ! 114: return gen_rtx (PLUS, mode, ! 115: plus_constant (XEXP (x, 0), c), ! 116: XEXP (x, 1)); ! 117: else if (CONSTANT_P (XEXP (x, 1))) ! 118: return gen_rtx (PLUS, mode, ! 119: XEXP (x, 0), ! 120: plus_constant (XEXP (x, 1), c)); ! 121: } ! 122: ! 123: if (c != 0) ! 124: x = gen_rtx (PLUS, mode, x, gen_rtx (CONST_INT, VOIDmode, c)); ! 125: ! 126: if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF) ! 127: return x; ! 128: else if (all_constant) ! 129: return gen_rtx (CONST, mode, x); ! 130: else ! 131: return x; ! 132: } ! 133: ! 134: /* This is the same a `plus_constant', except that it handles LO_SUM. */ ! 135: ! 136: rtx ! 137: plus_constant_for_output (x, c) ! 138: register rtx x; ! 139: register int c; ! 140: { ! 141: register RTX_CODE code = GET_CODE (x); ! 142: register enum machine_mode mode = GET_MODE (x); ! 143: int all_constant = 0; ! 144: ! 145: if (GET_CODE (x) == LO_SUM) ! 146: return gen_rtx (LO_SUM, mode, XEXP (x, 0), ! 147: plus_constant_for_output (XEXP (x, 1), c)); ! 148: ! 149: else ! 150: return plus_constant (x, c); ! 151: } ! 152: ! 153: /* If X is a sum, return a new sum like X but lacking any constant terms. ! 154: Add all the removed constant terms into *CONSTPTR. ! 155: X itself is not altered. The result != X if and only if ! 156: it is not isomorphic to X. */ ! 157: ! 158: rtx ! 159: eliminate_constant_term (x, constptr) ! 160: rtx x; ! 161: int *constptr; ! 162: { ! 163: int c; ! 164: register rtx x0, x1; ! 165: ! 166: if (GET_CODE (x) != PLUS) ! 167: return x; ! 168: ! 169: /* First handle constants appearing at this level explicitly. */ ! 170: if (GET_CODE (XEXP (x, 0)) == CONST_INT) ! 171: { ! 172: *constptr += INTVAL (XEXP (x, 0)); ! 173: return eliminate_constant_term (XEXP (x, 1), constptr); ! 174: } ! 175: ! 176: if (GET_CODE (XEXP (x, 1)) == CONST_INT) ! 177: { ! 178: *constptr += INTVAL (XEXP (x, 1)); ! 179: return eliminate_constant_term (XEXP (x, 0), constptr); ! 180: } ! 181: ! 182: c = 0; ! 183: x0 = eliminate_constant_term (XEXP (x, 0), &c); ! 184: x1 = eliminate_constant_term (XEXP (x, 1), &c); ! 185: if (x1 != XEXP (x, 1) || x0 != XEXP (x, 0)) ! 186: { ! 187: *constptr += c; ! 188: return gen_rtx (PLUS, GET_MODE (x), x0, x1); ! 189: } ! 190: return x; ! 191: } ! 192: ! 193: /* Returns the insn that next references REG after INSN, or 0 ! 194: if REG is clobbered before next referenced or we cannot find ! 195: an insn that references REG in a straight-line piece of code. */ ! 196: ! 197: rtx ! 198: find_next_ref (reg, insn) ! 199: rtx reg; ! 200: rtx insn; ! 201: { ! 202: rtx next; ! 203: ! 204: for (insn = NEXT_INSN (insn); insn; insn = next) ! 205: { ! 206: next = NEXT_INSN (insn); ! 207: if (GET_CODE (insn) == NOTE) ! 208: continue; ! 209: if (GET_CODE (insn) == CODE_LABEL ! 210: || GET_CODE (insn) == BARRIER) ! 211: return 0; ! 212: if (GET_CODE (insn) == INSN ! 213: || GET_CODE (insn) == JUMP_INSN ! 214: || GET_CODE (insn) == CALL_INSN) ! 215: { ! 216: if (reg_set_p (reg, insn)) ! 217: return 0; ! 218: if (reg_mentioned_p (reg, PATTERN (insn))) ! 219: return insn; ! 220: if (GET_CODE (insn) == JUMP_INSN) ! 221: { ! 222: if (simplejump_p (insn)) ! 223: next = JUMP_LABEL (insn); ! 224: else ! 225: return 0; ! 226: } ! 227: if (GET_CODE (insn) == CALL_INSN ! 228: && REGNO (reg) < FIRST_PSEUDO_REGISTER ! 229: && call_used_regs[REGNO (reg)]) ! 230: return 0; ! 231: } ! 232: else ! 233: abort (); ! 234: } ! 235: return 0; ! 236: } ! 237: ! 238: /* Return an rtx for the size in bytes of the value of EXP. */ ! 239: ! 240: rtx ! 241: expr_size (exp) ! 242: tree exp; ! 243: { ! 244: return expand_expr (size_in_bytes (TREE_TYPE (exp)), ! 245: 0, TYPE_MODE (sizetype), 0); ! 246: } ! 247: ! 248: /* Return a copy of X in which all memory references ! 249: and all constants that involve symbol refs ! 250: have been replaced with new temporary registers. ! 251: Also emit code to load the memory locations and constants ! 252: into those registers. ! 253: ! 254: If X contains no such constants or memory references, ! 255: X itself (not a copy) is returned. ! 256: ! 257: If a constant is found in the address that is not a legitimate constant ! 258: in an insn, it is left alone in the hope that it might be valid in the ! 259: address. ! 260: ! 261: X may contain no arithmetic except addition, subtraction and multiplication. ! 262: Values returned by expand_expr with 1 for sum_ok fit this constraint. */ ! 263: ! 264: static rtx ! 265: break_out_memory_refs (x) ! 266: register rtx x; ! 267: { ! 268: if (GET_CODE (x) == MEM ! 269: || (CONSTANT_P (x) && LEGITIMATE_CONSTANT_P (x) ! 270: && GET_MODE (x) != VOIDmode)) ! 271: { ! 272: register rtx temp = force_reg (GET_MODE (x), x); ! 273: mark_reg_pointer (temp); ! 274: x = temp; ! 275: } ! 276: else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS ! 277: || GET_CODE (x) == MULT) ! 278: { ! 279: register rtx op0 = break_out_memory_refs (XEXP (x, 0)); ! 280: register rtx op1 = break_out_memory_refs (XEXP (x, 1)); ! 281: if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1)) ! 282: x = gen_rtx (GET_CODE (x), Pmode, op0, op1); ! 283: } ! 284: return x; ! 285: } ! 286: ! 287: /* Given a memory address or facsimile X, construct a new address, ! 288: currently equivalent, that is stable: future stores won't change it. ! 289: ! 290: X must be composed of constants, register and memory references ! 291: combined with addition, subtraction and multiplication: ! 292: in other words, just what you can get from expand_expr if sum_ok is 1. ! 293: ! 294: Works by making copies of all regs and memory locations used ! 295: by X and combining them the same way X does. ! 296: You could also stabilize the reference to this address ! 297: by copying the address to a register with copy_to_reg; ! 298: but then you wouldn't get indexed addressing in the reference. */ ! 299: ! 300: rtx ! 301: copy_all_regs (x) ! 302: register rtx x; ! 303: { ! 304: if (GET_CODE (x) == REG) ! 305: { ! 306: if (REGNO (x) != FRAME_POINTER_REGNUM) ! 307: x = copy_to_reg (x); ! 308: } ! 309: else if (GET_CODE (x) == MEM) ! 310: x = copy_to_reg (x); ! 311: else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS ! 312: || GET_CODE (x) == MULT) ! 313: { ! 314: register rtx op0 = copy_all_regs (XEXP (x, 0)); ! 315: register rtx op1 = copy_all_regs (XEXP (x, 1)); ! 316: if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1)) ! 317: x = gen_rtx (GET_CODE (x), Pmode, op0, op1); ! 318: } ! 319: return x; ! 320: } ! 321: ! 322: /* Return something equivalent to X but valid as a memory address ! 323: for something of mode MODE. When X is not itself valid, this ! 324: works by copying X or subexpressions of it into registers. */ ! 325: ! 326: rtx ! 327: memory_address (mode, x) ! 328: enum machine_mode mode; ! 329: register rtx x; ! 330: { ! 331: register rtx oldx; ! 332: ! 333: /* By passing constant addresses thru registers ! 334: we get a chance to cse them. */ ! 335: if (! cse_not_expected && CONSTANT_P (x) && LEGITIMATE_CONSTANT_P (x)) ! 336: return force_reg (Pmode, x); ! 337: ! 338: /* Accept a QUEUED that refers to a REG ! 339: even though that isn't a valid address. ! 340: On attempting to put this in an insn we will call protect_from_queue ! 341: which will turn it into a REG, which is valid. */ ! 342: if (GET_CODE (x) == QUEUED ! 343: && GET_CODE (QUEUED_VAR (x)) == REG) ! 344: return x; ! 345: ! 346: /* We get better cse by rejecting indirect addressing at this stage. ! 347: Let the combiner create indirect addresses where appropriate. ! 348: For now, generate the code so that the subexpressions useful to share ! 349: are visible. But not if cse won't be done! */ ! 350: oldx = x; ! 351: if (! cse_not_expected && GET_CODE (x) != REG) ! 352: x = break_out_memory_refs (x); ! 353: ! 354: /* At this point, any valid address is accepted. */ ! 355: GO_IF_LEGITIMATE_ADDRESS (mode, x, win); ! 356: ! 357: /* If it was valid before but breaking out memory refs invalidated it, ! 358: use it the old way. */ ! 359: if (memory_address_p (mode, oldx)) ! 360: goto win2; ! 361: ! 362: /* Perform machine-dependent transformations on X ! 363: in certain cases. This is not necessary since the code ! 364: below can handle all possible cases, but machine-dependent ! 365: transformations can make better code. */ ! 366: LEGITIMIZE_ADDRESS (x, oldx, mode, win); ! 367: ! 368: /* PLUS and MULT can appear in special ways ! 369: as the result of attempts to make an address usable for indexing. ! 370: Usually they are dealt with by calling force_operand, below. ! 371: But a sum containing constant terms is special ! 372: if removing them makes the sum a valid address: ! 373: then we generate that address in a register ! 374: and index off of it. We do this because it often makes ! 375: shorter code, and because the addresses thus generated ! 376: in registers often become common subexpressions. */ ! 377: if (GET_CODE (x) == PLUS) ! 378: { ! 379: int constant_term = 0; ! 380: rtx y = eliminate_constant_term (x, &constant_term); ! 381: if (constant_term == 0 ! 382: || ! memory_address_p (mode, y)) ! 383: return force_operand (x, 0); ! 384: ! 385: y = plus_constant (copy_to_reg (y), constant_term); ! 386: if (! memory_address_p (mode, y)) ! 387: return force_operand (x, 0); ! 388: return y; ! 389: } ! 390: if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS) ! 391: return force_operand (x, 0); ! 392: ! 393: /* If we have a register that's an invalid address, ! 394: it must be a hard reg of the wrong class. Copy it to a pseudo. */ ! 395: if (GET_CODE (x) == REG) ! 396: return copy_to_reg (x); ! 397: ! 398: /* Last resort: copy the value to a register, since ! 399: the register is a valid address. */ ! 400: return force_reg (Pmode, x); ! 401: ! 402: win2: ! 403: x = oldx; ! 404: win: ! 405: if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG ! 406: /* Don't copy an addr via a reg if it is one of our stack slots. */ ! 407: && ! (GET_CODE (x) == PLUS ! 408: && (XEXP (x, 0) == virtual_stack_vars_rtx ! 409: || XEXP (x, 0) == virtual_incoming_args_rtx))) ! 410: { ! 411: if (general_operand (x, Pmode)) ! 412: return force_reg (Pmode, x); ! 413: else ! 414: return force_operand (x, 0); ! 415: } ! 416: return x; ! 417: } ! 418: ! 419: /* Like `memory_address' but pretend `flag_force_addr' is 0. */ ! 420: ! 421: rtx ! 422: memory_address_noforce (mode, x) ! 423: enum machine_mode mode; ! 424: rtx x; ! 425: { ! 426: int ambient_force_addr = flag_force_addr; ! 427: rtx val; ! 428: ! 429: flag_force_addr = 0; ! 430: val = memory_address (mode, x); ! 431: flag_force_addr = ambient_force_addr; ! 432: return val; ! 433: } ! 434: ! 435: /* Convert a mem ref into one with a valid memory address. ! 436: Pass through anything else unchanged. */ ! 437: ! 438: rtx ! 439: validize_mem (ref) ! 440: rtx ref; ! 441: { ! 442: if (GET_CODE (ref) != MEM) ! 443: return ref; ! 444: if (memory_address_p (GET_MODE (ref), XEXP (ref, 0))) ! 445: return ref; ! 446: /* Don't alter REF itself, since that is probably a stack slot. */ ! 447: return change_address (ref, GET_MODE (ref), XEXP (ref, 0)); ! 448: } ! 449: ! 450: /* Return a modified copy of X with its memory address copied ! 451: into a temporary register to protect it from side effects. ! 452: If X is not a MEM, it is returned unchanged (and not copied). ! 453: Perhaps even if it is a MEM, if there is no need to change it. */ ! 454: ! 455: rtx ! 456: stabilize (x) ! 457: rtx x; ! 458: { ! 459: register rtx addr; ! 460: if (GET_CODE (x) != MEM) ! 461: return x; ! 462: addr = XEXP (x, 0); ! 463: if (rtx_unstable_p (addr)) ! 464: { ! 465: rtx temp = copy_all_regs (addr); ! 466: rtx mem; ! 467: if (GET_CODE (temp) != REG) ! 468: temp = copy_to_reg (temp); ! 469: mem = gen_rtx (MEM, GET_MODE (x), temp); ! 470: /* Mark returned memref with in_struct ! 471: if it's in an array or structure. */ ! 472: if (GET_CODE (addr) == PLUS || MEM_IN_STRUCT_P (x)) ! 473: MEM_IN_STRUCT_P (mem) = 1; ! 474: return mem; ! 475: } ! 476: return x; ! 477: } ! 478: ! 479: /* Copy the value or contents of X to a new temp reg and return that reg. */ ! 480: ! 481: rtx ! 482: copy_to_reg (x) ! 483: rtx x; ! 484: { ! 485: register rtx temp = gen_reg_rtx (GET_MODE (x)); ! 486: ! 487: /* If not an operand, must be an address with PLUS and MULT so ! 488: do the computation. */ ! 489: if (! general_operand (x, VOIDmode)) ! 490: x = force_operand (x, temp); ! 491: ! 492: if (x != temp) ! 493: emit_move_insn (temp, x); ! 494: ! 495: return temp; ! 496: } ! 497: ! 498: /* Like copy_to_reg but always give the new register mode Pmode ! 499: in case X is a constant. */ ! 500: ! 501: rtx ! 502: copy_addr_to_reg (x) ! 503: rtx x; ! 504: { ! 505: return copy_to_mode_reg (Pmode, x); ! 506: } ! 507: ! 508: /* Like copy_to_reg but always give the new register mode MODE ! 509: in case X is a constant. */ ! 510: ! 511: rtx ! 512: copy_to_mode_reg (mode, x) ! 513: enum machine_mode mode; ! 514: rtx x; ! 515: { ! 516: register rtx temp = gen_reg_rtx (mode); ! 517: ! 518: /* If not an operand, must be an address with PLUS and MULT so ! 519: do the computation. */ ! 520: if (! general_operand (x, VOIDmode)) ! 521: x = force_operand (x, temp); ! 522: ! 523: if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode) ! 524: abort (); ! 525: if (x != temp) ! 526: emit_move_insn (temp, x); ! 527: return temp; ! 528: } ! 529: ! 530: /* Load X into a register if it is not already one. ! 531: Use mode MODE for the register. ! 532: X should be valid for mode MODE, but it may be a constant which ! 533: is valid for all integer modes; that's why caller must specify MODE. ! 534: ! 535: The caller must not alter the value in the register we return, ! 536: since we mark it as a "constant" register. */ ! 537: ! 538: rtx ! 539: force_reg (mode, x) ! 540: enum machine_mode mode; ! 541: rtx x; ! 542: { ! 543: register rtx temp, insn; ! 544: ! 545: if (GET_CODE (x) == REG) ! 546: return x; ! 547: temp = gen_reg_rtx (mode); ! 548: insn = emit_move_insn (temp, x); ! 549: /* Let optimizers know that TEMP's value never changes ! 550: and that X can be substituted for it. */ ! 551: if (CONSTANT_P (x)) ! 552: { ! 553: rtx note = find_reg_note (insn, REG_EQUAL, 0); ! 554: ! 555: if (note) ! 556: XEXP (note, 0) = x; ! 557: else ! 558: REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL, x, REG_NOTES (insn)); ! 559: } ! 560: return temp; ! 561: } ! 562: ! 563: /* If X is a memory ref, copy its contents to a new temp reg and return ! 564: that reg. Otherwise, return X. */ ! 565: ! 566: rtx ! 567: force_not_mem (x) ! 568: rtx x; ! 569: { ! 570: register rtx temp; ! 571: if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode) ! 572: return x; ! 573: temp = gen_reg_rtx (GET_MODE (x)); ! 574: emit_move_insn (temp, x); ! 575: return temp; ! 576: } ! 577: ! 578: /* Copy X to TARGET (if it's nonzero and a reg) ! 579: or to a new temp reg and return that reg. ! 580: ! 581: If we need to make a temp reg, try getting the mode from ! 582: both X and TARGET. */ ! 583: ! 584: rtx ! 585: copy_to_suggested_reg (x, target) ! 586: rtx x, target; ! 587: { ! 588: register rtx temp; ! 589: ! 590: if (target && GET_CODE (target) == REG) ! 591: temp = target; ! 592: else ! 593: { ! 594: enum machine_mode mode = GET_MODE (x); ! 595: ! 596: if (mode == VOIDmode && target != 0) ! 597: mode = GET_MODE (target); ! 598: ! 599: temp = gen_reg_rtx (mode); ! 600: } ! 601: ! 602: emit_move_insn (temp, x); ! 603: return temp; ! 604: } ! 605: ! 606: /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes). ! 607: This pops when ADJUST is positive. ADJUST need not be constant. */ ! 608: ! 609: void ! 610: adjust_stack (adjust) ! 611: rtx adjust; ! 612: { ! 613: rtx temp; ! 614: adjust = protect_from_queue (adjust, 0); ! 615: ! 616: if (adjust == const0_rtx) ! 617: return; ! 618: ! 619: temp = expand_binop (Pmode, ! 620: #ifdef STACK_GROWS_DOWNWARD ! 621: add_optab, ! 622: #else ! 623: sub_optab, ! 624: #endif ! 625: stack_pointer_rtx, adjust, stack_pointer_rtx, 0, ! 626: OPTAB_LIB_WIDEN); ! 627: ! 628: if (temp != stack_pointer_rtx) ! 629: emit_move_insn (stack_pointer_rtx, temp); ! 630: } ! 631: ! 632: /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes). ! 633: This pushes when ADJUST is positive. ADJUST need not be constant. */ ! 634: ! 635: void ! 636: anti_adjust_stack (adjust) ! 637: rtx adjust; ! 638: { ! 639: rtx temp; ! 640: adjust = protect_from_queue (adjust, 0); ! 641: ! 642: if (adjust == const0_rtx) ! 643: return; ! 644: ! 645: temp = expand_binop (Pmode, ! 646: #ifdef STACK_GROWS_DOWNWARD ! 647: sub_optab, ! 648: #else ! 649: add_optab, ! 650: #endif ! 651: stack_pointer_rtx, adjust, stack_pointer_rtx, 0, ! 652: OPTAB_LIB_WIDEN); ! 653: ! 654: if (temp != stack_pointer_rtx) ! 655: emit_move_insn (stack_pointer_rtx, temp); ! 656: } ! 657: ! 658: /* Round the size of a block to be pushed up to the boundary required ! 659: by this machine. SIZE is the desired size, which need not be constant. */ ! 660: ! 661: rtx ! 662: round_push (size) ! 663: rtx size; ! 664: { ! 665: #ifdef STACK_BOUNDARY ! 666: int align = STACK_BOUNDARY / BITS_PER_UNIT; ! 667: if (align == 1) ! 668: return size; ! 669: if (GET_CODE (size) == CONST_INT) ! 670: { ! 671: int new = (INTVAL (size) + align - 1) / align * align; ! 672: if (INTVAL (size) != new) ! 673: size = gen_rtx (CONST_INT, VOIDmode, new); ! 674: } ! 675: else ! 676: { ! 677: size = expand_divmod (0, CEIL_DIV_EXPR, Pmode, size, ! 678: gen_rtx (CONST_INT, VOIDmode, align), ! 679: 0, 1); ! 680: size = expand_mult (Pmode, size, ! 681: gen_rtx (CONST_INT, VOIDmode, align), ! 682: 0, 1); ! 683: } ! 684: #endif /* STACK_BOUNDARY */ ! 685: return size; ! 686: } ! 687: ! 688: /* Return an rtx representing the address of an area of memory dynamically ! 689: pushed on the stack. This region of memory is always aligned to ! 690: a multiple of BIGGEST_ALIGNMENT. ! 691: ! 692: Any required stack pointer alignment is preserved. ! 693: ! 694: SIZE is an rtx representing the size of the area. ! 695: TARGET is a place in which the address can be placed. */ ! 696: ! 697: rtx ! 698: allocate_dynamic_stack_space (size, target) ! 699: rtx size; ! 700: rtx target; ! 701: { ! 702: /* Ensure the size is in the proper mode. */ ! 703: if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode) ! 704: size = convert_to_mode (Pmode, size, 1); ! 705: ! 706: /* We will need to ensure that the address we return is aligned to ! 707: BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't ! 708: always know its final value at this point in the compilation (it ! 709: might depend on the size of the outgoing parameter lists, for ! 710: example), so we must align the value to be returned in that case. ! 711: (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if ! 712: STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined). ! 713: We must also do an alignment operation on the returned value if ! 714: the stack pointer alignment is less strict that BIGGEST_ALIGNMENT. ! 715: ! 716: If we have to align, we must leave space in SIZE for the hole ! 717: that might result from the alignment operation. */ ! 718: ! 719: #if defined (STACK_DYNAMIC_OFFSET) || defined(STACK_POINTER_OFFSET) || defined (ALLOCATE_OUTGOING_ARGS) ! 720: #define MUST_ALIGN ! 721: #endif ! 722: ! 723: #if ! defined (MUST_ALIGN) && (!defined(STACK_BOUNDARY) || STACK_BOUNDARY < BIGGEST_ALIGNMENT) ! 724: #define MUST_ALIGN ! 725: #endif ! 726: ! 727: #ifdef MUST_ALIGN ! 728: ! 729: if (GET_CODE (size) == CONST_INT) ! 730: size = gen_rtx (CONST_INT, VOIDmode, ! 731: INTVAL (size) + (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1)); ! 732: else ! 733: size = expand_binop (Pmode, add_optab, size, ! 734: gen_rtx (CONST_INT, VOIDmode, ! 735: BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1), ! 736: 0, 1, OPTAB_LIB_WIDEN); ! 737: #endif ! 738: ! 739: #ifdef SETJMP_VIA_SAVE_AREA ! 740: /* If setjmp restores regs from a save area in the stack frame, ! 741: avoid clobbering the reg save area. Note that the offset of ! 742: virtual_incoming_args_rtx includes the preallocated stack args space. ! 743: It would be no problem to clobber that, but it's on the wrong side ! 744: of the old save area. */ ! 745: { ! 746: rtx dynamic_offset ! 747: = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx, ! 748: stack_pointer_rtx, 0, 1, OPTAB_LIB_WIDEN); ! 749: size = expand_binop (Pmode, add_optab, size, dynamic_offset, ! 750: 0, 1, OPTAB_LIB_WIDEN); ! 751: } ! 752: #endif /* SETJMP_VIA_SAVE_AREA */ ! 753: ! 754: /* Round the size to a multiple of the required stack alignment. ! 755: Since the stack if presumed to be rounded before this allocation, ! 756: this will maintain the required alignment. ! 757: ! 758: If the stack grows downward, we could save an insn by subtracting ! 759: SIZE from the stack pointer and then aligning the stack pointer. ! 760: The problem with this is that the stack pointer may be unaligned ! 761: between the execution of the subtraction and alignment insns and ! 762: some machines do not allow this. Even on those that do, some ! 763: signal handlers malfunction if a signal should occur between those ! 764: insns. Since this is an extremely rare event, we have no reliable ! 765: way of knowing which systems have this problem. So we avoid even ! 766: momentarily mis-aligning the stack. */ ! 767: ! 768: size = round_push (size); ! 769: ! 770: do_pending_stack_adjust (); ! 771: ! 772: if (target == 0) ! 773: target = gen_reg_rtx (Pmode); ! 774: ! 775: #ifndef STACK_GROWS_DOWNWARD ! 776: emit_move_insn (target, virtual_stack_dynamic_rtx); ! 777: #endif ! 778: ! 779: /* Perform the required allocation from the stack. Some systems do ! 780: this differently than simply incrementing/decrementing from the ! 781: stack pointer. */ ! 782: #ifdef HAVE_allocate_stack ! 783: if (HAVE_allocate_stack) ! 784: { ! 785: enum machine_mode mode ! 786: = insn_operand_mode[(int) CODE_FOR_allocate_stack][0]; ! 787: ! 788: if (insn_operand_predicate[(int) CODE_FOR_allocate_stack][0] ! 789: && ! ((*insn_operand_predicate[(int) CODE_FOR_allocate_stack][0]) ! 790: (size, mode))) ! 791: size = copy_to_mode_reg (mode, size); ! 792: ! 793: emit_insn (gen_allocate_stack (size)); ! 794: } ! 795: else ! 796: #endif ! 797: anti_adjust_stack (size); ! 798: ! 799: #ifdef STACK_GROWS_DOWNWARD ! 800: emit_move_insn (target, virtual_stack_dynamic_rtx); ! 801: #endif ! 802: ! 803: #ifdef MUST_ALIGN ! 804: target = expand_divmod (0, CEIL_DIV_EXPR, Pmode, target, ! 805: gen_rtx (CONST_INT, VOIDmode, ! 806: BIGGEST_ALIGNMENT / BITS_PER_UNIT), ! 807: 0, 1); ! 808: ! 809: target = expand_mult (Pmode, target, ! 810: gen_rtx (CONST_INT, VOIDmode, ! 811: BIGGEST_ALIGNMENT / BITS_PER_UNIT), ! 812: 0, 1); ! 813: #endif ! 814: ! 815: /* Some systems require a particular insn to refer to the stack ! 816: to make the pages exist. */ ! 817: #ifdef HAVE_probe ! 818: if (HAVE_probe) ! 819: emit_insn (gen_probe ()); ! 820: #endif ! 821: ! 822: return target; ! 823: } ! 824: ! 825: /* Return an rtx representing the register or memory location ! 826: in which a scalar value of data type VALTYPE ! 827: was returned by a function call to function FUNC. ! 828: FUNC is a FUNCTION_DECL node if the precise function is known, ! 829: otherwise 0. */ ! 830: ! 831: rtx ! 832: hard_function_value (valtype, func) ! 833: tree valtype; ! 834: tree func; ! 835: { ! 836: return FUNCTION_VALUE (valtype, func); ! 837: } ! 838: ! 839: /* Return an rtx representing the register or memory location ! 840: in which a scalar value of mode MODE was returned by a library call. */ ! 841: ! 842: rtx ! 843: hard_libcall_value (mode) ! 844: enum machine_mode mode; ! 845: { ! 846: return LIBCALL_VALUE (mode); ! 847: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.