OSDN Git Service

* double-int.h (tree_to_double_int): Remove macro.
[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 /* Constructs tree in type TYPE from with value given by CST.  Signedness
1086    of CST is assumed to be the same as the signedness of TYPE.  */
1087
1088 tree
1089 double_int_to_tree (tree type, double_int cst)
1090 {
1091   cst = double_int_ext (cst, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
1092
1093   return build_int_cst_wide (type, cst.low, cst.high);
1094 }
1095
1096 /* Returns true if CST fits into range of TYPE.  Signedness of CST is assumed
1097    to be the same as the signedness of TYPE.  */
1098
1099 bool
1100 double_int_fits_to_tree_p (const_tree type, double_int cst)
1101 {
1102   double_int ext = double_int_ext (cst,
1103                                    TYPE_PRECISION (type),
1104                                    TYPE_UNSIGNED (type));
1105
1106   return double_int_equal_p (cst, ext);
1107 }
1108
1109 /* These are the hash table functions for the hash table of INTEGER_CST
1110    nodes of a sizetype.  */
1111
1112 /* Return the hash code code X, an INTEGER_CST.  */
1113
1114 static hashval_t
1115 int_cst_hash_hash (const void *x)
1116 {
1117   const_tree const t = (const_tree) x;
1118
1119   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1120           ^ htab_hash_pointer (TREE_TYPE (t)));
1121 }
1122
1123 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1124    is the same as that given by *Y, which is the same.  */
1125
1126 static int
1127 int_cst_hash_eq (const void *x, const void *y)
1128 {
1129   const_tree const xt = (const_tree) x;
1130   const_tree const yt = (const_tree) y;
1131
1132   return (TREE_TYPE (xt) == TREE_TYPE (yt)
1133           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1134           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1135 }
1136
1137 /* Create an INT_CST node of TYPE and value HI:LOW.
1138    The returned node is always shared.  For small integers we use a
1139    per-type vector cache, for larger ones we use a single hash table.  */
1140
1141 tree
1142 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1143 {
1144   tree t;
1145   int ix = -1;
1146   int limit = 0;
1147
1148   gcc_assert (type);
1149
1150   switch (TREE_CODE (type))
1151     {
1152     case POINTER_TYPE:
1153     case REFERENCE_TYPE:
1154       /* Cache NULL pointer.  */
1155       if (!hi && !low)
1156         {
1157           limit = 1;
1158           ix = 0;
1159         }
1160       break;
1161
1162     case BOOLEAN_TYPE:
1163       /* Cache false or true.  */
1164       limit = 2;
1165       if (!hi && low < 2)
1166         ix = low;
1167       break;
1168
1169     case INTEGER_TYPE:
1170     case OFFSET_TYPE:
1171       if (TYPE_UNSIGNED (type))
1172         {
1173           /* Cache 0..N */
1174           limit = INTEGER_SHARE_LIMIT;
1175           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1176             ix = low;
1177         }
1178       else
1179         {
1180           /* Cache -1..N */
1181           limit = INTEGER_SHARE_LIMIT + 1;
1182           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1183             ix = low + 1;
1184           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1185             ix = 0;
1186         }
1187       break;
1188
1189     case ENUMERAL_TYPE:
1190       break;
1191
1192     default:
1193       gcc_unreachable ();
1194     }
1195
1196   if (ix >= 0)
1197     {
1198       /* Look for it in the type's vector of small shared ints.  */
1199       if (!TYPE_CACHED_VALUES_P (type))
1200         {
1201           TYPE_CACHED_VALUES_P (type) = 1;
1202           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1203         }
1204
1205       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1206       if (t)
1207         {
1208           /* Make sure no one is clobbering the shared constant.  */
1209           gcc_assert (TREE_TYPE (t) == type);
1210           gcc_assert (TREE_INT_CST_LOW (t) == low);
1211           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1212         }
1213       else
1214         {
1215           /* Create a new shared int.  */
1216           t = make_node (INTEGER_CST);
1217
1218           TREE_INT_CST_LOW (t) = low;
1219           TREE_INT_CST_HIGH (t) = hi;
1220           TREE_TYPE (t) = type;
1221
1222           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1223         }
1224     }
1225   else
1226     {
1227       /* Use the cache of larger shared ints.  */
1228       void **slot;
1229
1230       TREE_INT_CST_LOW (int_cst_node) = low;
1231       TREE_INT_CST_HIGH (int_cst_node) = hi;
1232       TREE_TYPE (int_cst_node) = type;
1233
1234       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1235       t = (tree) *slot;
1236       if (!t)
1237         {
1238           /* Insert this one into the hash table.  */
1239           t = int_cst_node;
1240           *slot = t;
1241           /* Make a new node for next time round.  */
1242           int_cst_node = make_node (INTEGER_CST);
1243         }
1244     }
1245
1246   return t;
1247 }
1248
1249 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1250    and the rest are zeros.  */
1251
1252 tree
1253 build_low_bits_mask (tree type, unsigned bits)
1254 {
1255   double_int mask;
1256
1257   gcc_assert (bits <= TYPE_PRECISION (type));
1258
1259   if (bits == TYPE_PRECISION (type)
1260       && !TYPE_UNSIGNED (type))
1261     /* Sign extended all-ones mask.  */
1262     mask = double_int_minus_one;
1263   else
1264     mask = double_int_mask (bits);
1265
1266   return build_int_cst_wide (type, mask.low, mask.high);
1267 }
1268
1269 /* Checks that X is integer constant that can be expressed in (unsigned)
1270    HOST_WIDE_INT without loss of precision.  */
1271
1272 bool
1273 cst_and_fits_in_hwi (const_tree x)
1274 {
1275   if (TREE_CODE (x) != INTEGER_CST)
1276     return false;
1277
1278   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1279     return false;
1280
1281   return (TREE_INT_CST_HIGH (x) == 0
1282           || TREE_INT_CST_HIGH (x) == -1);
1283 }
1284
1285 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1286    are in a list pointed to by VALS.  */
1287
1288 tree
1289 build_vector (tree type, tree vals)
1290 {
1291   tree v = make_node (VECTOR_CST);
1292   int over = 0;
1293   tree link;
1294
1295   TREE_VECTOR_CST_ELTS (v) = vals;
1296   TREE_TYPE (v) = type;
1297
1298   /* Iterate through elements and check for overflow.  */
1299   for (link = vals; link; link = TREE_CHAIN (link))
1300     {
1301       tree value = TREE_VALUE (link);
1302
1303       /* Don't crash if we get an address constant.  */
1304       if (!CONSTANT_CLASS_P (value))
1305         continue;
1306
1307       over |= TREE_OVERFLOW (value);
1308     }
1309
1310   TREE_OVERFLOW (v) = over;
1311   return v;
1312 }
1313
1314 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1315    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1316
1317 tree
1318 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1319 {
1320   tree list = NULL_TREE;
1321   unsigned HOST_WIDE_INT idx;
1322   tree value;
1323
1324   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1325     list = tree_cons (NULL_TREE, value, list);
1326   return build_vector (type, nreverse (list));
1327 }
1328
1329 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1330    are in the VEC pointed to by VALS.  */
1331 tree
1332 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1333 {
1334   tree c = make_node (CONSTRUCTOR);
1335   TREE_TYPE (c) = type;
1336   CONSTRUCTOR_ELTS (c) = vals;
1337   return c;
1338 }
1339
1340 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1341    INDEX and VALUE.  */
1342 tree
1343 build_constructor_single (tree type, tree index, tree value)
1344 {
1345   VEC(constructor_elt,gc) *v;
1346   constructor_elt *elt;
1347   tree t;
1348
1349   v = VEC_alloc (constructor_elt, gc, 1);
1350   elt = VEC_quick_push (constructor_elt, v, NULL);
1351   elt->index = index;
1352   elt->value = value;
1353
1354   t = build_constructor (type, v);
1355   TREE_CONSTANT (t) = TREE_CONSTANT (value);
1356   return t;
1357 }
1358
1359
1360 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1361    are in a list pointed to by VALS.  */
1362 tree
1363 build_constructor_from_list (tree type, tree vals)
1364 {
1365   tree t, val;
1366   VEC(constructor_elt,gc) *v = NULL;
1367   bool constant_p = true;
1368
1369   if (vals)
1370     {
1371       v = VEC_alloc (constructor_elt, gc, list_length (vals));
1372       for (t = vals; t; t = TREE_CHAIN (t))
1373         {
1374           constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
1375           val = TREE_VALUE (t);
1376           elt->index = TREE_PURPOSE (t);
1377           elt->value = val;
1378           if (!TREE_CONSTANT (val))
1379             constant_p = false;
1380         }
1381     }
1382
1383   t = build_constructor (type, v);
1384   TREE_CONSTANT (t) = constant_p;
1385   return t;
1386 }
1387
1388 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1389
1390 tree
1391 build_fixed (tree type, FIXED_VALUE_TYPE f)
1392 {
1393   tree v;
1394   FIXED_VALUE_TYPE *fp;
1395
1396   v = make_node (FIXED_CST);
1397   fp = GGC_NEW (FIXED_VALUE_TYPE);
1398   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1399
1400   TREE_TYPE (v) = type;
1401   TREE_FIXED_CST_PTR (v) = fp;
1402   return v;
1403 }
1404
1405 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1406
1407 tree
1408 build_real (tree type, REAL_VALUE_TYPE d)
1409 {
1410   tree v;
1411   REAL_VALUE_TYPE *dp;
1412   int overflow = 0;
1413
1414   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1415      Consider doing it via real_convert now.  */
1416
1417   v = make_node (REAL_CST);
1418   dp = GGC_NEW (REAL_VALUE_TYPE);
1419   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1420
1421   TREE_TYPE (v) = type;
1422   TREE_REAL_CST_PTR (v) = dp;
1423   TREE_OVERFLOW (v) = overflow;
1424   return v;
1425 }
1426
1427 /* Return a new REAL_CST node whose type is TYPE
1428    and whose value is the integer value of the INTEGER_CST node I.  */
1429
1430 REAL_VALUE_TYPE
1431 real_value_from_int_cst (const_tree type, const_tree i)
1432 {
1433   REAL_VALUE_TYPE d;
1434
1435   /* Clear all bits of the real value type so that we can later do
1436      bitwise comparisons to see if two values are the same.  */
1437   memset (&d, 0, sizeof d);
1438
1439   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1440                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1441                      TYPE_UNSIGNED (TREE_TYPE (i)));
1442   return d;
1443 }
1444
1445 /* Given a tree representing an integer constant I, return a tree
1446    representing the same value as a floating-point constant of type TYPE.  */
1447
1448 tree
1449 build_real_from_int_cst (tree type, const_tree i)
1450 {
1451   tree v;
1452   int overflow = TREE_OVERFLOW (i);
1453
1454   v = build_real (type, real_value_from_int_cst (type, i));
1455
1456   TREE_OVERFLOW (v) |= overflow;
1457   return v;
1458 }
1459
1460 /* Return a newly constructed STRING_CST node whose value is
1461    the LEN characters at STR.
1462    The TREE_TYPE is not initialized.  */
1463
1464 tree
1465 build_string (int len, const char *str)
1466 {
1467   tree s;
1468   size_t length;
1469
1470   /* Do not waste bytes provided by padding of struct tree_string.  */
1471   length = len + offsetof (struct tree_string, str) + 1;
1472
1473 #ifdef GATHER_STATISTICS
1474   tree_node_counts[(int) c_kind]++;
1475   tree_node_sizes[(int) c_kind] += length;
1476 #endif
1477
1478   s = ggc_alloc_tree (length);
1479
1480   memset (s, 0, sizeof (struct tree_common));
1481   TREE_SET_CODE (s, STRING_CST);
1482   TREE_CONSTANT (s) = 1;
1483   TREE_STRING_LENGTH (s) = len;
1484   memcpy (s->string.str, str, len);
1485   s->string.str[len] = '\0';
1486
1487   return s;
1488 }
1489
1490 /* Return a newly constructed COMPLEX_CST node whose value is
1491    specified by the real and imaginary parts REAL and IMAG.
1492    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1493    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1494
1495 tree
1496 build_complex (tree type, tree real, tree imag)
1497 {
1498   tree t = make_node (COMPLEX_CST);
1499
1500   TREE_REALPART (t) = real;
1501   TREE_IMAGPART (t) = imag;
1502   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1503   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1504   return t;
1505 }
1506
1507 /* Return a constant of arithmetic type TYPE which is the
1508    multiplicative identity of the set TYPE.  */
1509
1510 tree
1511 build_one_cst (tree type)
1512 {
1513   switch (TREE_CODE (type))
1514     {
1515     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1516     case POINTER_TYPE: case REFERENCE_TYPE:
1517     case OFFSET_TYPE:
1518       return build_int_cst (type, 1);
1519
1520     case REAL_TYPE:
1521       return build_real (type, dconst1);
1522
1523     case FIXED_POINT_TYPE:
1524       /* We can only generate 1 for accum types.  */
1525       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1526       return build_fixed (type, FCONST1(TYPE_MODE (type)));
1527
1528     case VECTOR_TYPE:
1529       {
1530         tree scalar, cst;
1531         int i;
1532
1533         scalar = build_one_cst (TREE_TYPE (type));
1534
1535         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1536         cst = NULL_TREE;
1537         for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1538           cst = tree_cons (NULL_TREE, scalar, cst);
1539
1540         return build_vector (type, cst);
1541       }
1542
1543     case COMPLEX_TYPE:
1544       return build_complex (type,
1545                             build_one_cst (TREE_TYPE (type)),
1546                             fold_convert (TREE_TYPE (type), integer_zero_node));
1547
1548     default:
1549       gcc_unreachable ();
1550     }
1551 }
1552
1553 /* Build a BINFO with LEN language slots.  */
1554
1555 tree
1556 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1557 {
1558   tree t;
1559   size_t length = (offsetof (struct tree_binfo, base_binfos)
1560                    + VEC_embedded_size (tree, base_binfos));
1561
1562 #ifdef GATHER_STATISTICS
1563   tree_node_counts[(int) binfo_kind]++;
1564   tree_node_sizes[(int) binfo_kind] += length;
1565 #endif
1566
1567   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1568
1569   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1570
1571   TREE_SET_CODE (t, TREE_BINFO);
1572
1573   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1574
1575   return t;
1576 }
1577
1578
1579 /* Build a newly constructed TREE_VEC node of length LEN.  */
1580
1581 tree
1582 make_tree_vec_stat (int len MEM_STAT_DECL)
1583 {
1584   tree t;
1585   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1586
1587 #ifdef GATHER_STATISTICS
1588   tree_node_counts[(int) vec_kind]++;
1589   tree_node_sizes[(int) vec_kind] += length;
1590 #endif
1591
1592   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1593
1594   memset (t, 0, length);
1595
1596   TREE_SET_CODE (t, TREE_VEC);
1597   TREE_VEC_LENGTH (t) = len;
1598
1599   return t;
1600 }
1601 \f
1602 /* Return 1 if EXPR is the integer constant zero or a complex constant
1603    of zero.  */
1604
1605 int
1606 integer_zerop (const_tree expr)
1607 {
1608   STRIP_NOPS (expr);
1609
1610   return ((TREE_CODE (expr) == INTEGER_CST
1611            && TREE_INT_CST_LOW (expr) == 0
1612            && TREE_INT_CST_HIGH (expr) == 0)
1613           || (TREE_CODE (expr) == COMPLEX_CST
1614               && integer_zerop (TREE_REALPART (expr))
1615               && integer_zerop (TREE_IMAGPART (expr))));
1616 }
1617
1618 /* Return 1 if EXPR is the integer constant one or the corresponding
1619    complex constant.  */
1620
1621 int
1622 integer_onep (const_tree expr)
1623 {
1624   STRIP_NOPS (expr);
1625
1626   return ((TREE_CODE (expr) == INTEGER_CST
1627            && TREE_INT_CST_LOW (expr) == 1
1628            && TREE_INT_CST_HIGH (expr) == 0)
1629           || (TREE_CODE (expr) == COMPLEX_CST
1630               && integer_onep (TREE_REALPART (expr))
1631               && integer_zerop (TREE_IMAGPART (expr))));
1632 }
1633
1634 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1635    it contains.  Likewise for the corresponding complex constant.  */
1636
1637 int
1638 integer_all_onesp (const_tree expr)
1639 {
1640   int prec;
1641   int uns;
1642
1643   STRIP_NOPS (expr);
1644
1645   if (TREE_CODE (expr) == COMPLEX_CST
1646       && integer_all_onesp (TREE_REALPART (expr))
1647       && integer_zerop (TREE_IMAGPART (expr)))
1648     return 1;
1649
1650   else if (TREE_CODE (expr) != INTEGER_CST)
1651     return 0;
1652
1653   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1654   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1655       && TREE_INT_CST_HIGH (expr) == -1)
1656     return 1;
1657   if (!uns)
1658     return 0;
1659
1660   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1661      actual bits, not the (arbitrary) range of the type.  */
1662   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1663   if (prec >= HOST_BITS_PER_WIDE_INT)
1664     {
1665       HOST_WIDE_INT high_value;
1666       int shift_amount;
1667
1668       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1669
1670       /* Can not handle precisions greater than twice the host int size.  */
1671       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1672       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1673         /* Shifting by the host word size is undefined according to the ANSI
1674            standard, so we must handle this as a special case.  */
1675         high_value = -1;
1676       else
1677         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1678
1679       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1680               && TREE_INT_CST_HIGH (expr) == high_value);
1681     }
1682   else
1683     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1684 }
1685
1686 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1687    one bit on).  */
1688
1689 int
1690 integer_pow2p (const_tree expr)
1691 {
1692   int prec;
1693   HOST_WIDE_INT high, low;
1694
1695   STRIP_NOPS (expr);
1696
1697   if (TREE_CODE (expr) == COMPLEX_CST
1698       && integer_pow2p (TREE_REALPART (expr))
1699       && integer_zerop (TREE_IMAGPART (expr)))
1700     return 1;
1701
1702   if (TREE_CODE (expr) != INTEGER_CST)
1703     return 0;
1704
1705   prec = TYPE_PRECISION (TREE_TYPE (expr));
1706   high = TREE_INT_CST_HIGH (expr);
1707   low = TREE_INT_CST_LOW (expr);
1708
1709   /* First clear all bits that are beyond the type's precision in case
1710      we've been sign extended.  */
1711
1712   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1713     ;
1714   else if (prec > HOST_BITS_PER_WIDE_INT)
1715     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1716   else
1717     {
1718       high = 0;
1719       if (prec < HOST_BITS_PER_WIDE_INT)
1720         low &= ~((HOST_WIDE_INT) (-1) << prec);
1721     }
1722
1723   if (high == 0 && low == 0)
1724     return 0;
1725
1726   return ((high == 0 && (low & (low - 1)) == 0)
1727           || (low == 0 && (high & (high - 1)) == 0));
1728 }
1729
1730 /* Return 1 if EXPR is an integer constant other than zero or a
1731    complex constant other than zero.  */
1732
1733 int
1734 integer_nonzerop (const_tree expr)
1735 {
1736   STRIP_NOPS (expr);
1737
1738   return ((TREE_CODE (expr) == INTEGER_CST
1739            && (TREE_INT_CST_LOW (expr) != 0
1740                || TREE_INT_CST_HIGH (expr) != 0))
1741           || (TREE_CODE (expr) == COMPLEX_CST
1742               && (integer_nonzerop (TREE_REALPART (expr))
1743                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1744 }
1745
1746 /* Return 1 if EXPR is the fixed-point constant zero.  */
1747
1748 int
1749 fixed_zerop (const_tree expr)
1750 {
1751   return (TREE_CODE (expr) == FIXED_CST
1752           && double_int_zero_p (TREE_FIXED_CST (expr).data));
1753 }
1754
1755 /* Return the power of two represented by a tree node known to be a
1756    power of two.  */
1757
1758 int
1759 tree_log2 (const_tree expr)
1760 {
1761   int prec;
1762   HOST_WIDE_INT high, low;
1763
1764   STRIP_NOPS (expr);
1765
1766   if (TREE_CODE (expr) == COMPLEX_CST)
1767     return tree_log2 (TREE_REALPART (expr));
1768
1769   prec = TYPE_PRECISION (TREE_TYPE (expr));
1770   high = TREE_INT_CST_HIGH (expr);
1771   low = TREE_INT_CST_LOW (expr);
1772
1773   /* First clear all bits that are beyond the type's precision in case
1774      we've been sign extended.  */
1775
1776   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1777     ;
1778   else if (prec > HOST_BITS_PER_WIDE_INT)
1779     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1780   else
1781     {
1782       high = 0;
1783       if (prec < HOST_BITS_PER_WIDE_INT)
1784         low &= ~((HOST_WIDE_INT) (-1) << prec);
1785     }
1786
1787   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1788           : exact_log2 (low));
1789 }
1790
1791 /* Similar, but return the largest integer Y such that 2 ** Y is less
1792    than or equal to EXPR.  */
1793
1794 int
1795 tree_floor_log2 (const_tree expr)
1796 {
1797   int prec;
1798   HOST_WIDE_INT high, low;
1799
1800   STRIP_NOPS (expr);
1801
1802   if (TREE_CODE (expr) == COMPLEX_CST)
1803     return tree_log2 (TREE_REALPART (expr));
1804
1805   prec = TYPE_PRECISION (TREE_TYPE (expr));
1806   high = TREE_INT_CST_HIGH (expr);
1807   low = TREE_INT_CST_LOW (expr);
1808
1809   /* First clear all bits that are beyond the type's precision in case
1810      we've been sign extended.  Ignore if type's precision hasn't been set
1811      since what we are doing is setting it.  */
1812
1813   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1814     ;
1815   else if (prec > HOST_BITS_PER_WIDE_INT)
1816     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1817   else
1818     {
1819       high = 0;
1820       if (prec < HOST_BITS_PER_WIDE_INT)
1821         low &= ~((HOST_WIDE_INT) (-1) << prec);
1822     }
1823
1824   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1825           : floor_log2 (low));
1826 }
1827
1828 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1829    decimal float constants, so don't return 1 for them.  */
1830
1831 int
1832 real_zerop (const_tree expr)
1833 {
1834   STRIP_NOPS (expr);
1835
1836   return ((TREE_CODE (expr) == REAL_CST
1837            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1838            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1839           || (TREE_CODE (expr) == COMPLEX_CST
1840               && real_zerop (TREE_REALPART (expr))
1841               && real_zerop (TREE_IMAGPART (expr))));
1842 }
1843
1844 /* Return 1 if EXPR is the real constant one in real or complex form.
1845    Trailing zeroes matter for decimal float constants, so don't return
1846    1 for them.  */
1847
1848 int
1849 real_onep (const_tree expr)
1850 {
1851   STRIP_NOPS (expr);
1852
1853   return ((TREE_CODE (expr) == REAL_CST
1854            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1855            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1856           || (TREE_CODE (expr) == COMPLEX_CST
1857               && real_onep (TREE_REALPART (expr))
1858               && real_zerop (TREE_IMAGPART (expr))));
1859 }
1860
1861 /* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1862    for decimal float constants, so don't return 1 for them.  */
1863
1864 int
1865 real_twop (const_tree expr)
1866 {
1867   STRIP_NOPS (expr);
1868
1869   return ((TREE_CODE (expr) == REAL_CST
1870            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1871            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1872           || (TREE_CODE (expr) == COMPLEX_CST
1873               && real_twop (TREE_REALPART (expr))
1874               && real_zerop (TREE_IMAGPART (expr))));
1875 }
1876
1877 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1878    matter for decimal float constants, so don't return 1 for them.  */
1879
1880 int
1881 real_minus_onep (const_tree expr)
1882 {
1883   STRIP_NOPS (expr);
1884
1885   return ((TREE_CODE (expr) == REAL_CST
1886            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1887            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1888           || (TREE_CODE (expr) == COMPLEX_CST
1889               && real_minus_onep (TREE_REALPART (expr))
1890               && real_zerop (TREE_IMAGPART (expr))));
1891 }
1892
1893 /* Nonzero if EXP is a constant or a cast of a constant.  */
1894
1895 int
1896 really_constant_p (const_tree exp)
1897 {
1898   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1899   while (CONVERT_EXPR_P (exp)
1900          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1901     exp = TREE_OPERAND (exp, 0);
1902   return TREE_CONSTANT (exp);
1903 }
1904 \f
1905 /* Return first list element whose TREE_VALUE is ELEM.
1906    Return 0 if ELEM is not in LIST.  */
1907
1908 tree
1909 value_member (tree elem, tree list)
1910 {
1911   while (list)
1912     {
1913       if (elem == TREE_VALUE (list))
1914         return list;
1915       list = TREE_CHAIN (list);
1916     }
1917   return NULL_TREE;
1918 }
1919
1920 /* Return first list element whose TREE_PURPOSE is ELEM.
1921    Return 0 if ELEM is not in LIST.  */
1922
1923 tree
1924 purpose_member (const_tree elem, tree list)
1925 {
1926   while (list)
1927     {
1928       if (elem == TREE_PURPOSE (list))
1929         return list;
1930       list = TREE_CHAIN (list);
1931     }
1932   return NULL_TREE;
1933 }
1934
1935 /* Returns element number IDX (zero-origin) of chain CHAIN, or
1936    NULL_TREE.  */
1937
1938 tree
1939 chain_index (int idx, tree chain)
1940 {
1941   for (; chain && idx > 0; --idx)
1942     chain = TREE_CHAIN (chain);
1943   return chain;
1944 }
1945
1946 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1947
1948 int
1949 chain_member (const_tree elem, const_tree chain)
1950 {
1951   while (chain)
1952     {
1953       if (elem == chain)
1954         return 1;
1955       chain = TREE_CHAIN (chain);
1956     }
1957
1958   return 0;
1959 }
1960
1961 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1962    We expect a null pointer to mark the end of the chain.
1963    This is the Lisp primitive `length'.  */
1964
1965 int
1966 list_length (const_tree t)
1967 {
1968   const_tree p = t;
1969 #ifdef ENABLE_TREE_CHECKING
1970   const_tree q = t;
1971 #endif
1972   int len = 0;
1973
1974   while (p)
1975     {
1976       p = TREE_CHAIN (p);
1977 #ifdef ENABLE_TREE_CHECKING
1978       if (len % 2)
1979         q = TREE_CHAIN (q);
1980       gcc_assert (p != q);
1981 #endif
1982       len++;
1983     }
1984
1985   return len;
1986 }
1987
1988 /* Returns the number of FIELD_DECLs in TYPE.  */
1989
1990 int
1991 fields_length (const_tree type)
1992 {
1993   tree t = TYPE_FIELDS (type);
1994   int count = 0;
1995
1996   for (; t; t = TREE_CHAIN (t))
1997     if (TREE_CODE (t) == FIELD_DECL)
1998       ++count;
1999
2000   return count;
2001 }
2002
2003 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2004    UNION_TYPE TYPE, or NULL_TREE if none.  */
2005
2006 tree
2007 first_field (const_tree type)
2008 {
2009   tree t = TYPE_FIELDS (type);
2010   while (t && TREE_CODE (t) != FIELD_DECL)
2011     t = TREE_CHAIN (t);
2012   return t;
2013 }
2014
2015 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2016    by modifying the last node in chain 1 to point to chain 2.
2017    This is the Lisp primitive `nconc'.  */
2018
2019 tree
2020 chainon (tree op1, tree op2)
2021 {
2022   tree t1;
2023
2024   if (!op1)
2025     return op2;
2026   if (!op2)
2027     return op1;
2028
2029   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2030     continue;
2031   TREE_CHAIN (t1) = op2;
2032
2033 #ifdef ENABLE_TREE_CHECKING
2034   {
2035     tree t2;
2036     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2037       gcc_assert (t2 != t1);
2038   }
2039 #endif
2040
2041   return op1;
2042 }
2043
2044 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2045
2046 tree
2047 tree_last (tree chain)
2048 {
2049   tree next;
2050   if (chain)
2051     while ((next = TREE_CHAIN (chain)))
2052       chain = next;
2053   return chain;
2054 }
2055
2056 /* Reverse the order of elements in the chain T,
2057    and return the new head of the chain (old last element).  */
2058
2059 tree
2060 nreverse (tree t)
2061 {
2062   tree prev = 0, decl, next;
2063   for (decl = t; decl; decl = next)
2064     {
2065       next = TREE_CHAIN (decl);
2066       TREE_CHAIN (decl) = prev;
2067       prev = decl;
2068     }
2069   return prev;
2070 }
2071 \f
2072 /* Return a newly created TREE_LIST node whose
2073    purpose and value fields are PARM and VALUE.  */
2074
2075 tree
2076 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2077 {
2078   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2079   TREE_PURPOSE (t) = parm;
2080   TREE_VALUE (t) = value;
2081   return t;
2082 }
2083
2084 /* Build a chain of TREE_LIST nodes from a vector.  */
2085
2086 tree
2087 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2088 {
2089   tree ret = NULL_TREE;
2090   tree *pp = &ret;
2091   unsigned int i;
2092   tree t;
2093   for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
2094     {
2095       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2096       pp = &TREE_CHAIN (*pp);
2097     }
2098   return ret;
2099 }
2100
2101 /* Return a newly created TREE_LIST node whose
2102    purpose and value fields are PURPOSE and VALUE
2103    and whose TREE_CHAIN is CHAIN.  */
2104
2105 tree
2106 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2107 {
2108   tree node;
2109
2110   node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
2111
2112   memset (node, 0, sizeof (struct tree_common));
2113
2114 #ifdef GATHER_STATISTICS
2115   tree_node_counts[(int) x_kind]++;
2116   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2117 #endif
2118
2119   TREE_SET_CODE (node, TREE_LIST);
2120   TREE_CHAIN (node) = chain;
2121   TREE_PURPOSE (node) = purpose;
2122   TREE_VALUE (node) = value;
2123   return node;
2124 }
2125
2126 /* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
2127
2128 tree
2129 ctor_to_list (tree ctor)
2130 {
2131   tree list = NULL_TREE;
2132   tree *p = &list;
2133   unsigned ix;
2134   tree purpose, val;
2135
2136   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
2137     {
2138       *p = build_tree_list (purpose, val);
2139       p = &TREE_CHAIN (*p);
2140     }
2141
2142   return list;
2143 }
2144
2145 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2146    trees.  */
2147
2148 VEC(tree,gc) *
2149 ctor_to_vec (tree ctor)
2150 {
2151   VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2152   unsigned int ix;
2153   tree val;
2154
2155   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2156     VEC_quick_push (tree, vec, val);
2157
2158   return vec;
2159 }
2160 \f
2161 /* Return the size nominally occupied by an object of type TYPE
2162    when it resides in memory.  The value is measured in units of bytes,
2163    and its data type is that normally used for type sizes
2164    (which is the first type created by make_signed_type or
2165    make_unsigned_type).  */
2166
2167 tree
2168 size_in_bytes (const_tree type)
2169 {
2170   tree t;
2171
2172   if (type == error_mark_node)
2173     return integer_zero_node;
2174
2175   type = TYPE_MAIN_VARIANT (type);
2176   t = TYPE_SIZE_UNIT (type);
2177
2178   if (t == 0)
2179     {
2180       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2181       return size_zero_node;
2182     }
2183
2184   return t;
2185 }
2186
2187 /* Return the size of TYPE (in bytes) as a wide integer
2188    or return -1 if the size can vary or is larger than an integer.  */
2189
2190 HOST_WIDE_INT
2191 int_size_in_bytes (const_tree type)
2192 {
2193   tree t;
2194
2195   if (type == error_mark_node)
2196     return 0;
2197
2198   type = TYPE_MAIN_VARIANT (type);
2199   t = TYPE_SIZE_UNIT (type);
2200   if (t == 0
2201       || TREE_CODE (t) != INTEGER_CST
2202       || TREE_INT_CST_HIGH (t) != 0
2203       /* If the result would appear negative, it's too big to represent.  */
2204       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2205     return -1;
2206
2207   return TREE_INT_CST_LOW (t);
2208 }
2209
2210 /* Return the maximum size of TYPE (in bytes) as a wide integer
2211    or return -1 if the size can vary or is larger than an integer.  */
2212
2213 HOST_WIDE_INT
2214 max_int_size_in_bytes (const_tree type)
2215 {
2216   HOST_WIDE_INT size = -1;
2217   tree size_tree;
2218
2219   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2220
2221   if (TREE_CODE (type) == ARRAY_TYPE)
2222     {
2223       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2224
2225       if (size_tree && host_integerp (size_tree, 1))
2226         size = tree_low_cst (size_tree, 1);
2227     }
2228
2229   /* If we still haven't been able to get a size, see if the language
2230      can compute a maximum size.  */
2231
2232   if (size == -1)
2233     {
2234       size_tree = lang_hooks.types.max_size (type);
2235
2236       if (size_tree && host_integerp (size_tree, 1))
2237         size = tree_low_cst (size_tree, 1);
2238     }
2239
2240   return size;
2241 }
2242
2243 /* Returns a tree for the size of EXP in bytes.  */
2244
2245 tree
2246 tree_expr_size (const_tree exp)
2247 {
2248   if (DECL_P (exp)
2249       && DECL_SIZE_UNIT (exp) != 0)
2250     return DECL_SIZE_UNIT (exp);
2251   else
2252     return size_in_bytes (TREE_TYPE (exp));
2253 }
2254 \f
2255 /* Return the bit position of FIELD, in bits from the start of the record.
2256    This is a tree of type bitsizetype.  */
2257
2258 tree
2259 bit_position (const_tree field)
2260 {
2261   return bit_from_pos (DECL_FIELD_OFFSET (field),
2262                        DECL_FIELD_BIT_OFFSET (field));
2263 }
2264
2265 /* Likewise, but return as an integer.  It must be representable in
2266    that way (since it could be a signed value, we don't have the
2267    option of returning -1 like int_size_in_byte can.  */
2268
2269 HOST_WIDE_INT
2270 int_bit_position (const_tree field)
2271 {
2272   return tree_low_cst (bit_position (field), 0);
2273 }
2274 \f
2275 /* Return the byte position of FIELD, in bytes from the start of the record.
2276    This is a tree of type sizetype.  */
2277
2278 tree
2279 byte_position (const_tree field)
2280 {
2281   return byte_from_pos (DECL_FIELD_OFFSET (field),
2282                         DECL_FIELD_BIT_OFFSET (field));
2283 }
2284
2285 /* Likewise, but return as an integer.  It must be representable in
2286    that way (since it could be a signed value, we don't have the
2287    option of returning -1 like int_size_in_byte can.  */
2288
2289 HOST_WIDE_INT
2290 int_byte_position (const_tree field)
2291 {
2292   return tree_low_cst (byte_position (field), 0);
2293 }
2294 \f
2295 /* Return the strictest alignment, in bits, that T is known to have.  */
2296
2297 unsigned int
2298 expr_align (const_tree t)
2299 {
2300   unsigned int align0, align1;
2301
2302   switch (TREE_CODE (t))
2303     {
2304     CASE_CONVERT:  case NON_LVALUE_EXPR:
2305       /* If we have conversions, we know that the alignment of the
2306          object must meet each of the alignments of the types.  */
2307       align0 = expr_align (TREE_OPERAND (t, 0));
2308       align1 = TYPE_ALIGN (TREE_TYPE (t));
2309       return MAX (align0, align1);
2310
2311     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2312     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2313     case CLEANUP_POINT_EXPR:
2314       /* These don't change the alignment of an object.  */
2315       return expr_align (TREE_OPERAND (t, 0));
2316
2317     case COND_EXPR:
2318       /* The best we can do is say that the alignment is the least aligned
2319          of the two arms.  */
2320       align0 = expr_align (TREE_OPERAND (t, 1));
2321       align1 = expr_align (TREE_OPERAND (t, 2));
2322       return MIN (align0, align1);
2323
2324       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2325          meaningfully, it's always 1.  */
2326     case LABEL_DECL:     case CONST_DECL:
2327     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2328     case FUNCTION_DECL:
2329       gcc_assert (DECL_ALIGN (t) != 0);
2330       return DECL_ALIGN (t);
2331
2332     default:
2333       break;
2334     }
2335
2336   /* Otherwise take the alignment from that of the type.  */
2337   return TYPE_ALIGN (TREE_TYPE (t));
2338 }
2339 \f
2340 /* Return, as a tree node, the number of elements for TYPE (which is an
2341    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2342
2343 tree
2344 array_type_nelts (const_tree type)
2345 {
2346   tree index_type, min, max;
2347
2348   /* If they did it with unspecified bounds, then we should have already
2349      given an error about it before we got here.  */
2350   if (! TYPE_DOMAIN (type))
2351     return error_mark_node;
2352
2353   index_type = TYPE_DOMAIN (type);
2354   min = TYPE_MIN_VALUE (index_type);
2355   max = TYPE_MAX_VALUE (index_type);
2356
2357   return (integer_zerop (min)
2358           ? max
2359           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2360 }
2361 \f
2362 /* If arg is static -- a reference to an object in static storage -- then
2363    return the object.  This is not the same as the C meaning of `static'.
2364    If arg isn't static, return NULL.  */
2365
2366 tree
2367 staticp (tree arg)
2368 {
2369   switch (TREE_CODE (arg))
2370     {
2371     case FUNCTION_DECL:
2372       /* Nested functions are static, even though taking their address will
2373          involve a trampoline as we unnest the nested function and create
2374          the trampoline on the tree level.  */
2375       return arg;
2376
2377     case VAR_DECL:
2378       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2379               && ! DECL_THREAD_LOCAL_P (arg)
2380               && ! DECL_DLLIMPORT_P (arg)
2381               ? arg : NULL);
2382
2383     case CONST_DECL:
2384       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2385               ? arg : NULL);
2386
2387     case CONSTRUCTOR:
2388       return TREE_STATIC (arg) ? arg : NULL;
2389
2390     case LABEL_DECL:
2391     case STRING_CST:
2392       return arg;
2393
2394     case COMPONENT_REF:
2395       /* If the thing being referenced is not a field, then it is
2396          something language specific.  */
2397       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2398
2399       /* If we are referencing a bitfield, we can't evaluate an
2400          ADDR_EXPR at compile time and so it isn't a constant.  */
2401       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2402         return NULL;
2403
2404       return staticp (TREE_OPERAND (arg, 0));
2405
2406     case BIT_FIELD_REF:
2407       return NULL;
2408
2409     case MISALIGNED_INDIRECT_REF:
2410     case ALIGN_INDIRECT_REF:
2411     case INDIRECT_REF:
2412       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2413
2414     case ARRAY_REF:
2415     case ARRAY_RANGE_REF:
2416       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2417           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2418         return staticp (TREE_OPERAND (arg, 0));
2419       else
2420         return NULL;
2421
2422     case COMPOUND_LITERAL_EXPR:
2423       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2424
2425     default:
2426       return NULL;
2427     }
2428 }
2429
2430 \f
2431
2432
2433 /* Return whether OP is a DECL whose address is function-invariant.  */
2434
2435 bool
2436 decl_address_invariant_p (const_tree op)
2437 {
2438   /* The conditions below are slightly less strict than the one in
2439      staticp.  */
2440
2441   switch (TREE_CODE (op))
2442     {
2443     case PARM_DECL:
2444     case RESULT_DECL:
2445     case LABEL_DECL:
2446     case FUNCTION_DECL:
2447       return true;
2448
2449     case VAR_DECL:
2450       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2451            && !DECL_DLLIMPORT_P (op))
2452           || DECL_THREAD_LOCAL_P (op)
2453           || DECL_CONTEXT (op) == current_function_decl
2454           || decl_function_context (op) == current_function_decl)
2455         return true;
2456       break;
2457
2458     case CONST_DECL:
2459       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2460           || decl_function_context (op) == current_function_decl)
2461         return true;
2462       break;
2463
2464     default:
2465       break;
2466     }
2467
2468   return false;
2469 }
2470
2471 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2472
2473 bool
2474 decl_address_ip_invariant_p (const_tree op)
2475 {
2476   /* The conditions below are slightly less strict than the one in
2477      staticp.  */
2478
2479   switch (TREE_CODE (op))
2480     {
2481     case LABEL_DECL:
2482     case FUNCTION_DECL:
2483     case STRING_CST:
2484       return true;
2485
2486     case VAR_DECL:
2487       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2488            && !DECL_DLLIMPORT_P (op))
2489           || DECL_THREAD_LOCAL_P (op))
2490         return true;
2491       break;
2492
2493     case CONST_DECL:
2494       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2495         return true;
2496       break;
2497
2498     default:
2499       break;
2500     }
2501
2502   return false;
2503 }
2504
2505
2506 /* Return true if T is function-invariant (internal function, does
2507    not handle arithmetic; that's handled in skip_simple_arithmetic and
2508    tree_invariant_p).  */
2509
2510 static bool tree_invariant_p (tree t);
2511
2512 static bool
2513 tree_invariant_p_1 (tree t)
2514 {
2515   tree op;
2516
2517   if (TREE_CONSTANT (t)
2518       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2519     return true;
2520
2521   switch (TREE_CODE (t))
2522     {
2523     case SAVE_EXPR:
2524       return true;
2525
2526     case ADDR_EXPR:
2527       op = TREE_OPERAND (t, 0);
2528       while (handled_component_p (op))
2529         {
2530           switch (TREE_CODE (op))
2531             {
2532             case ARRAY_REF:
2533             case ARRAY_RANGE_REF:
2534               if (!tree_invariant_p (TREE_OPERAND (op, 1))
2535                   || TREE_OPERAND (op, 2) != NULL_TREE
2536                   || TREE_OPERAND (op, 3) != NULL_TREE)
2537                 return false;
2538               break;
2539
2540             case COMPONENT_REF:
2541               if (TREE_OPERAND (op, 2) != NULL_TREE)
2542                 return false;
2543               break;
2544
2545             default:;
2546             }
2547           op = TREE_OPERAND (op, 0);
2548         }
2549
2550       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2551
2552     default:
2553       break;
2554     }
2555
2556   return false;
2557 }
2558
2559 /* Return true if T is function-invariant.  */
2560
2561 static bool
2562 tree_invariant_p (tree t)
2563 {
2564   tree inner = skip_simple_arithmetic (t);
2565   return tree_invariant_p_1 (inner);
2566 }
2567
2568 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2569    Do this to any expression which may be used in more than one place,
2570    but must be evaluated only once.
2571
2572    Normally, expand_expr would reevaluate the expression each time.
2573    Calling save_expr produces something that is evaluated and recorded
2574    the first time expand_expr is called on it.  Subsequent calls to
2575    expand_expr just reuse the recorded value.
2576
2577    The call to expand_expr that generates code that actually computes
2578    the value is the first call *at compile time*.  Subsequent calls
2579    *at compile time* generate code to use the saved value.
2580    This produces correct result provided that *at run time* control
2581    always flows through the insns made by the first expand_expr
2582    before reaching the other places where the save_expr was evaluated.
2583    You, the caller of save_expr, must make sure this is so.
2584
2585    Constants, and certain read-only nodes, are returned with no
2586    SAVE_EXPR because that is safe.  Expressions containing placeholders
2587    are not touched; see tree.def for an explanation of what these
2588    are used for.  */
2589
2590 tree
2591 save_expr (tree expr)
2592 {
2593   tree t = fold (expr);
2594   tree inner;
2595
2596   /* If the tree evaluates to a constant, then we don't want to hide that
2597      fact (i.e. this allows further folding, and direct checks for constants).
2598      However, a read-only object that has side effects cannot be bypassed.
2599      Since it is no problem to reevaluate literals, we just return the
2600      literal node.  */
2601   inner = skip_simple_arithmetic (t);
2602   if (TREE_CODE (inner) == ERROR_MARK)
2603     return inner;
2604
2605   if (tree_invariant_p_1 (inner))
2606     return t;
2607
2608   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2609      it means that the size or offset of some field of an object depends on
2610      the value within another field.
2611
2612      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2613      and some variable since it would then need to be both evaluated once and
2614      evaluated more than once.  Front-ends must assure this case cannot
2615      happen by surrounding any such subexpressions in their own SAVE_EXPR
2616      and forcing evaluation at the proper time.  */
2617   if (contains_placeholder_p (inner))
2618     return t;
2619
2620   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2621   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2622
2623   /* This expression might be placed ahead of a jump to ensure that the
2624      value was computed on both sides of the jump.  So make sure it isn't
2625      eliminated as dead.  */
2626   TREE_SIDE_EFFECTS (t) = 1;
2627   return t;
2628 }
2629
2630 /* Look inside EXPR and into any simple arithmetic operations.  Return
2631    the innermost non-arithmetic node.  */
2632
2633 tree
2634 skip_simple_arithmetic (tree expr)
2635 {
2636   tree inner;
2637
2638   /* We don't care about whether this can be used as an lvalue in this
2639      context.  */
2640   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2641     expr = TREE_OPERAND (expr, 0);
2642
2643   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2644      a constant, it will be more efficient to not make another SAVE_EXPR since
2645      it will allow better simplification and GCSE will be able to merge the
2646      computations if they actually occur.  */
2647   inner = expr;
2648   while (1)
2649     {
2650       if (UNARY_CLASS_P (inner))
2651         inner = TREE_OPERAND (inner, 0);
2652       else if (BINARY_CLASS_P (inner))
2653         {
2654           if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2655             inner = TREE_OPERAND (inner, 0);
2656           else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2657             inner = TREE_OPERAND (inner, 1);
2658           else
2659             break;
2660         }
2661       else
2662         break;
2663     }
2664
2665   return inner;
2666 }
2667
2668
2669 /* Return which tree structure is used by T.  */
2670
2671 enum tree_node_structure_enum
2672 tree_node_structure (const_tree t)
2673 {
2674   const enum tree_code code = TREE_CODE (t);
2675   return tree_node_structure_for_code (code);
2676 }
2677
2678 /* Set various status flags when building a CALL_EXPR object T.  */
2679
2680 static void
2681 process_call_operands (tree t)
2682 {
2683   bool side_effects = TREE_SIDE_EFFECTS (t);
2684   bool read_only = false;
2685   int i = call_expr_flags (t);
2686
2687   /* Calls have side-effects, except those to const or pure functions.  */
2688   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2689     side_effects = true;
2690   /* Propagate TREE_READONLY of arguments for const functions.  */
2691   if (i & ECF_CONST)
2692     read_only = true;
2693
2694   if (!side_effects || read_only)
2695     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2696       {
2697         tree op = TREE_OPERAND (t, i);
2698         if (op && TREE_SIDE_EFFECTS (op))
2699           side_effects = true;
2700         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2701           read_only = false;
2702       }
2703
2704   TREE_SIDE_EFFECTS (t) = side_effects;
2705   TREE_READONLY (t) = read_only;
2706 }
2707 \f
2708 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2709    or offset that depends on a field within a record.  */
2710
2711 bool
2712 contains_placeholder_p (const_tree exp)
2713 {
2714   enum tree_code code;
2715
2716   if (!exp)
2717     return 0;
2718
2719   code = TREE_CODE (exp);
2720   if (code == PLACEHOLDER_EXPR)
2721     return 1;
2722
2723   switch (TREE_CODE_CLASS (code))
2724     {
2725     case tcc_reference:
2726       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2727          position computations since they will be converted into a
2728          WITH_RECORD_EXPR involving the reference, which will assume
2729          here will be valid.  */
2730       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2731
2732     case tcc_exceptional:
2733       if (code == TREE_LIST)
2734         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2735                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2736       break;
2737
2738     case tcc_unary:
2739     case tcc_binary:
2740     case tcc_comparison:
2741     case tcc_expression:
2742       switch (code)
2743         {
2744         case COMPOUND_EXPR:
2745           /* Ignoring the first operand isn't quite right, but works best.  */
2746           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2747
2748         case COND_EXPR:
2749           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2750                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2751                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2752
2753         case SAVE_EXPR:
2754           /* The save_expr function never wraps anything containing
2755              a PLACEHOLDER_EXPR. */
2756           return 0;
2757
2758         default:
2759           break;
2760         }
2761
2762       switch (TREE_CODE_LENGTH (code))
2763         {
2764         case 1:
2765           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2766         case 2:
2767           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2768                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2769         default:
2770           return 0;
2771         }
2772
2773     case tcc_vl_exp:
2774       switch (code)
2775         {
2776         case CALL_EXPR:
2777           {
2778             const_tree arg;
2779             const_call_expr_arg_iterator iter;
2780             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2781               if (CONTAINS_PLACEHOLDER_P (arg))
2782                 return 1;
2783             return 0;
2784           }
2785         default:
2786           return 0;
2787         }
2788
2789     default:
2790       return 0;
2791     }
2792   return 0;
2793 }
2794
2795 /* Return true if any part of the computation of TYPE involves a
2796    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2797    (for QUAL_UNION_TYPE) and field positions.  */
2798
2799 static bool
2800 type_contains_placeholder_1 (const_tree type)
2801 {
2802   /* If the size contains a placeholder or the parent type (component type in
2803      the case of arrays) type involves a placeholder, this type does.  */
2804   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2805       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2806       || (TREE_TYPE (type) != 0
2807           && type_contains_placeholder_p (TREE_TYPE (type))))
2808     return true;
2809
2810   /* Now do type-specific checks.  Note that the last part of the check above
2811      greatly limits what we have to do below.  */
2812   switch (TREE_CODE (type))
2813     {
2814     case VOID_TYPE:
2815     case COMPLEX_TYPE:
2816     case ENUMERAL_TYPE:
2817     case BOOLEAN_TYPE:
2818     case POINTER_TYPE:
2819     case OFFSET_TYPE:
2820     case REFERENCE_TYPE:
2821     case METHOD_TYPE:
2822     case FUNCTION_TYPE:
2823     case VECTOR_TYPE:
2824       return false;
2825
2826     case INTEGER_TYPE:
2827     case REAL_TYPE:
2828     case FIXED_POINT_TYPE:
2829       /* Here we just check the bounds.  */
2830       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2831               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2832
2833     case ARRAY_TYPE:
2834       /* We're already checked the component type (TREE_TYPE), so just check
2835          the index type.  */
2836       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2837
2838     case RECORD_TYPE:
2839     case UNION_TYPE:
2840     case QUAL_UNION_TYPE:
2841       {
2842         tree field;
2843
2844         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2845           if (TREE_CODE (field) == FIELD_DECL
2846               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2847                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2848                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2849                   || type_contains_placeholder_p (TREE_TYPE (field))))
2850             return true;
2851
2852         return false;
2853       }
2854
2855     default:
2856       gcc_unreachable ();
2857     }
2858 }
2859
2860 bool
2861 type_contains_placeholder_p (tree type)
2862 {
2863   bool result;
2864
2865   /* If the contains_placeholder_bits field has been initialized,
2866      then we know the answer.  */
2867   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2868     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2869
2870   /* Indicate that we've seen this type node, and the answer is false.
2871      This is what we want to return if we run into recursion via fields.  */
2872   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2873
2874   /* Compute the real value.  */
2875   result = type_contains_placeholder_1 (type);
2876
2877   /* Store the real value.  */
2878   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2879
2880   return result;
2881 }
2882 \f
2883 /* Push tree EXP onto vector QUEUE if it is not already present.  */
2884
2885 static void
2886 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2887 {
2888   unsigned int i;
2889   tree iter;
2890
2891   for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
2892     if (simple_cst_equal (iter, exp) == 1)
2893       break;
2894
2895   if (!iter)
2896     VEC_safe_push (tree, heap, *queue, exp);
2897 }
2898
2899 /* Given a tree EXP, find all occurences of references to fields
2900    in a PLACEHOLDER_EXPR and place them in vector REFS without
2901    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2902    we assume here that EXP contains only arithmetic expressions
2903    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2904    argument list.  */
2905
2906 void
2907 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2908 {
2909   enum tree_code code = TREE_CODE (exp);
2910   tree inner;
2911   int i;
2912
2913   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2914   if (code == TREE_LIST)
2915     {
2916       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2917       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2918     }
2919   else if (code == COMPONENT_REF)
2920     {
2921       for (inner = TREE_OPERAND (exp, 0);
2922            REFERENCE_CLASS_P (inner);
2923            inner = TREE_OPERAND (inner, 0))
2924         ;
2925
2926       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2927         push_without_duplicates (exp, refs);
2928       else
2929         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2930    }
2931   else
2932     switch (TREE_CODE_CLASS (code))
2933       {
2934       case tcc_constant:
2935         break;
2936
2937       case tcc_declaration:
2938         /* Variables allocated to static storage can stay.  */
2939         if (!TREE_STATIC (exp))
2940           push_without_duplicates (exp, refs);
2941         break;
2942
2943       case tcc_expression:
2944         /* This is the pattern built in ada/make_aligning_type.  */
2945         if (code == ADDR_EXPR
2946             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2947           {
2948             push_without_duplicates (exp, refs);
2949             break;
2950           }
2951
2952         /* Fall through...  */
2953
2954       case tcc_exceptional:
2955       case tcc_unary:
2956       case tcc_binary:
2957       case tcc_comparison:
2958       case tcc_reference:
2959         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2960           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2961         break;
2962
2963       case tcc_vl_exp:
2964         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2965           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2966         break;
2967
2968       default:
2969         gcc_unreachable ();
2970       }
2971 }
2972
2973 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2974    return a tree with all occurrences of references to F in a
2975    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
2976    CONST_DECLs.  Note that we assume here that EXP contains only
2977    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
2978    occurring only in their argument list.  */
2979
2980 tree
2981 substitute_in_expr (tree exp, tree f, tree r)
2982 {
2983   enum tree_code code = TREE_CODE (exp);
2984   tree op0, op1, op2, op3;
2985   tree new_tree;
2986
2987   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2988   if (code == TREE_LIST)
2989     {
2990       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2991       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2992       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2993         return exp;
2994
2995       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2996     }
2997   else if (code == COMPONENT_REF)
2998     {
2999       tree inner;
3000
3001       /* If this expression is getting a value from a PLACEHOLDER_EXPR
3002          and it is the right field, replace it with R.  */
3003       for (inner = TREE_OPERAND (exp, 0);
3004            REFERENCE_CLASS_P (inner);
3005            inner = TREE_OPERAND (inner, 0))
3006         ;
3007
3008       /* The field.  */
3009       op1 = TREE_OPERAND (exp, 1);
3010
3011       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3012         return r;
3013
3014       /* If this expression hasn't been completed let, leave it alone.  */
3015       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3016         return exp;
3017
3018       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3019       if (op0 == TREE_OPERAND (exp, 0))
3020         return exp;
3021
3022       new_tree
3023         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3024    }
3025   else
3026     switch (TREE_CODE_CLASS (code))
3027       {
3028       case tcc_constant:
3029         return exp;
3030
3031       case tcc_declaration:
3032         if (exp == f)
3033           return r;
3034         else
3035           return exp;
3036
3037       case tcc_expression:
3038         if (exp == f)
3039           return r;
3040
3041         /* Fall through...  */
3042
3043       case tcc_exceptional:
3044       case tcc_unary:
3045       case tcc_binary:
3046       case tcc_comparison:
3047       case tcc_reference:
3048         switch (TREE_CODE_LENGTH (code))
3049           {
3050           case 0:
3051             return exp;
3052
3053           case 1:
3054             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3055             if (op0 == TREE_OPERAND (exp, 0))
3056               return exp;
3057
3058             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3059             break;
3060
3061           case 2:
3062             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3063             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3064
3065             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3066               return exp;
3067
3068             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3069             break;
3070
3071           case 3:
3072             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3073             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3074             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3075
3076             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3077                 && op2 == TREE_OPERAND (exp, 2))
3078               return exp;
3079
3080             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3081             break;
3082
3083           case 4:
3084             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3085             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3086             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3087             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3088
3089             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3090                 && op2 == TREE_OPERAND (exp, 2)
3091                 && op3 == TREE_OPERAND (exp, 3))
3092               return exp;
3093
3094             new_tree
3095               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3096             break;
3097
3098           default:
3099             gcc_unreachable ();
3100           }
3101         break;
3102
3103       case tcc_vl_exp:
3104         {
3105           int i;
3106
3107           new_tree = NULL_TREE;
3108
3109           /* If we are trying to replace F with a constant, inline back
3110              functions which do nothing else than computing a value from
3111              the arguments they are passed.  This makes it possible to
3112              fold partially or entirely the replacement expression.  */
3113           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3114             {
3115               tree t = maybe_inline_call_in_expr (exp);
3116               if (t)
3117                 return SUBSTITUTE_IN_EXPR (t, f, r);
3118             }
3119
3120           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3121             {
3122               tree op = TREE_OPERAND (exp, i);
3123               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3124               if (new_op != op)
3125                 {
3126                   if (!new_tree)
3127                     new_tree = copy_node (exp);
3128                   TREE_OPERAND (new_tree, i) = new_op;
3129                 }
3130             }
3131
3132           if (new_tree)
3133             {
3134               new_tree = fold (new_tree);
3135               if (TREE_CODE (new_tree) == CALL_EXPR)
3136                 process_call_operands (new_tree);
3137             }
3138           else
3139             return exp;
3140         }
3141         break;
3142
3143       default:
3144         gcc_unreachable ();
3145       }
3146
3147   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3148   return new_tree;
3149 }
3150
3151 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3152    for it within OBJ, a tree that is an object or a chain of references.  */
3153
3154 tree
3155 substitute_placeholder_in_expr (tree exp, tree obj)
3156 {
3157   enum tree_code code = TREE_CODE (exp);
3158   tree op0, op1, op2, op3;
3159   tree new_tree;
3160
3161   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3162      in the chain of OBJ.  */
3163   if (code == PLACEHOLDER_EXPR)
3164     {
3165       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3166       tree elt;
3167
3168       for (elt = obj; elt != 0;
3169            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3170                    || TREE_CODE (elt) == COND_EXPR)
3171                   ? TREE_OPERAND (elt, 1)
3172                   : (REFERENCE_CLASS_P (elt)
3173                      || UNARY_CLASS_P (elt)
3174                      || BINARY_CLASS_P (elt)
3175                      || VL_EXP_CLASS_P (elt)
3176                      || EXPRESSION_CLASS_P (elt))
3177                   ? TREE_OPERAND (elt, 0) : 0))
3178         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3179           return elt;
3180
3181       for (elt = obj; elt != 0;
3182            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3183                    || TREE_CODE (elt) == COND_EXPR)
3184                   ? TREE_OPERAND (elt, 1)
3185                   : (REFERENCE_CLASS_P (elt)
3186                      || UNARY_CLASS_P (elt)
3187                      || BINARY_CLASS_P (elt)
3188                      || VL_EXP_CLASS_P (elt)
3189                      || EXPRESSION_CLASS_P (elt))
3190                   ? TREE_OPERAND (elt, 0) : 0))
3191         if (POINTER_TYPE_P (TREE_TYPE (elt))
3192             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3193                 == need_type))
3194           return fold_build1 (INDIRECT_REF, need_type, elt);
3195
3196       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3197          survives until RTL generation, there will be an error.  */
3198       return exp;
3199     }
3200
3201   /* TREE_LIST is special because we need to look at TREE_VALUE
3202      and TREE_CHAIN, not TREE_OPERANDS.  */
3203   else if (code == TREE_LIST)
3204     {
3205       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3206       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3207       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3208         return exp;
3209
3210       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3211     }
3212   else
3213     switch (TREE_CODE_CLASS (code))
3214       {
3215       case tcc_constant:
3216       case tcc_declaration:
3217         return exp;
3218
3219       case tcc_exceptional:
3220       case tcc_unary:
3221       case tcc_binary:
3222       case tcc_comparison:
3223       case tcc_expression:
3224       case tcc_reference:
3225       case tcc_statement:
3226         switch (TREE_CODE_LENGTH (code))
3227           {
3228           case 0:
3229             return exp;
3230
3231           case 1:
3232             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3233             if (op0 == TREE_OPERAND (exp, 0))
3234               return exp;
3235
3236             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3237             break;
3238
3239           case 2:
3240             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3241             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3242
3243             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3244               return exp;
3245
3246             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3247             break;
3248
3249           case 3:
3250             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3251             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3252             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3253
3254             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3255                 && op2 == TREE_OPERAND (exp, 2))
3256               return exp;
3257
3258             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3259             break;
3260
3261           case 4:
3262             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3263             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3264             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3265             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3266
3267             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3268                 && op2 == TREE_OPERAND (exp, 2)
3269                 && op3 == TREE_OPERAND (exp, 3))
3270               return exp;
3271
3272             new_tree
3273               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3274             break;
3275
3276           default:
3277             gcc_unreachable ();
3278           }
3279         break;
3280
3281       case tcc_vl_exp:
3282         {
3283           int i;
3284
3285           new_tree = NULL_TREE;
3286
3287           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3288             {
3289               tree op = TREE_OPERAND (exp, i);
3290               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3291               if (new_op != op)
3292                 {
3293                   if (!new_tree)
3294                     new_tree = copy_node (exp);
3295                   TREE_OPERAND (new_tree, i) = new_op;
3296                 }
3297             }
3298
3299           if (new_tree)
3300             {
3301               new_tree = fold (new_tree);
3302               if (TREE_CODE (new_tree) == CALL_EXPR)
3303                 process_call_operands (new_tree);
3304             }
3305           else
3306             return exp;
3307         }
3308         break;
3309
3310       default:
3311         gcc_unreachable ();
3312       }
3313
3314   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3315   return new_tree;
3316 }
3317 \f
3318 /* Stabilize a reference so that we can use it any number of times
3319    without causing its operands to be evaluated more than once.
3320    Returns the stabilized reference.  This works by means of save_expr,
3321    so see the caveats in the comments about save_expr.
3322
3323    Also allows conversion expressions whose operands are references.
3324    Any other kind of expression is returned unchanged.  */
3325
3326 tree
3327 stabilize_reference (tree ref)
3328 {
3329   tree result;
3330   enum tree_code code = TREE_CODE (ref);
3331
3332   switch (code)
3333     {
3334     case VAR_DECL:
3335     case PARM_DECL:
3336     case RESULT_DECL:
3337       /* No action is needed in this case.  */
3338       return ref;
3339
3340     CASE_CONVERT:
3341     case FLOAT_EXPR:
3342     case FIX_TRUNC_EXPR:
3343       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3344       break;
3345
3346     case INDIRECT_REF:
3347       result = build_nt (INDIRECT_REF,
3348                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3349       break;
3350
3351     case COMPONENT_REF:
3352       result = build_nt (COMPONENT_REF,
3353                          stabilize_reference (TREE_OPERAND (ref, 0)),
3354                          TREE_OPERAND (ref, 1), NULL_TREE);
3355       break;
3356
3357     case BIT_FIELD_REF:
3358       result = build_nt (BIT_FIELD_REF,
3359                          stabilize_reference (TREE_OPERAND (ref, 0)),
3360                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3361                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3362       break;
3363
3364     case ARRAY_REF:
3365       result = build_nt (ARRAY_REF,
3366                          stabilize_reference (TREE_OPERAND (ref, 0)),
3367                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3368                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3369       break;
3370
3371     case ARRAY_RANGE_REF:
3372       result = build_nt (ARRAY_RANGE_REF,
3373                          stabilize_reference (TREE_OPERAND (ref, 0)),
3374                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3375                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3376       break;
3377
3378     case COMPOUND_EXPR:
3379       /* We cannot wrap the first expression in a SAVE_EXPR, as then
3380          it wouldn't be ignored.  This matters when dealing with
3381          volatiles.  */
3382       return stabilize_reference_1 (ref);
3383
3384       /* If arg isn't a kind of lvalue we recognize, make no change.
3385          Caller should recognize the error for an invalid lvalue.  */
3386     default:
3387       return ref;
3388
3389     case ERROR_MARK:
3390       return error_mark_node;
3391     }
3392
3393   TREE_TYPE (result) = TREE_TYPE (ref);
3394   TREE_READONLY (result) = TREE_READONLY (ref);
3395   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3396   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3397
3398   return result;
3399 }
3400
3401 /* Subroutine of stabilize_reference; this is called for subtrees of
3402    references.  Any expression with side-effects must be put in a SAVE_EXPR
3403    to ensure that it is only evaluated once.
3404
3405    We don't put SAVE_EXPR nodes around everything, because assigning very
3406    simple expressions to temporaries causes us to miss good opportunities
3407    for optimizations.  Among other things, the opportunity to fold in the
3408    addition of a constant into an addressing mode often gets lost, e.g.
3409    "y[i+1] += x;".  In general, we take the approach that we should not make
3410    an assignment unless we are forced into it - i.e., that any non-side effect
3411    operator should be allowed, and that cse should take care of coalescing
3412    multiple utterances of the same expression should that prove fruitful.  */
3413
3414 tree
3415 stabilize_reference_1 (tree e)
3416 {
3417   tree result;
3418   enum tree_code code = TREE_CODE (e);
3419
3420   /* We cannot ignore const expressions because it might be a reference
3421      to a const array but whose index contains side-effects.  But we can
3422      ignore things that are actual constant or that already have been
3423      handled by this function.  */
3424
3425   if (tree_invariant_p (e))
3426     return e;
3427
3428   switch (TREE_CODE_CLASS (code))
3429     {
3430     case tcc_exceptional:
3431     case tcc_type:
3432     case tcc_declaration:
3433     case tcc_comparison:
3434     case tcc_statement:
3435     case tcc_expression:
3436     case tcc_reference:
3437     case tcc_vl_exp:
3438       /* If the expression has side-effects, then encase it in a SAVE_EXPR
3439          so that it will only be evaluated once.  */
3440       /* The reference (r) and comparison (<) classes could be handled as
3441          below, but it is generally faster to only evaluate them once.  */
3442       if (TREE_SIDE_EFFECTS (e))
3443         return save_expr (e);
3444       return e;
3445
3446     case tcc_constant:
3447       /* Constants need no processing.  In fact, we should never reach
3448          here.  */
3449       return e;
3450
3451     case tcc_binary:
3452       /* Division is slow and tends to be compiled with jumps,
3453          especially the division by powers of 2 that is often
3454          found inside of an array reference.  So do it just once.  */
3455       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3456           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3457           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3458           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3459         return save_expr (e);
3460       /* Recursively stabilize each operand.  */
3461       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3462                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
3463       break;
3464
3465     case tcc_unary:
3466       /* Recursively stabilize each operand.  */
3467       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3468       break;
3469
3470     default:
3471       gcc_unreachable ();
3472     }
3473
3474   TREE_TYPE (result) = TREE_TYPE (e);
3475   TREE_READONLY (result) = TREE_READONLY (e);
3476   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3477   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3478
3479   return result;
3480 }
3481 \f
3482 /* Low-level constructors for expressions.  */
3483
3484 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3485    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3486
3487 void
3488 recompute_tree_invariant_for_addr_expr (tree t)
3489 {
3490   tree node;
3491   bool tc = true, se = false;
3492
3493   /* We started out assuming this address is both invariant and constant, but
3494      does not have side effects.  Now go down any handled components and see if
3495      any of them involve offsets that are either non-constant or non-invariant.
3496      Also check for side-effects.
3497
3498      ??? Note that this code makes no attempt to deal with the case where
3499      taking the address of something causes a copy due to misalignment.  */
3500
3501 #define UPDATE_FLAGS(NODE)  \
3502 do { tree _node = (NODE); \
3503      if (_node && !TREE_CONSTANT (_node)) tc = false; \
3504      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3505
3506   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3507        node = TREE_OPERAND (node, 0))
3508     {
3509       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3510          array reference (probably made temporarily by the G++ front end),
3511          so ignore all the operands.  */
3512       if ((TREE_CODE (node) == ARRAY_REF
3513            || TREE_CODE (node) == ARRAY_RANGE_REF)
3514           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3515         {
3516           UPDATE_FLAGS (TREE_OPERAND (node, 1));
3517           if (TREE_OPERAND (node, 2))
3518             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3519           if (TREE_OPERAND (node, 3))
3520             UPDATE_FLAGS (TREE_OPERAND (node, 3));
3521         }
3522       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3523          FIELD_DECL, apparently.  The G++ front end can put something else
3524          there, at least temporarily.  */
3525       else if (TREE_CODE (node) == COMPONENT_REF
3526                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3527         {
3528           if (TREE_OPERAND (node, 2))
3529             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3530         }
3531       else if (TREE_CODE (node) == BIT_FIELD_REF)
3532         UPDATE_FLAGS (TREE_OPERAND (node, 2));
3533     }
3534
3535   node = lang_hooks.expr_to_decl (node, &tc, &se);
3536
3537   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3538      the address, since &(*a)->b is a form of addition.  If it's a constant, the
3539      address is constant too.  If it's a decl, its address is constant if the
3540      decl is static.  Everything else is not constant and, furthermore,
3541      taking the address of a volatile variable is not volatile.  */
3542   if (TREE_CODE (node) == INDIRECT_REF)
3543     UPDATE_FLAGS (TREE_OPERAND (node, 0));
3544   else if (CONSTANT_CLASS_P (node))
3545     ;
3546   else if (DECL_P (node))
3547     tc &= (staticp (node) != NULL_TREE);
3548   else
3549     {
3550       tc = false;
3551       se |= TREE_SIDE_EFFECTS (node);
3552     }
3553
3554
3555   TREE_CONSTANT (t) = tc;
3556   TREE_SIDE_EFFECTS (t) = se;
3557 #undef UPDATE_FLAGS
3558 }
3559
3560 /* Build an expression of code CODE, data type TYPE, and operands as
3561    specified.  Expressions and reference nodes can be created this way.
3562    Constants, decls, types and misc nodes cannot be.
3563
3564    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3565    enough for all extant tree codes.  */
3566
3567 tree
3568 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3569 {
3570   tree t;
3571
3572   gcc_assert (TREE_CODE_LENGTH (code) == 0);
3573
3574   t = make_node_stat (code PASS_MEM_STAT);
3575   TREE_TYPE (t) = tt;
3576
3577   return t;
3578 }
3579
3580 tree
3581 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3582 {
3583   int length = sizeof (struct tree_exp);
3584 #ifdef GATHER_STATISTICS
3585   tree_node_kind kind;
3586 #endif
3587   tree t;
3588
3589 #ifdef GATHER_STATISTICS
3590   switch (TREE_CODE_CLASS (code))
3591     {
3592     case tcc_statement:  /* an expression with side effects */
3593       kind = s_kind;
3594       break;
3595     case tcc_reference:  /* a reference */
3596       kind = r_kind;
3597       break;
3598     default:
3599       kind = e_kind;
3600       break;
3601     }
3602
3603   tree_node_counts[(int) kind]++;
3604   tree_node_sizes[(int) kind] += length;
3605 #endif
3606
3607   gcc_assert (TREE_CODE_LENGTH (code) == 1);
3608
3609   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
3610
3611   memset (t, 0, sizeof (struct tree_common));
3612
3613   TREE_SET_CODE (t, code);
3614
3615   TREE_TYPE (t) = type;
3616   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3617   TREE_OPERAND (t, 0) = node;
3618   TREE_BLOCK (t) = NULL_TREE;
3619   if (node && !TYPE_P (node))
3620     {
3621       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3622       TREE_READONLY (t) = TREE_READONLY (node);
3623     }
3624
3625   if (TREE_CODE_CLASS (code) == tcc_statement)
3626     TREE_SIDE_EFFECTS (t) = 1;
3627   else switch (code)
3628     {
3629     case VA_ARG_EXPR:
3630       /* All of these have side-effects, no matter what their
3631          operands are.  */
3632       TREE_SIDE_EFFECTS (t) = 1;
3633       TREE_READONLY (t) = 0;
3634       break;
3635
3636     case MISALIGNED_INDIRECT_REF:
3637     case ALIGN_INDIRECT_REF:
3638     case INDIRECT_REF:
3639       /* Whether a dereference is readonly has nothing to do with whether
3640          its operand is readonly.  */
3641       TREE_READONLY (t) = 0;
3642       break;
3643
3644     case ADDR_EXPR:
3645       if (node)
3646         recompute_tree_invariant_for_addr_expr (t);
3647       break;
3648
3649     default:
3650       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3651           && node && !TYPE_P (node)
3652           && TREE_CONSTANT (node))
3653         TREE_CONSTANT (t) = 1;
3654       if (TREE_CODE_CLASS (code) == tcc_reference
3655           && node && TREE_THIS_VOLATILE (node))
3656         TREE_THIS_VOLATILE (t) = 1;
3657       break;
3658     }
3659
3660   return t;
3661 }
3662
3663 #define PROCESS_ARG(N)                          \
3664   do {                                          \
3665     TREE_OPERAND (t, N) = arg##N;               \
3666     if (arg##N &&!TYPE_P (arg##N))              \
3667       {                                         \
3668         if (TREE_SIDE_EFFECTS (arg##N))         \
3669           side_effects = 1;                     \
3670         if (!TREE_READONLY (arg##N)             \
3671             && !CONSTANT_CLASS_P (arg##N))      \
3672           (void) (read_only = 0);               \
3673         if (!TREE_CONSTANT (arg##N))            \
3674           (void) (constant = 0);                \
3675       }                                         \
3676   } while (0)
3677
3678 tree
3679 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3680 {
3681   bool constant, read_only, side_effects;
3682   tree t;
3683
3684   gcc_assert (TREE_CODE_LENGTH (code) == 2);
3685
3686   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3687       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3688       /* When sizetype precision doesn't match that of pointers
3689          we need to be able to build explicit extensions or truncations
3690          of the offset argument.  */
3691       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3692     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3693                 && TREE_CODE (arg1) == INTEGER_CST);
3694
3695   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3696     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3697                 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3698                 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3699
3700   t = make_node_stat (code PASS_MEM_STAT);
3701   TREE_TYPE (t) = tt;
3702
3703   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3704      result based on those same flags for the arguments.  But if the
3705      arguments aren't really even `tree' expressions, we shouldn't be trying
3706      to do this.  */
3707
3708   /* Expressions without side effects may be constant if their
3709      arguments are as well.  */
3710   constant = (TREE_CODE_CLASS (code) == tcc_comparison
3711               || TREE_CODE_CLASS (code) == tcc_binary);
3712   read_only = 1;
3713   side_effects = TREE_SIDE_EFFECTS (t);
3714
3715   PROCESS_ARG(0);
3716   PROCESS_ARG(1);
3717
3718   TREE_READONLY (t) = read_only;
3719   TREE_CONSTANT (t) = constant;
3720   TREE_SIDE_EFFECTS (t) = side_effects;
3721   TREE_THIS_VOLATILE (t)
3722     = (TREE_CODE_CLASS (code) == tcc_reference
3723        && arg0 && TREE_THIS_VOLATILE (arg0));
3724
3725   return t;
3726 }
3727
3728
3729 tree
3730 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3731              tree arg2 MEM_STAT_DECL)
3732 {
3733   bool constant, read_only, side_effects;
3734   tree t;
3735
3736   gcc_assert (TREE_CODE_LENGTH (code) == 3);
3737   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3738
3739   t = make_node_stat (code PASS_MEM_STAT);
3740   TREE_TYPE (t) = tt;
3741
3742   read_only = 1;
3743
3744   /* As a special exception, if COND_EXPR has NULL branches, we
3745      assume that it is a gimple statement and always consider
3746      it to have side effects.  */
3747   if (code == COND_EXPR
3748       && tt == void_type_node
3749       && arg1 == NULL_TREE
3750       && arg2 == NULL_TREE)
3751     side_effects = true;
3752   else
3753     side_effects = TREE_SIDE_EFFECTS (t);