OSDN Git Service

* explow.c (probe_stack_range): Restore simple control flow and stop
[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, 1999, 2000,
3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "diagnostic-core.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "tm_p.h"
31 #include "flags.h"
32 #include "except.h"
33 #include "function.h"
34 #include "expr.h"
35 #include "optabs.h"
36 #include "libfuncs.h"
37 #include "hard-reg-set.h"
38 #include "insn-config.h"
39 #include "ggc.h"
40 #include "recog.h"
41 #include "langhooks.h"
42 #include "target.h"
43 #include "common/common-target.h"
44 #include "output.h"
45
46 static rtx break_out_memory_refs (rtx);
47
48
49 /* Truncate and perhaps sign-extend C as appropriate for MODE.  */
50
51 HOST_WIDE_INT
52 trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode)
53 {
54   int width = GET_MODE_PRECISION (mode);
55
56   /* You want to truncate to a _what_?  */
57   gcc_assert (SCALAR_INT_MODE_P (mode));
58
59   /* Canonicalize BImode to 0 and STORE_FLAG_VALUE.  */
60   if (mode == BImode)
61     return c & 1 ? STORE_FLAG_VALUE : 0;
62
63   /* Sign-extend for the requested mode.  */
64
65   if (width < HOST_BITS_PER_WIDE_INT)
66     {
67       HOST_WIDE_INT sign = 1;
68       sign <<= width - 1;
69       c &= (sign << 1) - 1;
70       c ^= sign;
71       c -= sign;
72     }
73
74   return c;
75 }
76
77 /* Return an rtx for the sum of X and the integer C.  */
78
79 rtx
80 plus_constant (rtx x, HOST_WIDE_INT c)
81 {
82   RTX_CODE code;
83   rtx y;
84   enum machine_mode mode;
85   rtx tem;
86   int all_constant = 0;
87
88   if (c == 0)
89     return x;
90
91  restart:
92
93   code = GET_CODE (x);
94   mode = GET_MODE (x);
95   y = x;
96
97   switch (code)
98     {
99     case CONST_INT:
100       return GEN_INT (INTVAL (x) + c);
101
102     case CONST_DOUBLE:
103       {
104         unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
105         HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
106         unsigned HOST_WIDE_INT l2 = c;
107         HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
108         unsigned HOST_WIDE_INT lv;
109         HOST_WIDE_INT hv;
110
111         add_double (l1, h1, l2, h2, &lv, &hv);
112
113         return immed_double_const (lv, hv, VOIDmode);
114       }
115
116     case MEM:
117       /* If this is a reference to the constant pool, try replacing it with
118          a reference to a new constant.  If the resulting address isn't
119          valid, don't return it because we have no way to validize it.  */
120       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
121           && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
122         {
123           tem
124             = force_const_mem (GET_MODE (x),
125                                plus_constant (get_pool_constant (XEXP (x, 0)),
126                                               c));
127           if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
128             return tem;
129         }
130       break;
131
132     case CONST:
133       /* If adding to something entirely constant, set a flag
134          so that we can add a CONST around the result.  */
135       x = XEXP (x, 0);
136       all_constant = 1;
137       goto restart;
138
139     case SYMBOL_REF:
140     case LABEL_REF:
141       all_constant = 1;
142       break;
143
144     case PLUS:
145       /* The interesting case is adding the integer to a sum.
146          Look for constant term in the sum and combine
147          with C.  For an integer constant term, we make a combined
148          integer.  For a constant term that is not an explicit integer,
149          we cannot really combine, but group them together anyway.
150
151          Restart or use a recursive call in case the remaining operand is
152          something that we handle specially, such as a SYMBOL_REF.
153
154          We may not immediately return from the recursive call here, lest
155          all_constant gets lost.  */
156
157       if (CONST_INT_P (XEXP (x, 1)))
158         {
159           c += INTVAL (XEXP (x, 1));
160
161           if (GET_MODE (x) != VOIDmode)
162             c = trunc_int_for_mode (c, GET_MODE (x));
163
164           x = XEXP (x, 0);
165           goto restart;
166         }
167       else if (CONSTANT_P (XEXP (x, 1)))
168         {
169           x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
170           c = 0;
171         }
172       else if (find_constant_term_loc (&y))
173         {
174           /* We need to be careful since X may be shared and we can't
175              modify it in place.  */
176           rtx copy = copy_rtx (x);
177           rtx *const_loc = find_constant_term_loc (&copy);
178
179           *const_loc = plus_constant (*const_loc, c);
180           x = copy;
181           c = 0;
182         }
183       break;
184
185     default:
186       break;
187     }
188
189   if (c != 0)
190     x = gen_rtx_PLUS (mode, x, GEN_INT (c));
191
192   if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
193     return x;
194   else if (all_constant)
195     return gen_rtx_CONST (mode, x);
196   else
197     return x;
198 }
199 \f
200 /* If X is a sum, return a new sum like X but lacking any constant terms.
201    Add all the removed constant terms into *CONSTPTR.
202    X itself is not altered.  The result != X if and only if
203    it is not isomorphic to X.  */
204
205 rtx
206 eliminate_constant_term (rtx x, rtx *constptr)
207 {
208   rtx x0, x1;
209   rtx tem;
210
211   if (GET_CODE (x) != PLUS)
212     return x;
213
214   /* First handle constants appearing at this level explicitly.  */
215   if (CONST_INT_P (XEXP (x, 1))
216       && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
217                                                 XEXP (x, 1)))
218       && CONST_INT_P (tem))
219     {
220       *constptr = tem;
221       return eliminate_constant_term (XEXP (x, 0), constptr);
222     }
223
224   tem = const0_rtx;
225   x0 = eliminate_constant_term (XEXP (x, 0), &tem);
226   x1 = eliminate_constant_term (XEXP (x, 1), &tem);
227   if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
228       && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
229                                                 *constptr, tem))
230       && CONST_INT_P (tem))
231     {
232       *constptr = tem;
233       return gen_rtx_PLUS (GET_MODE (x), x0, x1);
234     }
235
236   return x;
237 }
238
239 /* Return an rtx for the size in bytes of the value of EXP.  */
240
241 rtx
242 expr_size (tree exp)
243 {
244   tree size;
245
246   if (TREE_CODE (exp) == WITH_SIZE_EXPR)
247     size = TREE_OPERAND (exp, 1);
248   else
249     {
250       size = tree_expr_size (exp);
251       gcc_assert (size);
252       gcc_assert (size == SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, exp));
253     }
254
255   return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), EXPAND_NORMAL);
256 }
257
258 /* Return a wide integer for the size in bytes of the value of EXP, or -1
259    if the size can vary or is larger than an integer.  */
260
261 HOST_WIDE_INT
262 int_expr_size (tree exp)
263 {
264   tree size;
265
266   if (TREE_CODE (exp) == WITH_SIZE_EXPR)
267     size = TREE_OPERAND (exp, 1);
268   else
269     {
270       size = tree_expr_size (exp);
271       gcc_assert (size);
272     }
273
274   if (size == 0 || !host_integerp (size, 0))
275     return -1;
276
277   return tree_low_cst (size, 0);
278 }
279 \f
280 /* Return a copy of X in which all memory references
281    and all constants that involve symbol refs
282    have been replaced with new temporary registers.
283    Also emit code to load the memory locations and constants
284    into those registers.
285
286    If X contains no such constants or memory references,
287    X itself (not a copy) is returned.
288
289    If a constant is found in the address that is not a legitimate constant
290    in an insn, it is left alone in the hope that it might be valid in the
291    address.
292
293    X may contain no arithmetic except addition, subtraction and multiplication.
294    Values returned by expand_expr with 1 for sum_ok fit this constraint.  */
295
296 static rtx
297 break_out_memory_refs (rtx x)
298 {
299   if (MEM_P (x)
300       || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
301           && GET_MODE (x) != VOIDmode))
302     x = force_reg (GET_MODE (x), x);
303   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
304            || GET_CODE (x) == MULT)
305     {
306       rtx op0 = break_out_memory_refs (XEXP (x, 0));
307       rtx op1 = break_out_memory_refs (XEXP (x, 1));
308
309       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
310         x = simplify_gen_binary (GET_CODE (x), GET_MODE (x), op0, op1);
311     }
312
313   return x;
314 }
315
316 /* Given X, a memory address in address space AS' pointer mode, convert it to
317    an address in the address space's address mode, or vice versa (TO_MODE says
318    which way).  We take advantage of the fact that pointers are not allowed to
319    overflow by commuting arithmetic operations over conversions so that address
320    arithmetic insns can be used.  */
321
322 rtx
323 convert_memory_address_addr_space (enum machine_mode to_mode ATTRIBUTE_UNUSED,
324                                    rtx x, addr_space_t as ATTRIBUTE_UNUSED)
325 {
326 #ifndef POINTERS_EXTEND_UNSIGNED
327   gcc_assert (GET_MODE (x) == to_mode || GET_MODE (x) == VOIDmode);
328   return x;
329 #else /* defined(POINTERS_EXTEND_UNSIGNED) */
330   enum machine_mode pointer_mode, address_mode, from_mode;
331   rtx temp;
332   enum rtx_code code;
333
334   /* If X already has the right mode, just return it.  */
335   if (GET_MODE (x) == to_mode)
336     return x;
337
338   pointer_mode = targetm.addr_space.pointer_mode (as);
339   address_mode = targetm.addr_space.address_mode (as);
340   from_mode = to_mode == pointer_mode ? address_mode : pointer_mode;
341
342   /* Here we handle some special cases.  If none of them apply, fall through
343      to the default case.  */
344   switch (GET_CODE (x))
345     {
346     case CONST_INT:
347     case CONST_DOUBLE:
348       if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode))
349         code = TRUNCATE;
350       else if (POINTERS_EXTEND_UNSIGNED < 0)
351         break;
352       else if (POINTERS_EXTEND_UNSIGNED > 0)
353         code = ZERO_EXTEND;
354       else
355         code = SIGN_EXTEND;
356       temp = simplify_unary_operation (code, to_mode, x, from_mode);
357       if (temp)
358         return temp;
359       break;
360
361     case SUBREG:
362       if ((SUBREG_PROMOTED_VAR_P (x) || REG_POINTER (SUBREG_REG (x)))
363           && GET_MODE (SUBREG_REG (x)) == to_mode)
364         return SUBREG_REG (x);
365       break;
366
367     case LABEL_REF:
368       temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
369       LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
370       return temp;
371       break;
372
373     case SYMBOL_REF:
374       temp = shallow_copy_rtx (x);
375       PUT_MODE (temp, to_mode);
376       return temp;
377       break;
378
379     case CONST:
380       return gen_rtx_CONST (to_mode,
381                             convert_memory_address_addr_space
382                               (to_mode, XEXP (x, 0), as));
383       break;
384
385     case PLUS:
386     case MULT:
387       /* FIXME: For addition, we used to permute the conversion and
388          addition operation only if one operand is a constant and
389          converting the constant does not change it or if one operand
390          is a constant and we are using a ptr_extend instruction
391          (POINTERS_EXTEND_UNSIGNED < 0) even if the resulting address
392          may overflow/underflow.  We relax the condition to include
393          zero-extend (POINTERS_EXTEND_UNSIGNED > 0) since the other
394          parts of the compiler depend on it.  See PR 49721.
395
396          We can always safely permute them if we are making the address
397          narrower.  */
398       if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
399           || (GET_CODE (x) == PLUS
400               && CONST_INT_P (XEXP (x, 1))
401               && (POINTERS_EXTEND_UNSIGNED != 0
402                   || XEXP (x, 1) == convert_memory_address_addr_space
403                                         (to_mode, XEXP (x, 1), as))))
404         return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
405                                convert_memory_address_addr_space
406                                  (to_mode, XEXP (x, 0), as),
407                                XEXP (x, 1));
408       break;
409
410     default:
411       break;
412     }
413
414   return convert_modes (to_mode, from_mode,
415                         x, POINTERS_EXTEND_UNSIGNED);
416 #endif /* defined(POINTERS_EXTEND_UNSIGNED) */
417 }
418 \f
419 /* Return something equivalent to X but valid as a memory address for something
420    of mode MODE in the named address space AS.  When X is not itself valid,
421    this works by copying X or subexpressions of it into registers.  */
422
423 rtx
424 memory_address_addr_space (enum machine_mode mode, rtx x, addr_space_t as)
425 {
426   rtx oldx = x;
427   enum machine_mode address_mode = targetm.addr_space.address_mode (as);
428
429   x = convert_memory_address_addr_space (address_mode, x, as);
430
431   /* By passing constant addresses through registers
432      we get a chance to cse them.  */
433   if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
434     x = force_reg (address_mode, x);
435
436   /* We get better cse by rejecting indirect addressing at this stage.
437      Let the combiner create indirect addresses where appropriate.
438      For now, generate the code so that the subexpressions useful to share
439      are visible.  But not if cse won't be done!  */
440   else
441     {
442       if (! cse_not_expected && !REG_P (x))
443         x = break_out_memory_refs (x);
444
445       /* At this point, any valid address is accepted.  */
446       if (memory_address_addr_space_p (mode, x, as))
447         goto done;
448
449       /* If it was valid before but breaking out memory refs invalidated it,
450          use it the old way.  */
451       if (memory_address_addr_space_p (mode, oldx, as))
452         {
453           x = oldx;
454           goto done;
455         }
456
457       /* Perform machine-dependent transformations on X
458          in certain cases.  This is not necessary since the code
459          below can handle all possible cases, but machine-dependent
460          transformations can make better code.  */
461       {
462         rtx orig_x = x;
463         x = targetm.addr_space.legitimize_address (x, oldx, mode, as);
464         if (orig_x != x && memory_address_addr_space_p (mode, x, as))
465           goto done;
466       }
467
468       /* PLUS and MULT can appear in special ways
469          as the result of attempts to make an address usable for indexing.
470          Usually they are dealt with by calling force_operand, below.
471          But a sum containing constant terms is special
472          if removing them makes the sum a valid address:
473          then we generate that address in a register
474          and index off of it.  We do this because it often makes
475          shorter code, and because the addresses thus generated
476          in registers often become common subexpressions.  */
477       if (GET_CODE (x) == PLUS)
478         {
479           rtx constant_term = const0_rtx;
480           rtx y = eliminate_constant_term (x, &constant_term);
481           if (constant_term == const0_rtx
482               || ! memory_address_addr_space_p (mode, y, as))
483             x = force_operand (x, NULL_RTX);
484           else
485             {
486               y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term);
487               if (! memory_address_addr_space_p (mode, y, as))
488                 x = force_operand (x, NULL_RTX);
489               else
490                 x = y;
491             }
492         }
493
494       else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
495         x = force_operand (x, NULL_RTX);
496
497       /* If we have a register that's an invalid address,
498          it must be a hard reg of the wrong class.  Copy it to a pseudo.  */
499       else if (REG_P (x))
500         x = copy_to_reg (x);
501
502       /* Last resort: copy the value to a register, since
503          the register is a valid address.  */
504       else
505         x = force_reg (address_mode, x);
506     }
507
508  done:
509
510   gcc_assert (memory_address_addr_space_p (mode, x, as));
511   /* If we didn't change the address, we are done.  Otherwise, mark
512      a reg as a pointer if we have REG or REG + CONST_INT.  */
513   if (oldx == x)
514     return x;
515   else if (REG_P (x))
516     mark_reg_pointer (x, BITS_PER_UNIT);
517   else if (GET_CODE (x) == PLUS
518            && REG_P (XEXP (x, 0))
519            && CONST_INT_P (XEXP (x, 1)))
520     mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
521
522   /* OLDX may have been the address on a temporary.  Update the address
523      to indicate that X is now used.  */
524   update_temp_slot_address (oldx, x);
525
526   return x;
527 }
528
529 /* Convert a mem ref into one with a valid memory address.
530    Pass through anything else unchanged.  */
531
532 rtx
533 validize_mem (rtx ref)
534 {
535   if (!MEM_P (ref))
536     return ref;
537   ref = use_anchored_address (ref);
538   if (memory_address_addr_space_p (GET_MODE (ref), XEXP (ref, 0),
539                                    MEM_ADDR_SPACE (ref)))
540     return ref;
541
542   /* Don't alter REF itself, since that is probably a stack slot.  */
543   return replace_equiv_address (ref, XEXP (ref, 0));
544 }
545
546 /* If X is a memory reference to a member of an object block, try rewriting
547    it to use an anchor instead.  Return the new memory reference on success
548    and the old one on failure.  */
549
550 rtx
551 use_anchored_address (rtx x)
552 {
553   rtx base;
554   HOST_WIDE_INT offset;
555
556   if (!flag_section_anchors)
557     return x;
558
559   if (!MEM_P (x))
560     return x;
561
562   /* Split the address into a base and offset.  */
563   base = XEXP (x, 0);
564   offset = 0;
565   if (GET_CODE (base) == CONST
566       && GET_CODE (XEXP (base, 0)) == PLUS
567       && CONST_INT_P (XEXP (XEXP (base, 0), 1)))
568     {
569       offset += INTVAL (XEXP (XEXP (base, 0), 1));
570       base = XEXP (XEXP (base, 0), 0);
571     }
572
573   /* Check whether BASE is suitable for anchors.  */
574   if (GET_CODE (base) != SYMBOL_REF
575       || !SYMBOL_REF_HAS_BLOCK_INFO_P (base)
576       || SYMBOL_REF_ANCHOR_P (base)
577       || SYMBOL_REF_BLOCK (base) == NULL
578       || !targetm.use_anchors_for_symbol_p (base))
579     return x;
580
581   /* Decide where BASE is going to be.  */
582   place_block_symbol (base);
583
584   /* Get the anchor we need to use.  */
585   offset += SYMBOL_REF_BLOCK_OFFSET (base);
586   base = get_section_anchor (SYMBOL_REF_BLOCK (base), offset,
587                              SYMBOL_REF_TLS_MODEL (base));
588
589   /* Work out the offset from the anchor.  */
590   offset -= SYMBOL_REF_BLOCK_OFFSET (base);
591
592   /* If we're going to run a CSE pass, force the anchor into a register.
593      We will then be able to reuse registers for several accesses, if the
594      target costs say that that's worthwhile.  */
595   if (!cse_not_expected)
596     base = force_reg (GET_MODE (base), base);
597
598   return replace_equiv_address (x, plus_constant (base, offset));
599 }
600 \f
601 /* Copy the value or contents of X to a new temp reg and return that reg.  */
602
603 rtx
604 copy_to_reg (rtx x)
605 {
606   rtx temp = gen_reg_rtx (GET_MODE (x));
607
608   /* If not an operand, must be an address with PLUS and MULT so
609      do the computation.  */
610   if (! general_operand (x, VOIDmode))
611     x = force_operand (x, temp);
612
613   if (x != temp)
614     emit_move_insn (temp, x);
615
616   return temp;
617 }
618
619 /* Like copy_to_reg but always give the new register mode Pmode
620    in case X is a constant.  */
621
622 rtx
623 copy_addr_to_reg (rtx x)
624 {
625   return copy_to_mode_reg (Pmode, x);
626 }
627
628 /* Like copy_to_reg but always give the new register mode MODE
629    in case X is a constant.  */
630
631 rtx
632 copy_to_mode_reg (enum machine_mode mode, rtx x)
633 {
634   rtx temp = gen_reg_rtx (mode);
635
636   /* If not an operand, must be an address with PLUS and MULT so
637      do the computation.  */
638   if (! general_operand (x, VOIDmode))
639     x = force_operand (x, temp);
640
641   gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode);
642   if (x != temp)
643     emit_move_insn (temp, x);
644   return temp;
645 }
646
647 /* Load X into a register if it is not already one.
648    Use mode MODE for the register.
649    X should be valid for mode MODE, but it may be a constant which
650    is valid for all integer modes; that's why caller must specify MODE.
651
652    The caller must not alter the value in the register we return,
653    since we mark it as a "constant" register.  */
654
655 rtx
656 force_reg (enum machine_mode mode, rtx x)
657 {
658   rtx temp, insn, set;
659
660   if (REG_P (x))
661     return x;
662
663   if (general_operand (x, mode))
664     {
665       temp = gen_reg_rtx (mode);
666       insn = emit_move_insn (temp, x);
667     }
668   else
669     {
670       temp = force_operand (x, NULL_RTX);
671       if (REG_P (temp))
672         insn = get_last_insn ();
673       else
674         {
675           rtx temp2 = gen_reg_rtx (mode);
676           insn = emit_move_insn (temp2, temp);
677           temp = temp2;
678         }
679     }
680
681   /* Let optimizers know that TEMP's value never changes
682      and that X can be substituted for it.  Don't get confused
683      if INSN set something else (such as a SUBREG of TEMP).  */
684   if (CONSTANT_P (x)
685       && (set = single_set (insn)) != 0
686       && SET_DEST (set) == temp
687       && ! rtx_equal_p (x, SET_SRC (set)))
688     set_unique_reg_note (insn, REG_EQUAL, x);
689
690   /* Let optimizers know that TEMP is a pointer, and if so, the
691      known alignment of that pointer.  */
692   {
693     unsigned align = 0;
694     if (GET_CODE (x) == SYMBOL_REF)
695       {
696         align = BITS_PER_UNIT;
697         if (SYMBOL_REF_DECL (x) && DECL_P (SYMBOL_REF_DECL (x)))
698           align = DECL_ALIGN (SYMBOL_REF_DECL (x));
699       }
700     else if (GET_CODE (x) == LABEL_REF)
701       align = BITS_PER_UNIT;
702     else if (GET_CODE (x) == CONST
703              && GET_CODE (XEXP (x, 0)) == PLUS
704              && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
705              && CONST_INT_P (XEXP (XEXP (x, 0), 1)))
706       {
707         rtx s = XEXP (XEXP (x, 0), 0);
708         rtx c = XEXP (XEXP (x, 0), 1);
709         unsigned sa, ca;
710
711         sa = BITS_PER_UNIT;
712         if (SYMBOL_REF_DECL (s) && DECL_P (SYMBOL_REF_DECL (s)))
713           sa = DECL_ALIGN (SYMBOL_REF_DECL (s));
714
715         if (INTVAL (c) == 0)
716           align = sa;
717         else
718           {
719             ca = ctz_hwi (INTVAL (c)) * BITS_PER_UNIT;
720             align = MIN (sa, ca);
721           }
722       }
723
724     if (align || (MEM_P (x) && MEM_POINTER (x)))
725       mark_reg_pointer (temp, align);
726   }
727
728   return temp;
729 }
730
731 /* If X is a memory ref, copy its contents to a new temp reg and return
732    that reg.  Otherwise, return X.  */
733
734 rtx
735 force_not_mem (rtx x)
736 {
737   rtx temp;
738
739   if (!MEM_P (x) || GET_MODE (x) == BLKmode)
740     return x;
741
742   temp = gen_reg_rtx (GET_MODE (x));
743
744   if (MEM_POINTER (x))
745     REG_POINTER (temp) = 1;
746
747   emit_move_insn (temp, x);
748   return temp;
749 }
750
751 /* Copy X to TARGET (if it's nonzero and a reg)
752    or to a new temp reg and return that reg.
753    MODE is the mode to use for X in case it is a constant.  */
754
755 rtx
756 copy_to_suggested_reg (rtx x, rtx target, enum machine_mode mode)
757 {
758   rtx temp;
759
760   if (target && REG_P (target))
761     temp = target;
762   else
763     temp = gen_reg_rtx (mode);
764
765   emit_move_insn (temp, x);
766   return temp;
767 }
768 \f
769 /* Return the mode to use to pass or return a scalar of TYPE and MODE.
770    PUNSIGNEDP points to the signedness of the type and may be adjusted
771    to show what signedness to use on extension operations.
772
773    FOR_RETURN is nonzero if the caller is promoting the return value
774    of FNDECL, else it is for promoting args.  */
775
776 enum machine_mode
777 promote_function_mode (const_tree type, enum machine_mode mode, int *punsignedp,
778                        const_tree funtype, int for_return)
779 {
780   /* Called without a type node for a libcall.  */
781   if (type == NULL_TREE)
782     {
783       if (INTEGRAL_MODE_P (mode))
784         return targetm.calls.promote_function_mode (NULL_TREE, mode,
785                                                     punsignedp, funtype,
786                                                     for_return);
787       else
788         return mode;
789     }
790
791   switch (TREE_CODE (type))
792     {
793     case INTEGER_TYPE:   case ENUMERAL_TYPE:   case BOOLEAN_TYPE:
794     case REAL_TYPE:      case OFFSET_TYPE:     case FIXED_POINT_TYPE:
795     case POINTER_TYPE:   case REFERENCE_TYPE:
796       return targetm.calls.promote_function_mode (type, mode, punsignedp, funtype,
797                                                   for_return);
798
799     default:
800       return mode;
801     }
802 }
803 /* Return the mode to use to store a scalar of TYPE and MODE.
804    PUNSIGNEDP points to the signedness of the type and may be adjusted
805    to show what signedness to use on extension operations.  */
806
807 enum machine_mode
808 promote_mode (const_tree type ATTRIBUTE_UNUSED, enum machine_mode mode,
809               int *punsignedp ATTRIBUTE_UNUSED)
810 {
811 #ifdef PROMOTE_MODE
812   enum tree_code code;
813   int unsignedp;
814 #endif
815
816   /* For libcalls this is invoked without TYPE from the backends
817      TARGET_PROMOTE_FUNCTION_MODE hooks.  Don't do anything in that
818      case.  */
819   if (type == NULL_TREE)
820     return mode;
821
822   /* FIXME: this is the same logic that was there until GCC 4.4, but we
823      probably want to test POINTERS_EXTEND_UNSIGNED even if PROMOTE_MODE
824      is not defined.  The affected targets are M32C, S390, SPARC.  */
825 #ifdef PROMOTE_MODE
826   code = TREE_CODE (type);
827   unsignedp = *punsignedp;
828
829   switch (code)
830     {
831     case INTEGER_TYPE:   case ENUMERAL_TYPE:   case BOOLEAN_TYPE:
832     case REAL_TYPE:      case OFFSET_TYPE:     case FIXED_POINT_TYPE:
833       PROMOTE_MODE (mode, unsignedp, type);
834       *punsignedp = unsignedp;
835       return mode;
836       break;
837
838 #ifdef POINTERS_EXTEND_UNSIGNED
839     case REFERENCE_TYPE:
840     case POINTER_TYPE:
841       *punsignedp = POINTERS_EXTEND_UNSIGNED;
842       return targetm.addr_space.address_mode
843                (TYPE_ADDR_SPACE (TREE_TYPE (type)));
844       break;
845 #endif
846
847     default:
848       return mode;
849     }
850 #else
851   return mode;
852 #endif
853 }
854
855
856 /* Use one of promote_mode or promote_function_mode to find the promoted
857    mode of DECL.  If PUNSIGNEDP is not NULL, store there the unsignedness
858    of DECL after promotion.  */
859
860 enum machine_mode
861 promote_decl_mode (const_tree decl, int *punsignedp)
862 {
863   tree type = TREE_TYPE (decl);
864   int unsignedp = TYPE_UNSIGNED (type);
865   enum machine_mode mode = DECL_MODE (decl);
866   enum machine_mode pmode;
867
868   if (TREE_CODE (decl) == RESULT_DECL
869       || TREE_CODE (decl) == PARM_DECL)
870     pmode = promote_function_mode (type, mode, &unsignedp,
871                                    TREE_TYPE (current_function_decl), 2);
872   else
873     pmode = promote_mode (type, mode, &unsignedp);
874
875   if (punsignedp)
876     *punsignedp = unsignedp;
877   return pmode;
878 }
879
880 \f
881 /* Controls the behaviour of {anti_,}adjust_stack.  */
882 static bool suppress_reg_args_size;
883
884 /* A helper for adjust_stack and anti_adjust_stack.  */
885
886 static void
887 adjust_stack_1 (rtx adjust, bool anti_p)
888 {
889   rtx temp, insn;
890
891 #ifndef STACK_GROWS_DOWNWARD
892   /* Hereafter anti_p means subtract_p.  */
893   anti_p = !anti_p;
894 #endif
895
896   temp = expand_binop (Pmode,
897                        anti_p ? sub_optab : add_optab,
898                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
899                        OPTAB_LIB_WIDEN);
900
901   if (temp != stack_pointer_rtx)
902     insn = emit_move_insn (stack_pointer_rtx, temp);
903   else
904     {
905       insn = get_last_insn ();
906       temp = single_set (insn);
907       gcc_assert (temp != NULL && SET_DEST (temp) == stack_pointer_rtx);
908     }
909
910   if (!suppress_reg_args_size)
911     add_reg_note (insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
912 }
913
914 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
915    This pops when ADJUST is positive.  ADJUST need not be constant.  */
916
917 void
918 adjust_stack (rtx adjust)
919 {
920   if (adjust == const0_rtx)
921     return;
922
923   /* We expect all variable sized adjustments to be multiple of
924      PREFERRED_STACK_BOUNDARY.  */
925   if (CONST_INT_P (adjust))
926     stack_pointer_delta -= INTVAL (adjust);
927
928   adjust_stack_1 (adjust, false);
929 }
930
931 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
932    This pushes when ADJUST is positive.  ADJUST need not be constant.  */
933
934 void
935 anti_adjust_stack (rtx adjust)
936 {
937   if (adjust == const0_rtx)
938     return;
939
940   /* We expect all variable sized adjustments to be multiple of
941      PREFERRED_STACK_BOUNDARY.  */
942   if (CONST_INT_P (adjust))
943     stack_pointer_delta += INTVAL (adjust);
944
945   adjust_stack_1 (adjust, true);
946 }
947
948 /* Round the size of a block to be pushed up to the boundary required
949    by this machine.  SIZE is the desired size, which need not be constant.  */
950
951 static rtx
952 round_push (rtx size)
953 {
954   rtx align_rtx, alignm1_rtx;
955
956   if (!SUPPORTS_STACK_ALIGNMENT
957       || crtl->preferred_stack_boundary == MAX_SUPPORTED_STACK_ALIGNMENT)
958     {
959       int align = crtl->preferred_stack_boundary / BITS_PER_UNIT;
960
961       if (align == 1)
962         return size;
963
964       if (CONST_INT_P (size))
965         {
966           HOST_WIDE_INT new_size = (INTVAL (size) + align - 1) / align * align;
967
968           if (INTVAL (size) != new_size)
969             size = GEN_INT (new_size);
970           return size;
971         }
972
973       align_rtx = GEN_INT (align);
974       alignm1_rtx = GEN_INT (align - 1);
975     }
976   else
977     {
978       /* If crtl->preferred_stack_boundary might still grow, use
979          virtual_preferred_stack_boundary_rtx instead.  This will be
980          substituted by the right value in vregs pass and optimized
981          during combine.  */
982       align_rtx = virtual_preferred_stack_boundary_rtx;
983       alignm1_rtx = force_operand (plus_constant (align_rtx, -1), NULL_RTX);
984     }
985
986   /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
987      but we know it can't.  So add ourselves and then do
988      TRUNC_DIV_EXPR.  */
989   size = expand_binop (Pmode, add_optab, size, alignm1_rtx,
990                        NULL_RTX, 1, OPTAB_LIB_WIDEN);
991   size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, align_rtx,
992                         NULL_RTX, 1);
993   size = expand_mult (Pmode, size, align_rtx, NULL_RTX, 1);
994
995   return size;
996 }
997 \f
998 /* Save the stack pointer for the purpose in SAVE_LEVEL.  PSAVE is a pointer
999    to a previously-created save area.  If no save area has been allocated,
1000    this function will allocate one.  If a save area is specified, it
1001    must be of the proper mode.  */
1002
1003 void
1004 emit_stack_save (enum save_level save_level, rtx *psave)
1005 {
1006   rtx sa = *psave;
1007   /* The default is that we use a move insn and save in a Pmode object.  */
1008   rtx (*fcn) (rtx, rtx) = gen_move_insn;
1009   enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
1010
1011   /* See if this machine has anything special to do for this kind of save.  */
1012   switch (save_level)
1013     {
1014 #ifdef HAVE_save_stack_block
1015     case SAVE_BLOCK:
1016       if (HAVE_save_stack_block)
1017         fcn = gen_save_stack_block;
1018       break;
1019 #endif
1020 #ifdef HAVE_save_stack_function
1021     case SAVE_FUNCTION:
1022       if (HAVE_save_stack_function)
1023         fcn = gen_save_stack_function;
1024       break;
1025 #endif
1026 #ifdef HAVE_save_stack_nonlocal
1027     case SAVE_NONLOCAL:
1028       if (HAVE_save_stack_nonlocal)
1029         fcn = gen_save_stack_nonlocal;
1030       break;
1031 #endif
1032     default:
1033       break;
1034     }
1035
1036   /* If there is no save area and we have to allocate one, do so.  Otherwise
1037      verify the save area is the proper mode.  */
1038
1039   if (sa == 0)
1040     {
1041       if (mode != VOIDmode)
1042         {
1043           if (save_level == SAVE_NONLOCAL)
1044             *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
1045           else
1046             *psave = sa = gen_reg_rtx (mode);
1047         }
1048     }
1049
1050   do_pending_stack_adjust ();
1051   if (sa != 0)
1052     sa = validize_mem (sa);
1053   emit_insn (fcn (sa, stack_pointer_rtx));
1054 }
1055
1056 /* Restore the stack pointer for the purpose in SAVE_LEVEL.  SA is the save
1057    area made by emit_stack_save.  If it is zero, we have nothing to do.  */
1058
1059 void
1060 emit_stack_restore (enum save_level save_level, rtx sa)
1061 {
1062   /* The default is that we use a move insn.  */
1063   rtx (*fcn) (rtx, rtx) = gen_move_insn;
1064
1065   /* If stack_realign_drap, the x86 backend emits a prologue that aligns both
1066      STACK_POINTER and HARD_FRAME_POINTER.
1067      If stack_realign_fp, the x86 backend emits a prologue that aligns only
1068      STACK_POINTER. This renders the HARD_FRAME_POINTER unusable for accessing
1069      aligned variables, which is reflected in ix86_can_eliminate.
1070      We normally still have the realigned STACK_POINTER that we can use.
1071      But if there is a stack restore still present at reload, it can trigger 
1072      mark_not_eliminable for the STACK_POINTER, leaving no way to eliminate
1073      FRAME_POINTER into a hard reg.
1074      To prevent this situation, we force need_drap if we emit a stack
1075      restore.  */
1076   if (SUPPORTS_STACK_ALIGNMENT)
1077     crtl->need_drap = true;
1078
1079   /* See if this machine has anything special to do for this kind of save.  */
1080   switch (save_level)
1081     {
1082 #ifdef HAVE_restore_stack_block
1083     case SAVE_BLOCK:
1084       if (HAVE_restore_stack_block)
1085         fcn = gen_restore_stack_block;
1086       break;
1087 #endif
1088 #ifdef HAVE_restore_stack_function
1089     case SAVE_FUNCTION:
1090       if (HAVE_restore_stack_function)
1091         fcn = gen_restore_stack_function;
1092       break;
1093 #endif
1094 #ifdef HAVE_restore_stack_nonlocal
1095     case SAVE_NONLOCAL:
1096       if (HAVE_restore_stack_nonlocal)
1097         fcn = gen_restore_stack_nonlocal;
1098       break;
1099 #endif
1100     default:
1101       break;
1102     }
1103
1104   if (sa != 0)
1105     {
1106       sa = validize_mem (sa);
1107       /* These clobbers prevent the scheduler from moving
1108          references to variable arrays below the code
1109          that deletes (pops) the arrays.  */
1110       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1111       emit_clobber (gen_rtx_MEM (BLKmode, stack_pointer_rtx));
1112     }
1113
1114   discard_pending_stack_adjust ();
1115
1116   emit_insn (fcn (stack_pointer_rtx, sa));
1117 }
1118
1119 /* Invoke emit_stack_save on the nonlocal_goto_save_area for the current
1120    function.  This function should be called whenever we allocate or
1121    deallocate dynamic stack space.  */
1122
1123 void
1124 update_nonlocal_goto_save_area (void)
1125 {
1126   tree t_save;
1127   rtx r_save;
1128
1129   /* The nonlocal_goto_save_area object is an array of N pointers.  The
1130      first one is used for the frame pointer save; the rest are sized by
1131      STACK_SAVEAREA_MODE.  Create a reference to array index 1, the first
1132      of the stack save area slots.  */
1133   t_save = build4 (ARRAY_REF,
1134                    TREE_TYPE (TREE_TYPE (cfun->nonlocal_goto_save_area)),
1135                    cfun->nonlocal_goto_save_area,
1136                    integer_one_node, NULL_TREE, NULL_TREE);
1137   r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE);
1138
1139   emit_stack_save (SAVE_NONLOCAL, &r_save);
1140 }
1141 \f
1142 /* Return an rtx representing the address of an area of memory dynamically
1143    pushed on the stack.
1144
1145    Any required stack pointer alignment is preserved.
1146
1147    SIZE is an rtx representing the size of the area.
1148
1149    SIZE_ALIGN is the alignment (in bits) that we know SIZE has.  This
1150    parameter may be zero.  If so, a proper value will be extracted 
1151    from SIZE if it is constant, otherwise BITS_PER_UNIT will be assumed.
1152
1153    REQUIRED_ALIGN is the alignment (in bits) required for the region
1154    of memory.
1155
1156    If CANNOT_ACCUMULATE is set to TRUE, the caller guarantees that the
1157    stack space allocated by the generated code cannot be added with itself
1158    in the course of the execution of the function.  It is always safe to
1159    pass FALSE here and the following criterion is sufficient in order to
1160    pass TRUE: every path in the CFG that starts at the allocation point and
1161    loops to it executes the associated deallocation code.  */
1162
1163 rtx
1164 allocate_dynamic_stack_space (rtx size, unsigned size_align,
1165                               unsigned required_align, bool cannot_accumulate)
1166 {
1167   HOST_WIDE_INT stack_usage_size = -1;
1168   rtx final_label, final_target, target;
1169   unsigned extra_align = 0;
1170   bool must_align;
1171
1172   /* If we're asking for zero bytes, it doesn't matter what we point
1173      to since we can't dereference it.  But return a reasonable
1174      address anyway.  */
1175   if (size == const0_rtx)
1176     return virtual_stack_dynamic_rtx;
1177
1178   /* Otherwise, show we're calling alloca or equivalent.  */
1179   cfun->calls_alloca = 1;
1180
1181   /* If stack usage info is requested, look into the size we are passed.
1182      We need to do so this early to avoid the obfuscation that may be
1183      introduced later by the various alignment operations.  */
1184   if (flag_stack_usage_info)
1185     {
1186       if (CONST_INT_P (size))
1187         stack_usage_size = INTVAL (size);
1188       else if (REG_P (size))
1189         {
1190           /* Look into the last emitted insn and see if we can deduce
1191              something for the register.  */
1192           rtx insn, set, note;
1193           insn = get_last_insn ();
1194           if ((set = single_set (insn)) && rtx_equal_p (SET_DEST (set), size))
1195             {
1196               if (CONST_INT_P (SET_SRC (set)))
1197                 stack_usage_size = INTVAL (SET_SRC (set));
1198               else if ((note = find_reg_equal_equiv_note (insn))
1199                        && CONST_INT_P (XEXP (note, 0)))
1200                 stack_usage_size = INTVAL (XEXP (note, 0));
1201             }
1202         }
1203
1204       /* If the size is not constant, we can't say anything.  */
1205       if (stack_usage_size == -1)
1206         {
1207           current_function_has_unbounded_dynamic_stack_size = 1;
1208           stack_usage_size = 0;
1209         }
1210     }
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   /* Adjust SIZE_ALIGN, if needed.  */
1217   if (CONST_INT_P (size))
1218     {
1219       unsigned HOST_WIDE_INT lsb;
1220
1221       lsb = INTVAL (size);
1222       lsb &= -lsb;
1223
1224       /* Watch out for overflow truncating to "unsigned".  */
1225       if (lsb > UINT_MAX / BITS_PER_UNIT)
1226         size_align = 1u << (HOST_BITS_PER_INT - 1);
1227       else
1228         size_align = (unsigned)lsb * BITS_PER_UNIT;
1229     }
1230   else if (size_align < BITS_PER_UNIT)
1231     size_align = BITS_PER_UNIT;
1232
1233   /* We can't attempt to minimize alignment necessary, because we don't
1234      know the final value of preferred_stack_boundary yet while executing
1235      this code.  */
1236   if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
1237     crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
1238
1239   /* We will need to ensure that the address we return is aligned to
1240      REQUIRED_ALIGN.  If STACK_DYNAMIC_OFFSET is defined, we don't
1241      always know its final value at this point in the compilation (it
1242      might depend on the size of the outgoing parameter lists, for
1243      example), so we must align the value to be returned in that case.
1244      (Note that STACK_DYNAMIC_OFFSET will have a default nonzero value if
1245      STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1246      We must also do an alignment operation on the returned value if
1247      the stack pointer alignment is less strict than REQUIRED_ALIGN.
1248
1249      If we have to align, we must leave space in SIZE for the hole
1250      that might result from the alignment operation.  */
1251
1252   must_align = (crtl->preferred_stack_boundary < required_align);
1253   if (must_align)
1254     {
1255       if (required_align > PREFERRED_STACK_BOUNDARY)
1256         extra_align = PREFERRED_STACK_BOUNDARY;
1257       else if (required_align > STACK_BOUNDARY)
1258         extra_align = STACK_BOUNDARY;
1259       else
1260         extra_align = BITS_PER_UNIT;
1261     }
1262
1263   /* ??? STACK_POINTER_OFFSET is always defined now.  */
1264 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET)
1265   must_align = true;
1266   extra_align = BITS_PER_UNIT;
1267 #endif
1268
1269   if (must_align)
1270     {
1271       unsigned extra = (required_align - extra_align) / BITS_PER_UNIT;
1272
1273       size = plus_constant (size, extra);
1274       size = force_operand (size, NULL_RTX);
1275
1276       if (flag_stack_usage_info)
1277         stack_usage_size += extra;
1278
1279       if (extra && size_align > extra_align)
1280         size_align = extra_align;
1281     }
1282
1283   /* Round the size to a multiple of the required stack alignment.
1284      Since the stack if presumed to be rounded before this allocation,
1285      this will maintain the required alignment.
1286
1287      If the stack grows downward, we could save an insn by subtracting
1288      SIZE from the stack pointer and then aligning the stack pointer.
1289      The problem with this is that the stack pointer may be unaligned
1290      between the execution of the subtraction and alignment insns and
1291      some machines do not allow this.  Even on those that do, some
1292      signal handlers malfunction if a signal should occur between those
1293      insns.  Since this is an extremely rare event, we have no reliable
1294      way of knowing which systems have this problem.  So we avoid even
1295      momentarily mis-aligning the stack.  */
1296   if (size_align % MAX_SUPPORTED_STACK_ALIGNMENT != 0)
1297     {
1298       size = round_push (size);
1299
1300       if (flag_stack_usage_info)
1301         {
1302           int align = crtl->preferred_stack_boundary / BITS_PER_UNIT;
1303           stack_usage_size = (stack_usage_size + align - 1) / align * align;
1304         }
1305     }
1306
1307   target = gen_reg_rtx (Pmode);
1308
1309   /* The size is supposed to be fully adjusted at this point so record it
1310      if stack usage info is requested.  */
1311   if (flag_stack_usage_info)
1312     {
1313       current_function_dynamic_stack_size += stack_usage_size;
1314
1315       /* ??? This is gross but the only safe stance in the absence
1316          of stack usage oriented flow analysis.  */
1317       if (!cannot_accumulate)
1318         current_function_has_unbounded_dynamic_stack_size = 1;
1319     }
1320
1321   final_label = NULL_RTX;
1322   final_target = NULL_RTX;
1323
1324   /* If we are splitting the stack, we need to ask the backend whether
1325      there is enough room on the current stack.  If there isn't, or if
1326      the backend doesn't know how to tell is, then we need to call a
1327      function to allocate memory in some other way.  This memory will
1328      be released when we release the current stack segment.  The
1329      effect is that stack allocation becomes less efficient, but at
1330      least it doesn't cause a stack overflow.  */
1331   if (flag_split_stack)
1332     {
1333       rtx available_label, ask, space, func;
1334
1335       available_label = NULL_RTX;
1336
1337 #ifdef HAVE_split_stack_space_check
1338       if (HAVE_split_stack_space_check)
1339         {
1340           available_label = gen_label_rtx ();
1341
1342           /* This instruction will branch to AVAILABLE_LABEL if there
1343              are SIZE bytes available on the stack.  */
1344           emit_insn (gen_split_stack_space_check (size, available_label));
1345         }
1346 #endif
1347
1348       /* The __morestack_allocate_stack_space function will allocate
1349          memory using malloc.  If the alignment of the memory returned
1350          by malloc does not meet REQUIRED_ALIGN, we increase SIZE to
1351          make sure we allocate enough space.  */
1352       if (MALLOC_ABI_ALIGNMENT >= required_align)
1353         ask = size;
1354       else
1355         {
1356           ask = expand_binop (Pmode, add_optab, size,
1357                               GEN_INT (required_align / BITS_PER_UNIT - 1),
1358                               NULL_RTX, 1, OPTAB_LIB_WIDEN);
1359           must_align = true;
1360         }
1361
1362       func = init_one_libfunc ("__morestack_allocate_stack_space");
1363
1364       space = emit_library_call_value (func, target, LCT_NORMAL, Pmode,
1365                                        1, ask, Pmode);
1366
1367       if (available_label == NULL_RTX)
1368         return space;
1369
1370       final_target = gen_reg_rtx (Pmode);
1371
1372       emit_move_insn (final_target, space);
1373
1374       final_label = gen_label_rtx ();
1375       emit_jump (final_label);
1376
1377       emit_label (available_label);
1378     }
1379
1380   do_pending_stack_adjust ();
1381
1382  /* We ought to be called always on the toplevel and stack ought to be aligned
1383     properly.  */
1384   gcc_assert (!(stack_pointer_delta
1385                 % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)));
1386
1387   /* If needed, check that we have the required amount of stack.  Take into
1388      account what has already been checked.  */
1389   if (STACK_CHECK_MOVING_SP)
1390     ;
1391   else if (flag_stack_check == GENERIC_STACK_CHECK)
1392     probe_stack_range (STACK_OLD_CHECK_PROTECT + STACK_CHECK_MAX_FRAME_SIZE,
1393                        size);
1394   else if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
1395     probe_stack_range (STACK_CHECK_PROTECT, size);
1396
1397   /* Don't let anti_adjust_stack emit notes.  */
1398   suppress_reg_args_size = true;
1399
1400   /* Perform the required allocation from the stack.  Some systems do
1401      this differently than simply incrementing/decrementing from the
1402      stack pointer, such as acquiring the space by calling malloc().  */
1403 #ifdef HAVE_allocate_stack
1404   if (HAVE_allocate_stack)
1405     {
1406       struct expand_operand ops[2];
1407       /* We don't have to check against the predicate for operand 0 since
1408          TARGET is known to be a pseudo of the proper mode, which must
1409          be valid for the operand.  */
1410       create_fixed_operand (&ops[0], target);
1411       create_convert_operand_to (&ops[1], size, STACK_SIZE_MODE, true);
1412       expand_insn (CODE_FOR_allocate_stack, 2, ops);
1413     }
1414   else
1415 #endif
1416     {
1417       int saved_stack_pointer_delta;
1418
1419 #ifndef STACK_GROWS_DOWNWARD
1420       emit_move_insn (target, virtual_stack_dynamic_rtx);
1421 #endif
1422
1423       /* Check stack bounds if necessary.  */
1424       if (crtl->limit_stack)
1425         {
1426           rtx available;
1427           rtx space_available = gen_label_rtx ();
1428 #ifdef STACK_GROWS_DOWNWARD
1429           available = expand_binop (Pmode, sub_optab,
1430                                     stack_pointer_rtx, stack_limit_rtx,
1431                                     NULL_RTX, 1, OPTAB_WIDEN);
1432 #else
1433           available = expand_binop (Pmode, sub_optab,
1434                                     stack_limit_rtx, stack_pointer_rtx,
1435                                     NULL_RTX, 1, OPTAB_WIDEN);
1436 #endif
1437           emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1,
1438                                    space_available);
1439 #ifdef HAVE_trap
1440           if (HAVE_trap)
1441             emit_insn (gen_trap ());
1442           else
1443 #endif
1444             error ("stack limits not supported on this target");
1445           emit_barrier ();
1446           emit_label (space_available);
1447         }
1448
1449       saved_stack_pointer_delta = stack_pointer_delta;
1450
1451       if (flag_stack_check && STACK_CHECK_MOVING_SP)
1452         anti_adjust_stack_and_probe (size, false);
1453       else
1454         anti_adjust_stack (size);
1455
1456       /* Even if size is constant, don't modify stack_pointer_delta.
1457          The constant size alloca should preserve
1458          crtl->preferred_stack_boundary alignment.  */
1459       stack_pointer_delta = saved_stack_pointer_delta;
1460
1461 #ifdef STACK_GROWS_DOWNWARD
1462       emit_move_insn (target, virtual_stack_dynamic_rtx);
1463 #endif
1464     }
1465
1466   suppress_reg_args_size = false;
1467
1468   /* Finish up the split stack handling.  */
1469   if (final_label != NULL_RTX)
1470     {
1471       gcc_assert (flag_split_stack);
1472       emit_move_insn (final_target, target);
1473       emit_label (final_label);
1474       target = final_target;
1475     }
1476
1477   if (must_align)
1478     {
1479       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1480          but we know it can't.  So add ourselves and then do
1481          TRUNC_DIV_EXPR.  */
1482       target = expand_binop (Pmode, add_optab, target,
1483                              GEN_INT (required_align / BITS_PER_UNIT - 1),
1484                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
1485       target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1486                               GEN_INT (required_align / BITS_PER_UNIT),
1487                               NULL_RTX, 1);
1488       target = expand_mult (Pmode, target,
1489                             GEN_INT (required_align / BITS_PER_UNIT),
1490                             NULL_RTX, 1);
1491     }
1492
1493   /* Now that we've committed to a return value, mark its alignment.  */
1494   mark_reg_pointer (target, required_align);
1495
1496   /* Record the new stack level for nonlocal gotos.  */
1497   if (cfun->nonlocal_goto_save_area != 0)
1498     update_nonlocal_goto_save_area ();
1499
1500   return target;
1501 }
1502 \f
1503 /* A front end may want to override GCC's stack checking by providing a
1504    run-time routine to call to check the stack, so provide a mechanism for
1505    calling that routine.  */
1506
1507 static GTY(()) rtx stack_check_libfunc;
1508
1509 void
1510 set_stack_check_libfunc (const char *libfunc_name)
1511 {
1512   gcc_assert (stack_check_libfunc == NULL_RTX);
1513   stack_check_libfunc = gen_rtx_SYMBOL_REF (Pmode, libfunc_name);
1514 }
1515 \f
1516 /* Emit one stack probe at ADDRESS, an address within the stack.  */
1517
1518 void
1519 emit_stack_probe (rtx address)
1520 {
1521   rtx memref = gen_rtx_MEM (word_mode, address);
1522
1523   MEM_VOLATILE_P (memref) = 1;
1524
1525   /* See if we have an insn to probe the stack.  */
1526 #ifdef HAVE_probe_stack
1527   if (HAVE_probe_stack)
1528     emit_insn (gen_probe_stack (memref));
1529   else
1530 #endif
1531     emit_move_insn (memref, const0_rtx);
1532 }
1533
1534 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
1535    FIRST is a constant and size is a Pmode RTX.  These are offsets from
1536    the current stack pointer.  STACK_GROWS_DOWNWARD says whether to add
1537    or subtract them from the stack pointer.  */
1538
1539 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
1540
1541 #ifdef STACK_GROWS_DOWNWARD
1542 #define STACK_GROW_OP MINUS
1543 #define STACK_GROW_OPTAB sub_optab
1544 #define STACK_GROW_OFF(off) -(off)
1545 #else
1546 #define STACK_GROW_OP PLUS
1547 #define STACK_GROW_OPTAB add_optab
1548 #define STACK_GROW_OFF(off) (off)
1549 #endif
1550
1551 void
1552 probe_stack_range (HOST_WIDE_INT first, rtx size)
1553 {
1554   /* First ensure SIZE is Pmode.  */
1555   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1556     size = convert_to_mode (Pmode, size, 1);
1557
1558   /* Next see if we have a function to check the stack.  */
1559   if (stack_check_libfunc)
1560     {
1561       rtx addr = memory_address (Pmode,
1562                                  gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1563                                                  stack_pointer_rtx,
1564                                                  plus_constant (size, first)));
1565       emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
1566                          Pmode);
1567     }
1568
1569   /* Next see if we have an insn to check the stack.  */
1570 #ifdef HAVE_check_stack
1571   else if (HAVE_check_stack)
1572     {
1573       struct expand_operand ops[1];
1574       rtx addr = memory_address (Pmode,
1575                                  gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1576                                                  stack_pointer_rtx,
1577                                                  plus_constant (size, first)));
1578       bool success;
1579       create_input_operand (&ops[0], addr, Pmode);
1580       success = maybe_expand_insn (CODE_FOR_check_stack, 1, ops);
1581       gcc_assert (success);
1582     }
1583 #endif
1584
1585   /* Otherwise we have to generate explicit probes.  If we have a constant
1586      small number of them to generate, that's the easy case.  */
1587   else if (CONST_INT_P (size) && INTVAL (size) < 7 * PROBE_INTERVAL)
1588     {
1589       HOST_WIDE_INT isize = INTVAL (size), i;
1590       rtx addr;
1591
1592       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
1593          it exceeds SIZE.  If only one probe is needed, this will not
1594          generate any code.  Then probe at FIRST + SIZE.  */
1595       for (i = PROBE_INTERVAL; i < isize; i += PROBE_INTERVAL)
1596         {
1597           addr = memory_address (Pmode,
1598                                  plus_constant (stack_pointer_rtx,
1599                                                 STACK_GROW_OFF (first + i)));
1600           emit_stack_probe (addr);
1601         }
1602
1603       addr = memory_address (Pmode,
1604                              plus_constant (stack_pointer_rtx,
1605                                             STACK_GROW_OFF (first + isize)));
1606       emit_stack_probe (addr);
1607     }
1608
1609   /* In the variable case, do the same as above, but in a loop.  Note that we
1610      must be extra careful with variables wrapping around because we might be
1611      at the very top (or the very bottom) of the address space and we have to
1612      be able to handle this case properly; in particular, we use an equality
1613      test for the loop condition.  */
1614   else
1615     {
1616       rtx rounded_size, rounded_size_op, test_addr, last_addr, temp;
1617       rtx loop_lab = gen_label_rtx ();
1618       rtx end_lab = gen_label_rtx ();
1619
1620
1621       /* Step 1: round SIZE to the previous multiple of the interval.  */
1622
1623       /* ROUNDED_SIZE = SIZE & -PROBE_INTERVAL  */
1624       rounded_size
1625         = simplify_gen_binary (AND, Pmode, size, GEN_INT (-PROBE_INTERVAL));
1626       rounded_size_op = force_operand (rounded_size, NULL_RTX);
1627
1628
1629       /* Step 2: compute initial and final value of the loop counter.  */
1630
1631       /* TEST_ADDR = SP + FIRST.  */
1632       test_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1633                                                  stack_pointer_rtx,
1634                                                  GEN_INT (first)), NULL_RTX);
1635
1636       /* LAST_ADDR = SP + FIRST + ROUNDED_SIZE.  */
1637       last_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1638                                                  test_addr,
1639                                                  rounded_size_op), NULL_RTX);
1640
1641
1642       /* Step 3: the loop
1643
1644          while (TEST_ADDR != LAST_ADDR)
1645            {
1646              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
1647              probe at TEST_ADDR
1648            }
1649
1650          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
1651          until it is equal to ROUNDED_SIZE.  */
1652
1653       emit_label (loop_lab);
1654
1655       /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
1656       emit_cmp_and_jump_insns (test_addr, last_addr, EQ, NULL_RTX, Pmode, 1,
1657                                end_lab);
1658
1659       /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
1660       temp = expand_binop (Pmode, STACK_GROW_OPTAB, test_addr,
1661                            GEN_INT (PROBE_INTERVAL), test_addr,
1662                            1, OPTAB_WIDEN);
1663
1664       gcc_assert (temp == test_addr);
1665
1666       /* Probe at TEST_ADDR.  */
1667       emit_stack_probe (test_addr);
1668
1669       emit_jump (loop_lab);
1670
1671       emit_label (end_lab);
1672
1673
1674       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
1675          that SIZE is equal to ROUNDED_SIZE.  */
1676
1677       /* TEMP = SIZE - ROUNDED_SIZE.  */
1678       temp = simplify_gen_binary (MINUS, Pmode, size, rounded_size);
1679       if (temp != const0_rtx)
1680         {
1681           rtx addr;
1682
1683           if (CONST_INT_P (temp))
1684             {
1685               /* Use [base + disp} addressing mode if supported.  */
1686               HOST_WIDE_INT offset = INTVAL (temp);
1687               addr = memory_address (Pmode,
1688                                      plus_constant (last_addr,
1689                                                     STACK_GROW_OFF (offset)));
1690             }
1691           else
1692             {
1693               /* Manual CSE if the difference is not known at compile-time.  */
1694               temp = gen_rtx_MINUS (Pmode, size, rounded_size_op);
1695               addr = memory_address (Pmode,
1696                                      gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1697                                                      last_addr, temp));
1698             }
1699
1700           emit_stack_probe (addr);
1701         }
1702     }
1703 }
1704
1705 /* Adjust the stack pointer by minus SIZE (an rtx for a number of bytes)
1706    while probing it.  This pushes when SIZE is positive.  SIZE need not
1707    be constant.  If ADJUST_BACK is true, adjust back the stack pointer
1708    by plus SIZE at the end.  */
1709
1710 void
1711 anti_adjust_stack_and_probe (rtx size, bool adjust_back)
1712 {
1713   /* We skip the probe for the first interval + a small dope of 4 words and
1714      probe that many bytes past the specified size to maintain a protection
1715      area at the botton of the stack.  */
1716   const int dope = 4 * UNITS_PER_WORD;
1717
1718   /* First ensure SIZE is Pmode.  */
1719   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1720     size = convert_to_mode (Pmode, size, 1);
1721
1722   /* If we have a constant small number of probes to generate, that's the
1723      easy case.  */
1724   if (CONST_INT_P (size) && INTVAL (size) < 7 * PROBE_INTERVAL)
1725     {
1726       HOST_WIDE_INT isize = INTVAL (size), i;
1727       bool first_probe = true;
1728
1729       /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for
1730          values of N from 1 until it exceeds SIZE.  If only one probe is
1731          needed, this will not generate any code.  Then adjust and probe
1732          to PROBE_INTERVAL + SIZE.  */
1733       for (i = PROBE_INTERVAL; i < isize; i += PROBE_INTERVAL)
1734         {
1735           if (first_probe)
1736             {
1737               anti_adjust_stack (GEN_INT (2 * PROBE_INTERVAL + dope));
1738               first_probe = false;
1739             }
1740           else
1741             anti_adjust_stack (GEN_INT (PROBE_INTERVAL));
1742           emit_stack_probe (stack_pointer_rtx);
1743         }
1744
1745       if (first_probe)
1746         anti_adjust_stack (plus_constant (size, PROBE_INTERVAL + dope));
1747       else
1748         anti_adjust_stack (plus_constant (size, PROBE_INTERVAL - i));
1749       emit_stack_probe (stack_pointer_rtx);
1750     }
1751
1752   /* In the variable case, do the same as above, but in a loop.  Note that we
1753      must be extra careful with variables wrapping around because we might be
1754      at the very top (or the very bottom) of the address space and we have to
1755      be able to handle this case properly; in particular, we use an equality
1756      test for the loop condition.  */
1757   else
1758     {
1759       rtx rounded_size, rounded_size_op, last_addr, temp;
1760       rtx loop_lab = gen_label_rtx ();
1761       rtx end_lab = gen_label_rtx ();
1762
1763
1764       /* Step 1: round SIZE to the previous multiple of the interval.  */
1765
1766       /* ROUNDED_SIZE = SIZE & -PROBE_INTERVAL  */
1767       rounded_size
1768         = simplify_gen_binary (AND, Pmode, size, GEN_INT (-PROBE_INTERVAL));
1769       rounded_size_op = force_operand (rounded_size, NULL_RTX);
1770
1771
1772       /* Step 2: compute initial and final value of the loop counter.  */
1773
1774       /* SP = SP_0 + PROBE_INTERVAL.  */
1775       anti_adjust_stack (GEN_INT (PROBE_INTERVAL + dope));
1776
1777       /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE.  */
1778       last_addr = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1779                                                  stack_pointer_rtx,
1780                                                  rounded_size_op), NULL_RTX);
1781
1782
1783       /* Step 3: the loop
1784
1785          while (SP != LAST_ADDR)
1786            {
1787              SP = SP + PROBE_INTERVAL
1788              probe at SP
1789            }
1790
1791          adjusts SP and probes at PROBE_INTERVAL + N * PROBE_INTERVAL for
1792          values of N from 1 until it is equal to ROUNDED_SIZE.  */
1793
1794       emit_label (loop_lab);
1795
1796       /* Jump to END_LAB if SP == LAST_ADDR.  */
1797       emit_cmp_and_jump_insns (stack_pointer_rtx, last_addr, EQ, NULL_RTX,
1798                                Pmode, 1, end_lab);
1799
1800       /* SP = SP + PROBE_INTERVAL and probe at SP.  */
1801       anti_adjust_stack (GEN_INT (PROBE_INTERVAL));
1802       emit_stack_probe (stack_pointer_rtx);
1803
1804       emit_jump (loop_lab);
1805
1806       emit_label (end_lab);
1807
1808
1809       /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot
1810          assert at compile-time that SIZE is equal to ROUNDED_SIZE.  */
1811
1812       /* TEMP = SIZE - ROUNDED_SIZE.  */
1813       temp = simplify_gen_binary (MINUS, Pmode, size, rounded_size);
1814       if (temp != const0_rtx)
1815         {
1816           /* Manual CSE if the difference is not known at compile-time.  */
1817           if (GET_CODE (temp) != CONST_INT)
1818             temp = gen_rtx_MINUS (Pmode, size, rounded_size_op);
1819           anti_adjust_stack (temp);
1820           emit_stack_probe (stack_pointer_rtx);
1821         }
1822     }
1823
1824   /* Adjust back and account for the additional first interval.  */
1825   if (adjust_back)
1826     adjust_stack (plus_constant (size, PROBE_INTERVAL + dope));
1827   else
1828     adjust_stack (GEN_INT (PROBE_INTERVAL + dope));
1829 }
1830
1831 /* Return an rtx representing the register or memory location
1832    in which a scalar value of data type VALTYPE
1833    was returned by a function call to function FUNC.
1834    FUNC is a FUNCTION_DECL, FNTYPE a FUNCTION_TYPE node if the precise
1835    function is known, otherwise 0.
1836    OUTGOING is 1 if on a machine with register windows this function
1837    should return the register in which the function will put its result
1838    and 0 otherwise.  */
1839
1840 rtx
1841 hard_function_value (const_tree valtype, const_tree func, const_tree fntype,
1842                      int outgoing ATTRIBUTE_UNUSED)
1843 {
1844   rtx val;
1845
1846   val = targetm.calls.function_value (valtype, func ? func : fntype, outgoing);
1847
1848   if (REG_P (val)
1849       && GET_MODE (val) == BLKmode)
1850     {
1851       unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
1852       enum machine_mode tmpmode;
1853
1854       /* int_size_in_bytes can return -1.  We don't need a check here
1855          since the value of bytes will then be large enough that no
1856          mode will match anyway.  */
1857
1858       for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1859            tmpmode != VOIDmode;
1860            tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1861         {
1862           /* Have we found a large enough mode?  */
1863           if (GET_MODE_SIZE (tmpmode) >= bytes)
1864             break;
1865         }
1866
1867       /* No suitable mode found.  */
1868       gcc_assert (tmpmode != VOIDmode);
1869
1870       PUT_MODE (val, tmpmode);
1871     }
1872   return val;
1873 }
1874
1875 /* Return an rtx representing the register or memory location
1876    in which a scalar value of mode MODE was returned by a library call.  */
1877
1878 rtx
1879 hard_libcall_value (enum machine_mode mode, rtx fun)
1880 {
1881   return targetm.calls.libcall_value (mode, fun);
1882 }
1883
1884 /* Look up the tree code for a given rtx code
1885    to provide the arithmetic operation for REAL_ARITHMETIC.
1886    The function returns an int because the caller may not know
1887    what `enum tree_code' means.  */
1888
1889 int
1890 rtx_to_tree_code (enum rtx_code code)
1891 {
1892   enum tree_code tcode;
1893
1894   switch (code)
1895     {
1896     case PLUS:
1897       tcode = PLUS_EXPR;
1898       break;
1899     case MINUS:
1900       tcode = MINUS_EXPR;
1901       break;
1902     case MULT:
1903       tcode = MULT_EXPR;
1904       break;
1905     case DIV:
1906       tcode = RDIV_EXPR;
1907       break;
1908     case SMIN:
1909       tcode = MIN_EXPR;
1910       break;
1911     case SMAX:
1912       tcode = MAX_EXPR;
1913       break;
1914     default:
1915       tcode = LAST_AND_UNUSED_TREE_CODE;
1916       break;
1917     }
1918   return ((int) tcode);
1919 }
1920
1921 #include "gt-explow.h"