![[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:
1.1.1.4 root 32: /* Return an rtx for the sum of X and the integer C.
33:
1.1.1.5 ! root 34: This function should be used via the `plus_constant' macro. */
1.1 root 35:
36: rtx
1.1.1.4 root 37: plus_constant_wide (x, c)
1.1 root 38: register rtx x;
1.1.1.4 root 39: register HOST_WIDE_INT c;
1.1 root 40: {
41: register RTX_CODE code;
42: register enum machine_mode mode;
43: register rtx tem;
44: int all_constant = 0;
45:
46: if (c == 0)
47: return x;
48:
49: restart:
50:
51: code = GET_CODE (x);
52: mode = GET_MODE (x);
53: switch (code)
54: {
55: case CONST_INT:
1.1.1.4 root 56: return GEN_INT (INTVAL (x) + c);
1.1 root 57:
58: case CONST_DOUBLE:
59: {
1.1.1.4 root 60: HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
61: HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
62: HOST_WIDE_INT l2 = c;
63: HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
64: HOST_WIDE_INT lv, hv;
1.1 root 65:
66: add_double (l1, h1, l2, h2, &lv, &hv);
67:
68: return immed_double_const (lv, hv, VOIDmode);
69: }
70:
71: case MEM:
72: /* If this is a reference to the constant pool, try replacing it with
73: a reference to a new constant. If the resulting address isn't
74: valid, don't return it because we have no way to validize it. */
75: if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
76: && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
77: {
78: tem
79: = force_const_mem (GET_MODE (x),
80: plus_constant (get_pool_constant (XEXP (x, 0)),
81: c));
82: if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
83: return tem;
84: }
85: break;
86:
87: case CONST:
88: /* If adding to something entirely constant, set a flag
89: so that we can add a CONST around the result. */
90: x = XEXP (x, 0);
91: all_constant = 1;
92: goto restart;
93:
94: case SYMBOL_REF:
95: case LABEL_REF:
96: all_constant = 1;
97: break;
98:
99: case PLUS:
100: /* The interesting case is adding the integer to a sum.
101: Look for constant term in the sum and combine
102: with C. For an integer constant term, we make a combined
103: integer. For a constant term that is not an explicit integer,
1.1.1.4 root 104: we cannot really combine, but group them together anyway.
105:
106: Use a recursive call in case the remaining operand is something
107: that we handle specially, such as a SYMBOL_REF. */
108:
109: if (GET_CODE (XEXP (x, 1)) == CONST_INT)
110: return plus_constant (XEXP (x, 0), c + INTVAL (XEXP (x, 1)));
1.1 root 111: else if (CONSTANT_P (XEXP (x, 0)))
112: return gen_rtx (PLUS, mode,
113: plus_constant (XEXP (x, 0), c),
114: XEXP (x, 1));
115: else if (CONSTANT_P (XEXP (x, 1)))
116: return gen_rtx (PLUS, mode,
117: XEXP (x, 0),
118: plus_constant (XEXP (x, 1), c));
119: }
120:
121: if (c != 0)
1.1.1.4 root 122: x = gen_rtx (PLUS, mode, x, GEN_INT (c));
1.1 root 123:
124: if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
125: return x;
126: else if (all_constant)
127: return gen_rtx (CONST, mode, x);
128: else
129: return x;
130: }
131:
1.1.1.4 root 132: /* This is the same as `plus_constant', except that it handles LO_SUM.
133:
134: This function should be used via the `plus_constant_for_output' macro. */
1.1 root 135:
136: rtx
1.1.1.4 root 137: plus_constant_for_output_wide (x, c)
1.1 root 138: register rtx x;
1.1.1.4 root 139: register HOST_WIDE_INT c;
1.1 root 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;
1.1.1.2 root 161: rtx *constptr;
1.1 root 162: {
163: register rtx x0, x1;
1.1.1.2 root 164: rtx tem;
1.1 root 165:
166: if (GET_CODE (x) != PLUS)
167: return x;
168:
169: /* First handle constants appearing at this level explicitly. */
1.1.1.2 root 170: if (GET_CODE (XEXP (x, 1)) == CONST_INT
171: && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
172: XEXP (x, 1)))
173: && GET_CODE (tem) == CONST_INT)
1.1 root 174: {
1.1.1.2 root 175: *constptr = tem;
1.1 root 176: return eliminate_constant_term (XEXP (x, 0), constptr);
177: }
178:
1.1.1.2 root 179: tem = const0_rtx;
180: x0 = eliminate_constant_term (XEXP (x, 0), &tem);
181: x1 = eliminate_constant_term (XEXP (x, 1), &tem);
182: if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
183: && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
184: *constptr, tem))
185: && GET_CODE (tem) == CONST_INT)
1.1 root 186: {
1.1.1.2 root 187: *constptr = tem;
1.1 root 188: return gen_rtx (PLUS, GET_MODE (x), x0, x1);
189: }
1.1.1.2 root 190:
1.1 root 191: return x;
192: }
193:
194: /* Returns the insn that next references REG after INSN, or 0
195: if REG is clobbered before next referenced or we cannot find
196: an insn that references REG in a straight-line piece of code. */
197:
198: rtx
199: find_next_ref (reg, insn)
200: rtx reg;
201: rtx insn;
202: {
203: rtx next;
204:
205: for (insn = NEXT_INSN (insn); insn; insn = next)
206: {
207: next = NEXT_INSN (insn);
208: if (GET_CODE (insn) == NOTE)
209: continue;
210: if (GET_CODE (insn) == CODE_LABEL
211: || GET_CODE (insn) == BARRIER)
212: return 0;
213: if (GET_CODE (insn) == INSN
214: || GET_CODE (insn) == JUMP_INSN
215: || GET_CODE (insn) == CALL_INSN)
216: {
217: if (reg_set_p (reg, insn))
218: return 0;
219: if (reg_mentioned_p (reg, PATTERN (insn)))
220: return insn;
221: if (GET_CODE (insn) == JUMP_INSN)
222: {
223: if (simplejump_p (insn))
224: next = JUMP_LABEL (insn);
225: else
226: return 0;
227: }
228: if (GET_CODE (insn) == CALL_INSN
229: && REGNO (reg) < FIRST_PSEUDO_REGISTER
230: && call_used_regs[REGNO (reg)])
231: return 0;
232: }
233: else
234: abort ();
235: }
236: return 0;
237: }
238:
239: /* Return an rtx for the size in bytes of the value of EXP. */
240:
241: rtx
242: expr_size (exp)
243: tree exp;
244: {
245: return expand_expr (size_in_bytes (TREE_TYPE (exp)),
1.1.1.4 root 246: NULL_RTX, TYPE_MODE (sizetype), 0);
1.1 root 247: }
248:
249: /* Return a copy of X in which all memory references
250: and all constants that involve symbol refs
251: have been replaced with new temporary registers.
252: Also emit code to load the memory locations and constants
253: into those registers.
254:
255: If X contains no such constants or memory references,
256: X itself (not a copy) is returned.
257:
258: If a constant is found in the address that is not a legitimate constant
259: in an insn, it is left alone in the hope that it might be valid in the
260: address.
261:
262: X may contain no arithmetic except addition, subtraction and multiplication.
263: Values returned by expand_expr with 1 for sum_ok fit this constraint. */
264:
265: static rtx
266: break_out_memory_refs (x)
267: register rtx x;
268: {
269: if (GET_CODE (x) == MEM
1.1.1.5 ! root 270: || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
1.1 root 271: && GET_MODE (x) != VOIDmode))
272: {
273: register rtx temp = force_reg (GET_MODE (x), x);
274: mark_reg_pointer (temp);
275: x = temp;
276: }
277: else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
278: || GET_CODE (x) == MULT)
279: {
280: register rtx op0 = break_out_memory_refs (XEXP (x, 0));
281: register rtx op1 = break_out_memory_refs (XEXP (x, 1));
282: if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
283: x = gen_rtx (GET_CODE (x), Pmode, op0, op1);
284: }
285: return x;
286: }
287:
288: /* Given a memory address or facsimile X, construct a new address,
289: currently equivalent, that is stable: future stores won't change it.
290:
291: X must be composed of constants, register and memory references
292: combined with addition, subtraction and multiplication:
293: in other words, just what you can get from expand_expr if sum_ok is 1.
294:
295: Works by making copies of all regs and memory locations used
296: by X and combining them the same way X does.
297: You could also stabilize the reference to this address
298: by copying the address to a register with copy_to_reg;
299: but then you wouldn't get indexed addressing in the reference. */
300:
301: rtx
302: copy_all_regs (x)
303: register rtx x;
304: {
305: if (GET_CODE (x) == REG)
306: {
307: if (REGNO (x) != FRAME_POINTER_REGNUM)
308: x = copy_to_reg (x);
309: }
310: else if (GET_CODE (x) == MEM)
311: x = copy_to_reg (x);
312: else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
313: || GET_CODE (x) == MULT)
314: {
315: register rtx op0 = copy_all_regs (XEXP (x, 0));
316: register rtx op1 = copy_all_regs (XEXP (x, 1));
317: if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
318: x = gen_rtx (GET_CODE (x), Pmode, op0, op1);
319: }
320: return x;
321: }
322:
323: /* Return something equivalent to X but valid as a memory address
324: for something of mode MODE. When X is not itself valid, this
325: works by copying X or subexpressions of it into registers. */
326:
327: rtx
328: memory_address (mode, x)
329: enum machine_mode mode;
330: register rtx x;
331: {
332: register rtx oldx;
333:
334: /* By passing constant addresses thru registers
335: we get a chance to cse them. */
1.1.1.5 ! root 336: if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
1.1 root 337: return force_reg (Pmode, x);
338:
339: /* Accept a QUEUED that refers to a REG
340: even though that isn't a valid address.
341: On attempting to put this in an insn we will call protect_from_queue
342: which will turn it into a REG, which is valid. */
343: if (GET_CODE (x) == QUEUED
344: && GET_CODE (QUEUED_VAR (x)) == REG)
345: return x;
346:
347: /* We get better cse by rejecting indirect addressing at this stage.
348: Let the combiner create indirect addresses where appropriate.
349: For now, generate the code so that the subexpressions useful to share
350: are visible. But not if cse won't be done! */
351: oldx = x;
352: if (! cse_not_expected && GET_CODE (x) != REG)
353: x = break_out_memory_refs (x);
354:
355: /* At this point, any valid address is accepted. */
356: GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
357:
358: /* If it was valid before but breaking out memory refs invalidated it,
359: use it the old way. */
360: if (memory_address_p (mode, oldx))
361: goto win2;
362:
363: /* Perform machine-dependent transformations on X
364: in certain cases. This is not necessary since the code
365: below can handle all possible cases, but machine-dependent
366: transformations can make better code. */
367: LEGITIMIZE_ADDRESS (x, oldx, mode, win);
368:
369: /* PLUS and MULT can appear in special ways
370: as the result of attempts to make an address usable for indexing.
371: Usually they are dealt with by calling force_operand, below.
372: But a sum containing constant terms is special
373: if removing them makes the sum a valid address:
374: then we generate that address in a register
375: and index off of it. We do this because it often makes
376: shorter code, and because the addresses thus generated
377: in registers often become common subexpressions. */
378: if (GET_CODE (x) == PLUS)
379: {
1.1.1.2 root 380: rtx constant_term = const0_rtx;
1.1 root 381: rtx y = eliminate_constant_term (x, &constant_term);
1.1.1.2 root 382: if (constant_term == const0_rtx
1.1 root 383: || ! memory_address_p (mode, y))
1.1.1.4 root 384: return force_operand (x, NULL_RTX);
1.1 root 385:
1.1.1.2 root 386: y = gen_rtx (PLUS, GET_MODE (x), copy_to_reg (y), constant_term);
1.1 root 387: if (! memory_address_p (mode, y))
1.1.1.4 root 388: return force_operand (x, NULL_RTX);
1.1 root 389: return y;
390: }
391: if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
1.1.1.4 root 392: return force_operand (x, NULL_RTX);
1.1 root 393:
394: /* If we have a register that's an invalid address,
395: it must be a hard reg of the wrong class. Copy it to a pseudo. */
396: if (GET_CODE (x) == REG)
397: return copy_to_reg (x);
398:
399: /* Last resort: copy the value to a register, since
400: the register is a valid address. */
401: return force_reg (Pmode, x);
402:
403: win2:
404: x = oldx;
405: win:
406: if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG
407: /* Don't copy an addr via a reg if it is one of our stack slots. */
408: && ! (GET_CODE (x) == PLUS
409: && (XEXP (x, 0) == virtual_stack_vars_rtx
410: || XEXP (x, 0) == virtual_incoming_args_rtx)))
411: {
412: if (general_operand (x, Pmode))
413: return force_reg (Pmode, x);
414: else
1.1.1.4 root 415: return force_operand (x, NULL_RTX);
1.1 root 416: }
417: return x;
418: }
419:
420: /* Like `memory_address' but pretend `flag_force_addr' is 0. */
421:
422: rtx
423: memory_address_noforce (mode, x)
424: enum machine_mode mode;
425: rtx x;
426: {
427: int ambient_force_addr = flag_force_addr;
428: rtx val;
429:
430: flag_force_addr = 0;
431: val = memory_address (mode, x);
432: flag_force_addr = ambient_force_addr;
433: return val;
434: }
435:
436: /* Convert a mem ref into one with a valid memory address.
437: Pass through anything else unchanged. */
438:
439: rtx
440: validize_mem (ref)
441: rtx ref;
442: {
443: if (GET_CODE (ref) != MEM)
444: return ref;
445: if (memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
446: return ref;
447: /* Don't alter REF itself, since that is probably a stack slot. */
448: return change_address (ref, GET_MODE (ref), XEXP (ref, 0));
449: }
450:
451: /* Return a modified copy of X with its memory address copied
452: into a temporary register to protect it from side effects.
453: If X is not a MEM, it is returned unchanged (and not copied).
454: Perhaps even if it is a MEM, if there is no need to change it. */
455:
456: rtx
457: stabilize (x)
458: rtx x;
459: {
460: register rtx addr;
461: if (GET_CODE (x) != MEM)
462: return x;
463: addr = XEXP (x, 0);
464: if (rtx_unstable_p (addr))
465: {
466: rtx temp = copy_all_regs (addr);
467: rtx mem;
468: if (GET_CODE (temp) != REG)
469: temp = copy_to_reg (temp);
470: mem = gen_rtx (MEM, GET_MODE (x), temp);
1.1.1.2 root 471:
472: /* Mark returned memref with in_struct if it's in an array or
473: structure. Copy const and volatile from original memref. */
474:
475: MEM_IN_STRUCT_P (mem) = MEM_IN_STRUCT_P (x) || GET_CODE (addr) == PLUS;
476: RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (x);
477: MEM_VOLATILE_P (mem) = MEM_VOLATILE_P (x);
1.1 root 478: return mem;
479: }
480: return x;
481: }
482:
483: /* Copy the value or contents of X to a new temp reg and return that reg. */
484:
485: rtx
486: copy_to_reg (x)
487: rtx x;
488: {
489: register rtx temp = gen_reg_rtx (GET_MODE (x));
490:
491: /* If not an operand, must be an address with PLUS and MULT so
492: do the computation. */
493: if (! general_operand (x, VOIDmode))
494: x = force_operand (x, temp);
495:
496: if (x != temp)
497: emit_move_insn (temp, x);
498:
499: return temp;
500: }
501:
502: /* Like copy_to_reg but always give the new register mode Pmode
503: in case X is a constant. */
504:
505: rtx
506: copy_addr_to_reg (x)
507: rtx x;
508: {
509: return copy_to_mode_reg (Pmode, x);
510: }
511:
512: /* Like copy_to_reg but always give the new register mode MODE
513: in case X is a constant. */
514:
515: rtx
516: copy_to_mode_reg (mode, x)
517: enum machine_mode mode;
518: rtx x;
519: {
520: register rtx temp = gen_reg_rtx (mode);
521:
522: /* If not an operand, must be an address with PLUS and MULT so
523: do the computation. */
524: if (! general_operand (x, VOIDmode))
525: x = force_operand (x, temp);
526:
527: if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
528: abort ();
529: if (x != temp)
530: emit_move_insn (temp, x);
531: return temp;
532: }
533:
534: /* Load X into a register if it is not already one.
535: Use mode MODE for the register.
536: X should be valid for mode MODE, but it may be a constant which
537: is valid for all integer modes; that's why caller must specify MODE.
538:
539: The caller must not alter the value in the register we return,
540: since we mark it as a "constant" register. */
541:
542: rtx
543: force_reg (mode, x)
544: enum machine_mode mode;
545: rtx x;
546: {
547: register rtx temp, insn;
548:
549: if (GET_CODE (x) == REG)
550: return x;
551: temp = gen_reg_rtx (mode);
552: insn = emit_move_insn (temp, x);
553: /* Let optimizers know that TEMP's value never changes
554: and that X can be substituted for it. */
555: if (CONSTANT_P (x))
556: {
1.1.1.4 root 557: rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
1.1 root 558:
559: if (note)
560: XEXP (note, 0) = x;
561: else
562: REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL, x, REG_NOTES (insn));
563: }
564: return temp;
565: }
566:
567: /* If X is a memory ref, copy its contents to a new temp reg and return
568: that reg. Otherwise, return X. */
569:
570: rtx
571: force_not_mem (x)
572: rtx x;
573: {
574: register rtx temp;
575: if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
576: return x;
577: temp = gen_reg_rtx (GET_MODE (x));
578: emit_move_insn (temp, x);
579: return temp;
580: }
581:
582: /* Copy X to TARGET (if it's nonzero and a reg)
583: or to a new temp reg and return that reg.
1.1.1.2 root 584: MODE is the mode to use for X in case it is a constant. */
1.1 root 585:
586: rtx
1.1.1.2 root 587: copy_to_suggested_reg (x, target, mode)
1.1 root 588: rtx x, target;
1.1.1.2 root 589: enum machine_mode mode;
1.1 root 590: {
591: register rtx temp;
592:
593: if (target && GET_CODE (target) == REG)
594: temp = target;
595: else
1.1.1.2 root 596: temp = gen_reg_rtx (mode);
1.1 root 597:
598: emit_move_insn (temp, x);
599: return temp;
600: }
601:
602: /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
603: This pops when ADJUST is positive. ADJUST need not be constant. */
604:
605: void
606: adjust_stack (adjust)
607: rtx adjust;
608: {
609: rtx temp;
610: adjust = protect_from_queue (adjust, 0);
611:
612: if (adjust == const0_rtx)
613: return;
614:
615: temp = expand_binop (Pmode,
616: #ifdef STACK_GROWS_DOWNWARD
617: add_optab,
618: #else
619: sub_optab,
620: #endif
621: stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
622: OPTAB_LIB_WIDEN);
623:
624: if (temp != stack_pointer_rtx)
625: emit_move_insn (stack_pointer_rtx, temp);
626: }
627:
628: /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
629: This pushes when ADJUST is positive. ADJUST need not be constant. */
630:
631: void
632: anti_adjust_stack (adjust)
633: rtx adjust;
634: {
635: rtx temp;
636: adjust = protect_from_queue (adjust, 0);
637:
638: if (adjust == const0_rtx)
639: return;
640:
641: temp = expand_binop (Pmode,
642: #ifdef STACK_GROWS_DOWNWARD
643: sub_optab,
644: #else
645: add_optab,
646: #endif
647: stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
648: OPTAB_LIB_WIDEN);
649:
650: if (temp != stack_pointer_rtx)
651: emit_move_insn (stack_pointer_rtx, temp);
652: }
653:
654: /* Round the size of a block to be pushed up to the boundary required
655: by this machine. SIZE is the desired size, which need not be constant. */
656:
657: rtx
658: round_push (size)
659: rtx size;
660: {
661: #ifdef STACK_BOUNDARY
662: int align = STACK_BOUNDARY / BITS_PER_UNIT;
663: if (align == 1)
664: return size;
665: if (GET_CODE (size) == CONST_INT)
666: {
667: int new = (INTVAL (size) + align - 1) / align * align;
668: if (INTVAL (size) != new)
1.1.1.4 root 669: size = GEN_INT (new);
1.1 root 670: }
671: else
672: {
1.1.1.4 root 673: size = expand_divmod (0, CEIL_DIV_EXPR, Pmode, size, GEN_INT (align),
674: NULL_RTX, 1);
675: size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
1.1 root 676: }
677: #endif /* STACK_BOUNDARY */
678: return size;
679: }
680:
1.1.1.3 root 681: /* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer
682: to a previously-created save area. If no save area has been allocated,
683: this function will allocate one. If a save area is specified, it
684: must be of the proper mode.
685:
686: The insns are emitted after insn AFTER, if nonzero, otherwise the insns
687: are emitted at the current position. */
688:
689: void
690: emit_stack_save (save_level, psave, after)
691: enum save_level save_level;
692: rtx *psave;
693: rtx after;
694: {
695: rtx sa = *psave;
696: /* The default is that we use a move insn and save in a Pmode object. */
697: rtx (*fcn) () = gen_move_insn;
698: enum machine_mode mode = Pmode;
699:
700: /* See if this machine has anything special to do for this kind of save. */
701: switch (save_level)
702: {
703: #ifdef HAVE_save_stack_block
704: case SAVE_BLOCK:
705: if (HAVE_save_stack_block)
706: {
707: fcn = gen_save_stack_block;
708: mode = insn_operand_mode[CODE_FOR_save_stack_block][0];
709: }
710: break;
711: #endif
712: #ifdef HAVE_save_stack_function
713: case SAVE_FUNCTION:
714: if (HAVE_save_stack_function)
715: {
716: fcn = gen_save_stack_function;
717: mode = insn_operand_mode[CODE_FOR_save_stack_function][0];
718: }
719: break;
720: #endif
721: #ifdef HAVE_save_stack_nonlocal
722: case SAVE_NONLOCAL:
723: if (HAVE_save_stack_nonlocal)
724: {
725: fcn = gen_save_stack_nonlocal;
726: mode = insn_operand_mode[CODE_FOR_save_stack_nonlocal][0];
727: }
728: break;
729: #endif
730: }
731:
732: /* If there is no save area and we have to allocate one, do so. Otherwise
733: verify the save area is the proper mode. */
734:
735: if (sa == 0)
736: {
737: if (mode != VOIDmode)
738: {
739: if (save_level == SAVE_NONLOCAL)
740: *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
741: else
742: *psave = sa = gen_reg_rtx (mode);
743: }
744: }
745: else
746: {
747: if (mode == VOIDmode || GET_MODE (sa) != mode)
748: abort ();
749: }
750:
751: if (after)
752: {
753: rtx seq;
754:
755: start_sequence ();
1.1.1.5 ! root 756: /* We must validize inside the sequence, to ensure that any instructions
! 757: created by the validize call also get moved to the right place. */
! 758: if (sa != 0)
! 759: sa = validize_mem (sa);
1.1.1.3 root 760: emit_insn (fcn (sa, stack_pointer_rtx));
761: seq = gen_sequence ();
762: end_sequence ();
763: emit_insn_after (seq, after);
764: }
765: else
1.1.1.5 ! root 766: {
! 767: if (sa != 0)
! 768: sa = validize_mem (sa);
! 769: emit_insn (fcn (sa, stack_pointer_rtx));
! 770: }
1.1.1.3 root 771: }
772:
773: /* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save
774: area made by emit_stack_save. If it is zero, we have nothing to do.
775:
776: Put any emitted insns after insn AFTER, if nonzero, otherwise at
777: current position. */
778:
779: void
780: emit_stack_restore (save_level, sa, after)
781: enum save_level save_level;
782: rtx after;
783: rtx sa;
784: {
785: /* The default is that we use a move insn. */
786: rtx (*fcn) () = gen_move_insn;
787:
788: /* See if this machine has anything special to do for this kind of save. */
789: switch (save_level)
790: {
791: #ifdef HAVE_restore_stack_block
792: case SAVE_BLOCK:
793: if (HAVE_restore_stack_block)
794: fcn = gen_restore_stack_block;
795: break;
796: #endif
797: #ifdef HAVE_restore_stack_function
798: case SAVE_FUNCTION:
799: if (HAVE_restore_stack_function)
800: fcn = gen_restore_stack_function;
801: break;
802: #endif
803: #ifdef HAVE_restore_stack_nonlocal
804:
805: case SAVE_NONLOCAL:
806: if (HAVE_restore_stack_nonlocal)
807: fcn = gen_restore_stack_nonlocal;
808: break;
809: #endif
810: }
811:
812: if (sa != 0)
813: sa = validize_mem (sa);
814:
815: if (after)
816: {
817: rtx seq;
818:
819: start_sequence ();
820: emit_insn (fcn (stack_pointer_rtx, sa));
821: seq = gen_sequence ();
822: end_sequence ();
823: emit_insn_after (seq, after);
824: }
825: else
826: emit_insn (fcn (stack_pointer_rtx, sa));
827: }
828:
1.1 root 829: /* Return an rtx representing the address of an area of memory dynamically
830: pushed on the stack. This region of memory is always aligned to
831: a multiple of BIGGEST_ALIGNMENT.
832:
833: Any required stack pointer alignment is preserved.
834:
835: SIZE is an rtx representing the size of the area.
1.1.1.3 root 836: TARGET is a place in which the address can be placed.
837:
838: KNOWN_ALIGN is the alignment (in bits) that we know SIZE has. */
1.1 root 839:
840: rtx
1.1.1.3 root 841: allocate_dynamic_stack_space (size, target, known_align)
1.1 root 842: rtx size;
843: rtx target;
1.1.1.3 root 844: int known_align;
1.1 root 845: {
846: /* Ensure the size is in the proper mode. */
847: if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
848: size = convert_to_mode (Pmode, size, 1);
849:
850: /* We will need to ensure that the address we return is aligned to
851: BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't
852: always know its final value at this point in the compilation (it
853: might depend on the size of the outgoing parameter lists, for
854: example), so we must align the value to be returned in that case.
855: (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
856: STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
857: We must also do an alignment operation on the returned value if
858: the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
859:
860: If we have to align, we must leave space in SIZE for the hole
861: that might result from the alignment operation. */
862:
863: #if defined (STACK_DYNAMIC_OFFSET) || defined(STACK_POINTER_OFFSET) || defined (ALLOCATE_OUTGOING_ARGS)
864: #define MUST_ALIGN
865: #endif
866:
867: #if ! defined (MUST_ALIGN) && (!defined(STACK_BOUNDARY) || STACK_BOUNDARY < BIGGEST_ALIGNMENT)
868: #define MUST_ALIGN
869: #endif
870:
871: #ifdef MUST_ALIGN
872:
1.1.1.4 root 873: #if 0 /* It turns out we must always make extra space, if MUST_ALIGN
874: because we must always round the address up at the end,
875: because we don't know whether the dynamic offset
876: will mess up the desired alignment. */
877: /* If we have to round the address up regardless of known_align,
878: make extra space regardless, also. */
1.1.1.3 root 879: if (known_align % BIGGEST_ALIGNMENT != 0)
1.1.1.4 root 880: #endif
1.1.1.3 root 881: {
882: if (GET_CODE (size) == CONST_INT)
1.1.1.4 root 883: size = GEN_INT (INTVAL (size)
884: + (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1));
1.1.1.3 root 885: else
886: size = expand_binop (Pmode, add_optab, size,
1.1.1.4 root 887: GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
888: NULL_RTX, 1, OPTAB_LIB_WIDEN);
1.1.1.3 root 889: }
1.1.1.4 root 890:
1.1 root 891: #endif
892:
893: #ifdef SETJMP_VIA_SAVE_AREA
894: /* If setjmp restores regs from a save area in the stack frame,
895: avoid clobbering the reg save area. Note that the offset of
896: virtual_incoming_args_rtx includes the preallocated stack args space.
897: It would be no problem to clobber that, but it's on the wrong side
898: of the old save area. */
899: {
900: rtx dynamic_offset
901: = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1.1.1.4 root 902: stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1.1 root 903: size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1.1.1.4 root 904: NULL_RTX, 1, OPTAB_LIB_WIDEN);
1.1 root 905: }
906: #endif /* SETJMP_VIA_SAVE_AREA */
907:
908: /* Round the size to a multiple of the required stack alignment.
909: Since the stack if presumed to be rounded before this allocation,
910: this will maintain the required alignment.
911:
912: If the stack grows downward, we could save an insn by subtracting
913: SIZE from the stack pointer and then aligning the stack pointer.
914: The problem with this is that the stack pointer may be unaligned
915: between the execution of the subtraction and alignment insns and
916: some machines do not allow this. Even on those that do, some
917: signal handlers malfunction if a signal should occur between those
918: insns. Since this is an extremely rare event, we have no reliable
919: way of knowing which systems have this problem. So we avoid even
920: momentarily mis-aligning the stack. */
921:
1.1.1.3 root 922: #ifdef STACK_BOUNDARY
1.1.1.4 root 923: /* If we added a variable amount to SIZE,
924: we can no longer assume it is aligned. */
925: #if !defined (SETJMP_VIA_SAVE_AREA) && !defined (MUST_ALIGN)
1.1.1.3 root 926: if (known_align % STACK_BOUNDARY != 0)
1.1.1.4 root 927: #endif
1.1.1.3 root 928: size = round_push (size);
929: #endif
1.1 root 930:
931: do_pending_stack_adjust ();
932:
1.1.1.3 root 933: /* Don't use a TARGET that isn't a pseudo. */
934: if (target == 0 || GET_CODE (target) != REG
935: || REGNO (target) < FIRST_PSEUDO_REGISTER)
1.1 root 936: target = gen_reg_rtx (Pmode);
937:
1.1.1.3 root 938: mark_reg_pointer (target);
939:
1.1 root 940: #ifndef STACK_GROWS_DOWNWARD
941: emit_move_insn (target, virtual_stack_dynamic_rtx);
942: #endif
943:
944: /* Perform the required allocation from the stack. Some systems do
945: this differently than simply incrementing/decrementing from the
946: stack pointer. */
947: #ifdef HAVE_allocate_stack
948: if (HAVE_allocate_stack)
949: {
950: enum machine_mode mode
951: = insn_operand_mode[(int) CODE_FOR_allocate_stack][0];
952:
953: if (insn_operand_predicate[(int) CODE_FOR_allocate_stack][0]
954: && ! ((*insn_operand_predicate[(int) CODE_FOR_allocate_stack][0])
955: (size, mode)))
956: size = copy_to_mode_reg (mode, size);
957:
958: emit_insn (gen_allocate_stack (size));
959: }
960: else
961: #endif
962: anti_adjust_stack (size);
963:
964: #ifdef STACK_GROWS_DOWNWARD
965: emit_move_insn (target, virtual_stack_dynamic_rtx);
966: #endif
967:
968: #ifdef MUST_ALIGN
1.1.1.4 root 969: #if 0 /* Even if we know the stack pointer has enough alignment,
970: there's no way to tell whether virtual_stack_dynamic_rtx shares that
971: alignment, so we still need to round the address up. */
1.1.1.3 root 972: if (known_align % BIGGEST_ALIGNMENT != 0)
1.1.1.4 root 973: #endif
1.1.1.3 root 974: {
975: target = expand_divmod (0, CEIL_DIV_EXPR, Pmode, target,
1.1.1.4 root 976: GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
977: NULL_RTX, 1);
1.1.1.3 root 978:
979: target = expand_mult (Pmode, target,
1.1.1.4 root 980: GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
981: NULL_RTX, 1);
1.1.1.3 root 982: }
1.1 root 983: #endif
984:
985: /* Some systems require a particular insn to refer to the stack
986: to make the pages exist. */
987: #ifdef HAVE_probe
988: if (HAVE_probe)
989: emit_insn (gen_probe ());
990: #endif
991:
992: return target;
993: }
994:
995: /* Return an rtx representing the register or memory location
996: in which a scalar value of data type VALTYPE
997: was returned by a function call to function FUNC.
998: FUNC is a FUNCTION_DECL node if the precise function is known,
999: otherwise 0. */
1000:
1001: rtx
1002: hard_function_value (valtype, func)
1003: tree valtype;
1004: tree func;
1005: {
1006: return FUNCTION_VALUE (valtype, func);
1007: }
1008:
1009: /* Return an rtx representing the register or memory location
1010: in which a scalar value of mode MODE was returned by a library call. */
1011:
1012: rtx
1013: hard_libcall_value (mode)
1014: enum machine_mode mode;
1015: {
1016: return LIBCALL_VALUE (mode);
1017: }
1.1.1.5 ! root 1018:
! 1019: /* Look up the tree code for a given rtx code
! 1020: to provide the arithmetic operation for REAL_ARITHMETIC.
! 1021: The function returns an int because the caller may not know
! 1022: what `enum tree_code' means. */
! 1023:
! 1024: int
! 1025: rtx_to_tree_code (code)
! 1026: enum rtx_code code;
! 1027: {
! 1028: enum tree_code tcode;
! 1029:
! 1030: switch (code)
! 1031: {
! 1032: case PLUS:
! 1033: tcode = PLUS_EXPR;
! 1034: break;
! 1035: case MINUS:
! 1036: tcode = MINUS_EXPR;
! 1037: break;
! 1038: case MULT:
! 1039: tcode = MULT_EXPR;
! 1040: break;
! 1041: case DIV:
! 1042: tcode = RDIV_EXPR;
! 1043: break;
! 1044: case SMIN:
! 1045: tcode = MIN_EXPR;
! 1046: break;
! 1047: case SMAX:
! 1048: tcode = MAX_EXPR;
! 1049: break;
! 1050: default:
! 1051: tcode = LAST_AND_UNUSED_TREE_CODE;
! 1052: break;
! 1053: }
! 1054: return ((int) tcode);
! 1055: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.