OSDN Git Service

2010-05-03 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / tree.c
1 /* Language-independent node constructors for parse phase of GNU compiler.
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /* This file contains the low level primitives for operating on tree nodes,
23    including allocation, list operations, interning of identifiers,
24    construction of data type nodes and statement nodes,
25    and construction of type conversion nodes.  It also contains
26    tables index by tree code that describe how to take apart
27    nodes of that code.
28
29    It is intended to be language-independent, but occasionally
30    calls language-dependent routines defined (for C) in typecheck.c.  */
31
32 #include "config.h"
33 #include "system.h"
34 #include "coretypes.h"
35 #include "tm.h"
36 #include "flags.h"
37 #include "tree.h"
38 #include "real.h"
39 #include "tm_p.h"
40 #include "function.h"
41 #include "obstack.h"
42 #include "toplev.h"
43 #include "ggc.h"
44 #include "hashtab.h"
45 #include "output.h"
46 #include "target.h"
47 #include "langhooks.h"
48 #include "tree-inline.h"
49 #include "tree-iterator.h"
50 #include "basic-block.h"
51 #include "tree-flow.h"
52 #include "params.h"
53 #include "pointer-set.h"
54 #include "fixed-value.h"
55 #include "tree-pass.h"
56 #include "langhooks-def.h"
57 #include "diagnostic.h"
58 #include "cgraph.h"
59 #include "timevar.h"
60 #include "except.h"
61 #include "debug.h"
62 #include "intl.h"
63
64 /* Tree code classes.  */
65
66 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
67 #define END_OF_BASE_TREE_CODES tcc_exceptional,
68
69 const enum tree_code_class tree_code_type[] = {
70 #include "all-tree.def"
71 };
72
73 #undef DEFTREECODE
74 #undef END_OF_BASE_TREE_CODES
75
76 /* Table indexed by tree code giving number of expression
77    operands beyond the fixed part of the node structure.
78    Not used for types or decls.  */
79
80 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
81 #define END_OF_BASE_TREE_CODES 0,
82
83 const unsigned char tree_code_length[] = {
84 #include "all-tree.def"
85 };
86
87 #undef DEFTREECODE
88 #undef END_OF_BASE_TREE_CODES
89
90 /* Names of tree components.
91    Used for printing out the tree and error messages.  */
92 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
93 #define END_OF_BASE_TREE_CODES "@dummy",
94
95 const char *const tree_code_name[] = {
96 #include "all-tree.def"
97 };
98
99 #undef DEFTREECODE
100 #undef END_OF_BASE_TREE_CODES
101
102 /* Each tree code class has an associated string representation.
103    These must correspond to the tree_code_class entries.  */
104
105 const char *const tree_code_class_strings[] =
106 {
107   "exceptional",
108   "constant",
109   "type",
110   "declaration",
111   "reference",
112   "comparison",
113   "unary",
114   "binary",
115   "statement",
116   "vl_exp",
117   "expression"
118 };
119
120 /* obstack.[ch] explicitly declined to prototype this.  */
121 extern int _obstack_allocated_p (struct obstack *h, void *obj);
122
123 #ifdef GATHER_STATISTICS
124 /* Statistics-gathering stuff.  */
125
126 int tree_node_counts[(int) all_kinds];
127 int tree_node_sizes[(int) all_kinds];
128
129 /* Keep in sync with tree.h:enum tree_node_kind.  */
130 static const char * const tree_node_kind_names[] = {
131   "decls",
132   "types",
133   "blocks",
134   "stmts",
135   "refs",
136   "exprs",
137   "constants",
138   "identifiers",
139   "perm_tree_lists",
140   "temp_tree_lists",
141   "vecs",
142   "binfos",
143   "ssa names",
144   "constructors",
145   "random kinds",
146   "lang_decl kinds",
147   "lang_type kinds",
148   "omp clauses",
149 };
150 #endif /* GATHER_STATISTICS */
151
152 /* Unique id for next decl created.  */
153 static GTY(()) int next_decl_uid;
154 /* Unique id for next type created.  */
155 static GTY(()) int next_type_uid = 1;
156 /* Unique id for next debug decl created.  Use negative numbers,
157    to catch erroneous uses.  */
158 static GTY(()) int next_debug_decl_uid;
159
160 /* Since we cannot rehash a type after it is in the table, we have to
161    keep the hash code.  */
162
163 struct GTY(()) type_hash {
164   unsigned long hash;
165   tree type;
166 };
167
168 /* Initial size of the hash table (rounded to next prime).  */
169 #define TYPE_HASH_INITIAL_SIZE 1000
170
171 /* Now here is the hash table.  When recording a type, it is added to
172    the slot whose index is the hash code.  Note that the hash table is
173    used for several kinds of types (function types, array types and
174    array index range types, for now).  While all these live in the
175    same table, they are completely independent, and the hash code is
176    computed differently for each of these.  */
177
178 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
179      htab_t type_hash_table;
180
181 /* Hash table and temporary node for larger integer const values.  */
182 static GTY (()) tree int_cst_node;
183 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
184      htab_t int_cst_hash_table;
185
186 /* Hash table for optimization flags and target option flags.  Use the same
187    hash table for both sets of options.  Nodes for building the current
188    optimization and target option nodes.  The assumption is most of the time
189    the options created will already be in the hash table, so we avoid
190    allocating and freeing up a node repeatably.  */
191 static GTY (()) tree cl_optimization_node;
192 static GTY (()) tree cl_target_option_node;
193 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
194      htab_t cl_option_hash_table;
195
196 /* General tree->tree mapping  structure for use in hash tables.  */
197
198
199 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
200      htab_t debug_expr_for_decl;
201
202 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
203      htab_t value_expr_for_decl;
204
205 static GTY ((if_marked ("tree_priority_map_marked_p"),
206              param_is (struct tree_priority_map)))
207   htab_t init_priority_for_decl;
208
209 static void set_type_quals (tree, int);
210 static int type_hash_eq (const void *, const void *);
211 static hashval_t type_hash_hash (const void *);
212 static hashval_t int_cst_hash_hash (const void *);
213 static int int_cst_hash_eq (const void *, const void *);
214 static hashval_t cl_option_hash_hash (const void *);
215 static int cl_option_hash_eq (const void *, const void *);
216 static void print_type_hash_statistics (void);
217 static void print_debug_expr_statistics (void);
218 static void print_value_expr_statistics (void);
219 static int type_hash_marked_p (const void *);
220 static unsigned int type_hash_list (const_tree, hashval_t);
221 static unsigned int attribute_hash_list (const_tree, hashval_t);
222
223 tree global_trees[TI_MAX];
224 tree integer_types[itk_none];
225
226 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
227
228 /* Number of operands for each OpenMP clause.  */
229 unsigned const char omp_clause_num_ops[] =
230 {
231   0, /* OMP_CLAUSE_ERROR  */
232   1, /* OMP_CLAUSE_PRIVATE  */
233   1, /* OMP_CLAUSE_SHARED  */
234   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
235   2, /* OMP_CLAUSE_LASTPRIVATE  */
236   4, /* OMP_CLAUSE_REDUCTION  */
237   1, /* OMP_CLAUSE_COPYIN  */
238   1, /* OMP_CLAUSE_COPYPRIVATE  */
239   1, /* OMP_CLAUSE_IF  */
240   1, /* OMP_CLAUSE_NUM_THREADS  */
241   1, /* OMP_CLAUSE_SCHEDULE  */
242   0, /* OMP_CLAUSE_NOWAIT  */
243   0, /* OMP_CLAUSE_ORDERED  */
244   0, /* OMP_CLAUSE_DEFAULT  */
245   3, /* OMP_CLAUSE_COLLAPSE  */
246   0  /* OMP_CLAUSE_UNTIED   */
247 };
248
249 const char * const omp_clause_code_name[] =
250 {
251   "error_clause",
252   "private",
253   "shared",
254   "firstprivate",
255   "lastprivate",
256   "reduction",
257   "copyin",
258   "copyprivate",
259   "if",
260   "num_threads",
261   "schedule",
262   "nowait",
263   "ordered",
264   "default",
265   "collapse",
266   "untied"
267 };
268
269
270 /* Return the tree node structure used by tree code CODE.  */
271
272 static inline enum tree_node_structure_enum
273 tree_node_structure_for_code (enum tree_code code)
274 {
275   switch (TREE_CODE_CLASS (code))
276     {
277     case tcc_declaration:
278       {
279         switch (code)
280           {
281           case FIELD_DECL:
282             return TS_FIELD_DECL;
283           case PARM_DECL:
284             return TS_PARM_DECL;
285           case VAR_DECL:
286             return TS_VAR_DECL;
287           case LABEL_DECL:
288             return TS_LABEL_DECL;
289           case RESULT_DECL:
290             return TS_RESULT_DECL;
291           case DEBUG_EXPR_DECL:
292             return TS_DECL_WRTL;
293           case CONST_DECL:
294             return TS_CONST_DECL;
295           case TYPE_DECL:
296             return TS_TYPE_DECL;
297           case FUNCTION_DECL:
298             return TS_FUNCTION_DECL;
299           default:
300             return TS_DECL_NON_COMMON;
301           }
302       }
303     case tcc_type:
304       return TS_TYPE;
305     case tcc_reference:
306     case tcc_comparison:
307     case tcc_unary:
308     case tcc_binary:
309     case tcc_expression:
310     case tcc_statement:
311     case tcc_vl_exp:
312       return TS_EXP;
313     default:  /* tcc_constant and tcc_exceptional */
314       break;
315     }
316   switch (code)
317     {
318       /* tcc_constant cases.  */
319     case INTEGER_CST:           return TS_INT_CST;
320     case REAL_CST:              return TS_REAL_CST;
321     case FIXED_CST:             return TS_FIXED_CST;
322     case COMPLEX_CST:           return TS_COMPLEX;
323     case VECTOR_CST:            return TS_VECTOR;
324     case STRING_CST:            return TS_STRING;
325       /* tcc_exceptional cases.  */
326     case ERROR_MARK:            return TS_COMMON;
327     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
328     case TREE_LIST:             return TS_LIST;
329     case TREE_VEC:              return TS_VEC;
330     case SSA_NAME:              return TS_SSA_NAME;
331     case PLACEHOLDER_EXPR:      return TS_COMMON;
332     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
333     case BLOCK:                 return TS_BLOCK;
334     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
335     case TREE_BINFO:            return TS_BINFO;
336     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
337     case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
338     case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
339
340     default:
341       gcc_unreachable ();
342     }
343 }
344
345
346 /* Initialize tree_contains_struct to describe the hierarchy of tree
347    nodes.  */
348
349 static void
350 initialize_tree_contains_struct (void)
351 {
352   unsigned i;
353
354 #define MARK_TS_BASE(C)                                 \
355   do {                                                  \
356     tree_contains_struct[C][TS_BASE] = 1;               \
357   } while (0)
358
359 #define MARK_TS_COMMON(C)                               \
360   do {                                                  \
361     MARK_TS_BASE (C);                                   \
362     tree_contains_struct[C][TS_COMMON] = 1;             \
363   } while (0)
364
365 #define MARK_TS_DECL_MINIMAL(C)                         \
366   do {                                                  \
367     MARK_TS_COMMON (C);                                 \
368     tree_contains_struct[C][TS_DECL_MINIMAL] = 1;       \
369   } while (0)
370
371 #define MARK_TS_DECL_COMMON(C)                          \
372   do {                                                  \
373     MARK_TS_DECL_MINIMAL (C);                           \
374     tree_contains_struct[C][TS_DECL_COMMON] = 1;        \
375   } while (0)
376
377 #define MARK_TS_DECL_WRTL(C)                            \
378   do {                                                  \
379     MARK_TS_DECL_COMMON (C);                            \
380     tree_contains_struct[C][TS_DECL_WRTL] = 1;          \
381   } while (0)
382
383 #define MARK_TS_DECL_WITH_VIS(C)                        \
384   do {                                                  \
385     MARK_TS_DECL_WRTL (C);                              \
386     tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;      \
387   } while (0)
388
389 #define MARK_TS_DECL_NON_COMMON(C)                      \
390   do {                                                  \
391     MARK_TS_DECL_WITH_VIS (C);                          \
392     tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;    \
393   } while (0)
394
395   for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
396     {
397       enum tree_code code;
398       enum tree_node_structure_enum ts_code;
399
400       code = (enum tree_code) i;
401       ts_code = tree_node_structure_for_code (code);
402
403       /* Mark the TS structure itself.  */
404       tree_contains_struct[code][ts_code] = 1;
405
406       /* Mark all the structures that TS is derived from.  */
407       switch (ts_code)
408         {
409         case TS_COMMON:
410           MARK_TS_BASE (code);
411           break;
412
413         case TS_INT_CST:
414         case TS_REAL_CST:
415         case TS_FIXED_CST:
416         case TS_VECTOR:
417         case TS_STRING:
418         case TS_COMPLEX:
419         case TS_IDENTIFIER:
420         case TS_DECL_MINIMAL:
421         case TS_TYPE:
422         case TS_LIST:
423         case TS_VEC:
424         case TS_EXP:
425         case TS_SSA_NAME:
426         case TS_BLOCK:
427         case TS_BINFO:
428         case TS_STATEMENT_LIST:
429         case TS_CONSTRUCTOR:
430         case TS_OMP_CLAUSE:
431         case TS_OPTIMIZATION:
432         case TS_TARGET_OPTION:
433           MARK_TS_COMMON (code);
434           break;
435
436         case TS_DECL_COMMON:
437           MARK_TS_DECL_MINIMAL (code);
438           break;
439
440         case TS_DECL_WRTL:
441           MARK_TS_DECL_COMMON (code);
442           break;
443
444         case TS_DECL_NON_COMMON:
445           MARK_TS_DECL_WITH_VIS (code);
446           break;
447
448         case TS_DECL_WITH_VIS:
449         case TS_PARM_DECL:
450         case TS_LABEL_DECL:
451         case TS_RESULT_DECL:
452         case TS_CONST_DECL:
453           MARK_TS_DECL_WRTL (code);
454           break;
455
456         case TS_FIELD_DECL:
457           MARK_TS_DECL_COMMON (code);
458           break;
459
460         case TS_VAR_DECL:
461           MARK_TS_DECL_WITH_VIS (code);
462           break;
463
464         case TS_TYPE_DECL:
465         case TS_FUNCTION_DECL:
466           MARK_TS_DECL_NON_COMMON (code);
467           break;
468
469         default:
470           gcc_unreachable ();
471         }
472     }
473
474   /* Basic consistency checks for attributes used in fold.  */
475   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
476   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON]);
477   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
478   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
479   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
480   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
481   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
482   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
483   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
484   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
485   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
486   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
487   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
488   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
489   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
490   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
491   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
492   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
493   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
494   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
495   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
496   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
497   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
498   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
499   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
500   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
501   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
502   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
503   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
504   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
505   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS]);
506   gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
507   gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
508   gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
509   gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
510   gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
511   gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
512   gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
513   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
514   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
515   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
516
517 #undef MARK_TS_BASE
518 #undef MARK_TS_COMMON
519 #undef MARK_TS_DECL_MINIMAL
520 #undef MARK_TS_DECL_COMMON
521 #undef MARK_TS_DECL_WRTL
522 #undef MARK_TS_DECL_WITH_VIS
523 #undef MARK_TS_DECL_NON_COMMON
524 }
525
526
527 /* Init tree.c.  */
528
529 void
530 init_ttree (void)
531 {
532   /* Initialize the hash table of types.  */
533   type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
534                                      type_hash_eq, 0);
535
536   debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
537                                          tree_map_eq, 0);
538
539   value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
540                                          tree_map_eq, 0);
541   init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
542                                             tree_priority_map_eq, 0);
543
544   int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
545                                         int_cst_hash_eq, NULL);
546
547   int_cst_node = make_node (INTEGER_CST);
548
549   cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
550                                           cl_option_hash_eq, NULL);
551
552   cl_optimization_node = make_node (OPTIMIZATION_NODE);
553   cl_target_option_node = make_node (TARGET_OPTION_NODE);
554
555   /* Initialize the tree_contains_struct array.  */
556   initialize_tree_contains_struct ();
557   lang_hooks.init_ts ();
558 }
559
560 \f
561 /* The name of the object as the assembler will see it (but before any
562    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
563    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
564 tree
565 decl_assembler_name (tree decl)
566 {
567   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
568     lang_hooks.set_decl_assembler_name (decl);
569   return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
570 }
571
572 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
573
574 bool
575 decl_assembler_name_equal (tree decl, const_tree asmname)
576 {
577   tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
578   const char *decl_str;
579   const char *asmname_str;
580   bool test = false;
581
582   if (decl_asmname == asmname)
583     return true;
584
585   decl_str = IDENTIFIER_POINTER (decl_asmname);
586   asmname_str = IDENTIFIER_POINTER (asmname);
587
588
589   /* If the target assembler name was set by the user, things are trickier.
590      We have a leading '*' to begin with.  After that, it's arguable what
591      is the correct thing to do with -fleading-underscore.  Arguably, we've
592      historically been doing the wrong thing in assemble_alias by always
593      printing the leading underscore.  Since we're not changing that, make
594      sure user_label_prefix follows the '*' before matching.  */
595   if (decl_str[0] == '*')
596     {
597       size_t ulp_len = strlen (user_label_prefix);
598
599       decl_str ++;
600
601       if (ulp_len == 0)
602         test = true;
603       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
604         decl_str += ulp_len, test=true;
605       else
606         decl_str --;
607     }
608   if (asmname_str[0] == '*')
609     {
610       size_t ulp_len = strlen (user_label_prefix);
611
612       asmname_str ++;
613
614       if (ulp_len == 0)
615         test = true;
616       else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
617         asmname_str += ulp_len, test=true;
618       else
619         asmname_str --;
620     }
621
622   if (!test)
623     return false;
624   return strcmp (decl_str, asmname_str) == 0;
625 }
626
627 /* Hash asmnames ignoring the user specified marks.  */
628
629 hashval_t
630 decl_assembler_name_hash (const_tree asmname)
631 {
632   if (IDENTIFIER_POINTER (asmname)[0] == '*')
633     {
634       const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
635       size_t ulp_len = strlen (user_label_prefix);
636
637       if (ulp_len == 0)
638         ;
639       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
640         decl_str += ulp_len;
641
642       return htab_hash_string (decl_str);
643     }
644
645   return htab_hash_string (IDENTIFIER_POINTER (asmname));
646 }
647
648 /* Compute the number of bytes occupied by a tree with code CODE.
649    This function cannot be used for nodes that have variable sizes,
650    including TREE_VEC, STRING_CST, and CALL_EXPR.  */
651 size_t
652 tree_code_size (enum tree_code code)
653 {
654   switch (TREE_CODE_CLASS (code))
655     {
656     case tcc_declaration:  /* A decl node */
657       {
658         switch (code)
659           {
660           case FIELD_DECL:
661             return sizeof (struct tree_field_decl);
662           case PARM_DECL:
663             return sizeof (struct tree_parm_decl);
664           case VAR_DECL:
665             return sizeof (struct tree_var_decl);
666           case LABEL_DECL:
667             return sizeof (struct tree_label_decl);
668           case RESULT_DECL:
669             return sizeof (struct tree_result_decl);
670           case CONST_DECL:
671             return sizeof (struct tree_const_decl);
672           case TYPE_DECL:
673             return sizeof (struct tree_type_decl);
674           case FUNCTION_DECL:
675             return sizeof (struct tree_function_decl);
676           case DEBUG_EXPR_DECL:
677             return sizeof (struct tree_decl_with_rtl);
678           default:
679             return sizeof (struct tree_decl_non_common);
680           }
681       }
682
683     case tcc_type:  /* a type node */
684       return sizeof (struct tree_type);
685
686     case tcc_reference:   /* a reference */
687     case tcc_expression:  /* an expression */
688     case tcc_statement:   /* an expression with side effects */
689     case tcc_comparison:  /* a comparison expression */
690     case tcc_unary:       /* a unary arithmetic expression */
691     case tcc_binary:      /* a binary arithmetic expression */
692       return (sizeof (struct tree_exp)
693               + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
694
695     case tcc_constant:  /* a constant */
696       switch (code)
697         {
698         case INTEGER_CST:       return sizeof (struct tree_int_cst);
699         case REAL_CST:          return sizeof (struct tree_real_cst);
700         case FIXED_CST:         return sizeof (struct tree_fixed_cst);
701         case COMPLEX_CST:       return sizeof (struct tree_complex);
702         case VECTOR_CST:        return sizeof (struct tree_vector);
703         case STRING_CST:        gcc_unreachable ();
704         default:
705           return lang_hooks.tree_size (code);
706         }
707
708     case tcc_exceptional:  /* something random, like an identifier.  */
709       switch (code)
710         {
711         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
712         case TREE_LIST:         return sizeof (struct tree_list);
713
714         case ERROR_MARK:
715         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
716
717         case TREE_VEC:
718         case OMP_CLAUSE:        gcc_unreachable ();
719
720         case SSA_NAME:          return sizeof (struct tree_ssa_name);
721
722         case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
723         case BLOCK:             return sizeof (struct tree_block);
724         case CONSTRUCTOR:       return sizeof (struct tree_constructor);
725         case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
726         case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
727
728         default:
729           return lang_hooks.tree_size (code);
730         }
731
732     default:
733       gcc_unreachable ();
734     }
735 }
736
737 /* Compute the number of bytes occupied by NODE.  This routine only
738    looks at TREE_CODE, except for those nodes that have variable sizes.  */
739 size_t
740 tree_size (const_tree node)
741 {
742   const enum tree_code code = TREE_CODE (node);
743   switch (code)
744     {
745     case TREE_BINFO:
746       return (offsetof (struct tree_binfo, base_binfos)
747               + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
748
749     case TREE_VEC:
750       return (sizeof (struct tree_vec)
751               + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
752
753     case STRING_CST:
754       return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
755
756     case OMP_CLAUSE:
757       return (sizeof (struct tree_omp_clause)
758               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
759                 * sizeof (tree));
760
761     default:
762       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
763         return (sizeof (struct tree_exp)
764                 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
765       else
766         return tree_code_size (code);
767     }
768 }
769
770 /* Return a newly allocated node of code CODE.  For decl and type
771    nodes, some other fields are initialized.  The rest of the node is
772    initialized to zero.  This function cannot be used for TREE_VEC or
773    OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
774
775    Achoo!  I got a code in the node.  */
776
777 tree
778 make_node_stat (enum tree_code code MEM_STAT_DECL)
779 {
780   tree t;
781   enum tree_code_class type = TREE_CODE_CLASS (code);
782   size_t length = tree_code_size (code);
783 #ifdef GATHER_STATISTICS
784   tree_node_kind kind;
785
786   switch (type)
787     {
788     case tcc_declaration:  /* A decl node */
789       kind = d_kind;
790       break;
791
792     case tcc_type:  /* a type node */
793       kind = t_kind;
794       break;
795
796     case tcc_statement:  /* an expression with side effects */
797       kind = s_kind;
798       break;
799
800     case tcc_reference:  /* a reference */
801       kind = r_kind;
802       break;
803
804     case tcc_expression:  /* an expression */
805     case tcc_comparison:  /* a comparison expression */
806     case tcc_unary:  /* a unary arithmetic expression */
807     case tcc_binary:  /* a binary arithmetic expression */
808       kind = e_kind;
809       break;
810
811     case tcc_constant:  /* a constant */
812       kind = c_kind;
813       break;
814
815     case tcc_exceptional:  /* something random, like an identifier.  */
816       switch (code)
817         {
818         case IDENTIFIER_NODE:
819           kind = id_kind;
820           break;
821
822         case TREE_VEC:
823           kind = vec_kind;
824           break;
825
826         case TREE_BINFO:
827           kind = binfo_kind;
828           break;
829
830         case SSA_NAME:
831           kind = ssa_name_kind;
832           break;
833
834         case BLOCK:
835           kind = b_kind;
836           break;
837
838         case CONSTRUCTOR:
839           kind = constr_kind;
840           break;
841
842         default:
843           kind = x_kind;
844           break;
845         }
846       break;
847
848     default:
849       gcc_unreachable ();
850     }
851
852   tree_node_counts[(int) kind]++;
853   tree_node_sizes[(int) kind] += length;
854 #endif
855
856   if (code == IDENTIFIER_NODE)
857     t = (tree) ggc_alloc_zone_pass_stat (length, &tree_id_zone);
858   else
859     t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
860
861   memset (t, 0, length);
862
863   TREE_SET_CODE (t, code);
864
865   switch (type)
866     {
867     case tcc_statement:
868       TREE_SIDE_EFFECTS (t) = 1;
869       break;
870
871     case tcc_declaration:
872       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
873         {
874           if (code == FUNCTION_DECL)
875             {
876               DECL_ALIGN (t) = FUNCTION_BOUNDARY;
877               DECL_MODE (t) = FUNCTION_MODE;
878             }
879           else
880             DECL_ALIGN (t) = 1;
881         }
882       DECL_SOURCE_LOCATION (t) = input_location;
883       if (TREE_CODE (t) == DEBUG_EXPR_DECL)
884         DECL_UID (t) = --next_debug_decl_uid;
885       else
886         {
887           DECL_UID (t) = next_decl_uid++;
888           SET_DECL_PT_UID (t, -1);
889         }
890       if (TREE_CODE (t) == LABEL_DECL)
891         LABEL_DECL_UID (t) = -1;
892
893       break;
894
895     case tcc_type:
896       TYPE_UID (t) = next_type_uid++;
897       TYPE_ALIGN (t) = BITS_PER_UNIT;
898       TYPE_USER_ALIGN (t) = 0;
899       TYPE_MAIN_VARIANT (t) = t;
900       TYPE_CANONICAL (t) = t;
901
902       /* Default to no attributes for type, but let target change that.  */
903       TYPE_ATTRIBUTES (t) = NULL_TREE;
904       targetm.set_default_type_attributes (t);
905
906       /* We have not yet computed the alias set for this type.  */
907       TYPE_ALIAS_SET (t) = -1;
908       break;
909
910     case tcc_constant:
911       TREE_CONSTANT (t) = 1;
912       break;
913
914     case tcc_expression:
915       switch (code)
916         {
917         case INIT_EXPR:
918         case MODIFY_EXPR:
919         case VA_ARG_EXPR:
920         case PREDECREMENT_EXPR:
921         case PREINCREMENT_EXPR:
922         case POSTDECREMENT_EXPR:
923         case POSTINCREMENT_EXPR:
924           /* All of these have side-effects, no matter what their
925              operands are.  */
926           TREE_SIDE_EFFECTS (t) = 1;
927           break;
928
929         default:
930           break;
931         }
932       break;
933
934     default:
935       /* Other classes need no special treatment.  */
936       break;
937     }
938
939   return t;
940 }
941 \f
942 /* Return a new node with the same contents as NODE except that its
943    TREE_CHAIN is zero and it has a fresh uid.  */
944
945 tree
946 copy_node_stat (tree node MEM_STAT_DECL)
947 {
948   tree t;
949   enum tree_code code = TREE_CODE (node);
950   size_t length;
951
952   gcc_assert (code != STATEMENT_LIST);
953
954   length = tree_size (node);
955   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
956   memcpy (t, node, length);
957
958   TREE_CHAIN (t) = 0;
959   TREE_ASM_WRITTEN (t) = 0;
960   TREE_VISITED (t) = 0;
961   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
962     *DECL_VAR_ANN_PTR (t) = 0;
963
964   if (TREE_CODE_CLASS (code) == tcc_declaration)
965     {
966       if (code == DEBUG_EXPR_DECL)
967         DECL_UID (t) = --next_debug_decl_uid;
968       else
969         {
970           DECL_UID (t) = next_decl_uid++;
971           if (DECL_PT_UID_SET_P (node))
972             SET_DECL_PT_UID (t, DECL_PT_UID (node));
973         }
974       if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
975           && DECL_HAS_VALUE_EXPR_P (node))
976         {
977           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
978           DECL_HAS_VALUE_EXPR_P (t) = 1;
979         }
980       if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
981         {
982           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
983           DECL_HAS_INIT_PRIORITY_P (t) = 1;
984         }
985     }
986   else if (TREE_CODE_CLASS (code) == tcc_type)
987     {
988       TYPE_UID (t) = next_type_uid++;
989       /* The following is so that the debug code for
990          the copy is different from the original type.
991          The two statements usually duplicate each other
992          (because they clear fields of the same union),
993          but the optimizer should catch that.  */
994       TYPE_SYMTAB_POINTER (t) = 0;
995       TYPE_SYMTAB_ADDRESS (t) = 0;
996
997       /* Do not copy the values cache.  */
998       if (TYPE_CACHED_VALUES_P(t))
999         {
1000           TYPE_CACHED_VALUES_P (t) = 0;
1001           TYPE_CACHED_VALUES (t) = NULL_TREE;
1002         }
1003     }
1004
1005   return t;
1006 }
1007
1008 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1009    For example, this can copy a list made of TREE_LIST nodes.  */
1010
1011 tree
1012 copy_list (tree list)
1013 {
1014   tree head;
1015   tree prev, next;
1016
1017   if (list == 0)
1018     return 0;
1019
1020   head = prev = copy_node (list);
1021   next = TREE_CHAIN (list);
1022   while (next)
1023     {
1024       TREE_CHAIN (prev) = copy_node (next);
1025       prev = TREE_CHAIN (prev);
1026       next = TREE_CHAIN (next);
1027     }
1028   return head;
1029 }
1030
1031 \f
1032 /* Create an INT_CST node with a LOW value sign extended.  */
1033
1034 tree
1035 build_int_cst (tree type, HOST_WIDE_INT low)
1036 {
1037   /* Support legacy code.  */
1038   if (!type)
1039     type = integer_type_node;
1040
1041   return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
1042 }
1043
1044 /* Create an INT_CST node with a LOW value zero extended.  */
1045
1046 tree
1047 build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
1048 {
1049   return build_int_cst_wide (type, low, 0);
1050 }
1051
1052 /* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
1053    if it is negative.  This function is similar to build_int_cst, but
1054    the extra bits outside of the type precision are cleared.  Constants
1055    with these extra bits may confuse the fold so that it detects overflows
1056    even in cases when they do not occur, and in general should be avoided.
1057    We cannot however make this a default behavior of build_int_cst without
1058    more intrusive changes, since there are parts of gcc that rely on the extra
1059    precision of the integer constants.  */
1060
1061 tree
1062 build_int_cst_type (tree type, HOST_WIDE_INT low)
1063 {
1064   unsigned HOST_WIDE_INT low1;
1065   HOST_WIDE_INT hi;
1066
1067   gcc_assert (type);
1068
1069   fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
1070
1071   return build_int_cst_wide (type, low1, hi);
1072 }
1073
1074 /* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
1075    and sign extended according to the value range of TYPE.  */
1076
1077 tree
1078 build_int_cst_wide_type (tree type,
1079                          unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
1080 {
1081   fit_double_type (low, high, &low, &high, type);
1082   return build_int_cst_wide (type, low, high);
1083 }
1084
1085 /* These are the hash table functions for the hash table of INTEGER_CST
1086    nodes of a sizetype.  */
1087
1088 /* Return the hash code code X, an INTEGER_CST.  */
1089
1090 static hashval_t
1091 int_cst_hash_hash (const void *x)
1092 {
1093   const_tree const t = (const_tree) x;
1094
1095   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1096           ^ htab_hash_pointer (TREE_TYPE (t)));
1097 }
1098
1099 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1100    is the same as that given by *Y, which is the same.  */
1101
1102 static int
1103 int_cst_hash_eq (const void *x, const void *y)
1104 {
1105   const_tree const xt = (const_tree) x;
1106   const_tree const yt = (const_tree) y;
1107
1108   return (TREE_TYPE (xt) == TREE_TYPE (yt)
1109           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1110           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1111 }
1112
1113 /* Create an INT_CST node of TYPE and value HI:LOW.
1114    The returned node is always shared.  For small integers we use a
1115    per-type vector cache, for larger ones we use a single hash table.  */
1116
1117 tree
1118 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1119 {
1120   tree t;
1121   int ix = -1;
1122   int limit = 0;
1123
1124   gcc_assert (type);
1125
1126   switch (TREE_CODE (type))
1127     {
1128     case POINTER_TYPE:
1129     case REFERENCE_TYPE:
1130       /* Cache NULL pointer.  */
1131       if (!hi && !low)
1132         {
1133           limit = 1;
1134           ix = 0;
1135         }
1136       break;
1137
1138     case BOOLEAN_TYPE:
1139       /* Cache false or true.  */
1140       limit = 2;
1141       if (!hi && low < 2)
1142         ix = low;
1143       break;
1144
1145     case INTEGER_TYPE:
1146     case OFFSET_TYPE:
1147       if (TYPE_UNSIGNED (type))
1148         {
1149           /* Cache 0..N */
1150           limit = INTEGER_SHARE_LIMIT;
1151           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1152             ix = low;
1153         }
1154       else
1155         {
1156           /* Cache -1..N */
1157           limit = INTEGER_SHARE_LIMIT + 1;
1158           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1159             ix = low + 1;
1160           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1161             ix = 0;
1162         }
1163       break;
1164
1165     case ENUMERAL_TYPE:
1166       break;
1167
1168     default:
1169       gcc_unreachable ();
1170     }
1171
1172   if (ix >= 0)
1173     {
1174       /* Look for it in the type's vector of small shared ints.  */
1175       if (!TYPE_CACHED_VALUES_P (type))
1176         {
1177           TYPE_CACHED_VALUES_P (type) = 1;
1178           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1179         }
1180
1181       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1182       if (t)
1183         {
1184           /* Make sure no one is clobbering the shared constant.  */
1185           gcc_assert (TREE_TYPE (t) == type);
1186           gcc_assert (TREE_INT_CST_LOW (t) == low);
1187           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1188         }
1189       else
1190         {
1191           /* Create a new shared int.  */
1192           t = make_node (INTEGER_CST);
1193
1194           TREE_INT_CST_LOW (t) = low;
1195           TREE_INT_CST_HIGH (t) = hi;
1196           TREE_TYPE (t) = type;
1197
1198           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1199         }
1200     }
1201   else
1202     {
1203       /* Use the cache of larger shared ints.  */
1204       void **slot;
1205
1206       TREE_INT_CST_LOW (int_cst_node) = low;
1207       TREE_INT_CST_HIGH (int_cst_node) = hi;
1208       TREE_TYPE (int_cst_node) = type;
1209
1210       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1211       t = (tree) *slot;
1212       if (!t)
1213         {
1214           /* Insert this one into the hash table.  */
1215           t = int_cst_node;
1216           *slot = t;
1217           /* Make a new node for next time round.  */
1218           int_cst_node = make_node (INTEGER_CST);
1219         }
1220     }
1221
1222   return t;
1223 }
1224
1225 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1226    and the rest are zeros.  */
1227
1228 tree
1229 build_low_bits_mask (tree type, unsigned bits)
1230 {
1231   double_int mask;
1232
1233   gcc_assert (bits <= TYPE_PRECISION (type));
1234
1235   if (bits == TYPE_PRECISION (type)
1236       && !TYPE_UNSIGNED (type))
1237     /* Sign extended all-ones mask.  */
1238     mask = double_int_minus_one;
1239   else
1240     mask = double_int_mask (bits);
1241
1242   return build_int_cst_wide (type, mask.low, mask.high);
1243 }
1244
1245 /* Checks that X is integer constant that can be expressed in (unsigned)
1246    HOST_WIDE_INT without loss of precision.  */
1247
1248 bool
1249 cst_and_fits_in_hwi (const_tree x)
1250 {
1251   if (TREE_CODE (x) != INTEGER_CST)
1252     return false;
1253
1254   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1255     return false;
1256
1257   return (TREE_INT_CST_HIGH (x) == 0
1258           || TREE_INT_CST_HIGH (x) == -1);
1259 }
1260
1261 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1262    are in a list pointed to by VALS.  */
1263
1264 tree
1265 build_vector (tree type, tree vals)
1266 {
1267   tree v = make_node (VECTOR_CST);
1268   int over = 0;
1269   tree link;
1270
1271   TREE_VECTOR_CST_ELTS (v) = vals;
1272   TREE_TYPE (v) = type;
1273
1274   /* Iterate through elements and check for overflow.  */
1275   for (link = vals; link; link = TREE_CHAIN (link))
1276     {
1277       tree value = TREE_VALUE (link);
1278
1279       /* Don't crash if we get an address constant.  */
1280       if (!CONSTANT_CLASS_P (value))
1281         continue;
1282
1283       over |= TREE_OVERFLOW (value);
1284     }
1285
1286   TREE_OVERFLOW (v) = over;
1287   return v;
1288 }
1289
1290 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1291    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1292
1293 tree
1294 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1295 {
1296   tree list = NULL_TREE;
1297   unsigned HOST_WIDE_INT idx;
1298   tree value;
1299
1300   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1301     list = tree_cons (NULL_TREE, value, list);
1302   return build_vector (type, nreverse (list));
1303 }
1304
1305 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1306    are in the VEC pointed to by VALS.  */
1307 tree
1308 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1309 {
1310   tree c = make_node (CONSTRUCTOR);
1311   TREE_TYPE (c) = type;
1312   CONSTRUCTOR_ELTS (c) = vals;
1313   return c;
1314 }
1315
1316 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1317    INDEX and VALUE.  */
1318 tree
1319 build_constructor_single (tree type, tree index, tree value)
1320 {
1321   VEC(constructor_elt,gc) *v;
1322   constructor_elt *elt;
1323   tree t;
1324
1325   v = VEC_alloc (constructor_elt, gc, 1);
1326   elt = VEC_quick_push (constructor_elt, v, NULL);
1327   elt->index = index;
1328   elt->value = value;
1329
1330   t = build_constructor (type, v);
1331   TREE_CONSTANT (t) = TREE_CONSTANT (value);
1332   return t;
1333 }
1334
1335
1336 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1337    are in a list pointed to by VALS.  */
1338 tree
1339 build_constructor_from_list (tree type, tree vals)
1340 {
1341   tree t, val;
1342   VEC(constructor_elt,gc) *v = NULL;
1343   bool constant_p = true;
1344
1345   if (vals)
1346     {
1347       v = VEC_alloc (constructor_elt, gc, list_length (vals));
1348       for (t = vals; t; t = TREE_CHAIN (t))
1349         {
1350           constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
1351           val = TREE_VALUE (t);
1352           elt->index = TREE_PURPOSE (t);
1353           elt->value = val;
1354           if (!TREE_CONSTANT (val))
1355             constant_p = false;
1356         }
1357     }
1358
1359   t = build_constructor (type, v);
1360   TREE_CONSTANT (t) = constant_p;
1361   return t;
1362 }
1363
1364 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1365
1366 tree
1367 build_fixed (tree type, FIXED_VALUE_TYPE f)
1368 {
1369   tree v;
1370   FIXED_VALUE_TYPE *fp;
1371
1372   v = make_node (FIXED_CST);
1373   fp = GGC_NEW (FIXED_VALUE_TYPE);
1374   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1375
1376   TREE_TYPE (v) = type;
1377   TREE_FIXED_CST_PTR (v) = fp;
1378   return v;
1379 }
1380
1381 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1382
1383 tree
1384 build_real (tree type, REAL_VALUE_TYPE d)
1385 {
1386   tree v;
1387   REAL_VALUE_TYPE *dp;
1388   int overflow = 0;
1389
1390   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1391      Consider doing it via real_convert now.  */
1392
1393   v = make_node (REAL_CST);
1394   dp = GGC_NEW (REAL_VALUE_TYPE);
1395   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1396
1397   TREE_TYPE (v) = type;
1398   TREE_REAL_CST_PTR (v) = dp;
1399   TREE_OVERFLOW (v) = overflow;
1400   return v;
1401 }
1402
1403 /* Return a new REAL_CST node whose type is TYPE
1404    and whose value is the integer value of the INTEGER_CST node I.  */
1405
1406 REAL_VALUE_TYPE
1407 real_value_from_int_cst (const_tree type, const_tree i)
1408 {
1409   REAL_VALUE_TYPE d;
1410
1411   /* Clear all bits of the real value type so that we can later do
1412      bitwise comparisons to see if two values are the same.  */
1413   memset (&d, 0, sizeof d);
1414
1415   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1416                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1417                      TYPE_UNSIGNED (TREE_TYPE (i)));
1418   return d;
1419 }
1420
1421 /* Given a tree representing an integer constant I, return a tree
1422    representing the same value as a floating-point constant of type TYPE.  */
1423
1424 tree
1425 build_real_from_int_cst (tree type, const_tree i)
1426 {
1427   tree v;
1428   int overflow = TREE_OVERFLOW (i);
1429
1430   v = build_real (type, real_value_from_int_cst (type, i));
1431
1432   TREE_OVERFLOW (v) |= overflow;
1433   return v;
1434 }
1435
1436 /* Return a newly constructed STRING_CST node whose value is
1437    the LEN characters at STR.
1438    The TREE_TYPE is not initialized.  */
1439
1440 tree
1441 build_string (int len, const char *str)
1442 {
1443   tree s;
1444   size_t length;
1445
1446   /* Do not waste bytes provided by padding of struct tree_string.  */
1447   length = len + offsetof (struct tree_string, str) + 1;
1448
1449 #ifdef GATHER_STATISTICS
1450   tree_node_counts[(int) c_kind]++;
1451   tree_node_sizes[(int) c_kind] += length;
1452 #endif
1453
1454   s = ggc_alloc_tree (length);
1455
1456   memset (s, 0, sizeof (struct tree_common));
1457   TREE_SET_CODE (s, STRING_CST);
1458   TREE_CONSTANT (s) = 1;
1459   TREE_STRING_LENGTH (s) = len;
1460   memcpy (s->string.str, str, len);
1461   s->string.str[len] = '\0';
1462
1463   return s;
1464 }
1465
1466 /* Return a newly constructed COMPLEX_CST node whose value is
1467    specified by the real and imaginary parts REAL and IMAG.
1468    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1469    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1470
1471 tree
1472 build_complex (tree type, tree real, tree imag)
1473 {
1474   tree t = make_node (COMPLEX_CST);
1475
1476   TREE_REALPART (t) = real;
1477   TREE_IMAGPART (t) = imag;
1478   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1479   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1480   return t;
1481 }
1482
1483 /* Return a constant of arithmetic type TYPE which is the
1484    multiplicative identity of the set TYPE.  */
1485
1486 tree
1487 build_one_cst (tree type)
1488 {
1489   switch (TREE_CODE (type))
1490     {
1491     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1492     case POINTER_TYPE: case REFERENCE_TYPE:
1493     case OFFSET_TYPE:
1494       return build_int_cst (type, 1);
1495
1496     case REAL_TYPE:
1497       return build_real (type, dconst1);
1498
1499     case FIXED_POINT_TYPE:
1500       /* We can only generate 1 for accum types.  */
1501       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1502       return build_fixed (type, FCONST1(TYPE_MODE (type)));
1503
1504     case VECTOR_TYPE:
1505       {
1506         tree scalar, cst;
1507         int i;
1508
1509         scalar = build_one_cst (TREE_TYPE (type));
1510
1511         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1512         cst = NULL_TREE;
1513         for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1514           cst = tree_cons (NULL_TREE, scalar, cst);
1515
1516         return build_vector (type, cst);
1517       }
1518
1519     case COMPLEX_TYPE:
1520       return build_complex (type,
1521                             build_one_cst (TREE_TYPE (type)),
1522                             fold_convert (TREE_TYPE (type), integer_zero_node));
1523
1524     default:
1525       gcc_unreachable ();
1526     }
1527 }
1528
1529 /* Build a BINFO with LEN language slots.  */
1530
1531 tree
1532 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1533 {
1534   tree t;
1535   size_t length = (offsetof (struct tree_binfo, base_binfos)
1536                    + VEC_embedded_size (tree, base_binfos));
1537
1538 #ifdef GATHER_STATISTICS
1539   tree_node_counts[(int) binfo_kind]++;
1540   tree_node_sizes[(int) binfo_kind] += length;
1541 #endif
1542
1543   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1544
1545   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1546
1547   TREE_SET_CODE (t, TREE_BINFO);
1548
1549   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1550
1551   return t;
1552 }
1553
1554
1555 /* Build a newly constructed TREE_VEC node of length LEN.  */
1556
1557 tree
1558 make_tree_vec_stat (int len MEM_STAT_DECL)
1559 {
1560   tree t;
1561   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1562
1563 #ifdef GATHER_STATISTICS
1564   tree_node_counts[(int) vec_kind]++;
1565   tree_node_sizes[(int) vec_kind] += length;
1566 #endif
1567
1568   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1569
1570   memset (t, 0, length);
1571
1572   TREE_SET_CODE (t, TREE_VEC);
1573   TREE_VEC_LENGTH (t) = len;
1574
1575   return t;
1576 }
1577 \f
1578 /* Return 1 if EXPR is the integer constant zero or a complex constant
1579    of zero.  */
1580
1581 int
1582 integer_zerop (const_tree expr)
1583 {
1584   STRIP_NOPS (expr);
1585
1586   return ((TREE_CODE (expr) == INTEGER_CST
1587            && TREE_INT_CST_LOW (expr) == 0
1588            && TREE_INT_CST_HIGH (expr) == 0)
1589           || (TREE_CODE (expr) == COMPLEX_CST
1590               && integer_zerop (TREE_REALPART (expr))
1591               && integer_zerop (TREE_IMAGPART (expr))));
1592 }
1593
1594 /* Return 1 if EXPR is the integer constant one or the corresponding
1595    complex constant.  */
1596
1597 int
1598 integer_onep (const_tree expr)
1599 {
1600   STRIP_NOPS (expr);
1601
1602   return ((TREE_CODE (expr) == INTEGER_CST
1603            && TREE_INT_CST_LOW (expr) == 1
1604            && TREE_INT_CST_HIGH (expr) == 0)
1605           || (TREE_CODE (expr) == COMPLEX_CST
1606               && integer_onep (TREE_REALPART (expr))
1607               && integer_zerop (TREE_IMAGPART (expr))));
1608 }
1609
1610 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1611    it contains.  Likewise for the corresponding complex constant.  */
1612
1613 int
1614 integer_all_onesp (const_tree expr)
1615 {
1616   int prec;
1617   int uns;
1618
1619   STRIP_NOPS (expr);
1620
1621   if (TREE_CODE (expr) == COMPLEX_CST
1622       && integer_all_onesp (TREE_REALPART (expr))
1623       && integer_zerop (TREE_IMAGPART (expr)))
1624     return 1;
1625
1626   else if (TREE_CODE (expr) != INTEGER_CST)
1627     return 0;
1628
1629   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1630   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1631       && TREE_INT_CST_HIGH (expr) == -1)
1632     return 1;
1633   if (!uns)
1634     return 0;
1635
1636   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1637      actual bits, not the (arbitrary) range of the type.  */
1638   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1639   if (prec >= HOST_BITS_PER_WIDE_INT)
1640     {
1641       HOST_WIDE_INT high_value;
1642       int shift_amount;
1643
1644       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1645
1646       /* Can not handle precisions greater than twice the host int size.  */
1647       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1648       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1649         /* Shifting by the host word size is undefined according to the ANSI
1650            standard, so we must handle this as a special case.  */
1651         high_value = -1;
1652       else
1653         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1654
1655       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1656               && TREE_INT_CST_HIGH (expr) == high_value);
1657     }
1658   else
1659     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1660 }
1661
1662 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1663    one bit on).  */
1664
1665 int
1666 integer_pow2p (const_tree expr)
1667 {
1668   int prec;
1669   HOST_WIDE_INT high, low;
1670
1671   STRIP_NOPS (expr);
1672
1673   if (TREE_CODE (expr) == COMPLEX_CST
1674       && integer_pow2p (TREE_REALPART (expr))
1675       && integer_zerop (TREE_IMAGPART (expr)))
1676     return 1;
1677
1678   if (TREE_CODE (expr) != INTEGER_CST)
1679     return 0;
1680
1681   prec = TYPE_PRECISION (TREE_TYPE (expr));
1682   high = TREE_INT_CST_HIGH (expr);
1683   low = TREE_INT_CST_LOW (expr);
1684
1685   /* First clear all bits that are beyond the type's precision in case
1686      we've been sign extended.  */
1687
1688   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1689     ;
1690   else if (prec > HOST_BITS_PER_WIDE_INT)
1691     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1692   else
1693     {
1694       high = 0;
1695       if (prec < HOST_BITS_PER_WIDE_INT)
1696         low &= ~((HOST_WIDE_INT) (-1) << prec);
1697     }
1698
1699   if (high == 0 && low == 0)
1700     return 0;
1701
1702   return ((high == 0 && (low & (low - 1)) == 0)
1703           || (low == 0 && (high & (high - 1)) == 0));
1704 }
1705
1706 /* Return 1 if EXPR is an integer constant other than zero or a
1707    complex constant other than zero.  */
1708
1709 int
1710 integer_nonzerop (const_tree expr)
1711 {
1712   STRIP_NOPS (expr);
1713
1714   return ((TREE_CODE (expr) == INTEGER_CST
1715            && (TREE_INT_CST_LOW (expr) != 0
1716                || TREE_INT_CST_HIGH (expr) != 0))
1717           || (TREE_CODE (expr) == COMPLEX_CST
1718               && (integer_nonzerop (TREE_REALPART (expr))
1719                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1720 }
1721
1722 /* Return 1 if EXPR is the fixed-point constant zero.  */
1723
1724 int
1725 fixed_zerop (const_tree expr)
1726 {
1727   return (TREE_CODE (expr) == FIXED_CST
1728           && double_int_zero_p (TREE_FIXED_CST (expr).data));
1729 }
1730
1731 /* Return the power of two represented by a tree node known to be a
1732    power of two.  */
1733
1734 int
1735 tree_log2 (const_tree expr)
1736 {
1737   int prec;
1738   HOST_WIDE_INT high, low;
1739
1740   STRIP_NOPS (expr);
1741
1742   if (TREE_CODE (expr) == COMPLEX_CST)
1743     return tree_log2 (TREE_REALPART (expr));
1744
1745   prec = TYPE_PRECISION (TREE_TYPE (expr));
1746   high = TREE_INT_CST_HIGH (expr);
1747   low = TREE_INT_CST_LOW (expr);
1748
1749   /* First clear all bits that are beyond the type's precision in case
1750      we've been sign extended.  */
1751
1752   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1753     ;
1754   else if (prec > HOST_BITS_PER_WIDE_INT)
1755     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1756   else
1757     {
1758       high = 0;
1759       if (prec < HOST_BITS_PER_WIDE_INT)
1760         low &= ~((HOST_WIDE_INT) (-1) << prec);
1761     }
1762
1763   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1764           : exact_log2 (low));
1765 }
1766
1767 /* Similar, but return the largest integer Y such that 2 ** Y is less
1768    than or equal to EXPR.  */
1769
1770 int
1771 tree_floor_log2 (const_tree expr)
1772 {
1773   int prec;
1774   HOST_WIDE_INT high, low;
1775
1776   STRIP_NOPS (expr);
1777
1778   if (TREE_CODE (expr) == COMPLEX_CST)
1779     return tree_log2 (TREE_REALPART (expr));
1780
1781   prec = TYPE_PRECISION (TREE_TYPE (expr));
1782   high = TREE_INT_CST_HIGH (expr);
1783   low = TREE_INT_CST_LOW (expr);
1784
1785   /* First clear all bits that are beyond the type's precision in case
1786      we've been sign extended.  Ignore if type's precision hasn't been set
1787      since what we are doing is setting it.  */
1788
1789   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1790     ;
1791   else if (prec > HOST_BITS_PER_WIDE_INT)
1792     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1793   else
1794     {
1795       high = 0;
1796       if (prec < HOST_BITS_PER_WIDE_INT)
1797         low &= ~((HOST_WIDE_INT) (-1) << prec);
1798     }
1799
1800   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1801           : floor_log2 (low));
1802 }
1803
1804 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1805    decimal float constants, so don't return 1 for them.  */
1806
1807 int
1808 real_zerop (const_tree expr)
1809 {
1810   STRIP_NOPS (expr);
1811
1812   return ((TREE_CODE (expr) == REAL_CST
1813            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1814            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1815           || (TREE_CODE (expr) == COMPLEX_CST
1816               && real_zerop (TREE_REALPART (expr))
1817               && real_zerop (TREE_IMAGPART (expr))));
1818 }
1819
1820 /* Return 1 if EXPR is the real constant one in real or complex form.
1821    Trailing zeroes matter for decimal float constants, so don't return
1822    1 for them.  */
1823
1824 int
1825 real_onep (const_tree expr)
1826 {
1827   STRIP_NOPS (expr);
1828
1829   return ((TREE_CODE (expr) == REAL_CST
1830            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1831            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1832           || (TREE_CODE (expr) == COMPLEX_CST
1833               && real_onep (TREE_REALPART (expr))
1834               && real_zerop (TREE_IMAGPART (expr))));
1835 }
1836
1837 /* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1838    for decimal float constants, so don't return 1 for them.  */
1839
1840 int
1841 real_twop (const_tree expr)
1842 {
1843   STRIP_NOPS (expr);
1844
1845   return ((TREE_CODE (expr) == REAL_CST
1846            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1847            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1848           || (TREE_CODE (expr) == COMPLEX_CST
1849               && real_twop (TREE_REALPART (expr))
1850               && real_zerop (TREE_IMAGPART (expr))));
1851 }
1852
1853 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1854    matter for decimal float constants, so don't return 1 for them.  */
1855
1856 int
1857 real_minus_onep (const_tree expr)
1858 {
1859   STRIP_NOPS (expr);
1860
1861   return ((TREE_CODE (expr) == REAL_CST
1862            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1863            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1864           || (TREE_CODE (expr) == COMPLEX_CST
1865               && real_minus_onep (TREE_REALPART (expr))
1866               && real_zerop (TREE_IMAGPART (expr))));
1867 }
1868
1869 /* Nonzero if EXP is a constant or a cast of a constant.  */
1870
1871 int
1872 really_constant_p (const_tree exp)
1873 {
1874   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1875   while (CONVERT_EXPR_P (exp)
1876          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1877     exp = TREE_OPERAND (exp, 0);
1878   return TREE_CONSTANT (exp);
1879 }
1880 \f
1881 /* Return first list element whose TREE_VALUE is ELEM.
1882    Return 0 if ELEM is not in LIST.  */
1883
1884 tree
1885 value_member (tree elem, tree list)
1886 {
1887   while (list)
1888     {
1889       if (elem == TREE_VALUE (list))
1890         return list;
1891       list = TREE_CHAIN (list);
1892     }
1893   return NULL_TREE;
1894 }
1895
1896 /* Return first list element whose TREE_PURPOSE is ELEM.
1897    Return 0 if ELEM is not in LIST.  */
1898
1899 tree
1900 purpose_member (const_tree elem, tree list)
1901 {
1902   while (list)
1903     {
1904       if (elem == TREE_PURPOSE (list))
1905         return list;
1906       list = TREE_CHAIN (list);
1907     }
1908   return NULL_TREE;
1909 }
1910
1911 /* Returns element number IDX (zero-origin) of chain CHAIN, or
1912    NULL_TREE.  */
1913
1914 tree
1915 chain_index (int idx, tree chain)
1916 {
1917   for (; chain && idx > 0; --idx)
1918     chain = TREE_CHAIN (chain);
1919   return chain;
1920 }
1921
1922 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1923
1924 int
1925 chain_member (const_tree elem, const_tree chain)
1926 {
1927   while (chain)
1928     {
1929       if (elem == chain)
1930         return 1;
1931       chain = TREE_CHAIN (chain);
1932     }
1933
1934   return 0;
1935 }
1936
1937 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1938    We expect a null pointer to mark the end of the chain.
1939    This is the Lisp primitive `length'.  */
1940
1941 int
1942 list_length (const_tree t)
1943 {
1944   const_tree p = t;
1945 #ifdef ENABLE_TREE_CHECKING
1946   const_tree q = t;
1947 #endif
1948   int len = 0;
1949
1950   while (p)
1951     {
1952       p = TREE_CHAIN (p);
1953 #ifdef ENABLE_TREE_CHECKING
1954       if (len % 2)
1955         q = TREE_CHAIN (q);
1956       gcc_assert (p != q);
1957 #endif
1958       len++;
1959     }
1960
1961   return len;
1962 }
1963
1964 /* Returns the number of FIELD_DECLs in TYPE.  */
1965
1966 int
1967 fields_length (const_tree type)
1968 {
1969   tree t = TYPE_FIELDS (type);
1970   int count = 0;
1971
1972   for (; t; t = TREE_CHAIN (t))
1973     if (TREE_CODE (t) == FIELD_DECL)
1974       ++count;
1975
1976   return count;
1977 }
1978
1979 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
1980    UNION_TYPE TYPE, or NULL_TREE if none.  */
1981
1982 tree
1983 first_field (const_tree type)
1984 {
1985   tree t = TYPE_FIELDS (type);
1986   while (t && TREE_CODE (t) != FIELD_DECL)
1987     t = TREE_CHAIN (t);
1988   return t;
1989 }
1990
1991 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1992    by modifying the last node in chain 1 to point to chain 2.
1993    This is the Lisp primitive `nconc'.  */
1994
1995 tree
1996 chainon (tree op1, tree op2)
1997 {
1998   tree t1;
1999
2000   if (!op1)
2001     return op2;
2002   if (!op2)
2003     return op1;
2004
2005   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2006     continue;
2007   TREE_CHAIN (t1) = op2;
2008
2009 #ifdef ENABLE_TREE_CHECKING
2010   {
2011     tree t2;
2012     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2013       gcc_assert (t2 != t1);
2014   }
2015 #endif
2016
2017   return op1;
2018 }
2019
2020 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2021
2022 tree
2023 tree_last (tree chain)
2024 {
2025   tree next;
2026   if (chain)
2027     while ((next = TREE_CHAIN (chain)))
2028       chain = next;
2029   return chain;
2030 }
2031
2032 /* Reverse the order of elements in the chain T,
2033    and return the new head of the chain (old last element).  */
2034
2035 tree
2036 nreverse (tree t)
2037 {
2038   tree prev = 0, decl, next;
2039   for (decl = t; decl; decl = next)
2040     {
2041       next = TREE_CHAIN (decl);
2042       TREE_CHAIN (decl) = prev;
2043       prev = decl;
2044     }
2045   return prev;
2046 }
2047 \f
2048 /* Return a newly created TREE_LIST node whose
2049    purpose and value fields are PARM and VALUE.  */
2050
2051 tree
2052 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2053 {
2054   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2055   TREE_PURPOSE (t) = parm;
2056   TREE_VALUE (t) = value;
2057   return t;
2058 }
2059
2060 /* Build a chain of TREE_LIST nodes from a vector.  */
2061
2062 tree
2063 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2064 {
2065   tree ret = NULL_TREE;
2066   tree *pp = &ret;
2067   unsigned int i;
2068   tree t;
2069   for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
2070     {
2071       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2072       pp = &TREE_CHAIN (*pp);
2073     }
2074   return ret;
2075 }
2076
2077 /* Return a newly created TREE_LIST node whose
2078    purpose and value fields are PURPOSE and VALUE
2079    and whose TREE_CHAIN is CHAIN.  */
2080
2081 tree
2082 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2083 {
2084   tree node;
2085
2086   node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
2087
2088   memset (node, 0, sizeof (struct tree_common));
2089
2090 #ifdef GATHER_STATISTICS
2091   tree_node_counts[(int) x_kind]++;
2092   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2093 #endif
2094
2095   TREE_SET_CODE (node, TREE_LIST);
2096   TREE_CHAIN (node) = chain;
2097   TREE_PURPOSE (node) = purpose;
2098   TREE_VALUE (node) = value;
2099   return node;
2100 }
2101
2102 /* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
2103
2104 tree
2105 ctor_to_list (tree ctor)
2106 {
2107   tree list = NULL_TREE;
2108   tree *p = &list;
2109   unsigned ix;
2110   tree purpose, val;
2111
2112   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
2113     {
2114       *p = build_tree_list (purpose, val);
2115       p = &TREE_CHAIN (*p);
2116     }
2117
2118   return list;
2119 }
2120
2121 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2122    trees.  */
2123
2124 VEC(tree,gc) *
2125 ctor_to_vec (tree ctor)
2126 {
2127   VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2128   unsigned int ix;
2129   tree val;
2130
2131   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2132     VEC_quick_push (tree, vec, val);
2133
2134   return vec;
2135 }
2136 \f
2137 /* Return the size nominally occupied by an object of type TYPE
2138    when it resides in memory.  The value is measured in units of bytes,
2139    and its data type is that normally used for type sizes
2140    (which is the first type created by make_signed_type or
2141    make_unsigned_type).  */
2142
2143 tree
2144 size_in_bytes (const_tree type)
2145 {
2146   tree t;
2147
2148   if (type == error_mark_node)
2149     return integer_zero_node;
2150
2151   type = TYPE_MAIN_VARIANT (type);
2152   t = TYPE_SIZE_UNIT (type);
2153
2154   if (t == 0)
2155     {
2156       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2157       return size_zero_node;
2158     }
2159
2160   return t;
2161 }
2162
2163 /* Return the size of TYPE (in bytes) as a wide integer
2164    or return -1 if the size can vary or is larger than an integer.  */
2165
2166 HOST_WIDE_INT
2167 int_size_in_bytes (const_tree type)
2168 {
2169   tree t;
2170
2171   if (type == error_mark_node)
2172     return 0;
2173
2174   type = TYPE_MAIN_VARIANT (type);
2175   t = TYPE_SIZE_UNIT (type);
2176   if (t == 0
2177       || TREE_CODE (t) != INTEGER_CST
2178       || TREE_INT_CST_HIGH (t) != 0
2179       /* If the result would appear negative, it's too big to represent.  */
2180       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2181     return -1;
2182
2183   return TREE_INT_CST_LOW (t);
2184 }
2185
2186 /* Return the maximum size of TYPE (in bytes) as a wide integer
2187    or return -1 if the size can vary or is larger than an integer.  */
2188
2189 HOST_WIDE_INT
2190 max_int_size_in_bytes (const_tree type)
2191 {
2192   HOST_WIDE_INT size = -1;
2193   tree size_tree;
2194
2195   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2196
2197   if (TREE_CODE (type) == ARRAY_TYPE)
2198     {
2199       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2200
2201       if (size_tree && host_integerp (size_tree, 1))
2202         size = tree_low_cst (size_tree, 1);
2203     }
2204
2205   /* If we still haven't been able to get a size, see if the language
2206      can compute a maximum size.  */
2207
2208   if (size == -1)
2209     {
2210       size_tree = lang_hooks.types.max_size (type);
2211
2212       if (size_tree && host_integerp (size_tree, 1))
2213         size = tree_low_cst (size_tree, 1);
2214     }
2215
2216   return size;
2217 }
2218
2219 /* Returns a tree for the size of EXP in bytes.  */
2220
2221 tree
2222 tree_expr_size (const_tree exp)
2223 {
2224   if (DECL_P (exp)
2225       && DECL_SIZE_UNIT (exp) != 0)
2226     return DECL_SIZE_UNIT (exp);
2227   else
2228     return size_in_bytes (TREE_TYPE (exp));
2229 }
2230 \f
2231 /* Return the bit position of FIELD, in bits from the start of the record.
2232    This is a tree of type bitsizetype.  */
2233
2234 tree
2235 bit_position (const_tree field)
2236 {
2237   return bit_from_pos (DECL_FIELD_OFFSET (field),
2238                        DECL_FIELD_BIT_OFFSET (field));
2239 }
2240
2241 /* Likewise, but return as an integer.  It must be representable in
2242    that way (since it could be a signed value, we don't have the
2243    option of returning -1 like int_size_in_byte can.  */
2244
2245 HOST_WIDE_INT
2246 int_bit_position (const_tree field)
2247 {
2248   return tree_low_cst (bit_position (field), 0);
2249 }
2250 \f
2251 /* Return the byte position of FIELD, in bytes from the start of the record.
2252    This is a tree of type sizetype.  */
2253
2254 tree
2255 byte_position (const_tree field)
2256 {
2257   return byte_from_pos (DECL_FIELD_OFFSET (field),
2258                         DECL_FIELD_BIT_OFFSET (field));
2259 }
2260
2261 /* Likewise, but return as an integer.  It must be representable in
2262    that way (since it could be a signed value, we don't have the
2263    option of returning -1 like int_size_in_byte can.  */
2264
2265 HOST_WIDE_INT
2266 int_byte_position (const_tree field)
2267 {
2268   return tree_low_cst (byte_position (field), 0);
2269 }
2270 \f
2271 /* Return the strictest alignment, in bits, that T is known to have.  */
2272
2273 unsigned int
2274 expr_align (const_tree t)
2275 {
2276   unsigned int align0, align1;
2277
2278   switch (TREE_CODE (t))
2279     {
2280     CASE_CONVERT:  case NON_LVALUE_EXPR:
2281       /* If we have conversions, we know that the alignment of the
2282          object must meet each of the alignments of the types.  */
2283       align0 = expr_align (TREE_OPERAND (t, 0));
2284       align1 = TYPE_ALIGN (TREE_TYPE (t));
2285       return MAX (align0, align1);
2286
2287     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2288     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2289     case CLEANUP_POINT_EXPR:
2290       /* These don't change the alignment of an object.  */
2291       return expr_align (TREE_OPERAND (t, 0));
2292
2293     case COND_EXPR:
2294       /* The best we can do is say that the alignment is the least aligned
2295          of the two arms.  */
2296       align0 = expr_align (TREE_OPERAND (t, 1));
2297       align1 = expr_align (TREE_OPERAND (t, 2));
2298       return MIN (align0, align1);
2299
2300       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2301          meaningfully, it's always 1.  */
2302     case LABEL_DECL:     case CONST_DECL:
2303     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2304     case FUNCTION_DECL:
2305       gcc_assert (DECL_ALIGN (t) != 0);
2306       return DECL_ALIGN (t);
2307
2308     default:
2309       break;
2310     }
2311
2312   /* Otherwise take the alignment from that of the type.  */
2313   return TYPE_ALIGN (TREE_TYPE (t));
2314 }
2315 \f
2316 /* Return, as a tree node, the number of elements for TYPE (which is an
2317    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2318
2319 tree
2320 array_type_nelts (const_tree type)
2321 {
2322   tree index_type, min, max;
2323
2324   /* If they did it with unspecified bounds, then we should have already
2325      given an error about it before we got here.  */
2326   if (! TYPE_DOMAIN (type))
2327     return error_mark_node;
2328
2329   index_type = TYPE_DOMAIN (type);
2330   min = TYPE_MIN_VALUE (index_type);
2331   max = TYPE_MAX_VALUE (index_type);
2332
2333   return (integer_zerop (min)
2334           ? max
2335           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2336 }
2337 \f
2338 /* If arg is static -- a reference to an object in static storage -- then
2339    return the object.  This is not the same as the C meaning of `static'.
2340    If arg isn't static, return NULL.  */
2341
2342 tree
2343 staticp (tree arg)
2344 {
2345   switch (TREE_CODE (arg))
2346     {
2347     case FUNCTION_DECL:
2348       /* Nested functions are static, even though taking their address will
2349          involve a trampoline as we unnest the nested function and create
2350          the trampoline on the tree level.  */
2351       return arg;
2352
2353     case VAR_DECL:
2354       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2355               && ! DECL_THREAD_LOCAL_P (arg)
2356               && ! DECL_DLLIMPORT_P (arg)
2357               ? arg : NULL);
2358
2359     case CONST_DECL:
2360       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2361               ? arg : NULL);
2362
2363     case CONSTRUCTOR:
2364       return TREE_STATIC (arg) ? arg : NULL;
2365
2366     case LABEL_DECL:
2367     case STRING_CST:
2368       return arg;
2369
2370     case COMPONENT_REF:
2371       /* If the thing being referenced is not a field, then it is
2372          something language specific.  */
2373       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2374
2375       /* If we are referencing a bitfield, we can't evaluate an
2376          ADDR_EXPR at compile time and so it isn't a constant.  */
2377       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2378         return NULL;
2379
2380       return staticp (TREE_OPERAND (arg, 0));
2381
2382     case BIT_FIELD_REF:
2383       return NULL;
2384
2385     case MISALIGNED_INDIRECT_REF:
2386     case ALIGN_INDIRECT_REF:
2387     case INDIRECT_REF:
2388       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2389
2390     case ARRAY_REF:
2391     case ARRAY_RANGE_REF:
2392       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2393           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2394         return staticp (TREE_OPERAND (arg, 0));
2395       else
2396         return NULL;
2397
2398     case COMPOUND_LITERAL_EXPR:
2399       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2400
2401     default:
2402       return NULL;
2403     }
2404 }
2405
2406 \f
2407
2408
2409 /* Return whether OP is a DECL whose address is function-invariant.  */
2410
2411 bool
2412 decl_address_invariant_p (const_tree op)
2413 {
2414   /* The conditions below are slightly less strict than the one in
2415      staticp.  */
2416
2417   switch (TREE_CODE (op))
2418     {
2419     case PARM_DECL:
2420     case RESULT_DECL:
2421     case LABEL_DECL:
2422     case FUNCTION_DECL:
2423       return true;
2424
2425     case VAR_DECL:
2426       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2427            && !DECL_DLLIMPORT_P (op))
2428           || DECL_THREAD_LOCAL_P (op)
2429           || DECL_CONTEXT (op) == current_function_decl
2430           || decl_function_context (op) == current_function_decl)
2431         return true;
2432       break;
2433
2434     case CONST_DECL:
2435       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2436           || decl_function_context (op) == current_function_decl)
2437         return true;
2438       break;
2439
2440     default:
2441       break;
2442     }
2443
2444   return false;
2445 }
2446
2447 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2448
2449 bool
2450 decl_address_ip_invariant_p (const_tree op)
2451 {
2452   /* The conditions below are slightly less strict than the one in
2453      staticp.  */
2454
2455   switch (TREE_CODE (op))
2456     {
2457     case LABEL_DECL:
2458     case FUNCTION_DECL:
2459     case STRING_CST:
2460       return true;
2461
2462     case VAR_DECL:
2463       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2464            && !DECL_DLLIMPORT_P (op))
2465           || DECL_THREAD_LOCAL_P (op))
2466         return true;
2467       break;
2468
2469     case CONST_DECL:
2470       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2471         return true;
2472       break;
2473
2474     default:
2475       break;
2476     }
2477
2478   return false;
2479 }
2480
2481
2482 /* Return true if T is function-invariant (internal function, does
2483    not handle arithmetic; that's handled in skip_simple_arithmetic and
2484    tree_invariant_p).  */
2485
2486 static bool tree_invariant_p (tree t);
2487
2488 static bool
2489 tree_invariant_p_1 (tree t)
2490 {
2491   tree op;
2492
2493   if (TREE_CONSTANT (t)
2494       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2495     return true;
2496
2497   switch (TREE_CODE (t))
2498     {
2499     case SAVE_EXPR:
2500       return true;
2501
2502     case ADDR_EXPR:
2503       op = TREE_OPERAND (t, 0);
2504       while (handled_component_p (op))
2505         {
2506           switch (TREE_CODE (op))
2507             {
2508             case ARRAY_REF:
2509             case ARRAY_RANGE_REF:
2510               if (!tree_invariant_p (TREE_OPERAND (op, 1))
2511                   || TREE_OPERAND (op, 2) != NULL_TREE
2512                   || TREE_OPERAND (op, 3) != NULL_TREE)
2513                 return false;
2514               break;
2515
2516             case COMPONENT_REF:
2517               if (TREE_OPERAND (op, 2) != NULL_TREE)
2518                 return false;
2519               break;
2520
2521             default:;
2522             }
2523           op = TREE_OPERAND (op, 0);
2524         }
2525
2526       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2527
2528     default:
2529       break;
2530     }
2531
2532   return false;
2533 }
2534
2535 /* Return true if T is function-invariant.  */
2536
2537 static bool
2538 tree_invariant_p (tree t)
2539 {
2540   tree inner = skip_simple_arithmetic (t);
2541   return tree_invariant_p_1 (inner);
2542 }
2543
2544 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2545    Do this to any expression which may be used in more than one place,
2546    but must be evaluated only once.
2547
2548    Normally, expand_expr would reevaluate the expression each time.
2549    Calling save_expr produces something that is evaluated and recorded
2550    the first time expand_expr is called on it.  Subsequent calls to
2551    expand_expr just reuse the recorded value.
2552
2553    The call to expand_expr that generates code that actually computes
2554    the value is the first call *at compile time*.  Subsequent calls
2555    *at compile time* generate code to use the saved value.
2556    This produces correct result provided that *at run time* control
2557    always flows through the insns made by the first expand_expr
2558    before reaching the other places where the save_expr was evaluated.
2559    You, the caller of save_expr, must make sure this is so.
2560
2561    Constants, and certain read-only nodes, are returned with no
2562    SAVE_EXPR because that is safe.  Expressions containing placeholders
2563    are not touched; see tree.def for an explanation of what these
2564    are used for.  */
2565
2566 tree
2567 save_expr (tree expr)
2568 {
2569   tree t = fold (expr);
2570   tree inner;
2571
2572   /* If the tree evaluates to a constant, then we don't want to hide that
2573      fact (i.e. this allows further folding, and direct checks for constants).
2574      However, a read-only object that has side effects cannot be bypassed.
2575      Since it is no problem to reevaluate literals, we just return the
2576      literal node.  */
2577   inner = skip_simple_arithmetic (t);
2578   if (TREE_CODE (inner) == ERROR_MARK)
2579     return inner;
2580
2581   if (tree_invariant_p_1 (inner))
2582     return t;
2583
2584   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2585      it means that the size or offset of some field of an object depends on
2586      the value within another field.
2587
2588      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2589      and some variable since it would then need to be both evaluated once and
2590      evaluated more than once.  Front-ends must assure this case cannot
2591      happen by surrounding any such subexpressions in their own SAVE_EXPR
2592      and forcing evaluation at the proper time.  */
2593   if (contains_placeholder_p (inner))
2594     return t;
2595
2596   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2597   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2598
2599   /* This expression might be placed ahead of a jump to ensure that the
2600      value was computed on both sides of the jump.  So make sure it isn't
2601      eliminated as dead.  */
2602   TREE_SIDE_EFFECTS (t) = 1;
2603   return t;
2604 }
2605
2606 /* Look inside EXPR and into any simple arithmetic operations.  Return
2607    the innermost non-arithmetic node.  */
2608
2609 tree
2610 skip_simple_arithmetic (tree expr)
2611 {
2612   tree inner;
2613
2614   /* We don't care about whether this can be used as an lvalue in this
2615      context.  */
2616   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2617     expr = TREE_OPERAND (expr, 0);
2618
2619   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2620      a constant, it will be more efficient to not make another SAVE_EXPR since
2621      it will allow better simplification and GCSE will be able to merge the
2622      computations if they actually occur.  */
2623   inner = expr;
2624   while (1)
2625     {
2626       if (UNARY_CLASS_P (inner))
2627         inner = TREE_OPERAND (inner, 0);
2628       else if (BINARY_CLASS_P (inner))
2629         {
2630           if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2631             inner = TREE_OPERAND (inner, 0);
2632           else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2633             inner = TREE_OPERAND (inner, 1);
2634           else
2635             break;
2636         }
2637       else
2638         break;
2639     }
2640
2641   return inner;
2642 }
2643
2644
2645 /* Return which tree structure is used by T.  */
2646
2647 enum tree_node_structure_enum
2648 tree_node_structure (const_tree t)
2649 {
2650   const enum tree_code code = TREE_CODE (t);
2651   return tree_node_structure_for_code (code);
2652 }
2653
2654 /* Set various status flags when building a CALL_EXPR object T.  */
2655
2656 static void
2657 process_call_operands (tree t)
2658 {
2659   bool side_effects = TREE_SIDE_EFFECTS (t);
2660   bool read_only = false;
2661   int i = call_expr_flags (t);
2662
2663   /* Calls have side-effects, except those to const or pure functions.  */
2664   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2665     side_effects = true;
2666   /* Propagate TREE_READONLY of arguments for const functions.  */
2667   if (i & ECF_CONST)
2668     read_only = true;
2669
2670   if (!side_effects || read_only)
2671     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2672       {
2673         tree op = TREE_OPERAND (t, i);
2674         if (op && TREE_SIDE_EFFECTS (op))
2675           side_effects = true;
2676         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2677           read_only = false;
2678       }
2679
2680   TREE_SIDE_EFFECTS (t) = side_effects;
2681   TREE_READONLY (t) = read_only;
2682 }
2683 \f
2684 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2685    or offset that depends on a field within a record.  */
2686
2687 bool
2688 contains_placeholder_p (const_tree exp)
2689 {
2690   enum tree_code code;
2691
2692   if (!exp)
2693     return 0;
2694
2695   code = TREE_CODE (exp);
2696   if (code == PLACEHOLDER_EXPR)
2697     return 1;
2698
2699   switch (TREE_CODE_CLASS (code))
2700     {
2701     case tcc_reference:
2702       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2703          position computations since they will be converted into a
2704          WITH_RECORD_EXPR involving the reference, which will assume
2705          here will be valid.  */
2706       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2707
2708     case tcc_exceptional:
2709       if (code == TREE_LIST)
2710         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2711                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2712       break;
2713
2714     case tcc_unary:
2715     case tcc_binary:
2716     case tcc_comparison:
2717     case tcc_expression:
2718       switch (code)
2719         {
2720         case COMPOUND_EXPR:
2721           /* Ignoring the first operand isn't quite right, but works best.  */
2722           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2723
2724         case COND_EXPR:
2725           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2726                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2727                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2728
2729         case SAVE_EXPR:
2730           /* The save_expr function never wraps anything containing
2731              a PLACEHOLDER_EXPR. */
2732           return 0;
2733
2734         default:
2735           break;
2736         }
2737
2738       switch (TREE_CODE_LENGTH (code))
2739         {
2740         case 1:
2741           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2742         case 2:
2743           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2744                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2745         default:
2746           return 0;
2747         }
2748
2749     case tcc_vl_exp:
2750       switch (code)
2751         {
2752         case CALL_EXPR:
2753           {
2754             const_tree arg;
2755             const_call_expr_arg_iterator iter;
2756             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2757               if (CONTAINS_PLACEHOLDER_P (arg))
2758                 return 1;
2759             return 0;
2760           }
2761         default:
2762           return 0;
2763         }
2764
2765     default:
2766       return 0;
2767     }
2768   return 0;
2769 }
2770
2771 /* Return true if any part of the computation of TYPE involves a
2772    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2773    (for QUAL_UNION_TYPE) and field positions.  */
2774
2775 static bool
2776 type_contains_placeholder_1 (const_tree type)
2777 {
2778   /* If the size contains a placeholder or the parent type (component type in
2779      the case of arrays) type involves a placeholder, this type does.  */
2780   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2781       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2782       || (TREE_TYPE (type) != 0
2783           && type_contains_placeholder_p (TREE_TYPE (type))))
2784     return true;
2785
2786   /* Now do type-specific checks.  Note that the last part of the check above
2787      greatly limits what we have to do below.  */
2788   switch (TREE_CODE (type))
2789     {
2790     case VOID_TYPE:
2791     case COMPLEX_TYPE:
2792     case ENUMERAL_TYPE:
2793     case BOOLEAN_TYPE:
2794     case POINTER_TYPE:
2795     case OFFSET_TYPE:
2796     case REFERENCE_TYPE:
2797     case METHOD_TYPE:
2798     case FUNCTION_TYPE:
2799     case VECTOR_TYPE:
2800       return false;
2801
2802     case INTEGER_TYPE:
2803     case REAL_TYPE:
2804     case FIXED_POINT_TYPE:
2805       /* Here we just check the bounds.  */
2806       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2807               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2808
2809     case ARRAY_TYPE:
2810       /* We're already checked the component type (TREE_TYPE), so just check
2811          the index type.  */
2812       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2813
2814     case RECORD_TYPE:
2815     case UNION_TYPE:
2816     case QUAL_UNION_TYPE:
2817       {
2818         tree field;
2819
2820         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2821           if (TREE_CODE (field) == FIELD_DECL
2822               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2823                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2824                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2825                   || type_contains_placeholder_p (TREE_TYPE (field))))
2826             return true;
2827
2828         return false;
2829       }
2830
2831     default:
2832       gcc_unreachable ();
2833     }
2834 }
2835
2836 bool
2837 type_contains_placeholder_p (tree type)
2838 {
2839   bool result;
2840
2841   /* If the contains_placeholder_bits field has been initialized,
2842      then we know the answer.  */
2843   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2844     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2845
2846   /* Indicate that we've seen this type node, and the answer is false.
2847      This is what we want to return if we run into recursion via fields.  */
2848   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2849
2850   /* Compute the real value.  */
2851   result = type_contains_placeholder_1 (type);
2852
2853   /* Store the real value.  */
2854   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2855
2856   return result;
2857 }
2858 \f
2859 /* Push tree EXP onto vector QUEUE if it is not already present.  */
2860
2861 static void
2862 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2863 {
2864   unsigned int i;
2865   tree iter;
2866
2867   for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
2868     if (simple_cst_equal (iter, exp) == 1)
2869       break;
2870
2871   if (!iter)
2872     VEC_safe_push (tree, heap, *queue, exp);
2873 }
2874
2875 /* Given a tree EXP, find all occurences of references to fields
2876    in a PLACEHOLDER_EXPR and place them in vector REFS without
2877    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2878    we assume here that EXP contains only arithmetic expressions
2879    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2880    argument list.  */
2881
2882 void
2883 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2884 {
2885   enum tree_code code = TREE_CODE (exp);
2886   tree inner;
2887   int i;
2888
2889   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2890   if (code == TREE_LIST)
2891     {
2892       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2893       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2894     }
2895   else if (code == COMPONENT_REF)
2896     {
2897       for (inner = TREE_OPERAND (exp, 0);
2898            REFERENCE_CLASS_P (inner);
2899            inner = TREE_OPERAND (inner, 0))
2900         ;
2901
2902       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2903         push_without_duplicates (exp, refs);
2904       else
2905         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2906    }
2907   else
2908     switch (TREE_CODE_CLASS (code))
2909       {
2910       case tcc_constant:
2911         break;
2912
2913       case tcc_declaration:
2914         /* Variables allocated to static storage can stay.  */
2915         if (!TREE_STATIC (exp))
2916           push_without_duplicates (exp, refs);
2917         break;
2918
2919       case tcc_expression:
2920         /* This is the pattern built in ada/make_aligning_type.  */
2921         if (code == ADDR_EXPR
2922             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2923           {
2924             push_without_duplicates (exp, refs);
2925             break;
2926           }
2927
2928         /* Fall through...  */
2929
2930       case tcc_exceptional:
2931       case tcc_unary:
2932       case tcc_binary:
2933       case tcc_comparison:
2934       case tcc_reference:
2935         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2936           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2937         break;
2938
2939       case tcc_vl_exp:
2940         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2941           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2942         break;
2943
2944       default:
2945         gcc_unreachable ();
2946       }
2947 }
2948
2949 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2950    return a tree with all occurrences of references to F in a
2951    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
2952    CONST_DECLs.  Note that we assume here that EXP contains only
2953    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
2954    occurring only in their argument list.  */
2955
2956 tree
2957 substitute_in_expr (tree exp, tree f, tree r)
2958 {
2959   enum tree_code code = TREE_CODE (exp);
2960   tree op0, op1, op2, op3;
2961   tree new_tree;
2962
2963   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2964   if (code == TREE_LIST)
2965     {
2966       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2967       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2968       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2969         return exp;
2970
2971       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2972     }
2973   else if (code == COMPONENT_REF)
2974     {
2975       tree inner;
2976
2977       /* If this expression is getting a value from a PLACEHOLDER_EXPR
2978          and it is the right field, replace it with R.  */
2979       for (inner = TREE_OPERAND (exp, 0);
2980            REFERENCE_CLASS_P (inner);
2981            inner = TREE_OPERAND (inner, 0))
2982         ;
2983
2984       /* The field.  */
2985       op1 = TREE_OPERAND (exp, 1);
2986
2987       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
2988         return r;
2989
2990       /* If this expression hasn't been completed let, leave it alone.  */
2991       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
2992         return exp;
2993
2994       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2995       if (op0 == TREE_OPERAND (exp, 0))
2996         return exp;
2997
2998       new_tree
2999         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3000    }
3001   else
3002     switch (TREE_CODE_CLASS (code))
3003       {
3004       case tcc_constant:
3005         return exp;
3006
3007       case tcc_declaration:
3008         if (exp == f)
3009           return r;
3010         else
3011           return exp;
3012
3013       case tcc_expression:
3014         if (exp == f)
3015           return r;
3016
3017         /* Fall through...  */
3018
3019       case tcc_exceptional:
3020       case tcc_unary:
3021       case tcc_binary:
3022       case tcc_comparison:
3023       case tcc_reference:
3024         switch (TREE_CODE_LENGTH (code))
3025           {
3026           case 0:
3027             return exp;
3028
3029           case 1:
3030             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3031             if (op0 == TREE_OPERAND (exp, 0))
3032               return exp;
3033
3034             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3035             break;
3036
3037           case 2:
3038             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3039             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3040
3041             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3042               return exp;
3043
3044             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3045             break;
3046
3047           case 3:
3048             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3049             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3050             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3051
3052             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3053                 && op2 == TREE_OPERAND (exp, 2))
3054               return exp;
3055
3056             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3057             break;
3058
3059           case 4:
3060             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3061             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3062             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3063             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3064
3065             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3066                 && op2 == TREE_OPERAND (exp, 2)
3067                 && op3 == TREE_OPERAND (exp, 3))
3068               return exp;
3069
3070             new_tree
3071               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3072             break;
3073
3074           default:
3075             gcc_unreachable ();
3076           }
3077         break;
3078
3079       case tcc_vl_exp:
3080         {
3081           int i;
3082
3083           new_tree = NULL_TREE;
3084
3085           /* If we are trying to replace F with a constant, inline back
3086              functions which do nothing else than computing a value from
3087              the arguments they are passed.  This makes it possible to
3088              fold partially or entirely the replacement expression.  */
3089           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3090             {
3091               tree t = maybe_inline_call_in_expr (exp);
3092               if (t)
3093                 return SUBSTITUTE_IN_EXPR (t, f, r);
3094             }
3095
3096           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3097             {
3098               tree op = TREE_OPERAND (exp, i);
3099               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3100               if (new_op != op)
3101                 {
3102                   if (!new_tree)
3103                     new_tree = copy_node (exp);
3104                   TREE_OPERAND (new_tree, i) = new_op;
3105                 }
3106             }
3107
3108           if (new_tree)
3109             {
3110               new_tree = fold (new_tree);
3111               if (TREE_CODE (new_tree) == CALL_EXPR)
3112                 process_call_operands (new_tree);
3113             }
3114           else
3115             return exp;
3116         }
3117         break;
3118
3119       default:
3120         gcc_unreachable ();
3121       }
3122
3123   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3124   return new_tree;
3125 }
3126
3127 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3128    for it within OBJ, a tree that is an object or a chain of references.  */
3129
3130 tree
3131 substitute_placeholder_in_expr (tree exp, tree obj)
3132 {
3133   enum tree_code code = TREE_CODE (exp);
3134   tree op0, op1, op2, op3;
3135   tree new_tree;
3136
3137   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3138      in the chain of OBJ.  */
3139   if (code == PLACEHOLDER_EXPR)
3140     {
3141       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3142       tree elt;
3143
3144       for (elt = obj; elt != 0;
3145            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3146                    || TREE_CODE (elt) == COND_EXPR)
3147                   ? TREE_OPERAND (elt, 1)
3148                   : (REFERENCE_CLASS_P (elt)
3149                      || UNARY_CLASS_P (elt)
3150                      || BINARY_CLASS_P (elt)
3151                      || VL_EXP_CLASS_P (elt)
3152                      || EXPRESSION_CLASS_P (elt))
3153                   ? TREE_OPERAND (elt, 0) : 0))
3154         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3155           return elt;
3156
3157       for (elt = obj; elt != 0;
3158            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3159                    || TREE_CODE (elt) == COND_EXPR)
3160                   ? TREE_OPERAND (elt, 1)
3161                   : (REFERENCE_CLASS_P (elt)
3162                      || UNARY_CLASS_P (elt)
3163                      || BINARY_CLASS_P (elt)
3164                      || VL_EXP_CLASS_P (elt)
3165                      || EXPRESSION_CLASS_P (elt))
3166                   ? TREE_OPERAND (elt, 0) : 0))
3167         if (POINTER_TYPE_P (TREE_TYPE (elt))
3168             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3169                 == need_type))
3170           return fold_build1 (INDIRECT_REF, need_type, elt);
3171
3172       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3173          survives until RTL generation, there will be an error.  */
3174       return exp;
3175     }
3176
3177   /* TREE_LIST is special because we need to look at TREE_VALUE
3178      and TREE_CHAIN, not TREE_OPERANDS.  */
3179   else if (code == TREE_LIST)
3180     {
3181       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3182       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3183       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3184         return exp;
3185
3186       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3187     }
3188   else
3189     switch (TREE_CODE_CLASS (code))
3190       {
3191       case tcc_constant:
3192       case tcc_declaration:
3193         return exp;
3194
3195       case tcc_exceptional:
3196       case tcc_unary:
3197       case tcc_binary:
3198       case tcc_comparison:
3199       case tcc_expression:
3200       case tcc_reference:
3201       case tcc_statement:
3202         switch (TREE_CODE_LENGTH (code))
3203           {
3204           case 0:
3205             return exp;
3206
3207           case 1:
3208             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3209             if (op0 == TREE_OPERAND (exp, 0))
3210               return exp;
3211
3212             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3213             break;
3214
3215           case 2:
3216             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3217             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3218
3219             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3220               return exp;
3221
3222             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3223             break;
3224
3225           case 3:
3226             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3227             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3228             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3229
3230             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3231                 && op2 == TREE_OPERAND (exp, 2))
3232               return exp;
3233
3234             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3235             break;
3236
3237           case 4:
3238             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3239             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3240             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3241             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3242
3243             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3244                 && op2 == TREE_OPERAND (exp, 2)
3245                 && op3 == TREE_OPERAND (exp, 3))
3246               return exp;
3247
3248             new_tree
3249               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3250             break;
3251
3252           default:
3253             gcc_unreachable ();
3254           }
3255         break;
3256
3257       case tcc_vl_exp:
3258         {
3259           int i;
3260
3261           new_tree = NULL_TREE;
3262
3263           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3264             {
3265               tree op = TREE_OPERAND (exp, i);
3266               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3267               if (new_op != op)
3268                 {
3269                   if (!new_tree)
3270                     new_tree = copy_node (exp);
3271                   TREE_OPERAND (new_tree, i) = new_op;
3272                 }
3273             }
3274
3275           if (new_tree)
3276             {
3277               new_tree = fold (new_tree);
3278               if (TREE_CODE (new_tree) == CALL_EXPR)
3279                 process_call_operands (new_tree);
3280             }
3281           else
3282             return exp;
3283         }
3284         break;
3285
3286       default:
3287         gcc_unreachable ();
3288       }
3289
3290   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3291   return new_tree;
3292 }
3293 \f
3294 /* Stabilize a reference so that we can use it any number of times
3295    without causing its operands to be evaluated more than once.
3296    Returns the stabilized reference.  This works by means of save_expr,
3297    so see the caveats in the comments about save_expr.
3298
3299    Also allows conversion expressions whose operands are references.
3300    Any other kind of expression is returned unchanged.  */
3301
3302 tree
3303 stabilize_reference (tree ref)
3304 {
3305   tree result;
3306   enum tree_code code = TREE_CODE (ref);
3307
3308   switch (code)
3309     {
3310     case VAR_DECL:
3311     case PARM_DECL:
3312     case RESULT_DECL:
3313       /* No action is needed in this case.  */
3314       return ref;
3315
3316     CASE_CONVERT:
3317     case FLOAT_EXPR:
3318     case FIX_TRUNC_EXPR:
3319       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3320       break;
3321
3322     case INDIRECT_REF:
3323       result = build_nt (INDIRECT_REF,
3324                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3325       break;
3326
3327     case COMPONENT_REF:
3328       result = build_nt (COMPONENT_REF,
3329                          stabilize_reference (TREE_OPERAND (ref, 0)),
3330                          TREE_OPERAND (ref, 1), NULL_TREE);
3331       break;
3332
3333     case BIT_FIELD_REF:
3334       result = build_nt (BIT_FIELD_REF,
3335                          stabilize_reference (TREE_OPERAND (ref, 0)),
3336                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3337                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3338       break;
3339
3340     case ARRAY_REF:
3341       result = build_nt (ARRAY_REF,
3342                          stabilize_reference (TREE_OPERAND (ref, 0)),
3343                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3344                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3345       break;
3346
3347     case ARRAY_RANGE_REF:
3348       result = build_nt (ARRAY_RANGE_REF,
3349                          stabilize_reference (TREE_OPERAND (ref, 0)),
3350                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3351                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3352       break;
3353
3354     case COMPOUND_EXPR:
3355       /* We cannot wrap the first expression in a SAVE_EXPR, as then
3356          it wouldn't be ignored.  This matters when dealing with
3357          volatiles.  */
3358       return stabilize_reference_1 (ref);
3359
3360       /* If arg isn't a kind of lvalue we recognize, make no change.
3361          Caller should recognize the error for an invalid lvalue.  */
3362     default:
3363       return ref;
3364
3365     case ERROR_MARK:
3366       return error_mark_node;
3367     }
3368
3369   TREE_TYPE (result) = TREE_TYPE (ref);
3370   TREE_READONLY (result) = TREE_READONLY (ref);
3371   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3372   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3373
3374   return result;
3375 }
3376
3377 /* Subroutine of stabilize_reference; this is called for subtrees of
3378    references.  Any expression with side-effects must be put in a SAVE_EXPR
3379    to ensure that it is only evaluated once.
3380
3381    We don't put SAVE_EXPR nodes around everything, because assigning very
3382    simple expressions to temporaries causes us to miss good opportunities
3383    for optimizations.  Among other things, the opportunity to fold in the
3384    addition of a constant into an addressing mode often gets lost, e.g.
3385    "y[i+1] += x;".  In general, we take the approach that we should not make
3386    an assignment unless we are forced into it - i.e., that any non-side effect
3387    operator should be allowed, and that cse should take care of coalescing
3388    multiple utterances of the same expression should that prove fruitful.  */
3389
3390 tree
3391 stabilize_reference_1 (tree e)
3392 {
3393   tree result;
3394   enum tree_code code = TREE_CODE (e);
3395
3396   /* We cannot ignore const expressions because it might be a reference
3397      to a const array but whose index contains side-effects.  But we can
3398      ignore things that are actual constant or that already have been
3399      handled by this function.  */
3400
3401   if (tree_invariant_p (e))
3402     return e;
3403
3404   switch (TREE_CODE_CLASS (code))
3405     {
3406     case tcc_exceptional:
3407     case tcc_type:
3408     case tcc_declaration:
3409     case tcc_comparison:
3410     case tcc_statement:
3411     case tcc_expression:
3412     case tcc_reference:
3413     case tcc_vl_exp:
3414       /* If the expression has side-effects, then encase it in a SAVE_EXPR
3415          so that it will only be evaluated once.  */
3416       /* The reference (r) and comparison (<) classes could be handled as
3417          below, but it is generally faster to only evaluate them once.  */
3418       if (TREE_SIDE_EFFECTS (e))
3419         return save_expr (e);
3420       return e;
3421
3422     case tcc_constant:
3423       /* Constants need no processing.  In fact, we should never reach
3424          here.  */
3425       return e;
3426
3427     case tcc_binary:
3428       /* Division is slow and tends to be compiled with jumps,
3429          especially the division by powers of 2 that is often
3430          found inside of an array reference.  So do it just once.  */
3431       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3432           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3433           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3434           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3435         return save_expr (e);
3436       /* Recursively stabilize each operand.  */
3437       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3438                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
3439       break;
3440
3441     case tcc_unary:
3442       /* Recursively stabilize each operand.  */
3443       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3444       break;
3445
3446     default:
3447       gcc_unreachable ();
3448     }
3449
3450   TREE_TYPE (result) = TREE_TYPE (e);
3451   TREE_READONLY (result) = TREE_READONLY (e);
3452   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3453   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3454
3455   return result;
3456 }
3457 \f
3458 /* Low-level constructors for expressions.  */
3459
3460 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3461    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3462
3463 void
3464 recompute_tree_invariant_for_addr_expr (tree t)
3465 {
3466   tree node;
3467   bool tc = true, se = false;
3468
3469   /* We started out assuming this address is both invariant and constant, but
3470      does not have side effects.  Now go down any handled components and see if
3471      any of them involve offsets that are either non-constant or non-invariant.
3472      Also check for side-effects.
3473
3474      ??? Note that this code makes no attempt to deal with the case where
3475      taking the address of something causes a copy due to misalignment.  */
3476
3477 #define UPDATE_FLAGS(NODE)  \
3478 do { tree _node = (NODE); \
3479      if (_node && !TREE_CONSTANT (_node)) tc = false; \
3480      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3481
3482   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3483        node = TREE_OPERAND (node, 0))
3484     {
3485       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3486          array reference (probably made temporarily by the G++ front end),
3487          so ignore all the operands.  */
3488       if ((TREE_CODE (node) == ARRAY_REF
3489            || TREE_CODE (node) == ARRAY_RANGE_REF)
3490           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3491         {
3492           UPDATE_FLAGS (TREE_OPERAND (node, 1));
3493           if (TREE_OPERAND (node, 2))
3494             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3495           if (TREE_OPERAND (node, 3))
3496             UPDATE_FLAGS (TREE_OPERAND (node, 3));
3497         }
3498       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3499          FIELD_DECL, apparently.  The G++ front end can put something else
3500          there, at least temporarily.  */
3501       else if (TREE_CODE (node) == COMPONENT_REF
3502                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3503         {
3504           if (TREE_OPERAND (node, 2))
3505             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3506         }
3507       else if (TREE_CODE (node) == BIT_FIELD_REF)
3508         UPDATE_FLAGS (TREE_OPERAND (node, 2));
3509     }
3510
3511   node = lang_hooks.expr_to_decl (node, &tc, &se);
3512
3513   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3514      the address, since &(*a)->b is a form of addition.  If it's a constant, the
3515      address is constant too.  If it's a decl, its address is constant if the
3516      decl is static.  Everything else is not constant and, furthermore,
3517      taking the address of a volatile variable is not volatile.  */
3518   if (TREE_CODE (node) == INDIRECT_REF)
3519     UPDATE_FLAGS (TREE_OPERAND (node, 0));
3520   else if (CONSTANT_CLASS_P (node))
3521     ;
3522   else if (DECL_P (node))
3523     tc &= (staticp (node) != NULL_TREE);
3524   else
3525     {
3526       tc = false;
3527       se |= TREE_SIDE_EFFECTS (node);
3528     }
3529
3530
3531   TREE_CONSTANT (t) = tc;
3532   TREE_SIDE_EFFECTS (t) = se;
3533 #undef UPDATE_FLAGS
3534 }
3535
3536 /* Build an expression of code CODE, data type TYPE, and operands as
3537    specified.  Expressions and reference nodes can be created this way.
3538    Constants, decls, types and misc nodes cannot be.
3539
3540    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3541    enough for all extant tree codes.  */
3542
3543 tree
3544 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3545 {
3546   tree t;
3547
3548   gcc_assert (TREE_CODE_LENGTH (code) == 0);
3549
3550   t = make_node_stat (code PASS_MEM_STAT);
3551   TREE_TYPE (t) = tt;
3552
3553   return t;
3554 }
3555
3556 tree
3557 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3558 {
3559   int length = sizeof (struct tree_exp);
3560 #ifdef GATHER_STATISTICS
3561   tree_node_kind kind;
3562 #endif
3563   tree t;
3564
3565 #ifdef GATHER_STATISTICS
3566   switch (TREE_CODE_CLASS (code))
3567     {
3568     case tcc_statement:  /* an expression with side effects */
3569       kind = s_kind;
3570       break;
3571     case tcc_reference:  /* a reference */
3572       kind = r_kind;
3573       break;
3574     default:
3575       kind = e_kind;
3576       break;
3577     }
3578
3579   tree_node_counts[(int) kind]++;
3580   tree_node_sizes[(int) kind] += length;
3581 #endif
3582
3583   gcc_assert (TREE_CODE_LENGTH (code) == 1);
3584
3585   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
3586
3587   memset (t, 0, sizeof (struct tree_common));
3588
3589   TREE_SET_CODE (t, code);
3590
3591   TREE_TYPE (t) = type;
3592   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3593   TREE_OPERAND (t, 0) = node;
3594   TREE_BLOCK (t) = NULL_TREE;
3595   if (node && !TYPE_P (node))
3596     {
3597       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3598       TREE_READONLY (t) = TREE_READONLY (node);
3599     }
3600
3601   if (TREE_CODE_CLASS (code) == tcc_statement)
3602     TREE_SIDE_EFFECTS (t) = 1;
3603   else switch (code)
3604     {
3605     case VA_ARG_EXPR:
3606       /* All of these have side-effects, no matter what their
3607          operands are.  */
3608       TREE_SIDE_EFFECTS (t) = 1;
3609       TREE_READONLY (t) = 0;
3610       break;
3611
3612     case MISALIGNED_INDIRECT_REF:
3613     case ALIGN_INDIRECT_REF:
3614     case INDIRECT_REF:
3615       /* Whether a dereference is readonly has nothing to do with whether
3616          its operand is readonly.  */
3617       TREE_READONLY (t) = 0;
3618       break;
3619
3620     case ADDR_EXPR:
3621       if (node)
3622         recompute_tree_invariant_for_addr_expr (t);
3623       break;
3624
3625     default:
3626       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3627           && node && !TYPE_P (node)
3628           && TREE_CONSTANT (node))
3629         TREE_CONSTANT (t) = 1;
3630       if (TREE_CODE_CLASS (code) == tcc_reference
3631           && node && TREE_THIS_VOLATILE (node))
3632         TREE_THIS_VOLATILE (t) = 1;
3633       break;
3634     }
3635
3636   return t;
3637 }
3638
3639 #define PROCESS_ARG(N)                          \
3640   do {                                          \
3641     TREE_OPERAND (t, N) = arg##N;               \
3642     if (arg##N &&!TYPE_P (arg##N))              \
3643       {                                         \
3644         if (TREE_SIDE_EFFECTS (arg##N))         \
3645           side_effects = 1;                     \
3646         if (!TREE_READONLY (arg##N)             \
3647             && !CONSTANT_CLASS_P (arg##N))      \
3648           (void) (read_only = 0);               \
3649         if (!TREE_CONSTANT (arg##N))            \
3650           (void) (constant = 0);                \
3651       }                                         \
3652   } while (0)
3653
3654 tree
3655 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3656 {
3657   bool constant, read_only, side_effects;
3658   tree t;
3659
3660   gcc_assert (TREE_CODE_LENGTH (code) == 2);
3661
3662   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3663       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3664       /* When sizetype precision doesn't match that of pointers
3665          we need to be able to build explicit extensions or truncations
3666          of the offset argument.  */
3667       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3668     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3669                 && TREE_CODE (arg1) == INTEGER_CST);
3670
3671   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3672     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3673                 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3674                 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3675
3676   t = make_node_stat (code PASS_MEM_STAT);
3677   TREE_TYPE (t) = tt;
3678
3679   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3680      result based on those same flags for the arguments.  But if the
3681      arguments aren't really even `tree' expressions, we shouldn't be trying
3682      to do this.  */
3683
3684   /* Expressions without side effects may be constant if their
3685      arguments are as well.  */
3686   constant = (TREE_CODE_CLASS (code) == tcc_comparison
3687               || TREE_CODE_CLASS (code) == tcc_binary);
3688   read_only = 1;
3689   side_effects = TREE_SIDE_EFFECTS (t);
3690
3691   PROCESS_ARG(0);
3692   PROCESS_ARG(1);
3693
3694   TREE_READONLY (t) = read_only;
3695   TREE_CONSTANT (t) = constant;
3696   TREE_SIDE_EFFECTS (t) = side_effects;
3697   TREE_THIS_VOLATILE (t)
3698     = (TREE_CODE_CLASS (code) == tcc_reference
3699        && arg0 && TREE_THIS_VOLATILE (arg0));
3700
3701   return t;
3702 }
3703
3704
3705 tree
3706 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3707              tree arg2 MEM_STAT_DECL)
3708 {
3709   bool constant, read_only, side_effects;
3710   tree t;
3711
3712   gcc_assert (TREE_CODE_LENGTH (code) == 3);
3713   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3714
3715   t = make_node_stat (code PASS_MEM_STAT);
3716   TREE_TYPE (t) = tt;
3717
3718   read_only = 1;
3719
3720   /* As a special exception, if COND_EXPR has NULL branches, we
3721      assume that it is a gimple statement and always consider
3722      it to have side effects.  */
3723   if (code == COND_EXPR
3724       && tt == void_type_node
3725       && arg1 == NULL_TREE
3726       && arg2 == NULL_TREE)
3727     side_effects = true;
3728   else
3729     side_effects = TREE_SIDE_EFFECTS (t);
3730
3731   PROCESS_ARG(0);
3732   PROCESS_ARG(1);
3733   PROCESS_ARG(2);
3734
3735   if (code == COND_EXPR)
3736     TREE_READONLY (t) = read_only;
3737
3738   TREE_SIDE_EFFECTS (t) = side_effects;
3739   TREE_THIS_VOLATILE (t)
3740     = (TREE_CODE_CLASS (code) == tcc_reference
3741        && arg0 && TREE_THIS_VOLATILE (arg0));
3742
3743   return t;
3744 }
3745
3746 tree
3747 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3748              tree arg2, tree arg3 MEM_STAT_DECL)
3749 {
3750   bool constant, read_only, side_effects;
3751   tree t;
3752
3753   gcc_assert (TREE_CODE_LENGTH (code) == 4);
3754
3755   t = make_node_stat (code PASS_MEM_STAT);
3756   TREE_TYPE