Merge branch 'vendor/GCC47'
[dragonfly.git] / contrib / gcc-4.7 / gcc / cfgexpand.c
1 /* A pass for lowering trees to RTL.
2    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3    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
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "rtl.h"
27 #include "tm_p.h"
28 #include "basic-block.h"
29 #include "function.h"
30 #include "expr.h"
31 #include "langhooks.h"
32 #include "tree-flow.h"
33 #include "timevar.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
36 #include "except.h"
37 #include "flags.h"
38 #include "diagnostic.h"
39 #include "tree-pretty-print.h"
40 #include "gimple-pretty-print.h"
41 #include "toplev.h"
42 #include "debug.h"
43 #include "params.h"
44 #include "tree-inline.h"
45 #include "value-prof.h"
46 #include "target.h"
47 #include "ssaexpand.h"
48 #include "bitmap.h"
49 #include "sbitmap.h"
50 #include "insn-attr.h" /* For INSN_SCHEDULING.  */
51
52 /* This variable holds information helping the rewriting of SSA trees
53    into RTL.  */
54 struct ssaexpand SA;
55
56 /* This variable holds the currently expanded gimple statement for purposes
57    of comminucating the profile info to the builtin expanders.  */
58 gimple currently_expanding_gimple_stmt;
59
60 static rtx expand_debug_expr (tree);
61
62 /* Return an expression tree corresponding to the RHS of GIMPLE
63    statement STMT.  */
64
65 tree
66 gimple_assign_rhs_to_tree (gimple stmt)
67 {
68   tree t;
69   enum gimple_rhs_class grhs_class;
70
71   grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
72
73   if (grhs_class == GIMPLE_TERNARY_RHS)
74     t = build3 (gimple_assign_rhs_code (stmt),
75                 TREE_TYPE (gimple_assign_lhs (stmt)),
76                 gimple_assign_rhs1 (stmt),
77                 gimple_assign_rhs2 (stmt),
78                 gimple_assign_rhs3 (stmt));
79   else if (grhs_class == GIMPLE_BINARY_RHS)
80     t = build2 (gimple_assign_rhs_code (stmt),
81                 TREE_TYPE (gimple_assign_lhs (stmt)),
82                 gimple_assign_rhs1 (stmt),
83                 gimple_assign_rhs2 (stmt));
84   else if (grhs_class == GIMPLE_UNARY_RHS)
85     t = build1 (gimple_assign_rhs_code (stmt),
86                 TREE_TYPE (gimple_assign_lhs (stmt)),
87                 gimple_assign_rhs1 (stmt));
88   else if (grhs_class == GIMPLE_SINGLE_RHS)
89     {
90       t = gimple_assign_rhs1 (stmt);
91       /* Avoid modifying this tree in place below.  */
92       if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
93            && gimple_location (stmt) != EXPR_LOCATION (t))
94           || (gimple_block (stmt)
95               && currently_expanding_to_rtl
96               && EXPR_P (t)
97               && gimple_block (stmt) != TREE_BLOCK (t)))
98         t = copy_node (t);
99     }
100   else
101     gcc_unreachable ();
102
103   if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
104     SET_EXPR_LOCATION (t, gimple_location (stmt));
105   if (gimple_block (stmt) && currently_expanding_to_rtl && EXPR_P (t))
106     TREE_BLOCK (t) = gimple_block (stmt);
107
108   return t;
109 }
110
111
112 #ifndef STACK_ALIGNMENT_NEEDED
113 #define STACK_ALIGNMENT_NEEDED 1
114 #endif
115
116 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
117
118 /* Associate declaration T with storage space X.  If T is no
119    SSA name this is exactly SET_DECL_RTL, otherwise make the
120    partition of T associated with X.  */
121 static inline void
122 set_rtl (tree t, rtx x)
123 {
124   if (TREE_CODE (t) == SSA_NAME)
125     {
126       SA.partition_to_pseudo[var_to_partition (SA.map, t)] = x;
127       if (x && !MEM_P (x))
128         set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
129       /* For the benefit of debug information at -O0 (where vartracking
130          doesn't run) record the place also in the base DECL if it's
131          a normal variable (not a parameter).  */
132       if (x && x != pc_rtx && TREE_CODE (SSA_NAME_VAR (t)) == VAR_DECL)
133         {
134           tree var = SSA_NAME_VAR (t);
135           /* If we don't yet have something recorded, just record it now.  */
136           if (!DECL_RTL_SET_P (var))
137             SET_DECL_RTL (var, x);
138           /* If we have it set already to "multiple places" don't
139              change this.  */
140           else if (DECL_RTL (var) == pc_rtx)
141             ;
142           /* If we have something recorded and it's not the same place
143              as we want to record now, we have multiple partitions for the
144              same base variable, with different places.  We can't just
145              randomly chose one, hence we have to say that we don't know.
146              This only happens with optimization, and there var-tracking
147              will figure out the right thing.  */
148           else if (DECL_RTL (var) != x)
149             SET_DECL_RTL (var, pc_rtx);
150         }
151     }
152   else
153     SET_DECL_RTL (t, x);
154 }
155
156 /* This structure holds data relevant to one variable that will be
157    placed in a stack slot.  */
158 struct stack_var
159 {
160   /* The Variable.  */
161   tree decl;
162
163   /* Initially, the size of the variable.  Later, the size of the partition,
164      if this variable becomes it's partition's representative.  */
165   HOST_WIDE_INT size;
166
167   /* The *byte* alignment required for this variable.  Or as, with the
168      size, the alignment for this partition.  */
169   unsigned int alignb;
170
171   /* The partition representative.  */
172   size_t representative;
173
174   /* The next stack variable in the partition, or EOC.  */
175   size_t next;
176
177   /* The numbers of conflicting stack variables.  */
178   bitmap conflicts;
179 };
180
181 #define EOC  ((size_t)-1)
182
183 /* We have an array of such objects while deciding allocation.  */
184 static struct stack_var *stack_vars;
185 static size_t stack_vars_alloc;
186 static size_t stack_vars_num;
187 static struct pointer_map_t *decl_to_stack_part;
188
189 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
190    is non-decreasing.  */
191 static size_t *stack_vars_sorted;
192
193 /* The phase of the stack frame.  This is the known misalignment of
194    virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY.  That is,
195    (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0.  */
196 static int frame_phase;
197
198 /* Used during expand_used_vars to remember if we saw any decls for
199    which we'd like to enable stack smashing protection.  */
200 static bool has_protected_decls;
201
202 /* Used during expand_used_vars.  Remember if we say a character buffer
203    smaller than our cutoff threshold.  Used for -Wstack-protector.  */
204 static bool has_short_buffer;
205
206 /* Compute the byte alignment to use for DECL.  Ignore alignment
207    we can't do with expected alignment of the stack boundary.  */
208
209 static unsigned int
210 align_local_variable (tree decl)
211 {
212   unsigned int align = LOCAL_DECL_ALIGNMENT (decl);
213   DECL_ALIGN (decl) = align;
214   return align / BITS_PER_UNIT;
215 }
216
217 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
218    Return the frame offset.  */
219
220 static HOST_WIDE_INT
221 alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
222 {
223   HOST_WIDE_INT offset, new_frame_offset;
224
225   new_frame_offset = frame_offset;
226   if (FRAME_GROWS_DOWNWARD)
227     {
228       new_frame_offset -= size + frame_phase;
229       new_frame_offset &= -align;
230       new_frame_offset += frame_phase;
231       offset = new_frame_offset;
232     }
233   else
234     {
235       new_frame_offset -= frame_phase;
236       new_frame_offset += align - 1;
237       new_frame_offset &= -align;
238       new_frame_offset += frame_phase;
239       offset = new_frame_offset;
240       new_frame_offset += size;
241     }
242   frame_offset = new_frame_offset;
243
244   if (frame_offset_overflow (frame_offset, cfun->decl))
245     frame_offset = offset = 0;
246
247   return offset;
248 }
249
250 /* Accumulate DECL into STACK_VARS.  */
251
252 static void
253 add_stack_var (tree decl)
254 {
255   struct stack_var *v;
256
257   if (stack_vars_num >= stack_vars_alloc)
258     {
259       if (stack_vars_alloc)
260         stack_vars_alloc = stack_vars_alloc * 3 / 2;
261       else
262         stack_vars_alloc = 32;
263       stack_vars
264         = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
265     }
266   if (!decl_to_stack_part)
267     decl_to_stack_part = pointer_map_create ();
268
269   v = &stack_vars[stack_vars_num];
270   * (size_t *)pointer_map_insert (decl_to_stack_part, decl) = stack_vars_num;
271
272   v->decl = decl;
273   v->size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl)), 1);
274   /* Ensure that all variables have size, so that &a != &b for any two
275      variables that are simultaneously live.  */
276   if (v->size == 0)
277     v->size = 1;
278   v->alignb = align_local_variable (SSAVAR (decl));
279   /* An alignment of zero can mightily confuse us later.  */
280   gcc_assert (v->alignb != 0);
281
282   /* All variables are initially in their own partition.  */
283   v->representative = stack_vars_num;
284   v->next = EOC;
285
286   /* All variables initially conflict with no other.  */
287   v->conflicts = NULL;
288
289   /* Ensure that this decl doesn't get put onto the list twice.  */
290   set_rtl (decl, pc_rtx);
291
292   stack_vars_num++;
293 }
294
295 /* Make the decls associated with luid's X and Y conflict.  */
296
297 static void
298 add_stack_var_conflict (size_t x, size_t y)
299 {
300   struct stack_var *a = &stack_vars[x];
301   struct stack_var *b = &stack_vars[y];
302   if (!a->conflicts)
303     a->conflicts = BITMAP_ALLOC (NULL);
304   if (!b->conflicts)
305     b->conflicts = BITMAP_ALLOC (NULL);
306   bitmap_set_bit (a->conflicts, y);
307   bitmap_set_bit (b->conflicts, x);
308 }
309
310 /* Check whether the decls associated with luid's X and Y conflict.  */
311
312 static bool
313 stack_var_conflict_p (size_t x, size_t y)
314 {
315   struct stack_var *a = &stack_vars[x];
316   struct stack_var *b = &stack_vars[y];
317   if (x == y)
318     return false;
319   /* Partitions containing an SSA name result from gimple registers
320      with things like unsupported modes.  They are top-level and
321      hence conflict with everything else.  */
322   if (TREE_CODE (a->decl) == SSA_NAME || TREE_CODE (b->decl) == SSA_NAME)
323     return true;
324
325   if (!a->conflicts || !b->conflicts)
326     return false;
327   return bitmap_bit_p (a->conflicts, y);
328 }
329
330 /* Returns true if TYPE is or contains a union type.  */
331
332 static bool
333 aggregate_contains_union_type (tree type)
334 {
335   tree field;
336
337   if (TREE_CODE (type) == UNION_TYPE
338       || TREE_CODE (type) == QUAL_UNION_TYPE)
339     return true;
340   if (TREE_CODE (type) == ARRAY_TYPE)
341     return aggregate_contains_union_type (TREE_TYPE (type));
342   if (TREE_CODE (type) != RECORD_TYPE)
343     return false;
344
345   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
346     if (TREE_CODE (field) == FIELD_DECL)
347       if (aggregate_contains_union_type (TREE_TYPE (field)))
348         return true;
349
350   return false;
351 }
352
353 /* A subroutine of expand_used_vars.  If two variables X and Y have alias
354    sets that do not conflict, then do add a conflict for these variables
355    in the interference graph.  We also need to make sure to add conflicts
356    for union containing structures.  Else RTL alias analysis comes along
357    and due to type based aliasing rules decides that for two overlapping
358    union temporaries { short s; int i; } accesses to the same mem through
359    different types may not alias and happily reorders stores across
360    life-time boundaries of the temporaries (See PR25654).  */
361
362 static void
363 add_alias_set_conflicts (void)
364 {
365   size_t i, j, n = stack_vars_num;
366
367   for (i = 0; i < n; ++i)
368     {
369       tree type_i = TREE_TYPE (stack_vars[i].decl);
370       bool aggr_i = AGGREGATE_TYPE_P (type_i);
371       bool contains_union;
372
373       contains_union = aggregate_contains_union_type (type_i);
374       for (j = 0; j < i; ++j)
375         {
376           tree type_j = TREE_TYPE (stack_vars[j].decl);
377           bool aggr_j = AGGREGATE_TYPE_P (type_j);
378           if (aggr_i != aggr_j
379               /* Either the objects conflict by means of type based
380                  aliasing rules, or we need to add a conflict.  */
381               || !objects_must_conflict_p (type_i, type_j)
382               /* In case the types do not conflict ensure that access
383                  to elements will conflict.  In case of unions we have
384                  to be careful as type based aliasing rules may say
385                  access to the same memory does not conflict.  So play
386                  safe and add a conflict in this case when
387                  -fstrict-aliasing is used.  */
388               || (contains_union && flag_strict_aliasing))
389             add_stack_var_conflict (i, j);
390         }
391     }
392 }
393
394 /* Callback for walk_stmt_ops.  If OP is a decl touched by add_stack_var
395    enter its partition number into bitmap DATA.  */
396
397 static bool
398 visit_op (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
399 {
400   bitmap active = (bitmap)data;
401   op = get_base_address (op);
402   if (op
403       && DECL_P (op)
404       && DECL_RTL_IF_SET (op) == pc_rtx)
405     {
406       size_t *v = (size_t *) pointer_map_contains (decl_to_stack_part, op);
407       if (v)
408         bitmap_set_bit (active, *v);
409     }
410   return false;
411 }
412
413 /* Callback for walk_stmt_ops.  If OP is a decl touched by add_stack_var
414    record conflicts between it and all currently active other partitions
415    from bitmap DATA.  */
416
417 static bool
418 visit_conflict (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
419 {
420   bitmap active = (bitmap)data;
421   op = get_base_address (op);
422   if (op
423       && DECL_P (op)
424       && DECL_RTL_IF_SET (op) == pc_rtx)
425     {
426       size_t *v =
427         (size_t *) pointer_map_contains (decl_to_stack_part, op);
428       if (v && bitmap_set_bit (active, *v))
429         {
430           size_t num = *v;
431           bitmap_iterator bi;
432           unsigned i;
433           gcc_assert (num < stack_vars_num);
434           EXECUTE_IF_SET_IN_BITMAP (active, 0, i, bi)
435             add_stack_var_conflict (num, i);
436         }
437     }
438   return false;
439 }
440
441 /* Helper routine for add_scope_conflicts, calculating the active partitions
442    at the end of BB, leaving the result in WORK.  We're called to generate
443    conflicts when FOR_CONFLICT is true, otherwise we're just tracking
444    liveness.  */
445
446 static void
447 add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
448 {
449   edge e;
450   edge_iterator ei;
451   gimple_stmt_iterator gsi;
452   bool (*visit)(gimple, tree, void *);
453
454   bitmap_clear (work);
455   FOR_EACH_EDGE (e, ei, bb->preds)
456     bitmap_ior_into (work, (bitmap)e->src->aux);
457
458   visit = visit_op;
459
460   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
461     {
462       gimple stmt = gsi_stmt (gsi);
463       walk_stmt_load_store_addr_ops (stmt, work, NULL, NULL, visit);
464     }
465   for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
466     {
467       gimple stmt = gsi_stmt (gsi);
468
469       if (gimple_clobber_p (stmt))
470         {
471           tree lhs = gimple_assign_lhs (stmt);
472           size_t *v;
473           /* Nested function lowering might introduce LHSs
474              that are COMPONENT_REFs.  */
475           if (TREE_CODE (lhs) != VAR_DECL)
476             continue;
477           if (DECL_RTL_IF_SET (lhs) == pc_rtx
478               && (v = (size_t *)
479                   pointer_map_contains (decl_to_stack_part, lhs)))
480             bitmap_clear_bit (work, *v);
481         }
482       else if (!is_gimple_debug (stmt))
483         {
484           if (for_conflict
485               && visit == visit_op)
486             {
487               /* If this is the first real instruction in this BB we need
488                  to add conflicts for everything live at this point now.
489                  Unlike classical liveness for named objects we can't
490                  rely on seeing a def/use of the names we're interested in.
491                  There might merely be indirect loads/stores.  We'd not add any
492                  conflicts for such partitions.  */
493               bitmap_iterator bi;
494               unsigned i;
495               EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
496                 {
497                   unsigned j;
498                   bitmap_iterator bj;
499                   EXECUTE_IF_SET_IN_BITMAP (work, i + 1, j, bj)
500                     add_stack_var_conflict (i, j);
501                 }
502               visit = visit_conflict;
503             }
504           walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
505         }
506     }
507 }
508
509 /* Generate stack partition conflicts between all partitions that are
510    simultaneously live.  */
511
512 static void
513 add_scope_conflicts (void)
514 {
515   basic_block bb;
516   bool changed;
517   bitmap work = BITMAP_ALLOC (NULL);
518
519   /* We approximate the live range of a stack variable by taking the first
520      mention of its name as starting point(s), and by the end-of-scope
521      death clobber added by gimplify as ending point(s) of the range.
522      This overapproximates in the case we for instance moved an address-taken
523      operation upward, without also moving a dereference to it upwards.
524      But it's conservatively correct as a variable never can hold values
525      before its name is mentioned at least once.
526
527      We then do a mostly classical bitmap liveness algorithm.  */
528
529   FOR_ALL_BB (bb)
530     bb->aux = BITMAP_ALLOC (NULL);
531
532   changed = true;
533   while (changed)
534     {
535       changed = false;
536       FOR_EACH_BB (bb)
537         {
538           bitmap active = (bitmap)bb->aux;
539           add_scope_conflicts_1 (bb, work, false);
540           if (bitmap_ior_into (active, work))
541             changed = true;
542         }
543     }
544
545   FOR_EACH_BB (bb)
546     add_scope_conflicts_1 (bb, work, true);
547
548   BITMAP_FREE (work);
549   FOR_ALL_BB (bb)
550     BITMAP_FREE (bb->aux);
551 }
552
553 /* A subroutine of partition_stack_vars.  A comparison function for qsort,
554    sorting an array of indices by the properties of the object.  */
555
556 static int
557 stack_var_cmp (const void *a, const void *b)
558 {
559   size_t ia = *(const size_t *)a;
560   size_t ib = *(const size_t *)b;
561   unsigned int aligna = stack_vars[ia].alignb;
562   unsigned int alignb = stack_vars[ib].alignb;
563   HOST_WIDE_INT sizea = stack_vars[ia].size;
564   HOST_WIDE_INT sizeb = stack_vars[ib].size;
565   tree decla = stack_vars[ia].decl;
566   tree declb = stack_vars[ib].decl;
567   bool largea, largeb;
568   unsigned int uida, uidb;
569
570   /* Primary compare on "large" alignment.  Large comes first.  */
571   largea = (aligna * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
572   largeb = (alignb * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
573   if (largea != largeb)
574     return (int)largeb - (int)largea;
575
576   /* Secondary compare on size, decreasing  */
577   if (sizea > sizeb)
578     return -1;
579   if (sizea < sizeb)
580     return 1;
581
582   /* Tertiary compare on true alignment, decreasing.  */
583   if (aligna < alignb)
584     return -1;
585   if (aligna > alignb)
586     return 1;
587
588   /* Final compare on ID for sort stability, increasing.
589      Two SSA names are compared by their version, SSA names come before
590      non-SSA names, and two normal decls are compared by their DECL_UID.  */
591   if (TREE_CODE (decla) == SSA_NAME)
592     {
593       if (TREE_CODE (declb) == SSA_NAME)
594         uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
595       else
596         return -1;
597     }
598   else if (TREE_CODE (declb) == SSA_NAME)
599     return 1;
600   else
601     uida = DECL_UID (decla), uidb = DECL_UID (declb);
602   if (uida < uidb)
603     return 1;
604   if (uida > uidb)
605     return -1;
606   return 0;
607 }
608
609
610 /* If the points-to solution *PI points to variables that are in a partition
611    together with other variables add all partition members to the pointed-to
612    variables bitmap.  */
613
614 static void
615 add_partitioned_vars_to_ptset (struct pt_solution *pt,
616                                struct pointer_map_t *decls_to_partitions,
617                                struct pointer_set_t *visited, bitmap temp)
618 {
619   bitmap_iterator bi;
620   unsigned i;
621   bitmap *part;
622
623   if (pt->anything
624       || pt->vars == NULL
625       /* The pointed-to vars bitmap is shared, it is enough to
626          visit it once.  */
627       || pointer_set_insert(visited, pt->vars))
628     return;
629
630   bitmap_clear (temp);
631
632   /* By using a temporary bitmap to store all members of the partitions
633      we have to add we make sure to visit each of the partitions only
634      once.  */
635   EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
636     if ((!temp
637          || !bitmap_bit_p (temp, i))
638         && (part = (bitmap *) pointer_map_contains (decls_to_partitions,
639                                                     (void *)(size_t) i)))
640       bitmap_ior_into (temp, *part);
641   if (!bitmap_empty_p (temp))
642     bitmap_ior_into (pt->vars, temp);
643 }
644
645 /* Update points-to sets based on partition info, so we can use them on RTL.
646    The bitmaps representing stack partitions will be saved until expand,
647    where partitioned decls used as bases in memory expressions will be
648    rewritten.  */
649
650 static void
651 update_alias_info_with_stack_vars (void)
652 {
653   struct pointer_map_t *decls_to_partitions = NULL;
654   size_t i, j;
655   tree var = NULL_TREE;
656
657   for (i = 0; i < stack_vars_num; i++)
658     {
659       bitmap part = NULL;
660       tree name;
661       struct ptr_info_def *pi;
662
663       /* Not interested in partitions with single variable.  */
664       if (stack_vars[i].representative != i
665           || stack_vars[i].next == EOC)
666         continue;
667
668       if (!decls_to_partitions)
669         {
670           decls_to_partitions = pointer_map_create ();
671           cfun->gimple_df->decls_to_pointers = pointer_map_create ();
672         }
673
674       /* Create an SSA_NAME that points to the partition for use
675          as base during alias-oracle queries on RTL for bases that
676          have been partitioned.  */
677       if (var == NULL_TREE)
678         var = create_tmp_var (ptr_type_node, NULL);
679       name = make_ssa_name (var, NULL);
680
681       /* Create bitmaps representing partitions.  They will be used for
682          points-to sets later, so use GGC alloc.  */
683       part = BITMAP_GGC_ALLOC ();
684       for (j = i; j != EOC; j = stack_vars[j].next)
685         {
686           tree decl = stack_vars[j].decl;
687           unsigned int uid = DECL_PT_UID (decl);
688           /* We should never end up partitioning SSA names (though they
689              may end up on the stack).  Neither should we allocate stack
690              space to something that is unused and thus unreferenced, except
691              for -O0 where we are preserving even unreferenced variables.  */
692           gcc_assert (DECL_P (decl)
693                       && (!optimize
694                           || referenced_var_lookup (cfun, DECL_UID (decl))));
695           bitmap_set_bit (part, uid);
696           *((bitmap *) pointer_map_insert (decls_to_partitions,
697                                            (void *)(size_t) uid)) = part;
698           *((tree *) pointer_map_insert (cfun->gimple_df->decls_to_pointers,
699                                          decl)) = name;
700           if (TREE_ADDRESSABLE (decl))
701             TREE_ADDRESSABLE (name) = 1;
702         }
703
704       /* Make the SSA name point to all partition members.  */
705       pi = get_ptr_info (name);
706       pt_solution_set (&pi->pt, part, false);
707     }
708
709   /* Make all points-to sets that contain one member of a partition
710      contain all members of the partition.  */
711   if (decls_to_partitions)
712     {
713       unsigned i;
714       struct pointer_set_t *visited = pointer_set_create ();
715       bitmap temp = BITMAP_ALLOC (NULL);
716
717       for (i = 1; i < num_ssa_names; i++)
718         {
719           tree name = ssa_name (i);
720           struct ptr_info_def *pi;
721
722           if (name
723               && POINTER_TYPE_P (TREE_TYPE (name))
724               && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
725             add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
726                                            visited, temp);
727         }
728
729       add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
730                                      decls_to_partitions, visited, temp);
731
732       pointer_set_destroy (visited);
733       pointer_map_destroy (decls_to_partitions);
734       BITMAP_FREE (temp);
735     }
736 }
737
738 /* A subroutine of partition_stack_vars.  The UNION portion of a UNION/FIND
739    partitioning algorithm.  Partitions A and B are known to be non-conflicting.
740    Merge them into a single partition A.  */
741
742 static void
743 union_stack_vars (size_t a, size_t b)
744 {
745   struct stack_var *vb = &stack_vars[b];
746   bitmap_iterator bi;
747   unsigned u;
748
749   gcc_assert (stack_vars[b].next == EOC);
750    /* Add B to A's partition.  */
751   stack_vars[b].next = stack_vars[a].next;
752   stack_vars[b].representative = a;
753   stack_vars[a].next = b;
754
755   /* Update the required alignment of partition A to account for B.  */
756   if (stack_vars[a].alignb < stack_vars[b].alignb)
757     stack_vars[a].alignb = stack_vars[b].alignb;
758
759   /* Update the interference graph and merge the conflicts.  */
760   if (vb->conflicts)
761     {
762       EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)
763         add_stack_var_conflict (a, stack_vars[u].representative);
764       BITMAP_FREE (vb->conflicts);
765     }
766 }
767
768 /* A subroutine of expand_used_vars.  Binpack the variables into
769    partitions constrained by the interference graph.  The overall
770    algorithm used is as follows:
771
772         Sort the objects by size in descending order.
773         For each object A {
774           S = size(A)
775           O = 0
776           loop {
777             Look for the largest non-conflicting object B with size <= S.
778             UNION (A, B)
779           }
780         }
781 */
782
783 static void
784 partition_stack_vars (void)
785 {
786   size_t si, sj, n = stack_vars_num;
787
788   stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
789   for (si = 0; si < n; ++si)
790     stack_vars_sorted[si] = si;
791
792   if (n == 1)
793     return;
794
795   qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp);
796
797   for (si = 0; si < n; ++si)
798     {
799       size_t i = stack_vars_sorted[si];
800       unsigned int ialign = stack_vars[i].alignb;
801
802       /* Ignore objects that aren't partition representatives. If we
803          see a var that is not a partition representative, it must
804          have been merged earlier.  */
805       if (stack_vars[i].representative != i)
806         continue;
807
808       for (sj = si + 1; sj < n; ++sj)
809         {
810           size_t j = stack_vars_sorted[sj];
811           unsigned int jalign = stack_vars[j].alignb;
812
813           /* Ignore objects that aren't partition representatives.  */
814           if (stack_vars[j].representative != j)
815             continue;
816
817           /* Ignore conflicting objects.  */
818           if (stack_var_conflict_p (i, j))
819             continue;
820
821           /* Do not mix objects of "small" (supported) alignment
822              and "large" (unsupported) alignment.  */
823           if ((ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
824               != (jalign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT))
825             continue;
826
827           /* UNION the objects, placing J at OFFSET.  */
828           union_stack_vars (i, j);
829         }
830     }
831
832   update_alias_info_with_stack_vars ();
833 }
834
835 /* A debugging aid for expand_used_vars.  Dump the generated partitions.  */
836
837 static void
838 dump_stack_var_partition (void)
839 {
840   size_t si, i, j, n = stack_vars_num;
841
842   for (si = 0; si < n; ++si)
843     {
844       i = stack_vars_sorted[si];
845
846       /* Skip variables that aren't partition representatives, for now.  */
847       if (stack_vars[i].representative != i)
848         continue;
849
850       fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
851                " align %u\n", (unsigned long) i, stack_vars[i].size,
852                stack_vars[i].alignb);
853
854       for (j = i; j != EOC; j = stack_vars[j].next)
855         {
856           fputc ('\t', dump_file);
857           print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
858         }
859       fputc ('\n', dump_file);
860     }
861 }
862
863 /* Assign rtl to DECL at BASE + OFFSET.  */
864
865 static void
866 expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
867                          HOST_WIDE_INT offset)
868 {
869   unsigned align;
870   rtx x;
871
872   /* If this fails, we've overflowed the stack frame.  Error nicely?  */
873   gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
874
875   x = plus_constant (base, offset);
876   x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
877
878   if (TREE_CODE (decl) != SSA_NAME)
879     {
880       /* Set alignment we actually gave this decl if it isn't an SSA name.
881          If it is we generate stack slots only accidentally so it isn't as
882          important, we'll simply use the alignment that is already set.  */
883       if (base == virtual_stack_vars_rtx)
884         offset -= frame_phase;
885       align = offset & -offset;
886       align *= BITS_PER_UNIT;
887       if (align == 0 || align > base_align)
888         align = base_align;
889
890       /* One would think that we could assert that we're not decreasing
891          alignment here, but (at least) the i386 port does exactly this
892          via the MINIMUM_ALIGNMENT hook.  */
893
894       DECL_ALIGN (decl) = align;
895       DECL_USER_ALIGN (decl) = 0;
896     }
897
898   set_mem_attributes (x, SSAVAR (decl), true);
899   set_rtl (decl, x);
900 }
901
902 /* A subroutine of expand_used_vars.  Give each partition representative
903    a unique location within the stack frame.  Update each partition member
904    with that location.  */
905
906 static void
907 expand_stack_vars (bool (*pred) (tree))
908 {
909   size_t si, i, j, n = stack_vars_num;
910   HOST_WIDE_INT large_size = 0, large_alloc = 0;
911   rtx large_base = NULL;
912   unsigned large_align = 0;
913   tree decl;
914
915   /* Determine if there are any variables requiring "large" alignment.
916      Since these are dynamically allocated, we only process these if
917      no predicate involved.  */
918   large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT;
919   if (pred == NULL && large_align > MAX_SUPPORTED_STACK_ALIGNMENT)
920     {
921       /* Find the total size of these variables.  */
922       for (si = 0; si < n; ++si)
923         {
924           unsigned alignb;
925
926           i = stack_vars_sorted[si];
927           alignb = stack_vars[i].alignb;
928
929           /* Stop when we get to the first decl with "small" alignment.  */
930           if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
931             break;
932
933           /* Skip variables that aren't partition representatives.  */
934           if (stack_vars[i].representative != i)
935             continue;
936
937           /* Skip variables that have already had rtl assigned.  See also
938              add_stack_var where we perpetrate this pc_rtx hack.  */
939           decl = stack_vars[i].decl;
940           if ((TREE_CODE (decl) == SSA_NAME
941               ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
942               : DECL_RTL (decl)) != pc_rtx)
943             continue;
944
945           large_size += alignb - 1;
946           large_size &= -(HOST_WIDE_INT)alignb;
947           large_size += stack_vars[i].size;
948         }
949
950       /* If there were any, allocate space.  */
951       if (large_size > 0)
952         large_base = allocate_dynamic_stack_space (GEN_INT (large_size), 0,
953                                                    large_align, true);
954     }
955
956   for (si = 0; si < n; ++si)
957     {
958       rtx base;
959       unsigned base_align, alignb;
960       HOST_WIDE_INT offset;
961
962       i = stack_vars_sorted[si];
963
964       /* Skip variables that aren't partition representatives, for now.  */
965       if (stack_vars[i].representative != i)
966         continue;
967
968       /* Skip variables that have already had rtl assigned.  See also
969          add_stack_var where we perpetrate this pc_rtx hack.  */
970       decl = stack_vars[i].decl;
971       if ((TREE_CODE (decl) == SSA_NAME
972            ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
973            : DECL_RTL (decl)) != pc_rtx)
974         continue;
975
976       /* Check the predicate to see whether this variable should be
977          allocated in this pass.  */
978       if (pred && !pred (decl))
979         continue;
980
981       alignb = stack_vars[i].alignb;
982       if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
983         {
984           offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
985           base = virtual_stack_vars_rtx;
986           base_align = crtl->max_used_stack_slot_alignment;
987         }
988       else
989         {
990           /* Large alignment is only processed in the last pass.  */
991           if (pred)
992             continue;
993           gcc_assert (large_base != NULL);
994
995           large_alloc += alignb - 1;
996           large_alloc &= -(HOST_WIDE_INT)alignb;
997           offset = large_alloc;
998           large_alloc += stack_vars[i].size;
999
1000           base = large_base;
1001           base_align = large_align;
1002         }
1003
1004       /* Create rtl for each variable based on their location within the
1005          partition.  */
1006       for (j = i; j != EOC; j = stack_vars[j].next)
1007         {
1008           expand_one_stack_var_at (stack_vars[j].decl,
1009                                    base, base_align,
1010                                    offset);
1011         }
1012     }
1013
1014   gcc_assert (large_alloc == large_size);
1015 }
1016
1017 /* Take into account all sizes of partitions and reset DECL_RTLs.  */
1018 static HOST_WIDE_INT
1019 account_stack_vars (void)
1020 {
1021   size_t si, j, i, n = stack_vars_num;
1022   HOST_WIDE_INT size = 0;
1023
1024   for (si = 0; si < n; ++si)
1025     {
1026       i = stack_vars_sorted[si];
1027
1028       /* Skip variables that aren't partition representatives, for now.  */
1029       if (stack_vars[i].representative != i)
1030         continue;
1031
1032       size += stack_vars[i].size;
1033       for (j = i; j != EOC; j = stack_vars[j].next)
1034         set_rtl (stack_vars[j].decl, NULL);
1035     }
1036   return size;
1037 }
1038
1039 /* A subroutine of expand_one_var.  Called to immediately assign rtl
1040    to a variable to be allocated in the stack frame.  */
1041
1042 static void
1043 expand_one_stack_var (tree var)
1044 {
1045   HOST_WIDE_INT size, offset;
1046   unsigned byte_align;
1047
1048   size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var)), 1);
1049   byte_align = align_local_variable (SSAVAR (var));
1050
1051   /* We handle highly aligned variables in expand_stack_vars.  */
1052   gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
1053
1054   offset = alloc_stack_frame_space (size, byte_align);
1055
1056   expand_one_stack_var_at (var, virtual_stack_vars_rtx,
1057                            crtl->max_used_stack_slot_alignment, offset);
1058 }
1059
1060 /* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL
1061    that will reside in a hard register.  */
1062
1063 static void
1064 expand_one_hard_reg_var (tree var)
1065 {
1066   rest_of_decl_compilation (var, 0, 0);
1067 }
1068
1069 /* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL
1070    that will reside in a pseudo register.  */
1071
1072 static void
1073 expand_one_register_var (tree var)
1074 {
1075   tree decl = SSAVAR (var);
1076   tree type = TREE_TYPE (decl);
1077   enum machine_mode reg_mode = promote_decl_mode (decl, NULL);
1078   rtx x = gen_reg_rtx (reg_mode);
1079
1080   set_rtl (var, x);
1081
1082   /* Note if the object is a user variable.  */
1083   if (!DECL_ARTIFICIAL (decl))
1084     mark_user_reg (x);
1085
1086   if (POINTER_TYPE_P (type))
1087     mark_reg_pointer (x, get_pointer_alignment (var));
1088 }
1089
1090 /* A subroutine of expand_one_var.  Called to assign rtl to a VAR_DECL that
1091    has some associated error, e.g. its type is error-mark.  We just need
1092    to pick something that won't crash the rest of the compiler.  */
1093
1094 static void
1095 expand_one_error_var (tree var)
1096 {
1097   enum machine_mode mode = DECL_MODE (var);
1098   rtx x;
1099
1100   if (mode == BLKmode)
1101     x = gen_rtx_MEM (BLKmode, const0_rtx);
1102   else if (mode == VOIDmode)
1103     x = const0_rtx;
1104   else
1105     x = gen_reg_rtx (mode);
1106
1107   SET_DECL_RTL (var, x);
1108 }
1109
1110 /* A subroutine of expand_one_var.  VAR is a variable that will be
1111    allocated to the local stack frame.  Return true if we wish to
1112    add VAR to STACK_VARS so that it will be coalesced with other
1113    variables.  Return false to allocate VAR immediately.
1114
1115    This function is used to reduce the number of variables considered
1116    for coalescing, which reduces the size of the quadratic problem.  */
1117
1118 static bool
1119 defer_stack_allocation (tree var, bool toplevel)
1120 {
1121   /* If stack protection is enabled, *all* stack variables must be deferred,
1122      so that we can re-order the strings to the top of the frame.  */
1123   if (flag_stack_protect)
1124     return true;
1125
1126   /* We handle "large" alignment via dynamic allocation.  We want to handle
1127      this extra complication in only one place, so defer them.  */
1128   if (DECL_ALIGN (var) > MAX_SUPPORTED_STACK_ALIGNMENT)
1129     return true;
1130
1131   /* Variables in the outermost scope automatically conflict with
1132      every other variable.  The only reason to want to defer them
1133      at all is that, after sorting, we can more efficiently pack
1134      small variables in the stack frame.  Continue to defer at -O2.  */
1135   if (toplevel && optimize < 2)
1136     return false;
1137
1138   /* Without optimization, *most* variables are allocated from the
1139      stack, which makes the quadratic problem large exactly when we
1140      want compilation to proceed as quickly as possible.  On the
1141      other hand, we don't want the function's stack frame size to
1142      get completely out of hand.  So we avoid adding scalars and
1143      "small" aggregates to the list at all.  */
1144   if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
1145     return false;
1146
1147   return true;
1148 }
1149
1150 /* A subroutine of expand_used_vars.  Expand one variable according to
1151    its flavor.  Variables to be placed on the stack are not actually
1152    expanded yet, merely recorded.
1153    When REALLY_EXPAND is false, only add stack values to be allocated.
1154    Return stack usage this variable is supposed to take.
1155 */
1156
1157 static HOST_WIDE_INT
1158 expand_one_var (tree var, bool toplevel, bool really_expand)
1159 {
1160   unsigned int align = BITS_PER_UNIT;
1161   tree origvar = var;
1162
1163   var = SSAVAR (var);
1164
1165   if (TREE_TYPE (var) != error_mark_node && TREE_CODE (var) == VAR_DECL)
1166     {
1167       /* Because we don't know if VAR will be in register or on stack,
1168          we conservatively assume it will be on stack even if VAR is
1169          eventually put into register after RA pass.  For non-automatic
1170          variables, which won't be on stack, we collect alignment of
1171          type and ignore user specified alignment.  */
1172       if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1173         align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1174                                    TYPE_MODE (TREE_TYPE (var)),
1175                                    TYPE_ALIGN (TREE_TYPE (var)));
1176       else if (DECL_HAS_VALUE_EXPR_P (var)
1177                || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
1178         /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1179            or variables which were assigned a stack slot already by
1180            expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1181            changed from the offset chosen to it.  */
1182         align = crtl->stack_alignment_estimated;
1183       else
1184         align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
1185
1186       /* If the variable alignment is very large we'll dynamicaly allocate
1187          it, which means that in-frame portion is just a pointer.  */
1188       if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1189         align = POINTER_SIZE;
1190     }
1191
1192   if (SUPPORTS_STACK_ALIGNMENT
1193       && crtl->stack_alignment_estimated < align)
1194     {
1195       /* stack_alignment_estimated shouldn't change after stack
1196          realign decision made */
1197       gcc_assert(!crtl->stack_realign_processed);
1198       crtl->stack_alignment_estimated = align;
1199     }
1200
1201   /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1202      So here we only make sure stack_alignment_needed >= align.  */
1203   if (crtl->stack_alignment_needed < align)
1204     crtl->stack_alignment_needed = align;
1205   if (crtl->max_used_stack_slot_alignment < align)
1206     crtl->max_used_stack_slot_alignment = align;
1207
1208   if (TREE_CODE (origvar) == SSA_NAME)
1209     {
1210       gcc_assert (TREE_CODE (var) != VAR_DECL
1211                   || (!DECL_EXTERNAL (var)
1212                       && !DECL_HAS_VALUE_EXPR_P (var)
1213                       && !TREE_STATIC (var)
1214                       && TREE_TYPE (var) != error_mark_node
1215                       && !DECL_HARD_REGISTER (var)
1216                       && really_expand));
1217     }
1218   if (TREE_CODE (var) != VAR_DECL && TREE_CODE (origvar) != SSA_NAME)
1219     ;
1220   else if (DECL_EXTERNAL (var))
1221     ;
1222   else if (DECL_HAS_VALUE_EXPR_P (var))
1223     ;
1224   else if (TREE_STATIC (var))
1225     ;
1226   else if (TREE_CODE (origvar) != SSA_NAME && DECL_RTL_SET_P (var))
1227     ;
1228   else if (TREE_TYPE (var) == error_mark_node)
1229     {
1230       if (really_expand)
1231         expand_one_error_var (var);
1232     }
1233   else if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
1234     {
1235       if (really_expand)
1236         expand_one_hard_reg_var (var);
1237     }
1238   else if (use_register_for_decl (var))
1239     {
1240       if (really_expand)
1241         expand_one_register_var (origvar);
1242     }
1243   else if (!host_integerp (DECL_SIZE_UNIT (var), 1))
1244     {
1245       if (really_expand)
1246         {
1247           error ("size of variable %q+D is too large", var);
1248           expand_one_error_var (var);
1249         }
1250     }
1251   else if (defer_stack_allocation (var, toplevel))
1252     add_stack_var (origvar);
1253   else
1254     {
1255       if (really_expand)
1256         expand_one_stack_var (origvar);
1257       return tree_low_cst (DECL_SIZE_UNIT (var), 1);
1258     }
1259   return 0;
1260 }
1261
1262 /* A subroutine of expand_used_vars.  Walk down through the BLOCK tree
1263    expanding variables.  Those variables that can be put into registers
1264    are allocated pseudos; those that can't are put on the stack.
1265
1266    TOPLEVEL is true if this is the outermost BLOCK.  */
1267
1268 static void
1269 expand_used_vars_for_block (tree block, bool toplevel)
1270 {
1271   tree t;
1272
1273   /* Expand all variables at this level.  */
1274   for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1275     if (TREE_USED (t)
1276         && ((TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != RESULT_DECL)
1277             || !DECL_NONSHAREABLE (t)))
1278       expand_one_var (t, toplevel, true);
1279
1280   /* Expand all variables at containing levels.  */
1281   for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1282     expand_used_vars_for_block (t, false);
1283 }
1284
1285 /* A subroutine of expand_used_vars.  Walk down through the BLOCK tree
1286    and clear TREE_USED on all local variables.  */
1287
1288 static void
1289 clear_tree_used (tree block)
1290 {
1291   tree t;
1292
1293   for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1294     /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1295     if ((TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != RESULT_DECL)
1296         || !DECL_NONSHAREABLE (t))
1297       TREE_USED (t) = 0;
1298
1299   for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1300     clear_tree_used (t);
1301 }
1302
1303 /* Examine TYPE and determine a bit mask of the following features.  */
1304
1305 #define SPCT_HAS_LARGE_CHAR_ARRAY       1
1306 #define SPCT_HAS_SMALL_CHAR_ARRAY       2
1307 #define SPCT_HAS_ARRAY                  4
1308 #define SPCT_HAS_AGGREGATE              8
1309
1310 static unsigned int
1311 stack_protect_classify_type (tree type)
1312 {
1313   unsigned int ret = 0;
1314   tree t;
1315
1316   switch (TREE_CODE (type))
1317     {
1318     case ARRAY_TYPE:
1319       t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1320       if (t == char_type_node
1321           || t == signed_char_type_node
1322           || t == unsigned_char_type_node)
1323         {
1324           unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
1325           unsigned HOST_WIDE_INT len;
1326
1327           if (!TYPE_SIZE_UNIT (type)
1328               || !host_integerp (TYPE_SIZE_UNIT (type), 1))
1329             len = max;
1330           else
1331             len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
1332
1333           if (len < max)
1334             ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
1335           else
1336             ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
1337         }
1338       else
1339         ret = SPCT_HAS_ARRAY;
1340       break;
1341
1342     case UNION_TYPE:
1343     case QUAL_UNION_TYPE:
1344     case RECORD_TYPE:
1345       ret = SPCT_HAS_AGGREGATE;
1346       for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
1347         if (TREE_CODE (t) == FIELD_DECL)
1348           ret |= stack_protect_classify_type (TREE_TYPE (t));
1349       break;
1350
1351     default:
1352       break;
1353     }
1354
1355   return ret;
1356 }
1357
1358 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1359    part of the local stack frame.  Remember if we ever return nonzero for
1360    any variable in this function.  The return value is the phase number in
1361    which the variable should be allocated.  */
1362
1363 static int
1364 stack_protect_decl_phase (tree decl)
1365 {
1366   unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
1367   int ret = 0;
1368
1369   if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
1370     has_short_buffer = true;
1371
1372   if (flag_stack_protect == 2)
1373     {
1374       if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
1375           && !(bits & SPCT_HAS_AGGREGATE))
1376         ret = 1;
1377       else if (bits & SPCT_HAS_ARRAY)
1378         ret = 2;
1379     }
1380   else
1381     ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
1382
1383   if (ret)
1384     has_protected_decls = true;
1385
1386   return ret;
1387 }
1388
1389 /* Two helper routines that check for phase 1 and phase 2.  These are used
1390    as callbacks for expand_stack_vars.  */
1391
1392 static bool
1393 stack_protect_decl_phase_1 (tree decl)
1394 {
1395   return stack_protect_decl_phase (decl) == 1;
1396 }
1397
1398 static bool
1399 stack_protect_decl_phase_2 (tree decl)
1400 {
1401   return stack_protect_decl_phase (decl) == 2;
1402 }
1403
1404 /* Ensure that variables in different stack protection phases conflict
1405    so that they are not merged and share the same stack slot.  */
1406
1407 static void
1408 add_stack_protection_conflicts (void)
1409 {
1410   size_t i, j, n = stack_vars_num;
1411   unsigned char *phase;
1412
1413   phase = XNEWVEC (unsigned char, n);
1414   for (i = 0; i < n; ++i)
1415     phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
1416
1417   for (i = 0; i < n; ++i)
1418     {
1419       unsigned char ph_i = phase[i];
1420       for (j = 0; j < i; ++j)
1421         if (ph_i != phase[j])
1422           add_stack_var_conflict (i, j);
1423     }
1424
1425   XDELETEVEC (phase);
1426 }
1427
1428 /* Create a decl for the guard at the top of the stack frame.  */
1429
1430 static void
1431 create_stack_guard (void)
1432 {
1433   tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
1434                            VAR_DECL, NULL, ptr_type_node);
1435   TREE_THIS_VOLATILE (guard) = 1;
1436   TREE_USED (guard) = 1;
1437   expand_one_stack_var (guard);
1438   crtl->stack_protect_guard = guard;
1439 }
1440
1441 /* Prepare for expanding variables.  */
1442 static void
1443 init_vars_expansion (void)
1444 {
1445   tree t;
1446   unsigned ix;
1447   /* Set TREE_USED on all variables in the local_decls.  */
1448   FOR_EACH_LOCAL_DECL (cfun, ix, t)
1449     TREE_USED (t) = 1;
1450
1451   /* Clear TREE_USED on all variables associated with a block scope.  */
1452   clear_tree_used (DECL_INITIAL (current_function_decl));
1453
1454   /* Initialize local stack smashing state.  */
1455   has_protected_decls = false;
1456   has_short_buffer = false;
1457 }
1458
1459 /* Free up stack variable graph data.  */
1460 static void
1461 fini_vars_expansion (void)
1462 {
1463   size_t i, n = stack_vars_num;
1464   for (i = 0; i < n; i++)
1465     BITMAP_FREE (stack_vars[i].conflicts);
1466   XDELETEVEC (stack_vars);
1467   XDELETEVEC (stack_vars_sorted);
1468   stack_vars = NULL;
1469   stack_vars_alloc = stack_vars_num = 0;
1470   pointer_map_destroy (decl_to_stack_part);
1471   decl_to_stack_part = NULL;
1472 }
1473
1474 /* Make a fair guess for the size of the stack frame of the function
1475    in NODE.  This doesn't have to be exact, the result is only used in
1476    the inline heuristics.  So we don't want to run the full stack var
1477    packing algorithm (which is quadratic in the number of stack vars).
1478    Instead, we calculate the total size of all stack vars.  This turns
1479    out to be a pretty fair estimate -- packing of stack vars doesn't
1480    happen very often.  */
1481
1482 HOST_WIDE_INT
1483 estimated_stack_frame_size (struct cgraph_node *node)
1484 {
1485   HOST_WIDE_INT size = 0;
1486   size_t i;
1487   tree var;
1488   tree old_cur_fun_decl = current_function_decl;
1489   referenced_var_iterator rvi;
1490   struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
1491
1492   current_function_decl = node->decl;
1493   push_cfun (fn);
1494
1495   gcc_checking_assert (gimple_referenced_vars (fn));
1496   FOR_EACH_REFERENCED_VAR (fn, var, rvi)
1497     size += expand_one_var (var, true, false);
1498
1499   if (stack_vars_num > 0)
1500     {
1501       /* Fake sorting the stack vars for account_stack_vars ().  */
1502       stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
1503       for (i = 0; i < stack_vars_num; ++i)
1504         stack_vars_sorted[i] = i;
1505       size += account_stack_vars ();
1506       fini_vars_expansion ();
1507     }
1508   pop_cfun ();
1509   current_function_decl = old_cur_fun_decl;
1510   return size;
1511 }
1512
1513 /* Expand all variables used in the function.  */
1514
1515 static void
1516 expand_used_vars (void)
1517 {
1518   tree var, outer_block = DECL_INITIAL (current_function_decl);
1519   VEC(tree,heap) *maybe_local_decls = NULL;
1520   unsigned i;
1521   unsigned len;
1522
1523   /* Compute the phase of the stack frame for this function.  */
1524   {
1525     int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1526     int off = STARTING_FRAME_OFFSET % align;
1527     frame_phase = off ? align - off : 0;
1528   }
1529
1530   init_vars_expansion ();
1531
1532   for (i = 0; i < SA.map->num_partitions; i++)
1533     {
1534       tree var = partition_to_var (SA.map, i);
1535
1536       gcc_assert (is_gimple_reg (var));
1537       if (TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
1538         expand_one_var (var, true, true);
1539       else
1540         {
1541           /* This is a PARM_DECL or RESULT_DECL.  For those partitions that
1542              contain the default def (representing the parm or result itself)
1543              we don't do anything here.  But those which don't contain the
1544              default def (representing a temporary based on the parm/result)
1545              we need to allocate space just like for normal VAR_DECLs.  */
1546           if (!bitmap_bit_p (SA.partition_has_default_def, i))
1547             {
1548               expand_one_var (var, true, true);
1549               gcc_assert (SA.partition_to_pseudo[i]);
1550             }
1551         }
1552     }
1553
1554   /* At this point all variables on the local_decls with TREE_USED
1555      set are not associated with any block scope.  Lay them out.  */
1556
1557   len = VEC_length (tree, cfun->local_decls);
1558   FOR_EACH_LOCAL_DECL (cfun, i, var)
1559     {
1560       bool expand_now = false;
1561
1562       /* Expanded above already.  */
1563       if (is_gimple_reg (var))
1564         {
1565           TREE_USED (var) = 0;
1566           goto next;
1567         }
1568       /* We didn't set a block for static or extern because it's hard
1569          to tell the difference between a global variable (re)declared
1570          in a local scope, and one that's really declared there to
1571          begin with.  And it doesn't really matter much, since we're
1572          not giving them stack space.  Expand them now.  */
1573       else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1574         expand_now = true;
1575
1576       /* If the variable is not associated with any block, then it
1577          was created by the optimizers, and could be live anywhere
1578          in the function.  */
1579       else if (TREE_USED (var))
1580         expand_now = true;
1581
1582       /* Finally, mark all variables on the list as used.  We'll use
1583          this in a moment when we expand those associated with scopes.  */
1584       TREE_USED (var) = 1;
1585
1586       if (expand_now)
1587         expand_one_var (var, true, true);
1588
1589     next:
1590       if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
1591         {
1592           rtx rtl = DECL_RTL_IF_SET (var);
1593
1594           /* Keep artificial non-ignored vars in cfun->local_decls
1595              chain until instantiate_decls.  */
1596           if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
1597             add_local_decl (cfun, var);
1598           else if (rtl == NULL_RTX)
1599             /* If rtl isn't set yet, which can happen e.g. with
1600                -fstack-protector, retry before returning from this
1601                function.  */
1602             VEC_safe_push (tree, heap, maybe_local_decls, var);
1603         }
1604     }
1605
1606   /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1607
1608      +-----------------+-----------------+
1609      | ...processed... | ...duplicates...|
1610      +-----------------+-----------------+
1611                        ^
1612                        +-- LEN points here.
1613
1614      We just want the duplicates, as those are the artificial
1615      non-ignored vars that we want to keep until instantiate_decls.
1616      Move them down and truncate the array.  */
1617   if (!VEC_empty (tree, cfun->local_decls))
1618     VEC_block_remove (tree, cfun->local_decls, 0, len);
1619
1620   /* At this point, all variables within the block tree with TREE_USED
1621      set are actually used by the optimized function.  Lay them out.  */
1622   expand_used_vars_for_block (outer_block, true);
1623
1624   if (stack_vars_num > 0)
1625     {
1626       add_scope_conflicts ();
1627       /* Due to the way alias sets work, no variables with non-conflicting
1628          alias sets may be assigned the same address.  Add conflicts to
1629          reflect this.  */
1630       add_alias_set_conflicts ();
1631
1632       /* If stack protection is enabled, we don't share space between
1633          vulnerable data and non-vulnerable data.  */
1634       if (flag_stack_protect)
1635         add_stack_protection_conflicts ();
1636
1637       /* Now that we have collected all stack variables, and have computed a
1638          minimal interference graph, attempt to save some stack space.  */
1639       partition_stack_vars ();
1640       if (dump_file)
1641         dump_stack_var_partition ();
1642     }
1643
1644   /* There are several conditions under which we should create a
1645      stack guard: protect-all, alloca used, protected decls present.  */
1646   if (flag_stack_protect == 2
1647       || (flag_stack_protect
1648           && (cfun->calls_alloca || has_protected_decls)))
1649     create_stack_guard ();
1650
1651   /* Assign rtl to each variable based on these partitions.  */
1652   if (stack_vars_num > 0)
1653     {
1654       /* Reorder decls to be protected by iterating over the variables
1655          array multiple times, and allocating out of each phase in turn.  */
1656       /* ??? We could probably integrate this into the qsort we did
1657          earlier, such that we naturally see these variables first,
1658          and thus naturally allocate things in the right order.  */
1659       if (has_protected_decls)
1660         {
1661           /* Phase 1 contains only character arrays.  */
1662           expand_stack_vars (stack_protect_decl_phase_1);
1663
1664           /* Phase 2 contains other kinds of arrays.  */
1665           if (flag_stack_protect == 2)
1666             expand_stack_vars (stack_protect_decl_phase_2);
1667         }
1668
1669       expand_stack_vars (NULL);
1670
1671       fini_vars_expansion ();
1672     }
1673
1674   /* If there were any artificial non-ignored vars without rtl
1675      found earlier, see if deferred stack allocation hasn't assigned
1676      rtl to them.  */
1677   FOR_EACH_VEC_ELT_REVERSE (tree, maybe_local_decls, i, var)
1678     {
1679       rtx rtl = DECL_RTL_IF_SET (var);
1680
1681       /* Keep artificial non-ignored vars in cfun->local_decls
1682          chain until instantiate_decls.  */
1683       if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
1684         add_local_decl (cfun, var);
1685     }
1686   VEC_free (tree, heap, maybe_local_decls);
1687
1688   /* If the target requires that FRAME_OFFSET be aligned, do it.  */
1689   if (STACK_ALIGNMENT_NEEDED)
1690     {
1691       HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1692       if (!FRAME_GROWS_DOWNWARD)
1693         frame_offset += align - 1;
1694       frame_offset &= -align;
1695     }
1696 }
1697
1698
1699 /* If we need to produce a detailed dump, print the tree representation
1700    for STMT to the dump file.  SINCE is the last RTX after which the RTL
1701    generated for STMT should have been appended.  */
1702
1703 static void
1704 maybe_dump_rtl_for_gimple_stmt (gimple stmt, rtx since)
1705 {
1706   if (dump_file && (dump_flags & TDF_DETAILS))
1707     {
1708       fprintf (dump_file, "\n;; ");
1709       print_gimple_stmt (dump_file, stmt, 0,
1710                          TDF_SLIM | (dump_flags & TDF_LINENO));
1711       fprintf (dump_file, "\n");
1712
1713       print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1714     }
1715 }
1716
1717 /* Maps the blocks that do not contain tree labels to rtx labels.  */
1718
1719 static struct pointer_map_t *lab_rtx_for_bb;
1720
1721 /* Returns the label_rtx expression for a label starting basic block BB.  */
1722
1723 static rtx
1724 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
1725 {
1726   gimple_stmt_iterator gsi;
1727   tree lab;
1728   gimple lab_stmt;
1729   void **elt;
1730
1731   if (bb->flags & BB_RTL)
1732     return block_label (bb);
1733
1734   elt = pointer_map_contains (lab_rtx_for_bb, bb);
1735   if (elt)
1736     return (rtx) *elt;
1737
1738   /* Find the tree label if it is present.  */
1739
1740   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1741     {
1742       lab_stmt = gsi_stmt (gsi);
1743       if (gimple_code (lab_stmt) != GIMPLE_LABEL)
1744         break;
1745
1746       lab = gimple_label_label (lab_stmt);
1747       if (DECL_NONLOCAL (lab))
1748         break;
1749
1750       return label_rtx (lab);
1751     }
1752
1753   elt = pointer_map_insert (lab_rtx_for_bb, bb);
1754   *elt = gen_label_rtx ();
1755   return (rtx) *elt;
1756 }
1757
1758
1759 /* A subroutine of expand_gimple_cond.  Given E, a fallthrough edge
1760    of a basic block where we just expanded the conditional at the end,
1761    possibly clean up the CFG and instruction sequence.  LAST is the
1762    last instruction before the just emitted jump sequence.  */
1763
1764 static void
1765 maybe_cleanup_end_of_block (edge e, rtx last)
1766 {
1767   /* Special case: when jumpif decides that the condition is
1768      trivial it emits an unconditional jump (and the necessary
1769      barrier).  But we still have two edges, the fallthru one is
1770      wrong.  purge_dead_edges would clean this up later.  Unfortunately
1771      we have to insert insns (and split edges) before
1772      find_many_sub_basic_blocks and hence before purge_dead_edges.
1773      But splitting edges might create new blocks which depend on the
1774      fact that if there are two edges there's no barrier.  So the
1775      barrier would get lost and verify_flow_info would ICE.  Instead
1776      of auditing all edge splitters to care for the barrier (which
1777      normally isn't there in a cleaned CFG), fix it here.  */
1778   if (BARRIER_P (get_last_insn ()))
1779     {
1780       rtx insn;
1781       remove_edge (e);
1782       /* Now, we have a single successor block, if we have insns to
1783          insert on the remaining edge we potentially will insert
1784          it at the end of this block (if the dest block isn't feasible)
1785          in order to avoid splitting the edge.  This insertion will take
1786          place in front of the last jump.  But we might have emitted
1787          multiple jumps (conditional and one unconditional) to the
1788          same destination.  Inserting in front of the last one then
1789          is a problem.  See PR 40021.  We fix this by deleting all
1790          jumps except the last unconditional one.  */
1791       insn = PREV_INSN (get_last_insn ());
1792       /* Make sure we have an unconditional jump.  Otherwise we're
1793          confused.  */
1794       gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
1795       for (insn = PREV_INSN (insn); insn != last;)
1796         {
1797           insn = PREV_INSN (insn);
1798           if (JUMP_P (NEXT_INSN (insn)))
1799             {
1800               if (!any_condjump_p (NEXT_INSN (insn)))
1801                 {
1802                   gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))));
1803                   delete_insn (NEXT_INSN (NEXT_INSN (insn)));
1804                 }
1805               delete_insn (NEXT_INSN (insn));
1806             }
1807         }
1808     }
1809 }
1810
1811 /* A subroutine of expand_gimple_basic_block.  Expand one GIMPLE_COND.
1812    Returns a new basic block if we've terminated the current basic
1813    block and created a new one.  */
1814
1815 static basic_block
1816 expand_gimple_cond (basic_block bb, gimple stmt)
1817 {
1818   basic_block new_bb, dest;
1819   edge new_edge;
1820   edge true_edge;
1821   edge false_edge;
1822   rtx last2, last;
1823   enum tree_code code;
1824   tree op0, op1;
1825
1826   code = gimple_cond_code (stmt);
1827   op0 = gimple_cond_lhs (stmt);
1828   op1 = gimple_cond_rhs (stmt);
1829   /* We're sometimes presented with such code:
1830        D.123_1 = x < y;
1831        if (D.123_1 != 0)
1832          ...
1833      This would expand to two comparisons which then later might
1834      be cleaned up by combine.  But some pattern matchers like if-conversion
1835      work better when there's only one compare, so make up for this
1836      here as special exception if TER would have made the same change.  */
1837   if (gimple_cond_single_var_p (stmt)
1838       && SA.values
1839       && TREE_CODE (op0) == SSA_NAME
1840       && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
1841     {
1842       gimple second = SSA_NAME_DEF_STMT (op0);
1843       if (gimple_code (second) == GIMPLE_ASSIGN)
1844         {
1845           enum tree_code code2 = gimple_assign_rhs_code (second);
1846           if (TREE_CODE_CLASS (code2) == tcc_comparison)
1847             {
1848               code = code2;
1849               op0 = gimple_assign_rhs1 (second);
1850               op1 = gimple_assign_rhs2 (second);
1851             }
1852           /* If jumps are cheap turn some more codes into
1853              jumpy sequences.  */
1854           else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
1855             {
1856               if ((code2 == BIT_AND_EXPR
1857                    && TYPE_PRECISION (TREE_TYPE (op0)) == 1
1858                    && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
1859                   || code2 == TRUTH_AND_EXPR)
1860                 {
1861                   code = TRUTH_ANDIF_EXPR;
1862                   op0 = gimple_assign_rhs1 (second);
1863                   op1 = gimple_assign_rhs2 (second);
1864                 }
1865               else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
1866                 {
1867                   code = TRUTH_ORIF_EXPR;
1868                   op0 = gimple_assign_rhs1 (second);
1869                   op1 = gimple_assign_rhs2 (second);
1870                 }
1871             }
1872         }
1873     }
1874
1875   last2 = last = get_last_insn ();
1876
1877   extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1878   set_curr_insn_source_location (gimple_location (stmt));
1879   set_curr_insn_block (gimple_block (stmt));
1880
1881   /* These flags have no purpose in RTL land.  */
1882   true_edge->flags &= ~EDGE_TRUE_VALUE;
1883   false_edge->flags &= ~EDGE_FALSE_VALUE;
1884
1885   /* We can either have a pure conditional jump with one fallthru edge or
1886      two-way jump that needs to be decomposed into two basic blocks.  */
1887   if (false_edge->dest == bb->next_bb)
1888     {
1889       jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
1890                 true_edge->probability);
1891       maybe_dump_rtl_for_gimple_stmt (stmt, last);
1892       if (true_edge->goto_locus)
1893         {
1894           set_curr_insn_source_location (true_edge->goto_locus);
1895           set_curr_insn_block (true_edge->goto_block);
1896           true_edge->goto_locus = curr_insn_locator ();
1897         }
1898       true_edge->goto_block = NULL;
1899       false_edge->flags |= EDGE_FALLTHRU;
1900       maybe_cleanup_end_of_block (false_edge, last);
1901       return NULL;
1902     }
1903   if (true_edge->dest == bb->next_bb)
1904     {
1905       jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
1906                    false_edge->probability);
1907       maybe_dump_rtl_for_gimple_stmt (stmt, last);
1908       if (false_edge->goto_locus)
1909         {
1910           set_curr_insn_source_location (false_edge->goto_locus);
1911           set_curr_insn_block (false_edge->goto_block);
1912           false_edge->goto_locus = curr_insn_locator ();
1913         }
1914       false_edge->goto_block = NULL;
1915       true_edge->flags |= EDGE_FALLTHRU;
1916       maybe_cleanup_end_of_block (true_edge, last);
1917       return NULL;
1918     }
1919
1920   jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
1921             true_edge->probability);
1922   last = get_last_insn ();
1923   if (false_edge->goto_locus)
1924     {
1925       set_curr_insn_source_location (false_edge->goto_locus);
1926       set_curr_insn_block (false_edge->goto_block);
1927       false_edge->goto_locus = curr_insn_locator ();
1928     }
1929   false_edge->goto_block = NULL;
1930   emit_jump (label_rtx_for_bb (false_edge->dest));
1931
1932   BB_END (bb) = last;
1933   if (BARRIER_P (BB_END (bb)))
1934     BB_END (bb) = PREV_INSN (BB_END (bb));
1935   update_bb_for_insn (bb);
1936
1937   new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1938   dest = false_edge->dest;
1939   redirect_edge_succ (false_edge, new_bb);
1940   false_edge->flags |= EDGE_FALLTHRU;
1941   new_bb->count = false_edge->count;
1942   new_bb->frequency = EDGE_FREQUENCY (false_edge);
1943   new_edge = make_edge (new_bb, dest, 0);
1944   new_edge->probability = REG_BR_PROB_BASE;
1945   new_edge->count = new_bb->count;
1946   if (BARRIER_P (BB_END (new_bb)))
1947     BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1948   update_bb_for_insn (new_bb);
1949
1950   maybe_dump_rtl_for_gimple_stmt (stmt, last2);
1951
1952   if (true_edge->goto_locus)
1953     {
1954       set_curr_insn_source_location (true_edge->goto_locus);
1955       set_curr_insn_block (true_edge->goto_block);
1956       true_edge->goto_locus = curr_insn_locator ();
1957     }
1958   true_edge->goto_block = NULL;
1959
1960   return new_bb;
1961 }
1962
1963 /* Mark all calls that can have a transaction restart.  */
1964
1965 static void
1966 mark_transaction_restart_calls (gimple stmt)
1967 {
1968   struct tm_restart_node dummy;
1969   void **slot;
1970
1971   if (!cfun->gimple_df->tm_restart)
1972     return;
1973
1974   dummy.stmt = stmt;
1975   slot = htab_find_slot (cfun->gimple_df->tm_restart, &dummy, NO_INSERT);
1976   if (slot)
1977     {
1978       struct tm_restart_node *n = (struct tm_restart_node *) *slot;
1979       tree list = n->label_or_list;
1980       rtx insn;
1981
1982       for (insn = next_real_insn (get_last_insn ());
1983            !CALL_P (insn);
1984            insn = next_real_insn (insn))
1985         continue;
1986
1987       if (TREE_CODE (list) == LABEL_DECL)
1988         add_reg_note (insn, REG_TM, label_rtx (list));
1989       else
1990         for (; list ; list = TREE_CHAIN (list))
1991           add_reg_note (insn, REG_TM, label_rtx (TREE_VALUE (list)));
1992     }
1993 }
1994
1995 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
1996    statement STMT.  */
1997
1998 static void
1999 expand_call_stmt (gimple stmt)
2000 {
2001   tree exp, decl, lhs;
2002   bool builtin_p;
2003   size_t i;
2004
2005   if (gimple_call_internal_p (stmt))
2006     {
2007       expand_internal_call (stmt);
2008       return;
2009     }
2010
2011   exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2012
2013   CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2014   decl = gimple_call_fndecl (stmt);
2015   builtin_p = decl && DECL_BUILT_IN (decl);
2016
2017   /* If this is not a builtin function, the function type through which the
2018      call is made may be different from the type of the function.  */
2019   if (!builtin_p)
2020     CALL_EXPR_FN (exp)
2021       = fold_convert (build_pointer_type (gimple_call_fntype (stmt)),
2022                       CALL_EXPR_FN (exp));
2023
2024   TREE_TYPE (exp) = gimple_call_return_type (stmt);
2025   CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2026
2027   for (i = 0; i < gimple_call_num_args (stmt); i++)
2028     {
2029       tree arg = gimple_call_arg (stmt, i);
2030       gimple def;
2031       /* TER addresses into arguments of builtin functions so we have a
2032          chance to infer more correct alignment information.  See PR39954.  */
2033       if (builtin_p
2034           && TREE_CODE (arg) == SSA_NAME
2035           && (def = get_gimple_for_ssa_name (arg))
2036           && gimple_assign_rhs_code (def) == ADDR_EXPR)
2037         arg = gimple_assign_rhs1 (def);
2038       CALL_EXPR_ARG (exp, i) = arg;
2039     }
2040
2041   if (gimple_has_side_effects (stmt))
2042     TREE_SIDE_EFFECTS (exp) = 1;
2043
2044   if (gimple_call_nothrow_p (stmt))
2045     TREE_NOTHROW (exp) = 1;
2046
2047   CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
2048   CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
2049   if (decl
2050       && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2051       && (DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA
2052           || DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA_WITH_ALIGN))
2053     CALL_ALLOCA_FOR_VAR_P (exp) = gimple_call_alloca_for_var_p (stmt);
2054   else
2055     CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
2056   CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
2057   SET_EXPR_LOCATION (exp, gimple_location (stmt));
2058   TREE_BLOCK (exp) = gimple_block (stmt);
2059
2060   /* Ensure RTL is created for debug args.  */
2061   if (decl && DECL_HAS_DEBUG_ARGS_P (decl))
2062     {
2063       VEC(tree, gc) **debug_args = decl_debug_args_lookup (decl);
2064       unsigned int ix;
2065       tree dtemp;
2066
2067       if (debug_args)
2068         for (ix = 1; VEC_iterate (tree, *debug_args, ix, dtemp); ix += 2)
2069           {
2070             gcc_assert (TREE_CODE (dtemp) == DEBUG_EXPR_DECL);
2071             expand_debug_expr (dtemp);
2072           }
2073     }
2074
2075   lhs = gimple_call_lhs (stmt);
2076   if (lhs)
2077     expand_assignment (lhs, exp, false);
2078   else
2079     expand_expr_real_1 (exp, const0_rtx, VOIDmode, EXPAND_NORMAL, NULL);
2080
2081   mark_transaction_restart_calls (stmt);
2082 }
2083
2084 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
2085    STMT that doesn't require special handling for outgoing edges.  That
2086    is no tailcalls and no GIMPLE_COND.  */
2087
2088 static void
2089 expand_gimple_stmt_1 (gimple stmt)
2090 {
2091   tree op0;
2092
2093   set_curr_insn_source_location (gimple_location (stmt));
2094   set_curr_insn_block (gimple_block (stmt));
2095
2096   switch (gimple_code (stmt))
2097     {
2098     case GIMPLE_GOTO:
2099       op0 = gimple_goto_dest (stmt);
2100       if (TREE_CODE (op0) == LABEL_DECL)
2101         expand_goto (op0);
2102       else
2103         expand_computed_goto (op0);
2104       break;
2105     case GIMPLE_LABEL:
2106       expand_label (gimple_label_label (stmt));
2107       break;
2108     case GIMPLE_NOP:
2109     case GIMPLE_PREDICT:
2110       break;
2111     case GIMPLE_SWITCH:
2112       expand_case (stmt);
2113       break;
2114     case GIMPLE_ASM:
2115       expand_asm_stmt (stmt);
2116       break;
2117     case GIMPLE_CALL:
2118       expand_call_stmt (stmt);
2119       break;
2120
2121     case GIMPLE_RETURN:
2122       op0 = gimple_return_retval (stmt);
2123
2124       if (op0 && op0 != error_mark_node)
2125         {
2126           tree result = DECL_RESULT (current_function_decl);
2127
2128           /* If we are not returning the current function's RESULT_DECL,
2129              build an assignment to it.  */
2130           if (op0 != result)
2131             {
2132               /* I believe that a function's RESULT_DECL is unique.  */
2133               gcc_assert (TREE_CODE (op0) != RESULT_DECL);
2134
2135               /* ??? We'd like to use simply expand_assignment here,
2136                  but this fails if the value is of BLKmode but the return
2137                  decl is a register.  expand_return has special handling
2138                  for this combination, which eventually should move
2139                  to common code.  See comments there.  Until then, let's
2140                  build a modify expression :-/  */
2141               op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
2142                             result, op0);
2143             }
2144         }
2145       if (!op0)
2146         expand_null_return ();
2147       else
2148         expand_return (op0);
2149       break;
2150
2151     case GIMPLE_ASSIGN:
2152       {
2153         tree lhs = gimple_assign_lhs (stmt);
2154
2155         /* Tree expand used to fiddle with |= and &= of two bitfield
2156            COMPONENT_REFs here.  This can't happen with gimple, the LHS
2157            of binary assigns must be a gimple reg.  */
2158
2159         if (TREE_CODE (lhs) != SSA_NAME
2160             || get_gimple_rhs_class (gimple_expr_code (stmt))
2161                == GIMPLE_SINGLE_RHS)
2162           {
2163             tree rhs = gimple_assign_rhs1 (stmt);
2164             gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
2165                         == GIMPLE_SINGLE_RHS);
2166             if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs))
2167               SET_EXPR_LOCATION (rhs, gimple_location (stmt));
2168             if (TREE_CLOBBER_P (rhs))
2169               /* This is a clobber to mark the going out of scope for
2170                  this LHS.  */
2171               ;
2172             else
2173               expand_assignment (lhs, rhs,
2174                                  gimple_assign_nontemporal_move_p (stmt));
2175           }
2176         else
2177           {
2178             rtx target, temp;
2179             bool nontemporal = gimple_assign_nontemporal_move_p (stmt);
2180             struct separate_ops ops;
2181             bool promoted = false;
2182
2183             target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
2184             if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
2185               promoted = true;
2186
2187             ops.code = gimple_assign_rhs_code (stmt);
2188             ops.type = TREE_TYPE (lhs);
2189             switch (get_gimple_rhs_class (gimple_expr_code (stmt)))
2190               {
2191                 case GIMPLE_TERNARY_RHS:
2192                   ops.op2 = gimple_assign_rhs3 (stmt);
2193                   /* Fallthru */
2194                 case GIMPLE_BINARY_RHS:
2195                   ops.op1 = gimple_assign_rhs2 (stmt);
2196                   /* Fallthru */
2197                 case GIMPLE_UNARY_RHS:
2198                   ops.op0 = gimple_assign_rhs1 (stmt);
2199                   break;
2200                 default:
2201                   gcc_unreachable ();
2202               }
2203             ops.location = gimple_location (stmt);
2204
2205             /* If we want to use a nontemporal store, force the value to
2206                register first.  If we store into a promoted register,
2207                don't directly expand to target.  */
2208             temp = nontemporal || promoted ? NULL_RTX : target;
2209             temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
2210                                        EXPAND_NORMAL);
2211
2212             if (temp == target)
2213               ;
2214             else if (promoted)
2215               {
2216                 int unsignedp = SUBREG_PROMOTED_UNSIGNED_P (target);
2217                 /* If TEMP is a VOIDmode constant, use convert_modes to make
2218                    sure that we properly convert it.  */
2219                 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
2220                   {
2221                     temp = convert_modes (GET_MODE (target),
2222                                           TYPE_MODE (ops.type),
2223                                           temp, unsignedp);
2224                     temp = convert_modes (GET_MODE (SUBREG_REG (target)),
2225                                           GET_MODE (target), temp, unsignedp);
2226                   }
2227
2228                 convert_move (SUBREG_REG (target), temp, unsignedp);
2229               }
2230             else if (nontemporal && emit_storent_insn (target, temp))
2231               ;
2232             else
2233               {
2234                 temp = force_operand (temp, target);
2235                 if (temp != target)
2236                   emit_move_insn (target, temp);
2237               }
2238           }
2239       }
2240       break;
2241
2242     default:
2243       gcc_unreachable ();
2244     }
2245 }
2246
2247 /* Expand one gimple statement STMT and return the last RTL instruction
2248    before any of the newly generated ones.
2249
2250    In addition to generating the necessary RTL instructions this also
2251    sets REG_EH_REGION notes if necessary and sets the current source
2252    location for diagnostics.  */
2253
2254 static rtx
2255 expand_gimple_stmt (gimple stmt)
2256 {
2257   location_t saved_location = input_location;
2258   rtx last = get_last_insn ();
2259   int lp_nr;
2260
2261   gcc_assert (cfun);
2262
2263   /* We need to save and restore the current source location so that errors
2264      discovered during expansion are emitted with the right location.  But
2265      it would be better if the diagnostic routines used the source location
2266      embedded in the tree nodes rather than globals.  */
2267   if (gimple_has_location (stmt))
2268     input_location = gimple_location (stmt);
2269
2270   expand_gimple_stmt_1 (stmt);
2271
2272   /* Free any temporaries used to evaluate this statement.  */
2273   free_temp_slots ();
2274
2275   input_location = saved_location;
2276
2277   /* Mark all insns that may trap.  */
2278   lp_nr = lookup_stmt_eh_lp (stmt);
2279   if (lp_nr)
2280     {
2281       rtx insn;
2282       for (insn = next_real_insn (last); insn;
2283            insn = next_real_insn (insn))
2284         {
2285           if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
2286               /* If we want exceptions for non-call insns, any
2287                  may_trap_p instruction may throw.  */
2288               && GET_CODE (PATTERN (insn)) != CLOBBER
2289               && GET_CODE (PATTERN (insn)) != USE
2290               && insn_could_throw_p (insn))
2291             make_reg_eh_region_note (insn, 0, lp_nr);
2292         }
2293     }
2294
2295   return last;
2296 }
2297
2298 /* A subroutine of expand_gimple_basic_block.  Expand one GIMPLE_CALL
2299    that has CALL_EXPR_TAILCALL set.  Returns non-null if we actually
2300    generated a tail call (something that might be denied by the ABI
2301    rules governing the call; see calls.c).
2302
2303    Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
2304    can still reach the rest of BB.  The case here is __builtin_sqrt,
2305    where the NaN result goes through the external function (with a
2306    tailcall) and the normal result happens via a sqrt instruction.  */
2307
2308 static basic_block
2309 expand_gimple_tailcall (basic_block bb, gimple stmt, bool *can_fallthru)
2310 {
2311   rtx last2, last;
2312   edge e;
2313   edge_iterator ei;
2314   int probability;
2315   gcov_type count;
2316
2317   last2 = last = expand_gimple_stmt (stmt);
2318
2319   for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
2320     if (CALL_P (last) && SIBLING_CALL_P (last))
2321       goto found;
2322
2323   maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2324
2325   *can_fallthru = true;
2326   return NULL;
2327
2328  found:
2329   /* ??? Wouldn't it be better to just reset any pending stack adjust?
2330      Any instructions emitted here are about to be deleted.  */
2331   do_pending_stack_adjust ();
2332
2333   /* Remove any non-eh, non-abnormal edges that don't go to exit.  */
2334   /* ??? I.e. the fallthrough edge.  HOWEVER!  If there were to be
2335      EH or abnormal edges, we shouldn't have created a tail call in
2336      the first place.  So it seems to me we should just be removing
2337      all edges here, or redirecting the existing fallthru edge to
2338      the exit block.  */
2339
2340   probability = 0;
2341   count = 0;
2342
2343   for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
2344     {
2345       if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
2346         {
2347           if (e->dest != EXIT_BLOCK_PTR)
2348             {
2349               e->dest->count -= e->count;
2350               e->dest->frequency -= EDGE_FREQUENCY (e);
2351               if (e->dest->count < 0)
2352                 e->dest->count = 0;
2353               if (e->dest->frequency < 0)
2354                 e->dest->frequency = 0;
2355             }
2356           count += e->count;
2357           probability += e->probability;
2358           remove_edge (e);
2359         }
2360       else
2361         ei_next (&ei);
2362     }
2363
2364   /* This is somewhat ugly: the call_expr expander often emits instructions
2365      after the sibcall (to perform the function return).  These confuse the
2366      find_many_sub_basic_blocks code, so we need to get rid of these.  */
2367   last = NEXT_INSN (last);
2368   gcc_assert (BARRIER_P (last));
2369
2370   *can_fallthru = false;
2371   while (NEXT_INSN (last))
2372     {
2373       /* For instance an sqrt builtin expander expands if with
2374          sibcall in the then and label for `else`.  */
2375       if (LABEL_P (NEXT_INSN (last)))
2376         {
2377           *can_fallthru = true;
2378           break;
2379         }
2380       delete_insn (NEXT_INSN (last));
2381     }
2382
2383   e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
2384   e->probability += probability;
2385   e->count += count;
2386   BB_END (bb) = last;
2387   update_bb_for_insn (bb);
2388
2389   if (NEXT_INSN (last))
2390     {
2391       bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2392
2393       last = BB_END (bb);
2394       if (BARRIER_P (last))
2395         BB_END (bb) = PREV_INSN (last);
2396     }
2397
2398   maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2399
2400   return bb;
2401 }
2402
2403 /* Return the difference between the floor and the truncated result of
2404    a signed division by OP1 with remainder MOD.  */
2405 static rtx
2406 floor_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2407 {
2408   /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
2409   return gen_rtx_IF_THEN_ELSE
2410     (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2411      gen_rtx_IF_THEN_ELSE
2412      (mode, gen_rtx_LT (BImode,
2413                         gen_rtx_DIV (mode, op1, mod),
2414                         const0_rtx),
2415       constm1_rtx, const0_rtx),
2416      const0_rtx);
2417 }
2418
2419 /* Return the difference between the ceil and the truncated result of
2420    a signed division by OP1 with remainder MOD.  */
2421 static rtx
2422 ceil_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2423 {
2424   /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
2425   return gen_rtx_IF_THEN_ELSE
2426     (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2427      gen_rtx_IF_THEN_ELSE
2428      (mode, gen_rtx_GT (BImode,
2429                         gen_rtx_DIV (mode, op1, mod),
2430                         const0_rtx),
2431       const1_rtx, const0_rtx),
2432      const0_rtx);
2433 }
2434
2435 /* Return the difference between the ceil and the truncated result of
2436    an unsigned division by OP1 with remainder MOD.  */
2437 static rtx
2438 ceil_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
2439 {
2440   /* (mod != 0 ? 1 : 0) */
2441   return gen_rtx_IF_THEN_ELSE
2442     (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2443      const1_rtx, const0_rtx);
2444 }
2445
2446 /* Return the difference between the rounded and the truncated result
2447    of a signed division by OP1 with remainder MOD.  Halfway cases are
2448    rounded away from zero, rather than to the nearest even number.  */
2449 static rtx
2450 round_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2451 {
2452   /* (abs (mod) >= abs (op1) - abs (mod)
2453       ? (op1 / mod > 0 ? 1 : -1)
2454       : 0) */
2455   return gen_rtx_IF_THEN_ELSE
2456     (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
2457                        gen_rtx_MINUS (mode,
2458                                       gen_rtx_ABS (mode, op1),
2459                                       gen_rtx_ABS (mode, mod))),
2460      gen_rtx_IF_THEN_ELSE
2461      (mode, gen_rtx_GT (BImode,
2462                         gen_rtx_DIV (mode, op1, mod),
2463                         const0_rtx),
2464       const1_rtx, constm1_rtx),
2465      const0_rtx);
2466 }
2467
2468 /* Return the difference between the rounded and the truncated result
2469    of a unsigned division by OP1 with remainder MOD.  Halfway cases
2470    are rounded away from zero, rather than to the nearest even
2471    number.  */
2472 static rtx
2473 round_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2474 {
2475   /* (mod >= op1 - mod ? 1 : 0) */
2476   return gen_rtx_IF_THEN_ELSE
2477     (mode, gen_rtx_GE (BImode, mod,
2478                        gen_rtx_MINUS (mode, op1, mod)),
2479      const1_rtx, const0_rtx);
2480 }
2481
2482 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
2483    any rtl.  */
2484
2485 static rtx
2486 convert_debug_memory_address (enum machine_mode mode, rtx x,
2487                               addr_space_t as)
2488 {
2489   enum machine_mode xmode = GET_MODE (x);
2490
2491 #ifndef POINTERS_EXTEND_UNSIGNED
2492   gcc_assert (mode == Pmode
2493               || mode == targetm.addr_space.address_mode (as));
2494   gcc_assert (xmode == mode || xmode == VOIDmode);
2495 #else
2496   rtx temp;
2497
2498   gcc_assert (targetm.addr_space.valid_pointer_mode (mode, as));
2499
2500   if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
2501     return x;
2502
2503   if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (xmode))
2504     x = simplify_gen_subreg (mode, x, xmode,
2505                              subreg_lowpart_offset
2506                              (mode, xmode));
2507   else if (POINTERS_EXTEND_UNSIGNED > 0)
2508     x = gen_rtx_ZERO_EXTEND (mode, x);
2509   else if (!POINTERS_EXTEND_UNSIGNED)
2510     x = gen_rtx_SIGN_EXTEND (mode, x);
2511   else
2512     {
2513       switch (GET_CODE (x))
2514         {
2515         case SUBREG:
2516           if ((SUBREG_PROMOTED_VAR_P (x)
2517                || (REG_P (SUBREG_REG (x)) && REG_POINTER (SUBREG_REG (x)))
2518                || (GET_CODE (SUBREG_REG (x)) == PLUS
2519                    && REG_P (XEXP (SUBREG_REG (x), 0))
2520                    && REG_POINTER (XEXP (SUBREG_REG (x), 0))
2521                    && CONST_INT_P (XEXP (SUBREG_REG (x), 1))))
2522               && GET_MODE (SUBREG_REG (x)) == mode)
2523             return SUBREG_REG (x);
2524           break;
2525         case LABEL_REF:
2526           temp = gen_rtx_LABEL_REF (mode, XEXP (x, 0));
2527           LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
2528           return temp;
2529         case SYMBOL_REF:
2530           temp = shallow_copy_rtx (x);
2531           PUT_MODE (temp, mode);
2532           return temp;
2533         case CONST:
2534           temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
2535           if (temp)
2536             temp = gen_rtx_CONST (mode, temp);
2537           return temp;
2538         case PLUS:
2539         case MINUS:
2540           if (CONST_INT_P (XEXP (x, 1)))
2541             {
2542               temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
2543               if (temp)
2544                 return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1));
2545             }
2546           break;
2547         default:
2548           break;
2549         }
2550       /* Don't know how to express ptr_extend as operation in debug info.  */
2551       return NULL;
2552     }
2553 #endif /* POINTERS_EXTEND_UNSIGNED */
2554
2555   return x;
2556 }
2557
2558 /* Return an RTX equivalent to the value of the parameter DECL.  */
2559
2560 static rtx
2561 expand_debug_parm_decl (tree decl)
2562 {
2563   rtx incoming = DECL_INCOMING_RTL (decl);
2564
2565   if (incoming
2566       && GET_MODE (incoming) != BLKmode
2567       && ((REG_P (incoming) && HARD_REGISTER_P (incoming))
2568           || (MEM_P (incoming)
2569               && REG_P (XEXP (incoming, 0))
2570               && HARD_REGISTER_P (XEXP (incoming, 0)))))
2571     {
2572       rtx rtl = gen_rtx_ENTRY_VALUE (GET_MODE (incoming));
2573
2574 #ifdef HAVE_window_save
2575       /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
2576          If the target machine has an explicit window save instruction, the
2577          actual entry value is the corresponding OUTGOING_REGNO instead.  */
2578       if (REG_P (incoming)
2579           && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
2580         incoming
2581           = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
2582                                 OUTGOING_REGNO (REGNO (incoming)), 0);
2583       else if (MEM_P (incoming))
2584         {
2585           rtx reg = XEXP (incoming, 0);
2586           if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
2587             {
2588               reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
2589               incoming = replace_equiv_address_nv (incoming, reg);
2590             }
2591           else
2592             incoming = copy_rtx (incoming);
2593         }
2594 #endif
2595
2596       ENTRY_VALUE_EXP (rtl) = incoming;
2597       return rtl;
2598     }
2599
2600   if (incoming
2601       && GET_MODE (incoming) != BLKmode
2602       && !TREE_ADDRESSABLE (decl)
2603       && MEM_P (incoming)
2604       && (XEXP (incoming, 0) == virtual_incoming_args_rtx
2605           || (GET_CODE (XEXP (incoming, 0)) == PLUS
2606               && XEXP (XEXP (incoming, 0), 0) == virtual_incoming_args_rtx
2607               && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
2608     return copy_rtx (incoming);
2609
2610   return NULL_RTX;
2611 }
2612
2613 /* Return an RTX equivalent to the value of the tree expression EXP.  */
2614
2615 static rtx
2616 expand_debug_expr (tree exp)
2617 {
2618   rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
2619   enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2620   enum machine_mode inner_mode = VOIDmode;
2621   int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
2622   addr_space_t as;
2623
2624   switch (TREE_CODE_CLASS (TREE_CODE (exp)))
2625     {
2626     case tcc_expression:
2627       switch (TREE_CODE (exp))
2628         {
2629         case COND_EXPR:
2630         case DOT_PROD_EXPR:
2631         case WIDEN_MULT_PLUS_EXPR:
2632         case WIDEN_MULT_MINUS_EXPR:
2633         case FMA_EXPR:
2634           goto ternary;
2635
2636         case TRUTH_ANDIF_EXPR:
2637         case TRUTH_ORIF_EXPR:
2638         case TRUTH_AND_EXPR:
2639         case TRUTH_OR_EXPR:
2640         case TRUTH_XOR_EXPR:
2641           goto binary;
2642
2643         case TRUTH_NOT_EXPR:
2644           goto unary;
2645
2646         default:
2647           break;
2648         }
2649       break;
2650
2651     ternary:
2652       op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
2653       if (!op2)
2654         return NULL_RTX;
2655       /* Fall through.  */
2656
2657     binary:
2658     case tcc_binary:
2659     case tcc_comparison:
2660       op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
2661       if (!op1)
2662         return NULL_RTX;
2663       /* Fall through.  */
2664
2665     unary:
2666     case tcc_unary:
2667       inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
2668       op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
2669       if (!op0)
2670         return NULL_RTX;
2671       break;
2672
2673     case tcc_type:
2674     case tcc_statement:
2675       gcc_unreachable ();
2676
2677     case tcc_constant:
2678     case tcc_exceptional:
2679     case tcc_declaration:
2680     case tcc_reference:
2681     case tcc_vl_exp:
2682       break;
2683     }
2684
2685   switch (TREE_CODE (exp))
2686     {
2687     case STRING_CST:
2688       if (!lookup_constant_def (exp))
2689         {
2690           if (strlen (TREE_STRING_POINTER (exp)) + 1
2691               != (size_t) TREE_STRING_LENGTH (exp))
2692             return NULL_RTX;
2693           op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
2694           op0 = gen_rtx_MEM (BLKmode, op0);
2695           set_mem_attributes (op0, exp, 0);
2696           return op0;
2697         }
2698       /* Fall through...  */
2699
2700     case INTEGER_CST:
2701     case REAL_CST:
2702     case FIXED_CST:
2703       op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
2704       return op0;
2705
2706     case COMPLEX_CST:
2707       gcc_assert (COMPLEX_MODE_P (mode));
2708       op0 = expand_debug_expr (TREE_REALPART (exp));
2709       op1 = expand_debug_expr (TREE_IMAGPART (exp));
2710       return gen_rtx_CONCAT (mode, op0, op1);
2711
2712     case DEBUG_EXPR_DECL:
2713       op0 = DECL_RTL_IF_SET (exp);
2714
2715       if (op0)
2716         return op0;
2717
2718       op0 = gen_rtx_DEBUG_EXPR (mode);
2719       DEBUG_EXPR_TREE_DECL (op0) = exp;
2720       SET_DECL_RTL (exp, op0);
2721
2722       return op0;
2723
2724     case VAR_DECL:
2725     case PARM_DECL:
2726     case FUNCTION_DECL:
2727     case LABEL_DECL:
2728     case CONST_DECL:
2729     case RESULT_DECL:
2730       op0 = DECL_RTL_IF_SET (exp);
2731
2732       /* This decl was probably optimized away.  */
2733       if (!op0)
2734         {
2735           if (TREE_CODE (exp) != VAR_DECL
2736               || DECL_EXTERNAL (exp)
2737               || !TREE_STATIC (exp)
2738               || !DECL_NAME (exp)
2739               || DECL_HARD_REGISTER (exp)
2740               || DECL_IN_CONSTANT_POOL (exp)
2741               || mode == VOIDmode)
2742             return NULL;
2743
2744           op0 = make_decl_rtl_for_debug (exp);
2745           if (!MEM_P (op0)
2746               || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
2747               || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
2748             return NULL;
2749         }
2750       else
2751         op0 = copy_rtx (op0);
2752
2753       if (GET_MODE (op0) == BLKmode
2754           /* If op0 is not BLKmode, but BLKmode is, adjust_mode
2755              below would ICE.  While it is likely a FE bug,
2756              try to be robust here.  See PR43166.  */
2757           || mode == BLKmode
2758           || (mode == VOIDmode && GET_MODE (op0) != VOIDmode))
2759         {
2760           gcc_assert (MEM_P (op0));
2761           op0 = adjust_address_nv (op0, mode, 0);
2762           return op0;
2763         }
2764
2765       /* Fall through.  */
2766
2767     adjust_mode:
2768     case PAREN_EXPR:
2769     case NOP_EXPR:
2770     case CONVERT_EXPR:
2771       {
2772         inner_mode = GET_MODE (op0);
2773
2774         if (mode == inner_mode)
2775           return op0;
2776
2777         if (inner_mode == VOIDmode)
2778           {
2779             if (TREE_CODE (exp) == SSA_NAME)
2780               inner_mode = TYPE_MODE (TREE_TYPE (exp));
2781             else
2782               inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
2783             if (mode == inner_mode)
2784               return op0;
2785           }
2786
2787         if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
2788           {
2789             if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
2790               op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
2791             else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
2792               op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
2793             else
2794               op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
2795           }
2796         else if (FLOAT_MODE_P (mode))
2797           {
2798             gcc_assert (TREE_CODE (exp) != SSA_NAME);
2799             if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
2800               op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
2801             else
2802               op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
2803           }
2804         else if (FLOAT_MODE_P (inner_mode))
2805           {
2806             if (unsignedp)
2807               op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
2808             else
2809               op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
2810           }
2811         else if (CONSTANT_P (op0)
2812                  || GET_MODE_PRECISION (mode) <= GET_MODE_PRECISION (inner_mode))
2813           op0 = simplify_gen_subreg (mode, op0, inner_mode,
2814                                      subreg_lowpart_offset (mode,
2815                                                             inner_mode));
2816         else if (TREE_CODE_CLASS (TREE_CODE (exp)) == tcc_unary
2817                  ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
2818                  : unsignedp)
2819           op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
2820         else
2821           op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
2822
2823         return op0;
2824       }
2825
2826     case MEM_REF:
2827       if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
2828         {
2829           tree newexp = fold_binary (MEM_REF, TREE_TYPE (exp),
2830                                      TREE_OPERAND (exp, 0),
2831                                      TREE_OPERAND (exp, 1));
2832           if (newexp)
2833             return expand_debug_expr (newexp);
2834         }
2835       /* FALLTHROUGH */
2836     case INDIRECT_REF:
2837       op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
2838       if (!op0)
2839         return NULL;
2840
2841       if (TREE_CODE (exp) == MEM_REF)
2842         {
2843           if (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
2844               || (GET_CODE (op0) == PLUS
2845                   && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR))
2846             /* (mem (debug_implicit_ptr)) might confuse aliasing.
2847                Instead just use get_inner_reference.  */
2848             goto component_ref;
2849
2850           op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
2851           if (!op1 || !CONST_INT_P (op1))
2852             return NULL;
2853
2854           op0 = plus_constant (op0, INTVAL (op1));
2855         }
2856
2857       if (POINTER_TYPE_P (TREE_TYPE (exp)))
2858         as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
2859       else
2860         as = ADDR_SPACE_GENERIC;
2861
2862       op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
2863                                           op0, as);
2864       if (op0 == NULL_RTX)
2865         return NULL;
2866
2867       op0 = gen_rtx_MEM (mode, op0);
2868       set_mem_attributes (op0, exp, 0);
2869       if (TREE_CODE (exp) == MEM_REF
2870           && !is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
2871         set_mem_expr (op0, NULL_TREE);
2872       set_mem_addr_space (op0, as);
2873
2874       return op0;
2875
2876     case TARGET_MEM_REF:
2877       if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
2878           && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
2879         return NULL;
2880
2881       op0 = expand_debug_expr
2882             (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
2883       if (!op0)
2884         return NULL;
2885
2886       if (POINTER_TYPE_P (TREE_TYPE (exp)))
2887         as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
2888       else
2889         as = ADDR_SPACE_GENERIC;
2890
2891       op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
2892                                           op0, as);
2893       if (op0 == NULL_RTX)
2894         return NULL;
2895
2896       op0 = gen_rtx_MEM (mode, op0);
2897
2898       set_mem_attributes (op0, exp, 0);
2899       set_mem_addr_space (op0, as);
2900
2901       return op0;
2902
2903     component_ref:
2904     case ARRAY_REF:
2905     case ARRAY_RANGE_REF:
2906     case COMPONENT_REF:
2907     case BIT_FIELD_REF:
2908     case REALPART_EXPR:
2909     case IMAGPART_EXPR:
2910     case VIEW_CONVERT_EXPR:
2911       {
2912         enum machine_mode mode1;
2913         HOST_WIDE_INT bitsize, bitpos;
2914         tree offset;
2915         int volatilep = 0;
2916         tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
2917                                         &mode1, &unsignedp, &volatilep, false);
2918         rtx orig_op0;
2919
2920         if (bitsize == 0)
2921           return NULL;
2922
2923         orig_op0 = op0 = expand_debug_expr (tem);
2924
2925         if (!op0)
2926           return NULL;
2927
2928         if (offset)
2929           {
2930             enum machine_mode addrmode, offmode;
2931
2932             if (!MEM_P (op0))
2933               return NULL;
2934
2935             op0 = XEXP (op0, 0);
2936             addrmode = GET_MODE (op0);
2937             if (addrmode == VOIDmode)
2938               addrmode = Pmode;
2939
2940             op1 = expand_debug_expr (offset);
2941             if (!op1)
2942               return NULL;
2943
2944             offmode = GET_MODE (op1);
2945             if (offmode == VOIDmode)
2946               offmode = TYPE_MODE (TREE_TYPE (offset));
2947
2948             if (addrmode != offmode)
2949               op1 = simplify_gen_subreg (addrmode, op1, offmode,
2950                                          subreg_lowpart_offset (addrmode,
2951                                                                 offmode));
2952
2953             /* Don't use offset_address here, we don't need a
2954                recognizable address, and we don't want to generate
2955                code.  */
2956             op0 = gen_rtx_MEM (mode, simplify_gen_binary (PLUS, addrmode,
2957                                                           op0, op1));
2958           }
2959
2960         if (MEM_P (op0))
2961           {
2962             if (mode1 == VOIDmode)
2963               /* Bitfield.  */
2964               mode1 = smallest_mode_for_size (bitsize, MODE_INT);
2965             if (bitpos >= BITS_PER_UNIT)
2966               {
2967                 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
2968                 bitpos %= BITS_PER_UNIT;
2969               }
2970             else if (bitpos < 0)
2971               {
2972                 HOST_WIDE_INT units
2973                   = (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
2974                 op0 = adjust_address_nv (op0, mode1, units);
2975                 bitpos += units * BITS_PER_UNIT;
2976               }
2977             else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
2978               op0 = adjust_address_nv (op0, mode, 0);
2979             else if (GET_MODE (op0) != mode1)
2980               op0 = adjust_address_nv (op0, mode1, 0);
2981             else
2982               op0 = copy_rtx (op0);
2983             if (op0 == orig_op0)
2984               op0 = shallow_copy_rtx (op0);
2985             set_mem_attributes (op0, exp, 0);
2986           }
2987
2988         if (bitpos == 0 && mode == GET_MODE (op0))
2989           return op0;
2990
2991         if (bitpos < 0)
2992           return NULL;
2993
2994         if (GET_MODE (op0) == BLKmode)
2995           return NULL;
2996
2997         if ((bitpos % BITS_PER_UNIT) == 0
2998             && bitsize == GET_MODE_BITSIZE (mode1))
2999           {
3000             enum machine_mode opmode = GET_MODE (op0);
3001
3002             if (opmode == VOIDmode)
3003               opmode = TYPE_MODE (TREE_TYPE (tem));
3004
3005             /* This condition may hold if we're expanding the address
3006                right past the end of an array that turned out not to
3007                be addressable (i.e., the address was only computed in
3008                debug stmts).  The gen_subreg below would rightfully
3009                crash, and the address doesn't really exist, so just
3010                drop it.  */
3011             if (bitpos >= GET_MODE_BITSIZE (opmode))
3012               return NULL;
3013
3014             if ((bitpos % GET_MODE_BITSIZE (mode)) == 0)
3015               return simplify_gen_subreg (mode, op0, opmode,
3016                                           bitpos / BITS_PER_UNIT);
3017           }
3018
3019         return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
3020                                      && TYPE_UNSIGNED (TREE_TYPE (exp))
3021                                      ? SIGN_EXTRACT
3022                                      : ZERO_EXTRACT, mode,
3023                                      GET_MODE (op0) != VOIDmode
3024                                      ? GET_MODE (op0)
3025                                      : TYPE_MODE (TREE_TYPE (tem)),
3026                                      op0, GEN_INT (bitsize), GEN_INT (bitpos));
3027       }
3028
3029     case ABS_EXPR:
3030       return simplify_gen_unary (ABS, mode, op0, mode);
3031
3032     case NEGATE_EXPR:
3033       return simplify_gen_unary (NEG, mode, op0, mode);
3034
3035     case BIT_NOT_EXPR:
3036       return simplify_gen_unary (NOT, mode, op0, mode);
3037
3038     case FLOAT_EXPR:
3039       return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3040                                                                          0)))
3041                                  ? UNSIGNED_FLOAT : FLOAT, mode, op0,
3042                                  inner_mode);
3043
3044     case FIX_TRUNC_EXPR:
3045       return simplify_gen_unary (unsignedp ? UNSIGNED_FIX : FIX, mode, op0,
3046                                  inner_mode);
3047
3048     case POINTER_PLUS_EXPR:
3049       /* For the rare target where pointers are not the same size as
3050          size_t, we need to check for mis-matched modes and correct
3051          the addend.  */
3052       if (op0 && op1
3053           && GET_MODE (op0) != VOIDmode && GET_MODE (op1) != VOIDmode
3054           && GET_MODE (op0) != GET_MODE (op1))
3055         {
3056           if (GET_MODE_BITSIZE (GET_MODE (op0)) < GET_MODE_BITSIZE (GET_MODE (op1)))
3057             op1 = simplify_gen_unary (TRUNCATE, GET_MODE (op0), op1,
3058                                       GET_MODE (op1));
3059           else
3060             /* We always sign-extend, regardless of the signedness of
3061                the operand, because the operand is always unsigned
3062                here even if the original C expression is signed.  */
3063             op1 = simplify_gen_unary (SIGN_EXTEND, GET_MODE (op0), op1,
3064                                       GET_MODE (op1));
3065         }
3066       /* Fall through.  */
3067     case PLUS_EXPR:
3068       return simplify_gen_binary (PLUS, mode, op0, op1);
3069
3070     case MINUS_EXPR:
3071       return simplify_gen_binary (MINUS, mode, op0, op1);
3072
3073     case MULT_EXPR:
3074       return simplify_gen_binary (MULT, mode, op0, op1);
3075
3076     case RDIV_EXPR:
3077     case TRUNC_DIV_EXPR:
3078     case EXACT_DIV_EXPR:
3079       if (unsignedp)
3080         return simplify_gen_binary (UDIV, mode, op0, op1);
3081       else
3082         return simplify_gen_binary (DIV, mode, op0, op1);
3083
3084     case TRUNC_MOD_EXPR:
3085       return simplify_gen_binary (unsignedp ? UMOD : MOD, mode, op0, op1);
3086
3087     case FLOOR_DIV_EXPR:
3088       if (unsignedp)
3089         return simplify_gen_binary (UDIV, mode, op0, op1);
3090       else
3091         {
3092           rtx div = simplify_gen_binary (DIV, mode, op0, op1);
3093           rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3094           rtx adj = floor_sdiv_adjust (mode, mod, op1);
3095           return simplify_gen_binary (PLUS, mode, div, adj);
3096         }
3097
3098     case FLOOR_MOD_EXPR:
3099       if (unsignedp)
3100         return simplify_gen_binary (UMOD, mode, op0, op1);
3101       else
3102         {
3103           rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3104           rtx adj = floor_sdiv_adjust (mode, mod, op1);
3105           adj = simplify_gen_unary (NEG, mode,
3106                                     simplify_gen_binary (MULT, mode, adj, op1),
3107                                     mode);
3108           return simplify_gen_binary (PLUS, mode, mod, adj);
3109         }
3110
3111     case CEIL_DIV_EXPR:
3112       if (unsignedp)
3113         {
3114           rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
3115           rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3116           rtx adj = ceil_udiv_adjust (mode, mod, op1);
3117           return simplify_gen_binary (PLUS, mode, div, adj);
3118         }
3119       else
3120         {
3121           rtx div = simplify_gen_binary (DIV, mode, op0, op1);
3122           rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3123           rtx adj = ceil_sdiv_adjust (mode, mod, op1);
3124           return simplify_gen_binary (PLUS, mode, div, adj);
3125         }
3126
3127     case CEIL_MOD_EXPR:
3128       if (unsignedp)
3129         {
3130           rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3131           rtx adj = ceil_udiv_adjust (mode, mod, op1);
3132           adj = simplify_gen_unary (NEG, mode,
3133                                     simplify_gen_binary (MULT, mode, adj, op1),
3134                                     mode);
3135           return simplify_gen_binary (PLUS, mode, mod, adj);
3136         }
3137       else
3138         {
3139           rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3140           rtx adj = ceil_sdiv_adjust (mode, mod, op1);
3141           adj = simplify_gen_unary (NEG, mode,
3142                                     simplify_gen_binary (MULT, mode, adj, op1),
3143                                     mode);
3144           return simplify_gen_binary (PLUS, mode, mod, adj);
3145         }
3146
3147     case ROUND_DIV_EXPR:
3148       if (unsignedp)
3149         {
3150           rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
3151           rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3152           rtx adj = round_udiv_adjust (mode, mod, op1);
3153           return simplify_gen_binary (PLUS, mode, div, adj);
3154         }
3155       else
3156         {
3157           rtx div = simplify_gen_binary (DIV, mode, op0, op1);
3158           rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3159           rtx adj = round_sdiv_adjust (mode, mod, op1);
3160           return simplify_gen_binary (PLUS, mode, div, adj);
3161         }
3162
3163     case ROUND_MOD_EXPR:
3164       if (unsignedp)
3165         {
3166           rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3167           rtx adj = round_udiv_adjust (mode, mod, op1);
3168           adj = simplify_gen_unary (NEG, mode,
3169                                     simplify_gen_binary (MULT, mode, adj, op1),
3170                                     mode);
3171           return simplify_gen_binary (PLUS, mode, mod, adj);
3172         }
3173       else
3174         {
3175           rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3176           rtx adj = round_sdiv_adjust (mode, mod, op1);
3177           adj = simplify_gen_unary (NEG, mode,
3178                                     simplify_gen_binary (MULT, mode, adj, op1),
3179                                     mode);
3180           return simplify_gen_binary (PLUS, mode, mod, adj);
3181         }
3182
3183     case LSHIFT_EXPR:
3184       return simplify_gen_binary (ASHIFT, mode, op0, op1);
3185
3186     case RSHIFT_EXPR:
3187       if (unsignedp)
3188         return simplify_gen_binary (LSHIFTRT, mode, op0, op1);
3189       else
3190         return simplify_gen_binary (ASHIFTRT, mode, op0, op1);
3191
3192     case LROTATE_EXPR:
3193       return simplify_gen_binary (ROTATE, mode, op0, op1);
3194
3195     case RROTATE_EXPR:
3196       return simplify_gen_binary (ROTATERT, mode, op0, op1);
3197
3198     case MIN_EXPR:
3199       return simplify_gen_binary (unsignedp ? UMIN : SMIN, mode, op0, op1);
3200
3201     case MAX_EXPR:
3202       return simplify_gen_binary (unsignedp ? UMAX : SMAX, mode, op0, op1);
3203
3204     case BIT_AND_EXPR:
3205     case TRUTH_AND_EXPR:
3206       return simplify_gen_binary (AND, mode, op0, op1);
3207
3208     case BIT_IOR_EXPR:
3209     case TRUTH_OR_EXPR:
3210       return simplify_gen_binary (IOR, mode, op0, op1);
3211
3212     case BIT_XOR_EXPR:
3213     case TRUTH_XOR_EXPR:
3214       return simplify_gen_binary (XOR, mode, op0, op1);
3215
3216     case TRUTH_ANDIF_EXPR:
3217       return gen_rtx_IF_THEN_ELSE (mode, op0, op1, const0_rtx);
3218
3219     case TRUTH_ORIF_EXPR:
3220       return gen_rtx_IF_THEN_ELSE (mode, op0, const_true_rtx, op1);
3221
3222     case TRUTH_NOT_EXPR:
3223       return simplify_gen_relational (EQ, mode, inner_mode, op0, const0_rtx);
3224
3225     case LT_EXPR:
3226       return simplify_gen_relational (unsignedp ? LTU : LT, mode, inner_mode,
3227                                       op0, op1);
3228
3229     case LE_EXPR:
3230       return simplify_gen_relational (unsignedp ? LEU : LE, mode, inner_mode,
3231                                       op0, op1);
3232
3233     case GT_EXPR:
3234       return simplify_gen_relational (unsignedp ? GTU : GT, mode, inner_mode,
3235                                       op0, op1);
3236
3237     case GE_EXPR:
3238       return simplify_gen_relational (unsignedp ? GEU : GE, mode, inner_mode,
3239                                       op0, op1);
3240
3241     case EQ_EXPR:
3242       return simplify_gen_relational (EQ, mode, inner_mode, op0, op1);
3243
3244     case NE_EXPR:
3245       return simplify_gen_relational (NE, mode, inner_mode, op0, op1);
3246
3247     case UNORDERED_EXPR:
3248       return simplify_gen_relational (UNORDERED, mode, inner_mode, op0, op1);
3249
3250     case ORDERED_EXPR:
3251       return simplify_gen_relational (ORDERED, mode, inner_mode, op0, op1);
3252
3253     case UNLT_EXPR:
3254       return simplify_gen_relational (UNLT, mode, inner_mode, op0, op1);
3255
3256     case UNLE_EXPR:
3257       return simplify_gen_relational (UNLE, mode, inner_mode, op0, op1);
3258
3259     case UNGT_EXPR:
3260       return simplify_gen_relational (UNGT, mode, inner_mode, op0, op1);
3261
3262     case UNGE_EXPR:
3263       return simplify_gen_relational (UNGE, mode, inner_mode, op0, op1);
3264
3265     case UNEQ_EXPR:
3266       return simplify_gen_relational (UNEQ, mode, inner_mode, op0, op1);
3267
3268     case LTGT_EXPR:
3269       return simplify_gen_relational (LTGT, mode, inner_mode, op0, op1);
3270
3271     case COND_EXPR:
3272       return gen_rtx_IF_THEN_ELSE (mode, op0, op1, op2);
3273
3274     case COMPLEX_EXPR:
3275       gcc_assert (COMPLEX_MODE_P (mode));
3276       if (GET_MODE (op0) == VOIDmode)
3277         op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
3278       if (GET_MODE (op1) == VOIDmode)
3279         op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
3280       return gen_rtx_CONCAT (mode, op0, op1);
3281
3282     case CONJ_EXPR:
3283       if (GET_CODE (op0) == CONCAT)
3284         return gen_rtx_CONCAT (mode, XEXP (op0, 0),
3285                                simplify_gen_unary (NEG, GET_MODE_INNER (mode),
3286                                                    XEXP (op0, 1),
3287                                                    GET_MODE_INNER (mode)));
3288       else
3289         {
3290           enum machine_mode imode = GET_MODE_INNER (mode);
3291           rtx re, im;
3292
3293           if (MEM_P (op0))
3294             {
3295               re = adjust_address_nv (op0, imode, 0);
3296               im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
3297             }
3298           else
3299             {
3300               enum machine_mode ifmode = int_mode_for_mode (mode);
3301               enum machine_mode ihmode = int_mode_for_mode (imode);
3302               rtx halfsize;
3303               if (ifmode == BLKmode || ihmode == BLKmode)
3304                 return NULL;
3305               halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
3306               re = op0;
3307               if (mode != ifmode)
3308                 re = gen_rtx_SUBREG (ifmode, re, 0);
3309               re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
3310               if (imode != ihmode)
3311                 re = gen_rtx_SUBREG (imode, re, 0);
3312               im = copy_rtx (op0);
3313               if (mode != ifmode)
3314                 im = gen_rtx_SUBREG (ifmode, im, 0);
3315               im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
3316               if (imode != ihmode)
3317                 im = gen_rtx_SUBREG (imode, im, 0);
3318             }
3319           im = gen_rtx_NEG (imode, im);
3320           return gen_rtx_CONCAT (mode, re, im);
3321         }
3322
3323     case ADDR_EXPR:
3324       op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
3325       if (!op0 || !MEM_P (op0))
3326         {
3327           if ((TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL
3328                || TREE_CODE (TREE_OPERAND (exp, 0)) == PARM_DECL
3329                || TREE_CODE (TREE_OPERAND (exp, 0)) == RESULT_DECL)
3330               && (!TREE_ADDRESSABLE (TREE_OPERAND (exp, 0))
3331                   || target_for_debug_bind (TREE_OPERAND (exp, 0))))
3332             return gen_rtx_DEBUG_IMPLICIT_PTR (mode, TREE_OPERAND (exp, 0));
3333
3334           if (handled_component_p (TREE_OPERAND (exp, 0)))
3335             {
3336               HOST_WIDE_INT bitoffset, bitsize, maxsize;
3337               tree decl
3338                 = get_ref_base_and_extent (TREE_OPERAND (exp, 0),
3339                                            &bitoffset, &bitsize, &maxsize);
3340               if ((TREE_CODE (decl) == VAR_DECL
3341                    || TREE_CODE (decl) == PARM_DECL
3342                    || TREE_CODE (decl) == RESULT_DECL)
3343                   && (!TREE_ADDRESSABLE (decl)
3344                       || target_for_debug_bind (decl))
3345                   && (bitoffset % BITS_PER_UNIT) == 0
3346                   && bitsize > 0
3347                   && bitsize == maxsize)
3348                 return plus_constant (gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl),
3349                                       bitoffset / BITS_PER_UNIT);
3350             }
3351
3352           return NULL;
3353         }
3354
3355       as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
3356       op0 = convert_debug_memory_address (mode, XEXP (op0, 0), as);
3357
3358       return op0;
3359
3360     case VECTOR_CST:
3361       exp = build_constructor_from_list (TREE_TYPE (exp),
3362                                          TREE_VECTOR_CST_ELTS (exp));
3363       /* Fall through.  */
3364
3365     case CONSTRUCTOR:
3366       if (TREE_CLOBBER_P (exp))
3367         return NULL;
3368       else if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
3369         {
3370           unsigned i;
3371           tree val;
3372
3373           op0 = gen_rtx_CONCATN
3374             (mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
3375
3376           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
3377             {
3378               op1 = expand_debug_expr (val);
3379               if (!op1)
3380                 return NULL;
3381               XVECEXP (op0, 0, i) = op1;
3382             }
3383
3384           if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
3385             {
3386               op1 = expand_debug_expr
3387                 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
3388
3389               if (!op1)
3390                 return NULL;
3391
3392               for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
3393                 XVECEXP (op0, 0, i) = op1;
3394             }
3395
3396           return op0;
3397         }
3398       else
3399         goto flag_unsupported;
3400
3401     case CALL_EXPR:
3402       /* ??? Maybe handle some builtins?  */
3403       return NULL;
3404
3405     case SSA_NAME:
3406       {
3407         gimple g = get_gimple_for_ssa_name (exp);
3408         if (g)
3409           {
3410             op0 = expand_debug_expr (gimple_assign_rhs_to_tree (g));
3411             if (!op0)
3412               return NULL;
3413           }
3414         else
3415           {
3416             int part = var_to_partition (SA.map, exp);
3417
3418             if (part == NO_PARTITION)
3419               {
3420                 /* If this is a reference to an incoming value of parameter
3421                    that is never used in the code or where the incoming
3422                    value is never used in the code, use PARM_DECL's
3423                    DECL_RTL if set.  */
3424                 if (SSA_NAME_IS_DEFAULT_DEF (exp)
3425                     && TREE_CODE (SSA_NAME_VAR (exp)) == PARM_DECL)
3426                   {
3427                     op0 = expand_debug_parm_decl (SSA_NAME_VAR (exp));
3428                     if (op0)
3429                       goto adjust_mode;
3430                     op0 = expand_debug_expr (SSA_NAME_VAR (exp));
3431                     if (op0)
3432                       goto adjust_mode;
3433                   }
3434                 return NULL;
3435               }
3436
3437             gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
3438
3439             op0 = copy_rtx (SA.partition_to_pseudo[part]);
3440           }
3441         goto adjust_mode;
3442       }
3443
3444     case ERROR_MARK:
3445       return NULL;
3446
3447     /* Vector stuff.  For most of the codes we don't have rtl codes.  */
3448     case REALIGN_LOAD_EXPR:
3449     case REDUC_MAX_EXPR:
3450     case REDUC_MIN_EXPR:
3451     case REDUC_PLUS_EXPR:
3452     case VEC_COND_EXPR:
3453     case VEC_LSHIFT_EXPR:
3454     case VEC_PACK_FIX_TRUNC_EXPR:
3455     case VEC_PACK_SAT_EXPR:
3456     case VEC_PACK_TRUNC_EXPR:
3457     case VEC_RSHIFT_EXPR:
3458     case VEC_UNPACK_FLOAT_HI_EXPR:
3459     case VEC_UNPACK_FLOAT_LO_EXPR:
3460     case VEC_UNPACK_HI_EXPR:
3461     case VEC_UNPACK_LO_EXPR:
3462     case VEC_WIDEN_MULT_HI_EXPR:
3463     case VEC_WIDEN_MULT_LO_EXPR:
3464     case VEC_WIDEN_LSHIFT_HI_EXPR:
3465     case VEC_WIDEN_LSHIFT_LO_EXPR:
3466     case VEC_PERM_EXPR:
3467       return NULL;
3468
3469    /* Misc codes.  */
3470     case ADDR_SPACE_CONVERT_EXPR:
3471     case FIXED_CONVERT_EXPR:
3472     case OBJ_TYPE_REF:
3473     case WITH_SIZE_EXPR:
3474       return NULL;
3475
3476     case DOT_PROD_EXPR:
3477       if (SCALAR_INT_MODE_P (GET_MODE (op0))
3478           && SCALAR_INT_MODE_P (mode))
3479         {
3480           op0
3481             = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3482                                                                           0)))
3483                                   ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
3484                                   inner_mode);
3485           op1
3486             = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3487                                                                           1)))
3488                                   ? ZERO_EXTEND : SIGN_EXTEND, mode, op1,
3489                                   inner_mode);
3490           op0 = simplify_gen_binary (MULT, mode, op0, op1);
3491           return simplify_gen_binary (PLUS, mode, op0, op2);
3492         }
3493       return NULL;
3494
3495     case WIDEN_MULT_EXPR:
3496     case WIDEN_MULT_PLUS_EXPR:
3497     case WIDEN_MULT_MINUS_EXPR:
3498       if (SCALAR_INT_MODE_P (GET_MODE (op0))
3499           && SCALAR_INT_MODE_P (mode))
3500         {
3501           inner_mode = GET_MODE (op0);
3502           if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
3503             op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
3504           else
3505             op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
3506           if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
3507             op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode);
3508           else
3509             op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode);
3510           op0 = simplify_gen_binary (MULT, mode, op0, op1);
3511           if (TREE_CODE (exp) == WIDEN_MULT_EXPR)
3512             return op0;
3513           else if (TREE_CODE (exp) == WIDEN_MULT_PLUS_EXPR)
3514             return simplify_gen_binary (PLUS, mode, op0, op2);
3515           else
3516             return simplify_gen_binary (MINUS, mode, op2, op0);
3517         }
3518       return NULL;
3519
3520     case WIDEN_SUM_EXPR:
3521     case WIDEN_LSHIFT_EXPR:
3522       if (SCALAR_INT_MODE_P (GET_MODE (op0))
3523           && SCALAR_INT_MODE_P (mode))
3524         {
3525           op0
3526             = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3527                                                                           0)))
3528                                   ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
3529                                   inner_mode);
3530           return simplify_gen_binary (TREE_CODE (exp) == WIDEN_LSHIFT_EXPR
3531                                       ? ASHIFT : PLUS, mode, op0, op1);
3532         }
3533       return NULL;
3534
3535     case FMA_EXPR:
3536       return simplify_gen_ternary (FMA, mode, inner_mode, op0, op1, op2);
3537
3538     default:
3539     flag_unsupported:
3540 #ifdef ENABLE_CHECKING
3541       debug_tree (exp);
3542       gcc_unreachable ();
3543 #else
3544       return NULL;
3545 #endif
3546     }
3547 }
3548
3549 /* Return an RTX equivalent to the source bind value of the tree expression
3550    EXP.  */
3551
3552 static rtx
3553 expand_debug_source_expr (tree exp)
3554 {
3555   rtx op0 = NULL_RTX;
3556   enum machine_mode mode = VOIDmode, inner_mode;
3557
3558   switch (TREE_CODE (exp))
3559     {
3560     case PARM_DECL:
3561       {
3562         mode = DECL_MODE (exp);
3563         op0 = expand_debug_parm_decl (exp);
3564         if (op0)
3565            break;
3566         /* See if this isn't an argument that has been completely
3567            optimized out.  */
3568         if (!DECL_RTL_SET_P (exp)
3569             && !DECL_INCOMING_RTL (exp)
3570             && DECL_ABSTRACT_ORIGIN (current_function_decl))
3571           {
3572             tree aexp = exp;
3573             if (DECL_ABSTRACT_ORIGIN (exp))
3574               aexp = DECL_ABSTRACT_ORIGIN (exp);
3575             if (DECL_CONTEXT (aexp)
3576                 == DECL_ABSTRACT_ORIGIN (current_function_decl))
3577               {
3578                 VEC(tree, gc) **debug_args;
3579                 unsigned int ix;
3580                 tree ddecl;
3581 #ifdef ENABLE_CHECKING
3582                 tree parm;
3583                 for (parm = DECL_ARGUMENTS (current_function_decl);
3584                      parm; parm = DECL_CHAIN (parm))
3585                   gcc_assert (parm != exp
3586                               && DECL_ABSTRACT_ORIGIN (parm) != aexp);
3587 #endif
3588                 debug_args = decl_debug_args_lookup (current_function_decl);
3589                 if (debug_args != NULL)
3590                   {
3591                     for (ix = 0; VEC_iterate (tree, *debug_args, ix, ddecl);
3592                          ix += 2)
3593                       if (ddecl == aexp)
3594                         return gen_rtx_DEBUG_PARAMETER_REF (mode, aexp);
3595                   }
3596               }
3597           }
3598         break;
3599       }
3600     default:
3601       break;
3602     }
3603
3604   if (op0 == NULL_RTX)
3605     return NULL_RTX;
3606
3607   inner_mode = GET_MODE (op0);
3608   if (mode == inner_mode)
3609     return op0;
3610
3611   if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
3612     {
3613       if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
3614         op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
3615       else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
3616         op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
3617       else
3618         op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
3619     }
3620   else if (FLOAT_MODE_P (mode))
3621     gcc_unreachable ();
3622   else if (FLOAT_MODE_P (inner_mode))
3623     {
3624       if (TYPE_UNSIGNED (TREE_TYPE (exp)))
3625         op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
3626       else
3627         op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
3628     }
3629   else if (CONSTANT_P (op0)
3630            || GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (inner_mode))
3631     op0 = simplify_gen_subreg (mode, op0, inner_mode,
3632                                subreg_lowpart_offset (mode, inner_mode));
3633   else if (TYPE_UNSIGNED (TREE_TYPE (exp)))
3634     op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
3635   else
3636     op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
3637
3638   return op0;
3639 }
3640
3641 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
3642    Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
3643    deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN.  */
3644
3645 static void
3646 avoid_complex_debug_insns (rtx insn, rtx *exp_p, int depth)
3647 {
3648   rtx exp = *exp_p;
3649   const char *format_ptr;
3650   int i, j;
3651
3652   if (exp == NULL_RTX)
3653     return;
3654
3655   if ((OBJECT_P (exp) && !MEM_P (exp)) || GET_CODE (exp) == CLOBBER)
3656     return;
3657
3658   if (depth == 4)
3659     {
3660       /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL).  */
3661       rtx dval = make_debug_expr_from_rtl (exp);
3662
3663       /* Emit a debug bind insn before INSN.  */
3664       rtx bind = gen_rtx_VAR_LOCATION (GET_MODE (exp),
3665                                        DEBUG_EXPR_TREE_DECL (dval), exp,
3666                                        VAR_INIT_STATUS_INITIALIZED);
3667
3668       emit_debug_insn_before (bind, insn);
3669       *exp_p = dval;
3670       return;
3671     }
3672
3673   format_ptr = GET_RTX_FORMAT (GET_CODE (exp));
3674   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3675     switch (*format_ptr++)
3676       {
3677       case 'e':
3678         avoid_complex_debug_insns (insn, &XEXP (exp, i), depth + 1);
3679         break;
3680
3681       case 'E':
3682       case 'V':
3683         for (j = 0; j < XVECLEN (exp, i); j++)
3684           avoid_complex_debug_insns (insn, &XVECEXP (exp, i, j), depth + 1);
3685         break;
3686
3687       default:
3688         break;
3689       }
3690 }
3691
3692 /* Expand the _LOCs in debug insns.  We run this after expanding all
3693    regular insns, so that any variables referenced in the function
3694    will have their DECL_RTLs set.  */
3695
3696 static void
3697 expand_debug_locations (void)
3698 {
3699   rtx insn;
3700   rtx last = get_last_insn ();
3701   int save_strict_alias = flag_strict_aliasing;
3702
3703   /* New alias sets while setting up memory attributes cause
3704      -fcompare-debug failures, even though it doesn't bring about any
3705      codegen changes.  */
3706   flag_strict_aliasing = 0;
3707
3708   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3709     if (DEBUG_INSN_P (insn))
3710       {
3711         tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
3712         rtx val, prev_insn, insn2;
3713         enum machine_mode mode;
3714
3715         if (value == NULL_TREE)
3716           val = NULL_RTX;
3717         else
3718           {
3719             if (INSN_VAR_LOCATION_STATUS (insn)
3720                 == VAR_INIT_STATUS_UNINITIALIZED)
3721               val = expand_debug_source_expr (value);
3722             else
3723               val = expand_debug_expr (value);
3724             gcc_assert (last == get_last_insn ());
3725           }
3726
3727         if (!val)
3728           val = gen_rtx_UNKNOWN_VAR_LOC ();
3729         else
3730           {
3731             mode = GET_MODE (INSN_VAR_LOCATION (insn));
3732
3733             gcc_assert (mode == GET_MODE (val)
3734                         || (GET_MODE (val) == VOIDmode
3735                             && (CONST_INT_P (val)
3736                                 || GET_CODE (val) == CONST_FIXED
3737                                 || GET_CODE (val) == CONST_DOUBLE
3738                                 || GET_CODE (val) == LABEL_REF)));
3739           }
3740
3741         INSN_VAR_LOCATION_LOC (insn) = val;
3742         prev_insn = PREV_INSN (insn);
3743         for (insn2 = insn; insn2 != prev_insn; insn2 = PREV_INSN (insn2))
3744           avoid_complex_debug_insns (insn2, &INSN_VAR_LOCATION_LOC (insn2), 0);
3745       }
3746
3747   flag_strict_aliasing = save_strict_alias;
3748 }
3749
3750 /* Expand basic block BB from GIMPLE trees to RTL.  */
3751
3752 static basic_block
3753 expand_gimple_basic_block (basic_block bb)
3754 {
3755   gimple_stmt_iterator gsi;
3756   gimple_seq stmts;
3757   gimple stmt = NULL;
3758   rtx note, last;
3759   edge e;
3760   edge_iterator ei;
3761   void **elt;
3762
3763   if (dump_file)
3764     fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
3765              bb->index);
3766
3767   /* Note that since we are now transitioning from GIMPLE to RTL, we
3768      cannot use the gsi_*_bb() routines because they expect the basic
3769      block to be in GIMPLE, instead of RTL.  Therefore, we need to
3770      access the BB sequence directly.  */
3771   stmts = bb_seq (bb);
3772   bb->il.gimple = NULL;
3773   rtl_profile_for_bb (bb);
3774   init_rtl_bb_info (bb);
3775   bb->flags |= BB_RTL;
3776
3777   /* Remove the RETURN_EXPR if we may fall though to the exit
3778      instead.  */
3779   gsi = gsi_last (stmts);
3780   if (!gsi_end_p (gsi)
3781       && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
3782     {
3783       gimple ret_stmt = gsi_stmt (gsi);
3784
3785       gcc_assert (single_succ_p (bb));
3786       gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
3787
3788       if (bb->next_bb == EXIT_BLOCK_PTR
3789           && !gimple_return_retval (ret_stmt))
3790         {
3791           gsi_remove (&gsi, false);
3792           single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
3793         }
3794     }
3795
3796   gsi = gsi_start (stmts);
3797   if (!gsi_end_p (gsi))
3798     {
3799       stmt = gsi_stmt (gsi);
3800       if (gimple_code (stmt) != GIMPLE_LABEL)
3801         stmt = NULL;
3802     }
3803
3804   elt = pointer_map_contains (lab_rtx_for_bb, bb);
3805
3806   if (stmt || elt)
3807     {
3808       last = get_last_insn ();
3809
3810       if (stmt)
3811         {
3812           expand_gimple_stmt (stmt);
3813           gsi_next (&gsi);
3814         }
3815
3816       if (elt)
3817         emit_label ((rtx) *elt);
3818
3819       /* Java emits line number notes in the top of labels.
3820          ??? Make this go away once line number notes are obsoleted.  */
3821       BB_HEAD (bb) = NEXT_INSN (last);
3822       if (NOTE_P (BB_HEAD (bb)))
3823         BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
3824       note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
3825
3826       maybe_dump_rtl_for_gimple_stmt (stmt, last);
3827     }
3828   else
3829     note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
3830
3831   NOTE_BASIC_BLOCK (note) = bb;
3832
3833   for (; !gsi_end_p (gsi); gsi_next (&gsi))
3834     {
3835       basic_block new_bb;
3836
3837       stmt = gsi_stmt (gsi);
3838
3839       /* If this statement is a non-debug one, and we generate debug
3840          insns, then this one might be the last real use of a TERed
3841          SSA_NAME, but where there are still some debug uses further
3842          down.  Expanding the current SSA name in such further debug
3843          uses by their RHS might lead to wrong debug info, as coalescing
3844          might make the operands of such RHS be placed into the same
3845          pseudo as something else.  Like so:
3846            a_1 = a_0 + 1;   // Assume a_1 is TERed and a_0 is dead
3847            use(a_1);
3848            a_2 = ...
3849            #DEBUG ... => a_1
3850          As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
3851          If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
3852          the write to a_2 would actually have clobbered the place which
3853          formerly held a_0.
3854
3855          So, instead of that, we recognize the situation, and generate
3856          debug temporaries at the last real use of TERed SSA names:
3857            a_1 = a_0 + 1;
3858            #DEBUG #D1 => a_1
3859            use(a_1);
3860            a_2 = ...
3861            #DEBUG ... => #D1
3862          */
3863       if (MAY_HAVE_DEBUG_INSNS
3864           && SA.values
3865           && !is_gimple_debug (stmt))
3866         {
3867           ssa_op_iter iter;
3868           tree op;
3869           gimple def;
3870
3871           location_t sloc = get_curr_insn_source_location ();
3872           tree sblock = get_curr_insn_block ();
3873
3874           /* Look for SSA names that have their last use here (TERed
3875              names always have only one real use).  */
3876           FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
3877             if ((def = get_gimple_for_ssa_name (op)))
3878               {
3879                 imm_use_iterator imm_iter;
3880                 use_operand_p use_p;
3881                 bool have_debug_uses = false;
3882
3883                 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
3884                   {
3885                     if (gimple_debug_bind_p (USE_STMT (use_p)))
3886                       {
3887                         have_debug_uses = true;
3888                         break;
3889                       }
3890                   }
3891
3892                 if (have_debug_uses)
3893                   {
3894                     /* OP is a TERed SSA name, with DEF it's defining
3895                        statement, and where OP is used in further debug
3896                        instructions.  Generate a debug temporary, and
3897                        replace all uses of OP in debug insns with that
3898                        temporary.  */
3899                     gimple debugstmt;
3900                     tree value = gimple_assign_rhs_to_tree (def);
3901                     tree vexpr = make_node (DEBUG_EXPR_DECL);
3902                     rtx val;
3903                     enum machine_mode mode;
3904
3905                     set_curr_insn_source_location (gimple_location (def));
3906                     set_curr_insn_block (gimple_block (def));
3907
3908                     DECL_ARTIFICIAL (vexpr) = 1;
3909                     TREE_TYPE (vexpr) = TREE_TYPE (value);
3910                     if (DECL_P (value))
3911                       mode = DECL_MODE (value);
3912                     else
3913                       mode = TYPE_MODE (TREE_TYPE (value));
3914                     DECL_MODE (vexpr) = mode;
3915
3916                     val = gen_rtx_VAR_LOCATION
3917                         (mode, vexpr, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
3918
3919                     emit_debug_insn (val);
3920
3921                     FOR_EACH_IMM_USE_STMT (debugstmt, imm_iter, op)
3922                       {
3923                         if (!gimple_debug_bind_p (debugstmt))
3924                           continue;
3925
3926                         FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
3927                           SET_USE (use_p, vexpr);
3928
3929                         update_stmt (debugstmt);
3930                       }
3931                   }
3932               }
3933           set_curr_insn_source_location (sloc);
3934           set_curr_insn_block (sblock);
3935         }
3936
3937       currently_expanding_gimple_stmt = stmt;
3938
3939       /* Expand this statement, then evaluate the resulting RTL and
3940          fixup the CFG accordingly.  */
3941       if (gimple_code (stmt) == GIMPLE_COND)
3942         {
3943           new_bb = expand_gimple_cond (bb, stmt);
3944           if (new_bb)
3945             return new_bb;
3946         }
3947       else if (gimple_debug_bind_p (stmt))
3948         {
3949           location_t sloc = get_curr_insn_source_location ();
3950           tree sblock = get_curr_insn_block ();
3951           gimple_stmt_iterator nsi = gsi;
3952
3953           for (;;)
3954             {
3955               tree var = gimple_debug_bind_get_var (stmt);
3956               tree value;
3957               rtx val;
3958               enum machine_mode mode;
3959
3960               if (TREE_CODE (var) != DEBUG_EXPR_DECL
3961                   && TREE_CODE (var) != LABEL_DECL
3962                   && !target_for_debug_bind (var))
3963                 goto delink_debug_stmt;
3964
3965               if (gimple_debug_bind_has_value_p (stmt))
3966                 value = gimple_debug_bind_get_value (stmt);
3967               else
3968                 value = NULL_TREE;
3969
3970               last = get_last_insn ();
3971
3972               set_curr_insn_source_location (gimple_location (stmt));
3973               set_curr_insn_block (gimple_block (stmt));
3974
3975               if (DECL_P (var))
3976                 mode = DECL_MODE (var);
3977               else
3978                 mode = TYPE_MODE (TREE_TYPE (var));
3979
3980               val = gen_rtx_VAR_LOCATION
3981                 (mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
3982
3983               emit_debug_insn (val);
3984
3985               if (dump_file && (dump_flags & TDF_DETAILS))
3986                 {
3987                   /* We can't dump the insn with a TREE where an RTX
3988                      is expected.  */
3989                   PAT_VAR_LOCATION_LOC (val) = const0_rtx;
3990                   maybe_dump_rtl_for_gimple_stmt (stmt, last);
3991                   PAT_VAR_LOCATION_LOC (val) = (rtx)value;
3992                 }
3993
3994             delink_debug_stmt:
3995               /* In order not to generate too many debug temporaries,
3996                  we delink all uses of debug statements we already expanded.
3997                  Therefore debug statements between definition and real
3998                  use of TERed SSA names will continue to use the SSA name,
3999                  and not be replaced with debug temps.  */
4000               delink_stmt_imm_use (stmt);
4001
4002               gsi = nsi;
4003               gsi_next (&nsi);
4004               if (gsi_end_p (nsi))
4005                 break;
4006               stmt = gsi_stmt (nsi);
4007               if (!gimple_debug_bind_p (stmt))
4008                 break;
4009             }
4010
4011           set_curr_insn_source_location (sloc);
4012           set_curr_insn_block (sblock);
4013         }
4014       else if (gimple_debug_source_bind_p (stmt))
4015         {
4016           location_t sloc = get_curr_insn_source_location ();
4017           tree sblock = get_curr_insn_block ();
4018           tree var = gimple_debug_source_bind_get_var (stmt);
4019           tree value = gimple_debug_source_bind_get_value (stmt);
4020           rtx val;
4021           enum machine_mode mode;
4022
4023           last = get_last_insn ();
4024
4025           set_curr_insn_source_location (gimple_location (stmt));
4026           set_curr_insn_block (gimple_block (stmt));
4027
4028           mode = DECL_MODE (var);
4029
4030           val = gen_rtx_VAR_LOCATION (mode, var, (rtx)value,
4031                                       VAR_INIT_STATUS_UNINITIALIZED);
4032
4033           emit_debug_insn (val);
4034
4035           if (dump_file && (dump_flags & TDF_DETAILS))
4036             {
4037               /* We can't dump the insn with a TREE where an RTX
4038                  is expected.  */
4039               PAT_VAR_LOCATION_LOC (val) = const0_rtx;
4040               maybe_dump_rtl_for_gimple_stmt (stmt, last);
4041               PAT_VAR_LOCATION_LOC (val) = (rtx)value;
4042             }
4043
4044           set_curr_insn_source_location (sloc);
4045           set_curr_insn_block (sblock);
4046         }
4047       else
4048         {
4049           if (is_gimple_call (stmt) && gimple_call_tail_p (stmt))
4050             {
4051               bool can_fallthru;
4052               new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
4053               if (new_bb)
4054                 {
4055                   if (can_fallthru)
4056                     bb = new_bb;
4057                   else
4058                     return new_bb;
4059                 }
4060             }
4061           else
4062             {
4063               def_operand_p def_p;
4064               def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
4065
4066               if (def_p != NULL)
4067                 {
4068                   /* Ignore this stmt if it is in the list of
4069                      replaceable expressions.  */
4070                   if (SA.values
4071                       && bitmap_bit_p (SA.values,
4072                                        SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
4073                     continue;
4074                 }
4075               last = expand_gimple_stmt (stmt);