OSDN Git Service

cfaadf3afa98d9bfa0af26100df126ca40579979
[pf3gnuchains/gcc-fork.git] / gcc / explow.c
1 /* Subroutines for manipulating rtx's in semantically interesting ways.
2    Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "toplev.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "tm_p.h"
31 #include "flags.h"
32 #include "function.h"
33 #include "expr.h"
34 #include "optabs.h"
35 #include "hard-reg-set.h"
36 #include "insn-config.h"
37 #include "ggc.h"
38 #include "recog.h"
39 #include "langhooks.h"
40
41 static rtx break_out_memory_refs (rtx);
42 static void emit_stack_probe (rtx);
43
44
45 /* Truncate and perhaps sign-extend C as appropriate for MODE.  */
46
47 HOST_WIDE_INT
48 trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode)
49 {
50   int width = GET_MODE_BITSIZE (mode);
51
52   /* You want to truncate to a _what_?  */
53   if (! SCALAR_INT_MODE_P (mode))
54     abort ();
55
56   /* Canonicalize BImode to 0 and STORE_FLAG_VALUE.  */
57   if (mode == BImode)
58     return c & 1 ? STORE_FLAG_VALUE : 0;
59
60   /* Sign-extend for the requested mode.  */
61
62   if (width < HOST_BITS_PER_WIDE_INT)
63     {
64       HOST_WIDE_INT sign = 1;
65       sign <<= width - 1;
66       c &= (sign << 1) - 1;
67       c ^= sign;
68       c -= sign;
69     }
70
71   return c;
72 }
73
74 /* Return an rtx for the sum of X and the integer C.
75
76    This function should be used via the `plus_constant' macro.  */
77
78 rtx
79 plus_constant_wide (rtx x, HOST_WIDE_INT c)
80 {
81   RTX_CODE code;
82   rtx y;
83   enum machine_mode mode;
84   rtx tem;
85   int all_constant = 0;
86
87   if (c == 0)
88     return x;
89
90  restart:
91
92   code = GET_CODE (x);
93   mode = GET_MODE (x);
94   y = x;
95
96   switch (code)
97     {
98     case CONST_INT:
99       return GEN_INT (INTVAL (x) + c);
100
101     case CONST_DOUBLE:
102       {
103         unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
104         HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
105         unsigned HOST_WIDE_INT l2 = c;
106         HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
107         unsigned HOST_WIDE_INT lv;
108         HOST_WIDE_INT hv;
109
110         add_double (l1, h1, l2, h2, &lv, &hv);
111
112         return immed_double_const (lv, hv, VOIDmode);
113       }
114
115     case MEM:
116       /* If this is a reference to the constant pool, try replacing it with
117          a reference to a new constant.  If the resulting address isn't
118          valid, don't return it because we have no way to validize it.  */
119       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
120           && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
121         {
122           tem
123             = force_const_mem (GET_MODE (x),
124                                plus_constant (get_pool_constant (XEXP (x, 0)),
125                                               c));
126           if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
127             return tem;
128         }
129       break;
130
131     case CONST:
132       /* If adding to something entirely constant, set a flag
133          so that we can add a CONST around the result.  */
134       x = XEXP (x, 0);
135       all_constant = 1;
136       goto restart;
137
138     case SYMBOL_REF:
139     case LABEL_REF:
140       all_constant = 1;
141       break;
142
143     case PLUS:
144       /* The interesting case is adding the integer to a sum.
145          Look for constant term in the sum and combine
146          with C.  For an integer constant term, we make a combined
147          integer.  For a constant term that is not an explicit integer,
148          we cannot really combine, but group them together anyway.
149
150          Restart or use a recursive call in case the remaining operand is
151          something that we handle specially, such as a SYMBOL_REF.
152
153          We may not immediately return from the recursive call here, lest
154          all_constant gets lost.  */
155
156       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
157         {
158           c += INTVAL (XEXP (x, 1));
159
160           if (GET_MODE (x) != VOIDmode)
161             c = trunc_int_for_mode (c, GET_MODE (x));
162
163           x = XEXP (x, 0);
164           goto restart;
165         }
166       else if (CONSTANT_P (XEXP (x, 1)))
167         {
168           x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
169           c = 0;
170         }
171       else if (find_constant_term_loc (&y))
172         {
173           /* We need to be careful since X may be shared and we can't
174              modify it in place.  */
175           rtx copy = copy_rtx (x);
176           rtx *const_loc = find_constant_term_loc (&copy);
177
178           *const_loc = plus_constant (*const_loc, c);
179           x = copy;
180           c = 0;
181         }
182       break;
183
184     default:
185       break;
186     }
187
188   if (c != 0)
189     x = gen_rtx_PLUS (mode, x, GEN_INT (c));
190
191   if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
192     return x;
193   else if (all_constant)
194     return gen_rtx_CONST (mode, x);
195   else
196     return x;
197 }
198 \f
199 /* If X is a sum, return a new sum like X but lacking any constant terms.
200    Add all the removed constant terms into *CONSTPTR.
201    X itself is not altered.  The result != X if and only if
202    it is not isomorphic to X.  */
203
204 rtx
205 eliminate_constant_term (rtx x, rtx *constptr)
206 {
207   rtx x0, x1;
208   rtx tem;
209
210   if (GET_CODE (x) != PLUS)
211     return x;
212
213   /* First handle constants appearing at this level explicitly.  */
214   if (GET_CODE (XEXP (x, 1)) == CONST_INT
215       && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
216                                                 XEXP (x, 1)))
217       && GET_CODE (tem) == CONST_INT)
218     {
219       *constptr = tem;
220       return eliminate_constant_term (XEXP (x, 0), constptr);
221     }
222
223   tem = const0_rtx;
224   x0 = eliminate_constant_term (XEXP (x, 0), &tem);
225   x1 = eliminate_constant_term (XEXP (x, 1), &tem);
226   if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
227       && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
228                                                 *constptr, tem))
229       && GET_CODE (tem) == CONST_INT)
230     {
231       *constptr = tem;
232       return gen_rtx_PLUS (GET_MODE (x), x0, x1);
233     }
234
235   return x;
236 }
237
238 /* Return an rtx for the size in bytes of the value of EXP.  */
239
240 rtx
241 expr_size (tree exp)
242 {
243   tree size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (lang_hooks.expr_size (exp), exp);
244
245   return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
246 }
247
248 /* Return a wide integer for the size in bytes of the value of EXP, or -1
249    if the size can vary or is larger than an integer.  */
250
251 HOST_WIDE_INT
252 int_expr_size (tree exp)
253 {
254   tree t = lang_hooks.expr_size (exp);
255
256   if (t == 0
257       || TREE_CODE (t) != INTEGER_CST
258       || TREE_OVERFLOW (t)
259       || TREE_INT_CST_HIGH (t) != 0
260       /* If the result would appear negative, it's too big to represent.  */
261       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
262     return -1;
263
264   return TREE_INT_CST_LOW (t);
265 }
266 \f
267 /* Return a copy of X in which all memory references
268    and all constants that involve symbol refs
269    have been replaced with new temporary registers.
270    Also emit code to load the memory locations and constants
271    into those registers.
272
273    If X contains no such constants or memory references,
274    X itself (not a copy) is returned.
275
276    If a constant is found in the address that is not a legitimate constant
277    in an insn, it is left alone in the hope that it might be valid in the
278    address.
279
280    X may contain no arithmetic except addition, subtraction and multiplication.
281    Values returned by expand_expr with 1 for sum_ok fit this constraint.  */
282
283 static rtx
284 break_out_memory_refs (rtx x)
285 {
286   if (MEM_P (x)
287       || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
288           && GET_MODE (x) != VOIDmode))
289     x = force_reg (GET_MODE (x), x);
290   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
291            || GET_CODE (x) == MULT)
292     {
293       rtx op0 = break_out_memory_refs (XEXP (x, 0));
294       rtx op1 = break_out_memory_refs (XEXP (x, 1));
295
296       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
297         x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
298     }
299
300   return x;
301 }
302
303 /* Given X, a memory address in ptr_mode, convert it to an address
304    in Pmode, or vice versa (TO_MODE says which way).  We take advantage of
305    the fact that pointers are not allowed to overflow by commuting arithmetic
306    operations over conversions so that address arithmetic insns can be
307    used.  */
308
309 rtx
310 convert_memory_address (enum machine_mode to_mode ATTRIBUTE_UNUSED, 
311                         rtx x)
312 {
313 #ifndef POINTERS_EXTEND_UNSIGNED
314   return x;
315 #else /* defined(POINTERS_EXTEND_UNSIGNED) */
316   enum machine_mode from_mode;
317   rtx temp;
318   enum rtx_code code;
319
320   /* If X already has the right mode, just return it.  */
321   if (GET_MODE (x) == to_mode)
322     return x;
323
324   from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
325
326   /* Here we handle some special cases.  If none of them apply, fall through
327      to the default case.  */
328   switch (GET_CODE (x))
329     {
330     case CONST_INT:
331     case CONST_DOUBLE:
332       if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode))
333         code = TRUNCATE;
334       else if (POINTERS_EXTEND_UNSIGNED < 0)
335         break;
336       else if (POINTERS_EXTEND_UNSIGNED > 0)
337         code = ZERO_EXTEND;
338       else
339         code = SIGN_EXTEND;
340       temp = simplify_unary_operation (code, to_mode, x, from_mode);
341       if (temp)
342         return temp;
343       break;
344
345     case SUBREG:
346       if ((SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x)))
347           && GET_MODE (SUBREG_REG (x)) == to_mode)
348         return SUBREG_REG (x);
349       break;
350
351     case LABEL_REF:
352       temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
353       LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
354       return temp;
355       break;
356
357     case SYMBOL_REF:
358       temp = shallow_copy_rtx (x);
359       PUT_MODE (temp, to_mode);
360       return temp;
361       break;
362
363     case CONST:
364       return gen_rtx_CONST (to_mode,
365                             convert_memory_address (to_mode, XEXP (x, 0)));
366       break;
367
368     case PLUS:
369     case MULT:
370       /* For addition we can safely permute the conversion and addition
371          operation if one operand is a constant and converting the constant
372          does not change it.  We can always safely permute them if we are
373          making the address narrower.  */
374       if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
375           || (GET_CODE (x) == PLUS
376               && GET_CODE (XEXP (x, 1)) == CONST_INT
377               && XEXP (x, 1) == convert_memory_address (to_mode, XEXP (x, 1))))
378         return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
379                                convert_memory_address (to_mode, XEXP (x, 0)),
380                                XEXP (x, 1));
381       break;
382
383     default:
384       break;
385     }
386
387   return convert_modes (to_mode, from_mode,
388                         x, POINTERS_EXTEND_UNSIGNED);
389 #endif /* defined(POINTERS_EXTEND_UNSIGNED) */
390 }
391
392 /* Given a memory address or facsimile X, construct a new address,
393    currently equivalent, that is stable: future stores won't change it.
394
395    X must be composed of constants, register and memory references
396    combined with addition, subtraction and multiplication:
397    in other words, just what you can get from expand_expr if sum_ok is 1.
398
399    Works by making copies of all regs and memory locations used
400    by X and combining them the same way X does.
401    You could also stabilize the reference to this address
402    by copying the address to a register with copy_to_reg;
403    but then you wouldn't get indexed addressing in the reference.  */
404
405 rtx
406 copy_all_regs (rtx x)
407 {
408   if (REG_P (x))
409     {
410       if (REGNO (x) != FRAME_POINTER_REGNUM
411 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
412           && REGNO (x) != HARD_FRAME_POINTER_REGNUM
413 #endif
414           )
415         x = copy_to_reg (x);
416     }
417   else if (MEM_P (x))
418     x = copy_to_reg (x);
419   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
420            || GET_CODE (x) == MULT)
421     {
422       rtx op0 = copy_all_regs (XEXP (x, 0));
423       rtx op1 = copy_all_regs (XEXP (x, 1));
424       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
425         x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
426     }
427   return x;
428 }
429 \f
430 /* Return something equivalent to X but valid as a memory address
431    for something of mode MODE.  When X is not itself valid, this
432    works by copying X or subexpressions of it into registers.  */
433
434 rtx
435 memory_address (enum machine_mode mode, rtx x)
436 {
437   rtx oldx = x;
438
439   x = convert_memory_address (Pmode, x);
440
441   /* By passing constant addresses through registers
442      we get a chance to cse them.  */
443   if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
444     x = force_reg (Pmode, x);
445
446   /* Accept a QUEUED that refers to a REG
447      even though that isn't a valid address.
448      On attempting to put this in an insn we will call protect_from_queue
449      which will turn it into a REG, which is valid.  */
450   else if (GET_CODE (x) == QUEUED
451       && REG_P (QUEUED_VAR (x)))
452     ;
453
454   /* We get better cse by rejecting indirect addressing at this stage.
455      Let the combiner create indirect addresses where appropriate.
456      For now, generate the code so that the subexpressions useful to share
457      are visible.  But not if cse won't be done!  */
458   else
459     {
460       if (! cse_not_expected && !REG_P (x))
461         x = break_out_memory_refs (x);
462
463       /* At this point, any valid address is accepted.  */
464       GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
465
466       /* If it was valid before but breaking out memory refs invalidated it,
467          use it the old way.  */
468       if (memory_address_p (mode, oldx))
469         goto win2;
470
471       /* Perform machine-dependent transformations on X
472          in certain cases.  This is not necessary since the code
473          below can handle all possible cases, but machine-dependent
474          transformations can make better code.  */
475       LEGITIMIZE_ADDRESS (x, oldx, mode, win);
476
477       /* PLUS and MULT can appear in special ways
478          as the result of attempts to make an address usable for indexing.
479          Usually they are dealt with by calling force_operand, below.
480          But a sum containing constant terms is special
481          if removing them makes the sum a valid address:
482          then we generate that address in a register
483          and index off of it.  We do this because it often makes
484          shorter code, and because the addresses thus generated
485          in registers often become common subexpressions.  */
486       if (GET_CODE (x) == PLUS)
487         {
488           rtx constant_term = const0_rtx;
489           rtx y = eliminate_constant_term (x, &constant_term);
490           if (constant_term == const0_rtx
491               || ! memory_address_p (mode, y))
492             x = force_operand (x, NULL_RTX);
493           else
494             {
495               y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term);
496               if (! memory_address_p (mode, y))
497                 x = force_operand (x, NULL_RTX);
498               else
499                 x = y;
500             }
501         }
502
503       else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
504         x = force_operand (x, NULL_RTX);
505
506       /* If we have a register that's an invalid address,
507          it must be a hard reg of the wrong class.  Copy it to a pseudo.  */
508       else if (REG_P (x))
509         x = copy_to_reg (x);
510
511       /* Last resort: copy the value to a register, since
512          the register is a valid address.  */
513       else
514         x = force_reg (Pmode, x);
515
516       goto done;
517
518     win2:
519       x = oldx;
520     win:
521       if (flag_force_addr && ! cse_not_expected && !REG_P (x)
522           /* Don't copy an addr via a reg if it is one of our stack slots.  */
523           && ! (GET_CODE (x) == PLUS
524                 && (XEXP (x, 0) == virtual_stack_vars_rtx
525                     || XEXP (x, 0) == virtual_incoming_args_rtx)))
526         {
527           if (general_operand (x, Pmode))
528             x = force_reg (Pmode, x);
529           else
530             x = force_operand (x, NULL_RTX);
531         }
532     }
533
534  done:
535
536   /* If we didn't change the address, we are done.  Otherwise, mark
537      a reg as a pointer if we have REG or REG + CONST_INT.  */
538   if (oldx == x)
539     return x;
540   else if (REG_P (x))
541     mark_reg_pointer (x, BITS_PER_UNIT);
542   else if (GET_CODE (x) == PLUS
543            && REG_P (XEXP (x, 0))
544            && GET_CODE (XEXP (x, 1)) == CONST_INT)
545     mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
546
547   /* OLDX may have been the address on a temporary.  Update the address
548      to indicate that X is now used.  */
549   update_temp_slot_address (oldx, x);
550
551   return x;
552 }
553
554 /* Like `memory_address' but pretend `flag_force_addr' is 0.  */
555
556 rtx
557 memory_address_noforce (enum machine_mode mode, rtx x)
558 {
559   int ambient_force_addr = flag_force_addr;
560   rtx val;
561
562   flag_force_addr = 0;
563   val = memory_address (mode, x);
564   flag_force_addr = ambient_force_addr;
565   return val;
566 }
567
568 /* Convert a mem ref into one with a valid memory address.
569    Pass through anything else unchanged.  */
570
571 rtx
572 validize_mem (rtx ref)
573 {
574   if (!MEM_P (ref))
575     return ref;
576   if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
577       && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
578     return ref;
579
580   /* Don't alter REF itself, since that is probably a stack slot.  */
581   return replace_equiv_address (ref, XEXP (ref, 0));
582 }
583 \f
584 /* Given REF, either a MEM or a REG, and T, either the type of X or
585    the expression corresponding to REF, set RTX_UNCHANGING_P if
586    appropriate.  */
587
588 void
589 maybe_set_unchanging (rtx ref, tree t)
590 {
591   /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
592      initialization is only executed once, or whose initializer always
593      has the same value.  Currently we simplify this to PARM_DECLs in the
594      first case, and decls with TREE_CONSTANT initializers in the second.
595
596      We cannot do this for non-static aggregates, because of the double
597      writes that can be generated by store_constructor, depending on the
598      contents of the initializer.  Yes, this does eliminate a good fraction
599      of the number of uses of RTX_UNCHANGING_P for a language like Ada.
600      It also eliminates a good quantity of bugs.  Let this be incentive to
601      eliminate RTX_UNCHANGING_P entirely in favor of a more reliable
602      solution, perhaps based on alias sets.  */
603
604   if ((TREE_READONLY (t) && DECL_P (t)
605        && (TREE_STATIC (t) || ! AGGREGATE_TYPE_P (TREE_TYPE (t)))
606        && (TREE_CODE (t) == PARM_DECL
607            || (DECL_INITIAL (t) && TREE_CONSTANT (DECL_INITIAL (t)))))
608       || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
609     RTX_UNCHANGING_P (ref) = 1;
610 }
611 \f
612 /* Return a modified copy of X with its memory address copied
613    into a temporary register to protect it from side effects.
614    If X is not a MEM, it is returned unchanged (and not copied).
615    Perhaps even if it is a MEM, if there is no need to change it.  */
616
617 rtx
618 stabilize (rtx x)
619 {
620   if (!MEM_P (x)
621       || ! rtx_unstable_p (XEXP (x, 0)))
622     return x;
623
624   return
625     replace_equiv_address (x, force_reg (Pmode, copy_all_regs (XEXP (x, 0))));
626 }
627 \f
628 /* Copy the value or contents of X to a new temp reg and return that reg.  */
629
630 rtx
631 copy_to_reg (rtx x)
632 {
633   rtx temp = gen_reg_rtx (GET_MODE (x));
634
635   /* If not an operand, must be an address with PLUS and MULT so
636      do the computation.  */
637   if (! general_operand (x, VOIDmode))
638     x = force_operand (x, temp);
639
640   if (x != temp)
641     emit_move_insn (temp, x);
642
643   return temp;
644 }
645
646 /* Like copy_to_reg but always give the new register mode Pmode
647    in case X is a constant.  */
648
649 rtx
650 copy_addr_to_reg (rtx x)
651 {
652   return copy_to_mode_reg (Pmode, x);
653 }
654
655 /* Like copy_to_reg but always give the new register mode MODE
656    in case X is a constant.  */
657
658 rtx
659 copy_to_mode_reg (enum machine_mode mode, rtx x)
660 {
661   rtx temp = gen_reg_rtx (mode);
662
663   /* If not an operand, must be an address with PLUS and MULT so
664      do the computation.  */
665   if (! general_operand (x, VOIDmode))
666     x = force_operand (x, temp);
667
668   if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
669     abort ();
670   if (x != temp)
671     emit_move_insn (temp, x);
672   return temp;
673 }
674
675 /* Load X into a register if it is not already one.
676    Use mode MODE for the register.
677    X should be valid for mode MODE, but it may be a constant which
678    is valid for all integer modes; that's why caller must specify MODE.
679
680    The caller must not alter the value in the register we return,
681    since we mark it as a "constant" register.  */
682
683 rtx
684 force_reg (enum machine_mode mode, rtx x)
685 {
686   rtx temp, insn, set;
687
688   if (REG_P (x))
689     return x;
690
691   if (general_operand (x, mode))
692     {
693       temp = gen_reg_rtx (mode);
694       insn = emit_move_insn (temp, x);
695     }
696   else
697     {
698       temp = force_operand (x, NULL_RTX);
699       if (REG_P (temp))
700         insn = get_last_insn ();
701       else
702         {
703           rtx temp2 = gen_reg_rtx (mode);
704           insn = emit_move_insn (temp2, temp);
705           temp = temp2;
706         }
707     }
708
709   /* Let optimizers know that TEMP's value never changes
710      and that X can be substituted for it.  Don't get confused
711      if INSN set something else (such as a SUBREG of TEMP).  */
712   if (CONSTANT_P (x)
713       && (set = single_set (insn)) != 0
714       && SET_DEST (set) == temp
715       && ! rtx_equal_p (x, SET_SRC (set)))
716     set_unique_reg_note (insn, REG_EQUAL, x);
717
718   /* Let optimizers know that TEMP is a pointer, and if so, the
719      known alignment of that pointer.  */
720   {
721     unsigned align = 0;
722     if (GET_CODE (x) == SYMBOL_REF)
723       {
724         align = BITS_PER_UNIT;
725         if (SYMBOL_REF_DECL (x) && DECL_P (SYMBOL_REF_DECL (x)))
726           align = DECL_ALIGN (SYMBOL_REF_DECL (x));
727       }
728     else if (GET_CODE (x) == LABEL_REF)
729       align = BITS_PER_UNIT;
730     else if (GET_CODE (x) == CONST
731              && GET_CODE (XEXP (x, 0)) == PLUS
732              && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
733              && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
734       {
735         rtx s = XEXP (XEXP (x, 0), 0);
736         rtx c = XEXP (XEXP (x, 0), 1);
737         unsigned sa, ca;
738
739         sa = BITS_PER_UNIT;
740         if (SYMBOL_REF_DECL (s) && DECL_P (SYMBOL_REF_DECL (s)))
741           sa = DECL_ALIGN (SYMBOL_REF_DECL (s));
742
743         ca = exact_log2 (INTVAL (c) & -INTVAL (c)) * BITS_PER_UNIT;
744
745         align = MIN (sa, ca);
746       }
747
748     if (align)
749       mark_reg_pointer (temp, align);
750   }
751
752   return temp;
753 }
754
755 /* If X is a memory ref, copy its contents to a new temp reg and return
756    that reg.  Otherwise, return X.  */
757
758 rtx
759 force_not_mem (rtx x)
760 {
761   rtx temp;
762
763   if (!MEM_P (x) || GET_MODE (x) == BLKmode)
764     return x;
765
766   temp = gen_reg_rtx (GET_MODE (x));
767
768   if (MEM_POINTER (x))
769     REG_POINTER (temp) = 1;
770
771   emit_move_insn (temp, x);
772   return temp;
773 }
774
775 /* Copy X to TARGET (if it's nonzero and a reg)
776    or to a new temp reg and return that reg.
777    MODE is the mode to use for X in case it is a constant.  */
778
779 rtx
780 copy_to_suggested_reg (rtx x, rtx target, enum machine_mode mode)
781 {
782   rtx temp;
783
784   if (target && REG_P (target))
785     temp = target;
786   else
787     temp = gen_reg_rtx (mode);
788
789   emit_move_insn (temp, x);
790   return temp;
791 }
792 \f
793 /* Return the mode to use to store a scalar of TYPE and MODE.
794    PUNSIGNEDP points to the signedness of the type and may be adjusted
795    to show what signedness to use on extension operations.
796
797    FOR_CALL is nonzero if this call is promoting args for a call.  */
798
799 #if defined(PROMOTE_MODE) && !defined(PROMOTE_FUNCTION_MODE)
800 #define PROMOTE_FUNCTION_MODE PROMOTE_MODE
801 #endif
802
803 enum machine_mode
804 promote_mode (tree type, enum machine_mode mode, int *punsignedp,
805               int for_call ATTRIBUTE_UNUSED)
806 {
807   enum tree_code code = TREE_CODE (type);
808   int unsignedp = *punsignedp;
809
810 #ifndef PROMOTE_MODE
811   if (! for_call)
812     return mode;
813 #endif
814
815   switch (code)
816     {
817 #ifdef PROMOTE_FUNCTION_MODE
818     case INTEGER_TYPE:   case ENUMERAL_TYPE:   case BOOLEAN_TYPE:
819     case CHAR_TYPE:      case REAL_TYPE:       case OFFSET_TYPE:
820 #ifdef PROMOTE_MODE
821       if (for_call)
822         {
823 #endif
824           PROMOTE_FUNCTION_MODE (mode, unsignedp, type);
825 #ifdef PROMOTE_MODE
826         }
827       else
828         {
829           PROMOTE_MODE (mode, unsignedp, type);
830         }
831 #endif
832       break;
833 #endif
834
835 #ifdef POINTERS_EXTEND_UNSIGNED
836     case REFERENCE_TYPE:
837     case POINTER_TYPE:
838       mode = Pmode;
839       unsignedp = POINTERS_EXTEND_UNSIGNED;
840       break;
841 #endif
842
843     default:
844       break;
845     }
846
847   *punsignedp = unsignedp;
848   return mode;
849 }
850 \f
851 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
852    This pops when ADJUST is positive.  ADJUST need not be constant.  */
853
854 void
855 adjust_stack (rtx adjust)
856 {
857   rtx temp;
858   adjust = protect_from_queue (adjust, 0);
859
860   if (adjust == const0_rtx)
861     return;
862
863   /* We expect all variable sized adjustments to be multiple of
864      PREFERRED_STACK_BOUNDARY.  */
865   if (GET_CODE (adjust) == CONST_INT)
866     stack_pointer_delta -= INTVAL (adjust);
867
868   temp = expand_binop (Pmode,
869 #ifdef STACK_GROWS_DOWNWARD
870                        add_optab,
871 #else
872                        sub_optab,
873 #endif
874                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
875                        OPTAB_LIB_WIDEN);
876
877   if (temp != stack_pointer_rtx)
878     emit_move_insn (stack_pointer_rtx, temp);
879 }
880
881 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
882    This pushes when ADJUST is positive.  ADJUST need not be constant.  */
883
884 void
885 anti_adjust_stack (rtx adjust)
886 {
887   rtx temp;
888   adjust = protect_from_queue (adjust, 0);
889
890   if (adjust == const0_rtx)
891     return;
892
893   /* We expect all variable sized adjustments to be multiple of
894      PREFERRED_STACK_BOUNDARY.  */
895   if (GET_CODE (adjust) == CONST_INT)
896     stack_pointer_delta += INTVAL (adjust);
897
898   temp = expand_binop (Pmode,
899 #ifdef STACK_GROWS_DOWNWARD
900                        sub_optab,
901 #else
902                        add_optab,
903 #endif
904                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
905                        OPTAB_LIB_WIDEN);
906
907   if (temp != stack_pointer_rtx)
908     emit_move_insn (stack_pointer_rtx, temp);
909 }
910
911 /* Round the size of a block to be pushed up to the boundary required
912    by this machine.  SIZE is the desired size, which need not be constant.  */
913
914 rtx
915 round_push (rtx size)
916 {
917   int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
918
919   if (align == 1)
920     return size;
921
922   if (GET_CODE (size) == CONST_INT)
923     {
924       HOST_WIDE_INT new = (INTVAL (size) + align - 1) / align * align;
925
926       if (INTVAL (size) != new)
927         size = GEN_INT (new);
928     }
929   else
930     {
931       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
932          but we know it can't.  So add ourselves and then do
933          TRUNC_DIV_EXPR.  */
934       size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1),
935                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
936       size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align),
937                             NULL_RTX, 1);
938       size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
939     }
940
941   return size;
942 }
943 \f
944 /* Save the stack pointer for the purpose in SAVE_LEVEL.  PSAVE is a pointer
945    to a previously-created save area.  If no save area has been allocated,
946    this function will allocate one.  If a save area is specified, it
947    must be of the proper mode.
948
949    The insns are emitted after insn AFTER, if nonzero, otherwise the insns
950    are emitted at the current position.  */
951
952 void
953 emit_stack_save (enum save_level save_level, rtx *psave, rtx after)
954 {
955   rtx sa = *psave;
956   /* The default is that we use a move insn and save in a Pmode object.  */
957   rtx (*fcn) (rtx, rtx) = gen_move_insn;
958   enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
959
960   /* See if this machine has anything special to do for this kind of save.  */
961   switch (save_level)
962     {
963 #ifdef HAVE_save_stack_block
964     case SAVE_BLOCK:
965       if (HAVE_save_stack_block)
966         fcn = gen_save_stack_block;
967       break;
968 #endif
969 #ifdef HAVE_save_stack_function
970     case SAVE_FUNCTION:
971       if (HAVE_save_stack_function)
972         fcn = gen_save_stack_function;
973       break;
974 #endif
975 #ifdef HAVE_save_stack_nonlocal
976     case SAVE_NONLOCAL:
977       if (HAVE_save_stack_nonlocal)
978         fcn = gen_save_stack_nonlocal;
979       break;
980 #endif
981     default:
982       break;
983     }
984
985   /* If there is no save area and we have to allocate one, do so.  Otherwise
986      verify the save area is the proper mode.  */
987
988   if (sa == 0)
989     {
990       if (mode != VOIDmode)
991         {
992           if (save_level == SAVE_NONLOCAL)
993             *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
994           else
995             *psave = sa = gen_reg_rtx (mode);
996         }
997     }
998
999   if (after)
1000     {
1001       rtx seq;
1002
1003       start_sequence ();
1004       /* We must validize inside the sequence, to ensure that any instructions
1005          created by the validize call also get moved to the right place.  */
1006       if (sa != 0)
1007         sa = validize_mem (sa);
1008       emit_insn (fcn (sa, stack_pointer_rtx));
1009       seq = get_insns ();
1010       end_sequence ();
1011       emit_insn_after (seq, after);
1012     }
1013   else
1014     {
1015       if (sa != 0)
1016         sa = validize_mem (sa);
1017       emit_insn (fcn (sa, stack_pointer_rtx));
1018     }
1019 }
1020
1021 /* Restore the stack pointer for the purpose in SAVE_LEVEL.  SA is the save
1022    area made by emit_stack_save.  If it is zero, we have nothing to do.
1023
1024    Put any emitted insns after insn AFTER, if nonzero, otherwise at
1025    current position.  */
1026
1027 void
1028 emit_stack_restore (enum save_level save_level, rtx sa, rtx after)
1029 {
1030   /* The default is that we use a move insn.  */
1031   rtx (*fcn) (rtx, rtx) = gen_move_insn;
1032
1033   /* See if this machine has anything special to do for this kind of save.  */
1034   switch (save_level)
1035     {
1036 #ifdef HAVE_restore_stack_block
1037     case SAVE_BLOCK:
1038       if (HAVE_restore_stack_block)
1039         fcn = gen_restore_stack_block;
1040       break;
1041 #endif
1042 #ifdef HAVE_restore_stack_function
1043     case SAVE_FUNCTION:
1044       if (HAVE_restore_stack_function)
1045         fcn = gen_restore_stack_function;
1046       break;
1047 #endif
1048 #ifdef HAVE_restore_stack_nonlocal
1049     case SAVE_NONLOCAL:
1050       if (HAVE_restore_stack_nonlocal)
1051         fcn = gen_restore_stack_nonlocal;
1052       break;
1053 #endif
1054     default:
1055       break;
1056     }
1057
1058   if (sa != 0)
1059     {
1060       sa = validize_mem (sa);
1061       /* These clobbers prevent the scheduler from moving
1062          references to variable arrays below the code
1063          that deletes (pops) the arrays.  */
1064       emit_insn (gen_rtx_CLOBBER (VOIDmode,
1065                     gen_rtx_MEM (BLKmode,
1066                         gen_rtx_SCRATCH (VOIDmode))));
1067       emit_insn (gen_rtx_CLOBBER (VOIDmode,
1068                     gen_rtx_MEM (BLKmode, stack_pointer_rtx)));
1069     }
1070
1071   if (after)
1072     {
1073       rtx seq;
1074
1075       start_sequence ();
1076       emit_insn (fcn (stack_pointer_rtx, sa));
1077       seq = get_insns ();
1078       end_sequence ();
1079       emit_insn_after (seq, after);
1080     }
1081   else
1082     emit_insn (fcn (stack_pointer_rtx, sa));
1083 }
1084
1085 /* Invoke emit_stack_save on the nonlocal_goto_save_area for the current
1086    function.  This function should be called whenever we allocate or
1087    deallocate dynamic stack space.  */
1088
1089 void
1090 update_nonlocal_goto_save_area (void)
1091 {
1092   tree t_save;
1093   rtx r_save;
1094
1095   /* The nonlocal_goto_save_area object is an array of N pointers.  The
1096      first one is used for the frame pointer save; the rest are sized by
1097      STACK_SAVEAREA_MODE.  Create a reference to array index 1, the first
1098      of the stack save area slots.  */
1099   t_save = build (ARRAY_REF, ptr_type_node, cfun->nonlocal_goto_save_area,
1100                   integer_one_node, NULL_TREE, NULL_TREE);
1101   r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE);
1102
1103   emit_stack_save (SAVE_NONLOCAL, &r_save, NULL_RTX);
1104 }
1105 \f
1106 #ifdef SETJMP_VIA_SAVE_AREA
1107 /* Optimize RTL generated by allocate_dynamic_stack_space for targets
1108    where SETJMP_VIA_SAVE_AREA is true.  The problem is that on these
1109    platforms, the dynamic stack space used can corrupt the original
1110    frame, thus causing a crash if a longjmp unwinds to it.  */
1111
1112 void
1113 optimize_save_area_alloca (void)
1114 {
1115   rtx insn;
1116
1117   for (insn = get_insns (); insn; insn = NEXT_INSN(insn))
1118     {
1119       rtx note;
1120
1121       if (!NONJUMP_INSN_P (insn))
1122         continue;
1123
1124       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
1125         {
1126           if (REG_NOTE_KIND (note) != REG_SAVE_AREA)
1127             continue;
1128
1129           if (!current_function_calls_setjmp)
1130             {
1131               rtx pat = PATTERN (insn);
1132
1133               /* If we do not see the note in a pattern matching
1134                  these precise characteristics, we did something
1135                  entirely wrong in allocate_dynamic_stack_space.
1136
1137                  Note, one way this could happen is if SETJMP_VIA_SAVE_AREA
1138                  was defined on a machine where stacks grow towards higher
1139                  addresses.
1140
1141                  Right now only supported port with stack that grow upward
1142                  is the HPPA and it does not define SETJMP_VIA_SAVE_AREA.  */
1143               if (GET_CODE (pat) != SET
1144                   || SET_DEST (pat) != stack_pointer_rtx
1145                   || GET_CODE (SET_SRC (pat)) != MINUS
1146                   || XEXP (SET_SRC (pat), 0) != stack_pointer_rtx)
1147                 abort ();
1148
1149               /* This will now be transformed into a (set REG REG)
1150                  so we can just blow away all the other notes.  */
1151               XEXP (SET_SRC (pat), 1) = XEXP (note, 0);
1152               REG_NOTES (insn) = NULL_RTX;
1153             }
1154           else
1155             {
1156               /* setjmp was called, we must remove the REG_SAVE_AREA
1157                  note so that later passes do not get confused by its
1158                  presence.  */
1159               if (note == REG_NOTES (insn))
1160                 {
1161                   REG_NOTES (insn) = XEXP (note, 1);
1162                 }
1163               else
1164                 {
1165                   rtx srch;
1166
1167                   for (srch = REG_NOTES (insn); srch; srch = XEXP (srch, 1))
1168                     if (XEXP (srch, 1) == note)
1169                       break;
1170
1171                   if (srch == NULL_RTX)
1172                     abort ();
1173
1174                   XEXP (srch, 1) = XEXP (note, 1);
1175                 }
1176             }
1177           /* Once we've seen the note of interest, we need not look at
1178              the rest of them.  */
1179           break;
1180         }
1181     }
1182 }
1183 #endif /* SETJMP_VIA_SAVE_AREA */
1184
1185 /* Return an rtx representing the address of an area of memory dynamically
1186    pushed on the stack.  This region of memory is always aligned to
1187    a multiple of BIGGEST_ALIGNMENT.
1188
1189    Any required stack pointer alignment is preserved.
1190
1191    SIZE is an rtx representing the size of the area.
1192    TARGET is a place in which the address can be placed.
1193
1194    KNOWN_ALIGN is the alignment (in bits) that we know SIZE has.  */
1195
1196 rtx
1197 allocate_dynamic_stack_space (rtx size, rtx target, int known_align)
1198 {
1199 #ifdef SETJMP_VIA_SAVE_AREA
1200   rtx setjmpless_size = NULL_RTX;
1201 #endif
1202
1203   /* If we're asking for zero bytes, it doesn't matter what we point
1204      to since we can't dereference it.  But return a reasonable
1205      address anyway.  */
1206   if (size == const0_rtx)
1207     return virtual_stack_dynamic_rtx;
1208
1209   /* Otherwise, show we're calling alloca or equivalent.  */
1210   current_function_calls_alloca = 1;
1211
1212   /* Ensure the size is in the proper mode.  */
1213   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1214     size = convert_to_mode (Pmode, size, 1);
1215
1216   /* We can't attempt to minimize alignment necessary, because we don't
1217      know the final value of preferred_stack_boundary yet while executing
1218      this code.  */
1219   cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
1220
1221   /* We will need to ensure that the address we return is aligned to
1222      BIGGEST_ALIGNMENT.  If STACK_DYNAMIC_OFFSET is defined, we don't
1223      always know its final value at this point in the compilation (it
1224      might depend on the size of the outgoing parameter lists, for
1225      example), so we must align the value to be returned in that case.
1226      (Note that STACK_DYNAMIC_OFFSET will have a default nonzero value if
1227      STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1228      We must also do an alignment operation on the returned value if
1229      the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
1230
1231      If we have to align, we must leave space in SIZE for the hole
1232      that might result from the alignment operation.  */
1233
1234 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET)
1235 #define MUST_ALIGN 1
1236 #else
1237 #define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT)
1238 #endif
1239
1240   if (MUST_ALIGN)
1241     size
1242       = force_operand (plus_constant (size,
1243                                       BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1244                        NULL_RTX);
1245
1246 #ifdef SETJMP_VIA_SAVE_AREA
1247   /* If setjmp restores regs from a save area in the stack frame,
1248      avoid clobbering the reg save area.  Note that the offset of
1249      virtual_incoming_args_rtx includes the preallocated stack args space.
1250      It would be no problem to clobber that, but it's on the wrong side
1251      of the old save area.  */
1252   {
1253     rtx dynamic_offset
1254       = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1255                       stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1256
1257     if (!current_function_calls_setjmp)
1258       {
1259         int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1260
1261         /* See optimize_save_area_alloca to understand what is being
1262            set up here.  */
1263
1264         /* ??? Code below assumes that the save area needs maximal
1265            alignment.  This constraint may be too strong.  */
1266         if (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
1267           abort ();
1268
1269         if (GET_CODE (size) == CONST_INT)
1270           {
1271             HOST_WIDE_INT new = INTVAL (size) / align * align;
1272
1273             if (INTVAL (size) != new)
1274               setjmpless_size = GEN_INT (new);
1275             else
1276               setjmpless_size = size;
1277           }
1278         else
1279           {
1280             /* Since we know overflow is not possible, we avoid using
1281                CEIL_DIV_EXPR and use TRUNC_DIV_EXPR instead.  */
1282             setjmpless_size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size,
1283                                              GEN_INT (align), NULL_RTX, 1);
1284             setjmpless_size = expand_mult (Pmode, setjmpless_size,
1285                                            GEN_INT (align), NULL_RTX, 1);
1286           }
1287         /* Our optimization works based upon being able to perform a simple
1288            transformation of this RTL into a (set REG REG) so make sure things
1289            did in fact end up in a REG.  */
1290         if (!register_operand (setjmpless_size, Pmode))
1291           setjmpless_size = force_reg (Pmode, setjmpless_size);
1292       }
1293
1294     size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1295                          NULL_RTX, 1, OPTAB_LIB_WIDEN);
1296   }
1297 #endif /* SETJMP_VIA_SAVE_AREA */
1298
1299   /* Round the size to a multiple of the required stack alignment.
1300      Since the stack if presumed to be rounded before this allocation,
1301      this will maintain the required alignment.
1302
1303      If the stack grows downward, we could save an insn by subtracting
1304      SIZE from the stack pointer and then aligning the stack pointer.
1305      The problem with this is that the stack pointer may be unaligned
1306      between the execution of the subtraction and alignment insns and
1307      some machines do not allow this.  Even on those that do, some
1308      signal handlers malfunction if a signal should occur between those
1309      insns.  Since this is an extremely rare event, we have no reliable
1310      way of knowing which systems have this problem.  So we avoid even
1311      momentarily mis-aligning the stack.  */
1312
1313   /* If we added a variable amount to SIZE,
1314      we can no longer assume it is aligned.  */
1315 #if !defined (SETJMP_VIA_SAVE_AREA)
1316   if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0)
1317 #endif
1318     size = round_push (size);
1319
1320   do_pending_stack_adjust ();
1321
1322  /* We ought to be called always on the toplevel and stack ought to be aligned
1323     properly.  */
1324   if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))
1325     abort ();
1326
1327   /* If needed, check that we have the required amount of stack.  Take into
1328      account what has already been checked.  */
1329   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
1330     probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
1331
1332   /* Don't use a TARGET that isn't a pseudo or is the wrong mode.  */
1333   if (target == 0 || !REG_P (target)
1334       || REGNO (target) < FIRST_PSEUDO_REGISTER
1335       || GET_MODE (target) != Pmode)
1336     target = gen_reg_rtx (Pmode);
1337
1338   mark_reg_pointer (target, known_align);
1339
1340   /* Perform the required allocation from the stack.  Some systems do
1341      this differently than simply incrementing/decrementing from the
1342      stack pointer, such as acquiring the space by calling malloc().  */
1343 #ifdef HAVE_allocate_stack
1344   if (HAVE_allocate_stack)
1345     {
1346       enum machine_mode mode = STACK_SIZE_MODE;
1347       insn_operand_predicate_fn pred;
1348
1349       /* We don't have to check against the predicate for operand 0 since
1350          TARGET is known to be a pseudo of the proper mode, which must
1351          be valid for the operand.  For operand 1, convert to the
1352          proper mode and validate.  */
1353       if (mode == VOIDmode)
1354         mode = insn_data[(int) CODE_FOR_allocate_stack].operand[1].mode;
1355
1356       pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate;
1357       if (pred && ! ((*pred) (size, mode)))
1358         size = copy_to_mode_reg (mode, convert_to_mode (mode, size, 1));
1359
1360       emit_insn (gen_allocate_stack (target, size));
1361     }
1362   else
1363 #endif
1364     {
1365 #ifndef STACK_GROWS_DOWNWARD
1366       emit_move_insn (target, virtual_stack_dynamic_rtx);
1367 #endif
1368
1369       /* Check stack bounds if necessary.  */
1370       if (current_function_limit_stack)
1371         {
1372           rtx available;
1373           rtx space_available = gen_label_rtx ();
1374 #ifdef STACK_GROWS_DOWNWARD
1375           available = expand_binop (Pmode, sub_optab,
1376                                     stack_pointer_rtx, stack_limit_rtx,
1377                                     NULL_RTX, 1, OPTAB_WIDEN);
1378 #else
1379           available = expand_binop (Pmode, sub_optab,
1380                                     stack_limit_rtx, stack_pointer_rtx,
1381                                     NULL_RTX, 1, OPTAB_WIDEN);
1382 #endif
1383           emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1,
1384                                    space_available);
1385 #ifdef HAVE_trap
1386           if (HAVE_trap)
1387             emit_insn (gen_trap ());
1388           else
1389 #endif
1390             error ("stack limits not supported on this target");
1391           emit_barrier ();
1392           emit_label (space_available);
1393         }
1394
1395       anti_adjust_stack (size);
1396 #ifdef SETJMP_VIA_SAVE_AREA
1397       if (setjmpless_size != NULL_RTX)
1398         {
1399           rtx note_target = get_last_insn ();
1400
1401           REG_NOTES (note_target)
1402             = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
1403                                  REG_NOTES (note_target));
1404         }
1405 #endif /* SETJMP_VIA_SAVE_AREA */
1406
1407 #ifdef STACK_GROWS_DOWNWARD
1408       emit_move_insn (target, virtual_stack_dynamic_rtx);
1409 #endif
1410     }
1411
1412   if (MUST_ALIGN)
1413     {
1414       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1415          but we know it can't.  So add ourselves and then do
1416          TRUNC_DIV_EXPR.  */
1417       target = expand_binop (Pmode, add_optab, target,
1418                              GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1419                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
1420       target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1421                               GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1422                               NULL_RTX, 1);
1423       target = expand_mult (Pmode, target,
1424                             GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1425                             NULL_RTX, 1);
1426     }
1427
1428   /* Record the new stack level for nonlocal gotos.  */
1429   if (cfun->nonlocal_goto_save_area != 0)
1430     update_nonlocal_goto_save_area ();
1431
1432   return target;
1433 }
1434 \f
1435 /* A front end may want to override GCC's stack checking by providing a
1436    run-time routine to call to check the stack, so provide a mechanism for
1437    calling that routine.  */
1438
1439 static GTY(()) rtx stack_check_libfunc;
1440
1441 void
1442 set_stack_check_libfunc (rtx libfunc)
1443 {
1444   stack_check_libfunc = libfunc;
1445 }
1446 \f
1447 /* Emit one stack probe at ADDRESS, an address within the stack.  */
1448
1449 static void
1450 emit_stack_probe (rtx address)
1451 {
1452   rtx memref = gen_rtx_MEM (word_mode, address);
1453
1454   MEM_VOLATILE_P (memref) = 1;
1455
1456   if (STACK_CHECK_PROBE_LOAD)
1457     emit_move_insn (gen_reg_rtx (word_mode), memref);
1458   else
1459     emit_move_insn (memref, const0_rtx);
1460 }
1461
1462 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
1463    FIRST is a constant and size is a Pmode RTX.  These are offsets from the
1464    current stack pointer.  STACK_GROWS_DOWNWARD says whether to add or
1465    subtract from the stack.  If SIZE is constant, this is done
1466    with a fixed number of probes.  Otherwise, we must make a loop.  */
1467
1468 #ifdef STACK_GROWS_DOWNWARD
1469 #define STACK_GROW_OP MINUS
1470 #else
1471 #define STACK_GROW_OP PLUS
1472 #endif
1473
1474 void
1475 probe_stack_range (HOST_WIDE_INT first, rtx size)
1476 {
1477   /* First ensure SIZE is Pmode.  */
1478   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1479     size = convert_to_mode (Pmode, size, 1);
1480
1481   /* Next see if the front end has set up a function for us to call to
1482      check the stack.  */
1483   if (stack_check_libfunc != 0)
1484     {
1485       rtx addr = memory_address (QImode,
1486                                  gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1487                                                  stack_pointer_rtx,
1488                                                  plus_constant (size, first)));
1489
1490       addr = convert_memory_address (ptr_mode, addr);
1491       emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
1492                          ptr_mode);
1493     }
1494
1495   /* Next see if we have an insn to check the stack.  Use it if so.  */
1496 #ifdef HAVE_check_stack
1497   else if (HAVE_check_stack)
1498     {
1499       insn_operand_predicate_fn pred;
1500       rtx last_addr
1501         = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1502                                          stack_pointer_rtx,
1503                                          plus_constant (size, first)),
1504                          NULL_RTX);
1505
1506       pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate;
1507       if (pred && ! ((*pred) (last_addr, Pmode)))
1508         last_addr = copy_to_mode_reg (Pmode, last_addr);
1509
1510       emit_insn (gen_check_stack (last_addr));
1511     }
1512 #endif
1513
1514   /* If we have to generate explicit probes, see if we have a constant
1515      small number of them to generate.  If so, that's the easy case.  */
1516   else if (GET_CODE (size) == CONST_INT
1517            && INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL)
1518     {
1519       HOST_WIDE_INT offset;
1520
1521       /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL
1522          for values of N from 1 until it exceeds LAST.  If only one
1523          probe is needed, this will not generate any code.  Then probe
1524          at LAST.  */
1525       for (offset = first + STACK_CHECK_PROBE_INTERVAL;
1526            offset < INTVAL (size);
1527            offset = offset + STACK_CHECK_PROBE_INTERVAL)
1528         emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1529                                           stack_pointer_rtx,
1530                                           GEN_INT (offset)));
1531
1532       emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1533                                         stack_pointer_rtx,
1534                                         plus_constant (size, first)));
1535     }
1536
1537   /* In the variable case, do the same as above, but in a loop.  We emit loop
1538      notes so that loop optimization can be done.  */
1539   else
1540     {
1541       rtx test_addr
1542         = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1543                                          stack_pointer_rtx,
1544                                          GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)),
1545                          NULL_RTX);
1546       rtx last_addr
1547         = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1548                                          stack_pointer_rtx,
1549                                          plus_constant (size, first)),
1550                          NULL_RTX);
1551       rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL);
1552       rtx loop_lab = gen_label_rtx ();
1553       rtx test_lab = gen_label_rtx ();
1554       rtx end_lab = gen_label_rtx ();
1555       rtx temp;
1556
1557       if (!REG_P (test_addr)
1558           || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
1559         test_addr = force_reg (Pmode, test_addr);
1560
1561       emit_jump (test_lab);
1562
1563       emit_label (loop_lab);
1564       emit_stack_probe (test_addr);
1565
1566 #ifdef STACK_GROWS_DOWNWARD
1567 #define CMP_OPCODE GTU
1568       temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
1569                            1, OPTAB_WIDEN);
1570 #else
1571 #define CMP_OPCODE LTU
1572       temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr,
1573                            1, OPTAB_WIDEN);
1574 #endif
1575
1576       if (temp != test_addr)
1577         abort ();
1578
1579       emit_label (test_lab);
1580       emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
1581                                NULL_RTX, Pmode, 1, loop_lab);
1582       emit_jump (end_lab);
1583       emit_label (end_lab);
1584
1585       emit_stack_probe (last_addr);
1586     }
1587 }
1588 \f
1589 /* Return an rtx representing the register or memory location
1590    in which a scalar value of data type VALTYPE
1591    was returned by a function call to function FUNC.
1592    FUNC is a FUNCTION_DECL node if the precise function is known,
1593    otherwise 0.
1594    OUTGOING is 1 if on a machine with register windows this function
1595    should return the register in which the function will put its result
1596    and 0 otherwise.  */
1597
1598 rtx
1599 hard_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
1600                      int outgoing ATTRIBUTE_UNUSED)
1601 {
1602   rtx val;
1603
1604 #ifdef FUNCTION_OUTGOING_VALUE
1605   if (outgoing)
1606     val = FUNCTION_OUTGOING_VALUE (valtype, func);
1607   else
1608 #endif
1609     val = FUNCTION_VALUE (valtype, func);
1610
1611   if (REG_P (val)
1612       && GET_MODE (val) == BLKmode)
1613     {
1614       unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
1615       enum machine_mode tmpmode;
1616
1617       /* int_size_in_bytes can return -1.  We don't need a check here
1618          since the value of bytes will be large enough that no mode
1619          will match and we will abort later in this function.  */
1620
1621       for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1622            tmpmode != VOIDmode;
1623            tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1624         {
1625           /* Have we found a large enough mode?  */
1626           if (GET_MODE_SIZE (tmpmode) >= bytes)
1627             break;
1628         }
1629
1630       /* No suitable mode found.  */
1631       if (tmpmode == VOIDmode)
1632         abort ();
1633
1634       PUT_MODE (val, tmpmode);
1635     }
1636   return val;
1637 }
1638
1639 /* Return an rtx representing the register or memory location
1640    in which a scalar value of mode MODE was returned by a library call.  */
1641
1642 rtx
1643 hard_libcall_value (enum machine_mode mode)
1644 {
1645   return LIBCALL_VALUE (mode);
1646 }
1647
1648 /* Look up the tree code for a given rtx code
1649    to provide the arithmetic operation for REAL_ARITHMETIC.
1650    The function returns an int because the caller may not know
1651    what `enum tree_code' means.  */
1652
1653 int
1654 rtx_to_tree_code (enum rtx_code code)
1655 {
1656   enum tree_code tcode;
1657
1658   switch (code)
1659     {
1660     case PLUS:
1661       tcode = PLUS_EXPR;
1662       break;
1663     case MINUS:
1664       tcode = MINUS_EXPR;
1665       break;
1666     case MULT:
1667       tcode = MULT_EXPR;
1668       break;
1669     case DIV:
1670       tcode = RDIV_EXPR;
1671       break;
1672     case SMIN:
1673       tcode = MIN_EXPR;
1674       break;
1675     case SMAX:
1676       tcode = MAX_EXPR;
1677       break;
1678     default:
1679       tcode = LAST_AND_UNUSED_TREE_CODE;
1680       break;
1681     }
1682   return ((int) tcode);
1683 }
1684
1685 #include "gt-explow.h"