OSDN Git Service

8b04c376594d22093d3a62058106a300959d489d
[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 "tm_p.h"
39 #include "function.h"
40 #include "obstack.h"
41 #include "toplev.h"
42 #include "ggc.h"
43 #include "hashtab.h"
44 #include "output.h"
45 #include "target.h"
46 #include "langhooks.h"
47 #include "tree-inline.h"
48 #include "tree-iterator.h"
49 #include "basic-block.h"
50 #include "tree-flow.h"
51 #include "params.h"
52 #include "pointer-set.h"
53 #include "tree-pass.h"
54 #include "langhooks-def.h"
55 #include "diagnostic.h"
56 #include "tree-diagnostic.h"
57 #include "tree-pretty-print.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 in TYPE.  The value is sign extended
1045    if it is negative.  This function is similar to build_int_cst, but
1046    the extra bits outside of the type precision are cleared.  Constants
1047    with these extra bits may confuse the fold so that it detects overflows
1048    even in cases when they do not occur, and in general should be avoided.
1049    We cannot however make this a default behavior of build_int_cst without
1050    more intrusive changes, since there are parts of gcc that rely on the extra
1051    precision of the integer constants.  */
1052
1053 tree
1054 build_int_cst_type (tree type, HOST_WIDE_INT low)
1055 {
1056   unsigned HOST_WIDE_INT low1;
1057   HOST_WIDE_INT hi;
1058
1059   gcc_assert (type);
1060
1061   fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
1062
1063   return build_int_cst_wide (type, low1, hi);
1064 }
1065
1066 /* Constructs tree in type TYPE from with value given by CST.  Signedness
1067    of CST is assumed to be the same as the signedness of TYPE.  */
1068
1069 tree
1070 double_int_to_tree (tree type, double_int cst)
1071 {
1072   /* Size types *are* sign extended.  */
1073   bool sign_extended_type = (!TYPE_UNSIGNED (type)
1074                              || (TREE_CODE (type) == INTEGER_TYPE
1075                                  && TYPE_IS_SIZETYPE (type)));
1076
1077   cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1078
1079   return build_int_cst_wide (type, cst.low, cst.high);
1080 }
1081
1082 /* Returns true if CST fits into range of TYPE.  Signedness of CST is assumed
1083    to be the same as the signedness of TYPE.  */
1084
1085 bool
1086 double_int_fits_to_tree_p (const_tree type, double_int cst)
1087 {
1088   /* Size types *are* sign extended.  */
1089   bool sign_extended_type = (!TYPE_UNSIGNED (type)
1090                              || (TREE_CODE (type) == INTEGER_TYPE
1091                                  && TYPE_IS_SIZETYPE (type)));
1092
1093   double_int ext
1094     = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1095
1096   return double_int_equal_p (cst, ext);
1097 }
1098
1099 /* These are the hash table functions for the hash table of INTEGER_CST
1100    nodes of a sizetype.  */
1101
1102 /* Return the hash code code X, an INTEGER_CST.  */
1103
1104 static hashval_t
1105 int_cst_hash_hash (const void *x)
1106 {
1107   const_tree const t = (const_tree) x;
1108
1109   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1110           ^ htab_hash_pointer (TREE_TYPE (t)));
1111 }
1112
1113 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1114    is the same as that given by *Y, which is the same.  */
1115
1116 static int
1117 int_cst_hash_eq (const void *x, const void *y)
1118 {
1119   const_tree const xt = (const_tree) x;
1120   const_tree const yt = (const_tree) y;
1121
1122   return (TREE_TYPE (xt) == TREE_TYPE (yt)
1123           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1124           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1125 }
1126
1127 /* Create an INT_CST node of TYPE and value HI:LOW.
1128    The returned node is always shared.  For small integers we use a
1129    per-type vector cache, for larger ones we use a single hash table.  */
1130
1131 tree
1132 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1133 {
1134   tree t;
1135   int ix = -1;
1136   int limit = 0;
1137
1138   gcc_assert (type);
1139
1140   switch (TREE_CODE (type))
1141     {
1142     case POINTER_TYPE:
1143     case REFERENCE_TYPE:
1144       /* Cache NULL pointer.  */
1145       if (!hi && !low)
1146         {
1147           limit = 1;
1148           ix = 0;
1149         }
1150       break;
1151
1152     case BOOLEAN_TYPE:
1153       /* Cache false or true.  */
1154       limit = 2;
1155       if (!hi && low < 2)
1156         ix = low;
1157       break;
1158
1159     case INTEGER_TYPE:
1160     case OFFSET_TYPE:
1161       if (TYPE_UNSIGNED (type))
1162         {
1163           /* Cache 0..N */
1164           limit = INTEGER_SHARE_LIMIT;
1165           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1166             ix = low;
1167         }
1168       else
1169         {
1170           /* Cache -1..N */
1171           limit = INTEGER_SHARE_LIMIT + 1;
1172           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1173             ix = low + 1;
1174           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1175             ix = 0;
1176         }
1177       break;
1178
1179     case ENUMERAL_TYPE:
1180       break;
1181
1182     default:
1183       gcc_unreachable ();
1184     }
1185
1186   if (ix >= 0)
1187     {
1188       /* Look for it in the type's vector of small shared ints.  */
1189       if (!TYPE_CACHED_VALUES_P (type))
1190         {
1191           TYPE_CACHED_VALUES_P (type) = 1;
1192           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1193         }
1194
1195       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1196       if (t)
1197         {
1198           /* Make sure no one is clobbering the shared constant.  */
1199           gcc_assert (TREE_TYPE (t) == type);
1200           gcc_assert (TREE_INT_CST_LOW (t) == low);
1201           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1202         }
1203       else
1204         {
1205           /* Create a new shared int.  */
1206           t = make_node (INTEGER_CST);
1207
1208           TREE_INT_CST_LOW (t) = low;
1209           TREE_INT_CST_HIGH (t) = hi;
1210           TREE_TYPE (t) = type;
1211
1212           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1213         }
1214     }
1215   else
1216     {
1217       /* Use the cache of larger shared ints.  */
1218       void **slot;
1219
1220       TREE_INT_CST_LOW (int_cst_node) = low;
1221       TREE_INT_CST_HIGH (int_cst_node) = hi;
1222       TREE_TYPE (int_cst_node) = type;
1223
1224       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1225       t = (tree) *slot;
1226       if (!t)
1227         {
1228           /* Insert this one into the hash table.  */
1229           t = int_cst_node;
1230           *slot = t;
1231           /* Make a new node for next time round.  */
1232           int_cst_node = make_node (INTEGER_CST);
1233         }
1234     }
1235
1236   return t;
1237 }
1238
1239 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1240    and the rest are zeros.  */
1241
1242 tree
1243 build_low_bits_mask (tree type, unsigned bits)
1244 {
1245   double_int mask;
1246
1247   gcc_assert (bits <= TYPE_PRECISION (type));
1248
1249   if (bits == TYPE_PRECISION (type)
1250       && !TYPE_UNSIGNED (type))
1251     /* Sign extended all-ones mask.  */
1252     mask = double_int_minus_one;
1253   else
1254     mask = double_int_mask (bits);
1255
1256   return build_int_cst_wide (type, mask.low, mask.high);
1257 }
1258
1259 /* Checks that X is integer constant that can be expressed in (unsigned)
1260    HOST_WIDE_INT without loss of precision.  */
1261
1262 bool
1263 cst_and_fits_in_hwi (const_tree x)
1264 {
1265   if (TREE_CODE (x) != INTEGER_CST)
1266     return false;
1267
1268   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1269     return false;
1270
1271   return (TREE_INT_CST_HIGH (x) == 0
1272           || TREE_INT_CST_HIGH (x) == -1);
1273 }
1274
1275 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1276    are in a list pointed to by VALS.  */
1277
1278 tree
1279 build_vector (tree type, tree vals)
1280 {
1281   tree v = make_node (VECTOR_CST);
1282   int over = 0;
1283   tree link;
1284
1285   TREE_VECTOR_CST_ELTS (v) = vals;
1286   TREE_TYPE (v) = type;
1287
1288   /* Iterate through elements and check for overflow.  */
1289   for (link = vals; link; link = TREE_CHAIN (link))
1290     {
1291       tree value = TREE_VALUE (link);
1292
1293       /* Don't crash if we get an address constant.  */
1294       if (!CONSTANT_CLASS_P (value))
1295         continue;
1296
1297       over |= TREE_OVERFLOW (value);
1298     }
1299
1300   TREE_OVERFLOW (v) = over;
1301   return v;
1302 }
1303
1304 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1305    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1306
1307 tree
1308 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1309 {
1310   tree list = NULL_TREE;
1311   unsigned HOST_WIDE_INT idx;
1312   tree value;
1313
1314   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1315     list = tree_cons (NULL_TREE, value, list);
1316   return build_vector (type, nreverse (list));
1317 }
1318
1319 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1320    are in the VEC pointed to by VALS.  */
1321 tree
1322 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1323 {
1324   tree c = make_node (CONSTRUCTOR);
1325   unsigned int i;
1326   constructor_elt *elt;
1327   bool constant_p = true;
1328
1329   TREE_TYPE (c) = type;
1330   CONSTRUCTOR_ELTS (c) = vals;
1331
1332   for (i = 0; VEC_iterate (constructor_elt, vals, i, elt); i++)
1333     if (!TREE_CONSTANT (elt->value))
1334       {
1335         constant_p = false;
1336         break;
1337       }
1338
1339   TREE_CONSTANT (c) = constant_p;
1340
1341   return c;
1342 }
1343
1344 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1345    INDEX and VALUE.  */
1346 tree
1347 build_constructor_single (tree type, tree index, tree value)
1348 {
1349   VEC(constructor_elt,gc) *v;
1350   constructor_elt *elt;
1351
1352   v = VEC_alloc (constructor_elt, gc, 1);
1353   elt = VEC_quick_push (constructor_elt, v, NULL);
1354   elt->index = index;
1355   elt->value = value;
1356
1357   return build_constructor (type, v);
1358 }
1359
1360
1361 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1362    are in a list pointed to by VALS.  */
1363 tree
1364 build_constructor_from_list (tree type, tree vals)
1365 {
1366   tree t;
1367   VEC(constructor_elt,gc) *v = NULL;
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         CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1374     }
1375
1376   return build_constructor (type, v);
1377 }
1378
1379 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1380
1381 tree
1382 build_fixed (tree type, FIXED_VALUE_TYPE f)
1383 {
1384   tree v;
1385   FIXED_VALUE_TYPE *fp;
1386
1387   v = make_node (FIXED_CST);
1388   fp = GGC_NEW (FIXED_VALUE_TYPE);
1389   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1390
1391   TREE_TYPE (v) = type;
1392   TREE_FIXED_CST_PTR (v) = fp;
1393   return v;
1394 }
1395
1396 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1397
1398 tree
1399 build_real (tree type, REAL_VALUE_TYPE d)
1400 {
1401   tree v;
1402   REAL_VALUE_TYPE *dp;
1403   int overflow = 0;
1404
1405   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1406      Consider doing it via real_convert now.  */
1407
1408   v = make_node (REAL_CST);
1409   dp = GGC_NEW (REAL_VALUE_TYPE);
1410   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1411
1412   TREE_TYPE (v) = type;
1413   TREE_REAL_CST_PTR (v) = dp;
1414   TREE_OVERFLOW (v) = overflow;
1415   return v;
1416 }
1417
1418 /* Return a new REAL_CST node whose type is TYPE
1419    and whose value is the integer value of the INTEGER_CST node I.  */
1420
1421 REAL_VALUE_TYPE
1422 real_value_from_int_cst (const_tree type, const_tree i)
1423 {
1424   REAL_VALUE_TYPE d;
1425
1426   /* Clear all bits of the real value type so that we can later do
1427      bitwise comparisons to see if two values are the same.  */
1428   memset (&d, 0, sizeof d);
1429
1430   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1431                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1432                      TYPE_UNSIGNED (TREE_TYPE (i)));
1433   return d;
1434 }
1435
1436 /* Given a tree representing an integer constant I, return a tree
1437    representing the same value as a floating-point constant of type TYPE.  */
1438
1439 tree
1440 build_real_from_int_cst (tree type, const_tree i)
1441 {
1442   tree v;
1443   int overflow = TREE_OVERFLOW (i);
1444
1445   v = build_real (type, real_value_from_int_cst (type, i));
1446
1447   TREE_OVERFLOW (v) |= overflow;
1448   return v;
1449 }
1450
1451 /* Return a newly constructed STRING_CST node whose value is
1452    the LEN characters at STR.
1453    The TREE_TYPE is not initialized.  */
1454
1455 tree
1456 build_string (int len, const char *str)
1457 {
1458   tree s;
1459   size_t length;
1460
1461   /* Do not waste bytes provided by padding of struct tree_string.  */
1462   length = len + offsetof (struct tree_string, str) + 1;
1463
1464 #ifdef GATHER_STATISTICS
1465   tree_node_counts[(int) c_kind]++;
1466   tree_node_sizes[(int) c_kind] += length;
1467 #endif
1468
1469   s = ggc_alloc_tree (length);
1470
1471   memset (s, 0, sizeof (struct tree_common));
1472   TREE_SET_CODE (s, STRING_CST);
1473   TREE_CONSTANT (s) = 1;
1474   TREE_STRING_LENGTH (s) = len;
1475   memcpy (s->string.str, str, len);
1476   s->string.str[len] = '\0';
1477
1478   return s;
1479 }
1480
1481 /* Return a newly constructed COMPLEX_CST node whose value is
1482    specified by the real and imaginary parts REAL and IMAG.
1483    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1484    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1485
1486 tree
1487 build_complex (tree type, tree real, tree imag)
1488 {
1489   tree t = make_node (COMPLEX_CST);
1490
1491   TREE_REALPART (t) = real;
1492   TREE_IMAGPART (t) = imag;
1493   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1494   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1495   return t;
1496 }
1497
1498 /* Return a constant of arithmetic type TYPE which is the
1499    multiplicative identity of the set TYPE.  */
1500
1501 tree
1502 build_one_cst (tree type)
1503 {
1504   switch (TREE_CODE (type))
1505     {
1506     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1507     case POINTER_TYPE: case REFERENCE_TYPE:
1508     case OFFSET_TYPE:
1509       return build_int_cst (type, 1);
1510
1511     case REAL_TYPE:
1512       return build_real (type, dconst1);
1513
1514     case FIXED_POINT_TYPE:
1515       /* We can only generate 1 for accum types.  */
1516       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1517       return build_fixed (type, FCONST1(TYPE_MODE (type)));
1518
1519     case VECTOR_TYPE:
1520       {
1521         tree scalar, cst;
1522         int i;
1523
1524         scalar = build_one_cst (TREE_TYPE (type));
1525
1526         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1527         cst = NULL_TREE;
1528         for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1529           cst = tree_cons (NULL_TREE, scalar, cst);
1530
1531         return build_vector (type, cst);
1532       }
1533
1534     case COMPLEX_TYPE:
1535       return build_complex (type,
1536                             build_one_cst (TREE_TYPE (type)),
1537                             fold_convert (TREE_TYPE (type), integer_zero_node));
1538
1539     default:
1540       gcc_unreachable ();
1541     }
1542 }
1543
1544 /* Build a BINFO with LEN language slots.  */
1545
1546 tree
1547 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1548 {
1549   tree t;
1550   size_t length = (offsetof (struct tree_binfo, base_binfos)
1551                    + VEC_embedded_size (tree, base_binfos));
1552
1553 #ifdef GATHER_STATISTICS
1554   tree_node_counts[(int) binfo_kind]++;
1555   tree_node_sizes[(int) binfo_kind] += length;
1556 #endif
1557
1558   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1559
1560   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1561
1562   TREE_SET_CODE (t, TREE_BINFO);
1563
1564   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1565
1566   return t;
1567 }
1568
1569
1570 /* Build a newly constructed TREE_VEC node of length LEN.  */
1571
1572 tree
1573 make_tree_vec_stat (int len MEM_STAT_DECL)
1574 {
1575   tree t;
1576   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1577
1578 #ifdef GATHER_STATISTICS
1579   tree_node_counts[(int) vec_kind]++;
1580   tree_node_sizes[(int) vec_kind] += length;
1581 #endif
1582
1583   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1584
1585   memset (t, 0, length);
1586
1587   TREE_SET_CODE (t, TREE_VEC);
1588   TREE_VEC_LENGTH (t) = len;
1589
1590   return t;
1591 }
1592 \f
1593 /* Return 1 if EXPR is the integer constant zero or a complex constant
1594    of zero.  */
1595
1596 int
1597 integer_zerop (const_tree expr)
1598 {
1599   STRIP_NOPS (expr);
1600
1601   return ((TREE_CODE (expr) == INTEGER_CST
1602            && TREE_INT_CST_LOW (expr) == 0
1603            && TREE_INT_CST_HIGH (expr) == 0)
1604           || (TREE_CODE (expr) == COMPLEX_CST
1605               && integer_zerop (TREE_REALPART (expr))
1606               && integer_zerop (TREE_IMAGPART (expr))));
1607 }
1608
1609 /* Return 1 if EXPR is the integer constant one or the corresponding
1610    complex constant.  */
1611
1612 int
1613 integer_onep (const_tree expr)
1614 {
1615   STRIP_NOPS (expr);
1616
1617   return ((TREE_CODE (expr) == INTEGER_CST
1618            && TREE_INT_CST_LOW (expr) == 1
1619            && TREE_INT_CST_HIGH (expr) == 0)
1620           || (TREE_CODE (expr) == COMPLEX_CST
1621               && integer_onep (TREE_REALPART (expr))
1622               && integer_zerop (TREE_IMAGPART (expr))));
1623 }
1624
1625 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1626    it contains.  Likewise for the corresponding complex constant.  */
1627
1628 int
1629 integer_all_onesp (const_tree expr)
1630 {
1631   int prec;
1632   int uns;
1633
1634   STRIP_NOPS (expr);
1635
1636   if (TREE_CODE (expr) == COMPLEX_CST
1637       && integer_all_onesp (TREE_REALPART (expr))
1638       && integer_zerop (TREE_IMAGPART (expr)))
1639     return 1;
1640
1641   else if (TREE_CODE (expr) != INTEGER_CST)
1642     return 0;
1643
1644   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1645   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1646       && TREE_INT_CST_HIGH (expr) == -1)
1647     return 1;
1648   if (!uns)
1649     return 0;
1650
1651   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1652      actual bits, not the (arbitrary) range of the type.  */
1653   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1654   if (prec >= HOST_BITS_PER_WIDE_INT)
1655     {
1656       HOST_WIDE_INT high_value;
1657       int shift_amount;
1658
1659       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1660
1661       /* Can not handle precisions greater than twice the host int size.  */
1662       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1663       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1664         /* Shifting by the host word size is undefined according to the ANSI
1665            standard, so we must handle this as a special case.  */
1666         high_value = -1;
1667       else
1668         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1669
1670       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1671               && TREE_INT_CST_HIGH (expr) == high_value);
1672     }
1673   else
1674     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1675 }
1676
1677 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1678    one bit on).  */
1679
1680 int
1681 integer_pow2p (const_tree expr)
1682 {
1683   int prec;
1684   HOST_WIDE_INT high, low;
1685
1686   STRIP_NOPS (expr);
1687
1688   if (TREE_CODE (expr) == COMPLEX_CST
1689       && integer_pow2p (TREE_REALPART (expr))
1690       && integer_zerop (TREE_IMAGPART (expr)))
1691     return 1;
1692
1693   if (TREE_CODE (expr) != INTEGER_CST)
1694     return 0;
1695
1696   prec = TYPE_PRECISION (TREE_TYPE (expr));
1697   high = TREE_INT_CST_HIGH (expr);
1698   low = TREE_INT_CST_LOW (expr);
1699
1700   /* First clear all bits that are beyond the type's precision in case
1701      we've been sign extended.  */
1702
1703   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1704     ;
1705   else if (prec > HOST_BITS_PER_WIDE_INT)
1706     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1707   else
1708     {
1709       high = 0;
1710       if (prec < HOST_BITS_PER_WIDE_INT)
1711         low &= ~((HOST_WIDE_INT) (-1) << prec);
1712     }
1713
1714   if (high == 0 && low == 0)
1715     return 0;
1716
1717   return ((high == 0 && (low & (low - 1)) == 0)
1718           || (low == 0 && (high & (high - 1)) == 0));
1719 }
1720
1721 /* Return 1 if EXPR is an integer constant other than zero or a
1722    complex constant other than zero.  */
1723
1724 int
1725 integer_nonzerop (const_tree expr)
1726 {
1727   STRIP_NOPS (expr);
1728
1729   return ((TREE_CODE (expr) == INTEGER_CST
1730            && (TREE_INT_CST_LOW (expr) != 0
1731                || TREE_INT_CST_HIGH (expr) != 0))
1732           || (TREE_CODE (expr) == COMPLEX_CST
1733               && (integer_nonzerop (TREE_REALPART (expr))
1734                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1735 }
1736
1737 /* Return 1 if EXPR is the fixed-point constant zero.  */
1738
1739 int
1740 fixed_zerop (const_tree expr)
1741 {
1742   return (TREE_CODE (expr) == FIXED_CST
1743           && double_int_zero_p (TREE_FIXED_CST (expr).data));
1744 }
1745
1746 /* Return the power of two represented by a tree node known to be a
1747    power of two.  */
1748
1749 int
1750 tree_log2 (const_tree expr)
1751 {
1752   int prec;
1753   HOST_WIDE_INT high, low;
1754
1755   STRIP_NOPS (expr);
1756
1757   if (TREE_CODE (expr) == COMPLEX_CST)
1758     return tree_log2 (TREE_REALPART (expr));
1759
1760   prec = TYPE_PRECISION (TREE_TYPE (expr));
1761   high = TREE_INT_CST_HIGH (expr);
1762   low = TREE_INT_CST_LOW (expr);
1763
1764   /* First clear all bits that are beyond the type's precision in case
1765      we've been sign extended.  */
1766
1767   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1768     ;
1769   else if (prec > HOST_BITS_PER_WIDE_INT)
1770     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1771   else
1772     {
1773       high = 0;
1774       if (prec < HOST_BITS_PER_WIDE_INT)
1775         low &= ~((HOST_WIDE_INT) (-1) << prec);
1776     }
1777
1778   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1779           : exact_log2 (low));
1780 }
1781
1782 /* Similar, but return the largest integer Y such that 2 ** Y is less
1783    than or equal to EXPR.  */
1784
1785 int
1786 tree_floor_log2 (const_tree expr)
1787 {
1788   int prec;
1789   HOST_WIDE_INT high, low;
1790
1791   STRIP_NOPS (expr);
1792
1793   if (TREE_CODE (expr) == COMPLEX_CST)
1794     return tree_log2 (TREE_REALPART (expr));
1795
1796   prec = TYPE_PRECISION (TREE_TYPE (expr));
1797   high = TREE_INT_CST_HIGH (expr);
1798   low = TREE_INT_CST_LOW (expr);
1799
1800   /* First clear all bits that are beyond the type's precision in case
1801      we've been sign extended.  Ignore if type's precision hasn't been set
1802      since what we are doing is setting it.  */
1803
1804   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1805     ;
1806   else if (prec > HOST_BITS_PER_WIDE_INT)
1807     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1808   else
1809     {
1810       high = 0;
1811       if (prec < HOST_BITS_PER_WIDE_INT)
1812         low &= ~((HOST_WIDE_INT) (-1) << prec);
1813     }
1814
1815   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1816           : floor_log2 (low));
1817 }
1818
1819 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1820    decimal float constants, so don't return 1 for them.  */
1821
1822 int
1823 real_zerop (const_tree expr)
1824 {
1825   STRIP_NOPS (expr);
1826
1827   return ((TREE_CODE (expr) == REAL_CST
1828            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1829            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1830           || (TREE_CODE (expr) == COMPLEX_CST
1831               && real_zerop (TREE_REALPART (expr))
1832               && real_zerop (TREE_IMAGPART (expr))));
1833 }
1834
1835 /* Return 1 if EXPR is the real constant one in real or complex form.
1836    Trailing zeroes matter for decimal float constants, so don't return
1837    1 for them.  */
1838
1839 int
1840 real_onep (const_tree expr)
1841 {
1842   STRIP_NOPS (expr);
1843
1844   return ((TREE_CODE (expr) == REAL_CST
1845            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1846            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1847           || (TREE_CODE (expr) == COMPLEX_CST
1848               && real_onep (TREE_REALPART (expr))
1849               && real_zerop (TREE_IMAGPART (expr))));
1850 }
1851
1852 /* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1853    for decimal float constants, so don't return 1 for them.  */
1854
1855 int
1856 real_twop (const_tree expr)
1857 {
1858   STRIP_NOPS (expr);
1859
1860   return ((TREE_CODE (expr) == REAL_CST
1861            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1862            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1863           || (TREE_CODE (expr) == COMPLEX_CST
1864               && real_twop (TREE_REALPART (expr))
1865               && real_zerop (TREE_IMAGPART (expr))));
1866 }
1867
1868 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1869    matter for decimal float constants, so don't return 1 for them.  */
1870
1871 int
1872 real_minus_onep (const_tree expr)
1873 {
1874   STRIP_NOPS (expr);
1875
1876   return ((TREE_CODE (expr) == REAL_CST
1877            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1878            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1879           || (TREE_CODE (expr) == COMPLEX_CST
1880               && real_minus_onep (TREE_REALPART (expr))
1881               && real_zerop (TREE_IMAGPART (expr))));
1882 }
1883
1884 /* Nonzero if EXP is a constant or a cast of a constant.  */
1885
1886 int
1887 really_constant_p (const_tree exp)
1888 {
1889   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1890   while (CONVERT_EXPR_P (exp)
1891          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1892     exp = TREE_OPERAND (exp, 0);
1893   return TREE_CONSTANT (exp);
1894 }
1895 \f
1896 /* Return first list element whose TREE_VALUE is ELEM.
1897    Return 0 if ELEM is not in LIST.  */
1898
1899 tree
1900 value_member (tree elem, tree list)
1901 {
1902   while (list)
1903     {
1904       if (elem == TREE_VALUE (list))
1905         return list;
1906       list = TREE_CHAIN (list);
1907     }
1908   return NULL_TREE;
1909 }
1910
1911 /* Return first list element whose TREE_PURPOSE is ELEM.
1912    Return 0 if ELEM is not in LIST.  */
1913
1914 tree
1915 purpose_member (const_tree elem, tree list)
1916 {
1917   while (list)
1918     {
1919       if (elem == TREE_PURPOSE (list))
1920         return list;
1921       list = TREE_CHAIN (list);
1922     }
1923   return NULL_TREE;
1924 }
1925
1926 /* Returns element number IDX (zero-origin) of chain CHAIN, or
1927    NULL_TREE.  */
1928
1929 tree
1930 chain_index (int idx, tree chain)
1931 {
1932   for (; chain && idx > 0; --idx)
1933     chain = TREE_CHAIN (chain);
1934   return chain;
1935 }
1936
1937 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1938
1939 int
1940 chain_member (const_tree elem, const_tree chain)
1941 {
1942   while (chain)
1943     {
1944       if (elem == chain)
1945         return 1;
1946       chain = TREE_CHAIN (chain);
1947     }
1948
1949   return 0;
1950 }
1951
1952 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1953    We expect a null pointer to mark the end of the chain.
1954    This is the Lisp primitive `length'.  */
1955
1956 int
1957 list_length (const_tree t)
1958 {
1959   const_tree p = t;
1960 #ifdef ENABLE_TREE_CHECKING
1961   const_tree q = t;
1962 #endif
1963   int len = 0;
1964
1965   while (p)
1966     {
1967       p = TREE_CHAIN (p);
1968 #ifdef ENABLE_TREE_CHECKING
1969       if (len % 2)
1970         q = TREE_CHAIN (q);
1971       gcc_assert (p != q);
1972 #endif
1973       len++;
1974     }
1975
1976   return len;
1977 }
1978
1979 /* Returns the number of FIELD_DECLs in TYPE.  */
1980
1981 int
1982 fields_length (const_tree type)
1983 {
1984   tree t = TYPE_FIELDS (type);
1985   int count = 0;
1986
1987   for (; t; t = TREE_CHAIN (t))
1988     if (TREE_CODE (t) == FIELD_DECL)
1989       ++count;
1990
1991   return count;
1992 }
1993
1994 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
1995    UNION_TYPE TYPE, or NULL_TREE if none.  */
1996
1997 tree
1998 first_field (const_tree type)
1999 {
2000   tree t = TYPE_FIELDS (type);
2001   while (t && TREE_CODE (t) != FIELD_DECL)
2002     t = TREE_CHAIN (t);
2003   return t;
2004 }
2005
2006 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2007    by modifying the last node in chain 1 to point to chain 2.
2008    This is the Lisp primitive `nconc'.  */
2009
2010 tree
2011 chainon (tree op1, tree op2)
2012 {
2013   tree t1;
2014
2015   if (!op1)
2016     return op2;
2017   if (!op2)
2018     return op1;
2019
2020   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2021     continue;
2022   TREE_CHAIN (t1) = op2;
2023
2024 #ifdef ENABLE_TREE_CHECKING
2025   {
2026     tree t2;
2027     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2028       gcc_assert (t2 != t1);
2029   }
2030 #endif
2031
2032   return op1;
2033 }
2034
2035 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2036
2037 tree
2038 tree_last (tree chain)
2039 {
2040   tree next;
2041   if (chain)
2042     while ((next = TREE_CHAIN (chain)))
2043       chain = next;
2044   return chain;
2045 }
2046
2047 /* Reverse the order of elements in the chain T,
2048    and return the new head of the chain (old last element).  */
2049
2050 tree
2051 nreverse (tree t)
2052 {
2053   tree prev = 0, decl, next;
2054   for (decl = t; decl; decl = next)
2055     {
2056       next = TREE_CHAIN (decl);
2057       TREE_CHAIN (decl) = prev;
2058       prev = decl;
2059     }
2060   return prev;
2061 }
2062 \f
2063 /* Return a newly created TREE_LIST node whose
2064    purpose and value fields are PARM and VALUE.  */
2065
2066 tree
2067 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2068 {
2069   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2070   TREE_PURPOSE (t) = parm;
2071   TREE_VALUE (t) = value;
2072   return t;
2073 }
2074
2075 /* Build a chain of TREE_LIST nodes from a vector.  */
2076
2077 tree
2078 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2079 {
2080   tree ret = NULL_TREE;
2081   tree *pp = &ret;
2082   unsigned int i;
2083   tree t;
2084   for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
2085     {
2086       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2087       pp = &TREE_CHAIN (*pp);
2088     }
2089   return ret;
2090 }
2091
2092 /* Return a newly created TREE_LIST node whose
2093    purpose and value fields are PURPOSE and VALUE
2094    and whose TREE_CHAIN is CHAIN.  */
2095
2096 tree
2097 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2098 {
2099   tree node;
2100
2101   node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
2102
2103   memset (node, 0, sizeof (struct tree_common));
2104
2105 #ifdef GATHER_STATISTICS
2106   tree_node_counts[(int) x_kind]++;
2107   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2108 #endif
2109
2110   TREE_SET_CODE (node, TREE_LIST);
2111   TREE_CHAIN (node) = chain;
2112   TREE_PURPOSE (node) = purpose;
2113   TREE_VALUE (node) = value;
2114   return node;
2115 }
2116
2117 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2118    trees.  */
2119
2120 VEC(tree,gc) *
2121 ctor_to_vec (tree ctor)
2122 {
2123   VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2124   unsigned int ix;
2125   tree val;
2126
2127   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2128     VEC_quick_push (tree, vec, val);
2129
2130   return vec;
2131 }
2132 \f
2133 /* Return the size nominally occupied by an object of type TYPE
2134    when it resides in memory.  The value is measured in units of bytes,
2135    and its data type is that normally used for type sizes
2136    (which is the first type created by make_signed_type or
2137    make_unsigned_type).  */
2138
2139 tree
2140 size_in_bytes (const_tree type)
2141 {
2142   tree t;
2143
2144   if (type == error_mark_node)
2145     return integer_zero_node;
2146
2147   type = TYPE_MAIN_VARIANT (type);
2148   t = TYPE_SIZE_UNIT (type);
2149
2150   if (t == 0)
2151     {
2152       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2153       return size_zero_node;
2154     }
2155
2156   return t;
2157 }
2158
2159 /* Return the size of TYPE (in bytes) as a wide integer
2160    or return -1 if the size can vary or is larger than an integer.  */
2161
2162 HOST_WIDE_INT
2163 int_size_in_bytes (const_tree type)
2164 {
2165   tree t;
2166
2167   if (type == error_mark_node)
2168     return 0;
2169
2170   type = TYPE_MAIN_VARIANT (type);
2171   t = TYPE_SIZE_UNIT (type);
2172   if (t == 0
2173       || TREE_CODE (t) != INTEGER_CST
2174       || TREE_INT_CST_HIGH (t) != 0
2175       /* If the result would appear negative, it's too big to represent.  */
2176       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2177     return -1;
2178
2179   return TREE_INT_CST_LOW (t);
2180 }
2181
2182 /* Return the maximum size of TYPE (in bytes) as a wide integer
2183    or return -1 if the size can vary or is larger than an integer.  */
2184
2185 HOST_WIDE_INT
2186 max_int_size_in_bytes (const_tree type)
2187 {
2188   HOST_WIDE_INT size = -1;
2189   tree size_tree;
2190
2191   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2192
2193   if (TREE_CODE (type) == ARRAY_TYPE)
2194     {
2195       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2196
2197       if (size_tree && host_integerp (size_tree, 1))
2198         size = tree_low_cst (size_tree, 1);
2199     }
2200
2201   /* If we still haven't been able to get a size, see if the language
2202      can compute a maximum size.  */
2203
2204   if (size == -1)
2205     {
2206       size_tree = lang_hooks.types.max_size (type);
2207
2208       if (size_tree && host_integerp (size_tree, 1))
2209         size = tree_low_cst (size_tree, 1);
2210     }
2211
2212   return size;
2213 }
2214
2215 /* Returns a tree for the size of EXP in bytes.  */
2216
2217 tree
2218 tree_expr_size (const_tree exp)
2219 {
2220   if (DECL_P (exp)
2221       && DECL_SIZE_UNIT (exp) != 0)
2222     return DECL_SIZE_UNIT (exp);
2223   else
2224     return size_in_bytes (TREE_TYPE (exp));
2225 }
2226 \f
2227 /* Return the bit position of FIELD, in bits from the start of the record.
2228    This is a tree of type bitsizetype.  */
2229
2230 tree
2231 bit_position (const_tree field)
2232 {
2233   return bit_from_pos (DECL_FIELD_OFFSET (field),
2234                        DECL_FIELD_BIT_OFFSET (field));
2235 }
2236
2237 /* Likewise, but return as an integer.  It must be representable in
2238    that way (since it could be a signed value, we don't have the
2239    option of returning -1 like int_size_in_byte can.  */
2240
2241 HOST_WIDE_INT
2242 int_bit_position (const_tree field)
2243 {
2244   return tree_low_cst (bit_position (field), 0);
2245 }
2246 \f
2247 /* Return the byte position of FIELD, in bytes from the start of the record.
2248    This is a tree of type sizetype.  */
2249
2250 tree
2251 byte_position (const_tree field)
2252 {
2253   return byte_from_pos (DECL_FIELD_OFFSET (field),
2254                         DECL_FIELD_BIT_OFFSET (field));
2255 }
2256
2257 /* Likewise, but return as an integer.  It must be representable in
2258    that way (since it could be a signed value, we don't have the
2259    option of returning -1 like int_size_in_byte can.  */
2260
2261 HOST_WIDE_INT
2262 int_byte_position (const_tree field)
2263 {
2264   return tree_low_cst (byte_position (field), 0);
2265 }
2266 \f
2267 /* Return the strictest alignment, in bits, that T is known to have.  */
2268
2269 unsigned int
2270 expr_align (const_tree t)
2271 {
2272   unsigned int align0, align1;
2273
2274   switch (TREE_CODE (t))
2275     {
2276     CASE_CONVERT:  case NON_LVALUE_EXPR:
2277       /* If we have conversions, we know that the alignment of the
2278          object must meet each of the alignments of the types.  */
2279       align0 = expr_align (TREE_OPERAND (t, 0));
2280       align1 = TYPE_ALIGN (TREE_TYPE (t));
2281       return MAX (align0, align1);
2282
2283     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2284     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2285     case CLEANUP_POINT_EXPR:
2286       /* These don't change the alignment of an object.  */
2287       return expr_align (TREE_OPERAND (t, 0));
2288
2289     case COND_EXPR:
2290       /* The best we can do is say that the alignment is the least aligned
2291          of the two arms.  */
2292       align0 = expr_align (TREE_OPERAND (t, 1));
2293       align1 = expr_align (TREE_OPERAND (t, 2));
2294       return MIN (align0, align1);
2295
2296       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2297          meaningfully, it's always 1.  */
2298     case LABEL_DECL:     case CONST_DECL:
2299     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2300     case FUNCTION_DECL:
2301       gcc_assert (DECL_ALIGN (t) != 0);
2302       return DECL_ALIGN (t);
2303
2304     default:
2305       break;
2306     }
2307
2308   /* Otherwise take the alignment from that of the type.  */
2309   return TYPE_ALIGN (TREE_TYPE (t));
2310 }
2311 \f
2312 /* Return, as a tree node, the number of elements for TYPE (which is an
2313    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2314
2315 tree
2316 array_type_nelts (const_tree type)
2317 {
2318   tree index_type, min, max;
2319
2320   /* If they did it with unspecified bounds, then we should have already
2321      given an error about it before we got here.  */
2322   if (! TYPE_DOMAIN (type))
2323     return error_mark_node;
2324
2325   index_type = TYPE_DOMAIN (type);
2326   min = TYPE_MIN_VALUE (index_type);
2327   max = TYPE_MAX_VALUE (index_type);
2328
2329   return (integer_zerop (min)
2330           ? max
2331           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2332 }
2333 \f
2334 /* If arg is static -- a reference to an object in static storage -- then
2335    return the object.  This is not the same as the C meaning of `static'.
2336    If arg isn't static, return NULL.  */
2337
2338 tree
2339 staticp (tree arg)
2340 {
2341   switch (TREE_CODE (arg))
2342     {
2343     case FUNCTION_DECL:
2344       /* Nested functions are static, even though taking their address will
2345          involve a trampoline as we unnest the nested function and create
2346          the trampoline on the tree level.  */
2347       return arg;
2348
2349     case VAR_DECL:
2350       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2351               && ! DECL_THREAD_LOCAL_P (arg)
2352               && ! DECL_DLLIMPORT_P (arg)
2353               ? arg : NULL);
2354
2355     case CONST_DECL:
2356       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2357               ? arg : NULL);
2358
2359     case CONSTRUCTOR:
2360       return TREE_STATIC (arg) ? arg : NULL;
2361
2362     case LABEL_DECL:
2363     case STRING_CST:
2364       return arg;
2365
2366     case COMPONENT_REF:
2367       /* If the thing being referenced is not a field, then it is
2368          something language specific.  */
2369       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2370
2371       /* If we are referencing a bitfield, we can't evaluate an
2372          ADDR_EXPR at compile time and so it isn't a constant.  */
2373       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2374         return NULL;
2375
2376       return staticp (TREE_OPERAND (arg, 0));
2377
2378     case BIT_FIELD_REF:
2379       return NULL;
2380
2381     case MISALIGNED_INDIRECT_REF:
2382     case ALIGN_INDIRECT_REF:
2383     case INDIRECT_REF:
2384       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2385
2386     case ARRAY_REF:
2387     case ARRAY_RANGE_REF:
2388       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2389           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2390         return staticp (TREE_OPERAND (arg, 0));
2391       else
2392         return NULL;
2393
2394     case COMPOUND_LITERAL_EXPR:
2395       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2396
2397     default:
2398       return NULL;
2399     }
2400 }
2401
2402 \f
2403
2404
2405 /* Return whether OP is a DECL whose address is function-invariant.  */
2406
2407 bool
2408 decl_address_invariant_p (const_tree op)
2409 {
2410   /* The conditions below are slightly less strict than the one in
2411      staticp.  */
2412
2413   switch (TREE_CODE (op))
2414     {
2415     case PARM_DECL:
2416     case RESULT_DECL:
2417     case LABEL_DECL:
2418     case FUNCTION_DECL:
2419       return true;
2420
2421     case VAR_DECL:
2422       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2423            && !DECL_DLLIMPORT_P (op))
2424           || DECL_THREAD_LOCAL_P (op)
2425           || DECL_CONTEXT (op) == current_function_decl
2426           || decl_function_context (op) == current_function_decl)
2427         return true;
2428       break;
2429
2430     case CONST_DECL:
2431       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2432           || decl_function_context (op) == current_function_decl)
2433         return true;
2434       break;
2435
2436     default:
2437       break;
2438     }
2439
2440   return false;
2441 }
2442
2443 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2444
2445 bool
2446 decl_address_ip_invariant_p (const_tree op)
2447 {
2448   /* The conditions below are slightly less strict than the one in
2449      staticp.  */
2450
2451   switch (TREE_CODE (op))
2452     {
2453     case LABEL_DECL:
2454     case FUNCTION_DECL:
2455     case STRING_CST:
2456       return true;
2457
2458     case VAR_DECL:
2459       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2460            && !DECL_DLLIMPORT_P (op))
2461           || DECL_THREAD_LOCAL_P (op))
2462         return true;
2463       break;
2464
2465     case CONST_DECL:
2466       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2467         return true;
2468       break;
2469
2470     default:
2471       break;
2472     }
2473
2474   return false;
2475 }
2476
2477
2478 /* Return true if T is function-invariant (internal function, does
2479    not handle arithmetic; that's handled in skip_simple_arithmetic and
2480    tree_invariant_p).  */
2481
2482 static bool tree_invariant_p (tree t);
2483
2484 static bool
2485 tree_invariant_p_1 (tree t)
2486 {
2487   tree op;
2488
2489   if (TREE_CONSTANT (t)
2490       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2491     return true;
2492
2493   switch (TREE_CODE (t))
2494     {
2495     case SAVE_EXPR:
2496       return true;
2497
2498     case ADDR_EXPR:
2499       op = TREE_OPERAND (t, 0);
2500       while (handled_component_p (op))
2501         {
2502           switch (TREE_CODE (op))
2503             {
2504             case ARRAY_REF:
2505             case ARRAY_RANGE_REF:
2506               if (!tree_invariant_p (TREE_OPERAND (op, 1))
2507                   || TREE_OPERAND (op, 2) != NULL_TREE
2508                   || TREE_OPERAND (op, 3) != NULL_TREE)
2509                 return false;
2510               break;
2511
2512             case COMPONENT_REF:
2513               if (TREE_OPERAND (op, 2) != NULL_TREE)
2514                 return false;
2515               break;
2516
2517             default:;
2518             }
2519           op = TREE_OPERAND (op, 0);
2520         }
2521
2522       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2523
2524     default:
2525       break;
2526     }
2527
2528   return false;
2529 }
2530
2531 /* Return true if T is function-invariant.  */
2532
2533 static bool
2534 tree_invariant_p (tree t)
2535 {
2536   tree inner = skip_simple_arithmetic (t);
2537   return tree_invariant_p_1 (inner);
2538 }
2539
2540 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2541    Do this to any expression which may be used in more than one place,
2542    but must be evaluated only once.
2543
2544    Normally, expand_expr would reevaluate the expression each time.
2545    Calling save_expr produces something that is evaluated and recorded
2546    the first time expand_expr is called on it.  Subsequent calls to
2547    expand_expr just reuse the recorded value.
2548
2549    The call to expand_expr that generates code that actually computes
2550    the value is the first call *at compile time*.  Subsequent calls
2551    *at compile time* generate code to use the saved value.
2552    This produces correct result provided that *at run time* control
2553    always flows through the insns made by the first expand_expr
2554    before reaching the other places where the save_expr was evaluated.
2555    You, the caller of save_expr, must make sure this is so.
2556
2557    Constants, and certain read-only nodes, are returned with no
2558    SAVE_EXPR because that is safe.  Expressions containing placeholders
2559    are not touched; see tree.def for an explanation of what these
2560    are used for.  */
2561
2562 tree
2563 save_expr (tree expr)
2564 {
2565   tree t = fold (expr);
2566   tree inner;
2567
2568   /* If the tree evaluates to a constant, then we don't want to hide that
2569      fact (i.e. this allows further folding, and direct checks for constants).
2570      However, a read-only object that has side effects cannot be bypassed.
2571      Since it is no problem to reevaluate literals, we just return the
2572      literal node.  */
2573   inner = skip_simple_arithmetic (t);
2574   if (TREE_CODE (inner) == ERROR_MARK)
2575     return inner;
2576
2577   if (tree_invariant_p_1 (inner))
2578     return t;
2579
2580   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2581      it means that the size or offset of some field of an object depends on
2582      the value within another field.
2583
2584      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2585      and some variable since it would then need to be both evaluated once and
2586      evaluated more than once.  Front-ends must assure this case cannot
2587      happen by surrounding any such subexpressions in their own SAVE_EXPR
2588      and forcing evaluation at the proper time.  */
2589   if (contains_placeholder_p (inner))
2590     return t;
2591
2592   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2593   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2594
2595   /* This expression might be placed ahead of a jump to ensure that the
2596      value was computed on both sides of the jump.  So make sure it isn't
2597      eliminated as dead.  */
2598   TREE_SIDE_EFFECTS (t) = 1;
2599   return t;
2600 }
2601
2602 /* Look inside EXPR and into any simple arithmetic operations.  Return
2603    the innermost non-arithmetic node.  */
2604
2605 tree
2606 skip_simple_arithmetic (tree expr)
2607 {
2608   tree inner;
2609
2610   /* We don't care about whether this can be used as an lvalue in this
2611      context.  */
2612   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2613     expr = TREE_OPERAND (expr, 0);
2614
2615   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2616      a constant, it will be more efficient to not make another SAVE_EXPR since
2617      it will allow better simplification and GCSE will be able to merge the
2618      computations if they actually occur.  */
2619   inner = expr;
2620   while (1)
2621     {
2622       if (UNARY_CLASS_P (inner))
2623         inner = TREE_OPERAND (inner, 0);
2624       else if (BINARY_CLASS_P (inner))
2625         {
2626           if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2627             inner = TREE_OPERAND (inner, 0);
2628           else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2629             inner = TREE_OPERAND (inner, 1);
2630           else
2631             break;
2632         }
2633       else
2634         break;
2635     }
2636
2637   return inner;
2638 }
2639
2640
2641 /* Return which tree structure is used by T.  */
2642
2643 enum tree_node_structure_enum
2644 tree_node_structure (const_tree t)
2645 {
2646   const enum tree_code code = TREE_CODE (t);
2647   return tree_node_structure_for_code (code);
2648 }
2649
2650 /* Set various status flags when building a CALL_EXPR object T.  */
2651
2652 static void
2653 process_call_operands (tree t)
2654 {
2655   bool side_effects = TREE_SIDE_EFFECTS (t);
2656   bool read_only = false;
2657   int i = call_expr_flags (t);
2658
2659   /* Calls have side-effects, except those to const or pure functions.  */
2660   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2661     side_effects = true;
2662   /* Propagate TREE_READONLY of arguments for const functions.  */
2663   if (i & ECF_CONST)
2664     read_only = true;
2665
2666   if (!side_effects || read_only)
2667     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2668       {
2669         tree op = TREE_OPERAND (t, i);
2670         if (op && TREE_SIDE_EFFECTS (op))
2671           side_effects = true;
2672         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2673           read_only = false;
2674       }
2675
2676   TREE_SIDE_EFFECTS (t) = side_effects;
2677   TREE_READONLY (t) = read_only;
2678 }
2679 \f
2680 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2681    or offset that depends on a field within a record.  */
2682
2683 bool
2684 contains_placeholder_p (const_tree exp)
2685 {
2686   enum tree_code code;
2687
2688   if (!exp)
2689     return 0;
2690
2691   code = TREE_CODE (exp);
2692   if (code == PLACEHOLDER_EXPR)
2693     return 1;
2694
2695   switch (TREE_CODE_CLASS (code))
2696     {
2697     case tcc_reference:
2698       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2699          position computations since they will be converted into a
2700          WITH_RECORD_EXPR involving the reference, which will assume
2701          here will be valid.  */
2702       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2703
2704     case tcc_exceptional:
2705       if (code == TREE_LIST)
2706         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2707                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2708       break;
2709
2710     case tcc_unary:
2711     case tcc_binary:
2712     case tcc_comparison:
2713     case tcc_expression:
2714       switch (code)
2715         {
2716         case COMPOUND_EXPR:
2717           /* Ignoring the first operand isn't quite right, but works best.  */
2718           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2719
2720         case COND_EXPR:
2721           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2722                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2723                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2724
2725         case SAVE_EXPR:
2726           /* The save_expr function never wraps anything containing
2727              a PLACEHOLDER_EXPR. */
2728           return 0;
2729
2730         default:
2731           break;
2732         }
2733
2734       switch (TREE_CODE_LENGTH (code))
2735         {
2736         case 1:
2737           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2738         case 2:
2739           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2740                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2741         default:
2742           return 0;
2743         }
2744
2745     case tcc_vl_exp:
2746       switch (code)
2747         {
2748         case CALL_EXPR:
2749           {
2750             const_tree arg;
2751             const_call_expr_arg_iterator iter;
2752             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2753               if (CONTAINS_PLACEHOLDER_P (arg))
2754                 return 1;
2755             return 0;
2756           }
2757         default:
2758           return 0;
2759         }
2760
2761     default:
2762       return 0;
2763     }
2764   return 0;
2765 }
2766
2767 /* Return true if any part of the computation of TYPE involves a
2768    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2769    (for QUAL_UNION_TYPE) and field positions.  */
2770
2771 static bool
2772 type_contains_placeholder_1 (const_tree type)
2773 {
2774   /* If the size contains a placeholder or the parent type (component type in
2775      the case of arrays) type involves a placeholder, this type does.  */
2776   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2777       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2778       || (TREE_TYPE (type) != 0
2779           && type_contains_placeholder_p (TREE_TYPE (type))))
2780     return true;
2781
2782   /* Now do type-specific checks.  Note that the last part of the check above
2783      greatly limits what we have to do below.  */
2784   switch (TREE_CODE (type))
2785     {
2786     case VOID_TYPE:
2787     case COMPLEX_TYPE:
2788     case ENUMERAL_TYPE:
2789     case BOOLEAN_TYPE:
2790     case POINTER_TYPE:
2791     case OFFSET_TYPE:
2792     case REFERENCE_TYPE:
2793     case METHOD_TYPE:
2794     case FUNCTION_TYPE:
2795     case VECTOR_TYPE:
2796       return false;
2797
2798     case INTEGER_TYPE:
2799     case REAL_TYPE:
2800     case FIXED_POINT_TYPE:
2801       /* Here we just check the bounds.  */
2802       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2803               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2804
2805     case ARRAY_TYPE:
2806       /* We're already checked the component type (TREE_TYPE), so just check
2807          the index type.  */
2808       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2809
2810     case RECORD_TYPE:
2811     case UNION_TYPE:
2812     case QUAL_UNION_TYPE:
2813       {
2814         tree field;
2815
2816         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2817           if (TREE_CODE (field) == FIELD_DECL
2818               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2819                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2820                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2821                   || type_contains_placeholder_p (TREE_TYPE (field))))
2822             return true;
2823
2824         return false;
2825       }
2826
2827     default:
2828       gcc_unreachable ();
2829     }
2830 }
2831
2832 bool
2833 type_contains_placeholder_p (tree type)
2834 {
2835   bool result;
2836
2837   /* If the contains_placeholder_bits field has been initialized,
2838      then we know the answer.  */
2839   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2840     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2841
2842   /* Indicate that we've seen this type node, and the answer is false.
2843      This is what we want to return if we run into recursion via fields.  */
2844   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2845
2846   /* Compute the real value.  */
2847   result = type_contains_placeholder_1 (type);
2848
2849   /* Store the real value.  */
2850   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2851
2852   return result;
2853 }
2854 \f
2855 /* Push tree EXP onto vector QUEUE if it is not already present.  */
2856
2857 static void
2858 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2859 {
2860   unsigned int i;
2861   tree iter;
2862
2863   for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
2864     if (simple_cst_equal (iter, exp) == 1)
2865       break;
2866
2867   if (!iter)
2868     VEC_safe_push (tree, heap, *queue, exp);
2869 }
2870
2871 /* Given a tree EXP, find all occurences of references to fields
2872    in a PLACEHOLDER_EXPR and place them in vector REFS without
2873    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2874    we assume here that EXP contains only arithmetic expressions
2875    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2876    argument list.  */
2877
2878 void
2879 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2880 {
2881   enum tree_code code = TREE_CODE (exp);
2882   tree inner;
2883   int i;
2884
2885   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2886   if (code == TREE_LIST)
2887     {
2888       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2889       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2890     }
2891   else if (code == COMPONENT_REF)
2892     {
2893       for (inner = TREE_OPERAND (exp, 0);
2894            REFERENCE_CLASS_P (inner);
2895            inner = TREE_OPERAND (inner, 0))
2896         ;
2897
2898       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2899         push_without_duplicates (exp, refs);
2900       else
2901         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2902    }
2903   else
2904     switch (TREE_CODE_CLASS (code))
2905       {
2906       case tcc_constant:
2907         break;
2908
2909       case tcc_declaration:
2910         /* Variables allocated to static storage can stay.  */
2911         if (!TREE_STATIC (exp))
2912           push_without_duplicates (exp, refs);
2913         break;
2914
2915       case tcc_expression:
2916         /* This is the pattern built in ada/make_aligning_type.  */
2917         if (code == ADDR_EXPR
2918             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2919           {
2920             push_without_duplicates (exp, refs);
2921             break;
2922           }
2923
2924         /* Fall through...  */
2925
2926       case tcc_exceptional:
2927       case tcc_unary:
2928       case tcc_binary:
2929       case tcc_comparison:
2930       case tcc_reference:
2931         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2932           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2933         break;
2934
2935       case tcc_vl_exp:
2936         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2937           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2938         break;
2939
2940       default:
2941         gcc_unreachable ();
2942       }
2943 }
2944
2945 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2946    return a tree with all occurrences of references to F in a
2947    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
2948    CONST_DECLs.  Note that we assume here that EXP contains only
2949    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
2950    occurring only in their argument list.  */
2951
2952 tree
2953 substitute_in_expr (tree exp, tree f, tree r)
2954 {
2955   enum tree_code code = TREE_CODE (exp);
2956   tree op0, op1, op2, op3;
2957   tree new_tree;
2958
2959   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2960   if (code == TREE_LIST)
2961     {
2962       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2963       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2964       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2965         return exp;
2966
2967       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2968     }
2969   else if (code == COMPONENT_REF)
2970     {
2971       tree inner;
2972
2973       /* If this expression is getting a value from a PLACEHOLDER_EXPR
2974          and it is the right field, replace it with R.  */
2975       for (inner = TREE_OPERAND (exp, 0);
2976            REFERENCE_CLASS_P (inner);
2977            inner = TREE_OPERAND (inner, 0))
2978         ;
2979
2980       /* The field.  */
2981       op1 = TREE_OPERAND (exp, 1);
2982
2983       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
2984         return r;
2985
2986       /* If this expression hasn't been completed let, leave it alone.  */
2987       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
2988         return exp;
2989
2990       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2991       if (op0 == TREE_OPERAND (exp, 0))
2992         return exp;
2993
2994       new_tree
2995         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
2996    }
2997   else
2998     switch (TREE_CODE_CLASS (code))
2999       {
3000       case tcc_constant:
3001         return exp;
3002
3003       case tcc_declaration:
3004         if (exp == f)
3005           return r;
3006         else
3007           return exp;
3008
3009       case tcc_expression:
3010         if (exp == f)
3011           return r;
3012
3013         /* Fall through...  */
3014
3015       case tcc_exceptional:
3016       case tcc_unary:
3017       case tcc_binary:
3018       case tcc_comparison:
3019       case tcc_reference:
3020         switch (TREE_CODE_LENGTH (code))
3021           {
3022           case 0:
3023             return exp;
3024
3025           case 1:
3026             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3027             if (op0 == TREE_OPERAND (exp, 0))
3028               return exp;
3029
3030             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3031             break;
3032
3033           case 2:
3034             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3035             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3036
3037             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3038               return exp;
3039
3040             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3041             break;
3042
3043           case 3:
3044             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3045             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3046             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3047
3048             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3049                 && op2 == TREE_OPERAND (exp, 2))
3050               return exp;
3051
3052             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3053             break;
3054
3055           case 4:
3056             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3057             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3058             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3059             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3060
3061             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3062                 && op2 == TREE_OPERAND (exp, 2)
3063                 && op3 == TREE_OPERAND (exp, 3))
3064               return exp;
3065
3066             new_tree
3067               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3068             break;
3069
3070           default:
3071             gcc_unreachable ();
3072           }
3073         break;
3074
3075       case tcc_vl_exp:
3076         {
3077           int i;
3078
3079           new_tree = NULL_TREE;
3080
3081           /* If we are trying to replace F with a constant, inline back
3082              functions which do nothing else than computing a value from
3083              the arguments they are passed.  This makes it possible to
3084              fold partially or entirely the replacement expression.  */
3085           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3086             {
3087               tree t = maybe_inline_call_in_expr (exp);
3088               if (t)
3089                 return SUBSTITUTE_IN_EXPR (t, f, r);
3090             }
3091
3092           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3093             {
3094               tree op = TREE_OPERAND (exp, i);
3095               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3096               if (new_op != op)
3097                 {
3098                   if (!new_tree)
3099                     new_tree = copy_node (exp);
3100                   TREE_OPERAND (new_tree, i) = new_op;
3101                 }
3102             }
3103
3104           if (new_tree)
3105             {
3106               new_tree = fold (new_tree);
3107               if (TREE_CODE (new_tree) == CALL_EXPR)
3108                 process_call_operands (new_tree);
3109             }
3110           else
3111             return exp;
3112         }
3113         break;
3114
3115       default:
3116         gcc_unreachable ();
3117       }
3118
3119   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3120   return new_tree;
3121 }
3122
3123 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3124    for it within OBJ, a tree that is an object or a chain of references.  */
3125
3126 tree
3127 substitute_placeholder_in_expr (tree exp, tree obj)
3128 {
3129   enum tree_code code = TREE_CODE (exp);
3130   tree op0, op1, op2, op3;
3131   tree new_tree;
3132
3133   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3134      in the chain of OBJ.  */
3135   if (code == PLACEHOLDER_EXPR)
3136     {
3137       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3138       tree elt;
3139
3140       for (elt = obj; elt != 0;
3141            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3142                    || TREE_CODE (elt) == COND_EXPR)
3143                   ? TREE_OPERAND (elt, 1)
3144                   : (REFERENCE_CLASS_P (elt)
3145                      || UNARY_CLASS_P (elt)
3146                      || BINARY_CLASS_P (elt)
3147                      || VL_EXP_CLASS_P (elt)
3148                      || EXPRESSION_CLASS_P (elt))
3149                   ? TREE_OPERAND (elt, 0) : 0))
3150         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3151           return elt;
3152
3153       for (elt = obj; elt != 0;
3154            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3155                    || TREE_CODE (elt) == COND_EXPR)
3156                   ? TREE_OPERAND (elt, 1)
3157                   : (REFERENCE_CLASS_P (elt)
3158                      || UNARY_CLASS_P (elt)
3159                      || BINARY_CLASS_P (elt)
3160                      || VL_EXP_CLASS_P (elt)
3161                      || EXPRESSION_CLASS_P (elt))
3162                   ? TREE_OPERAND (elt, 0) : 0))
3163         if (POINTER_TYPE_P (TREE_TYPE (elt))
3164             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3165                 == need_type))
3166           return fold_build1 (INDIRECT_REF, need_type, elt);
3167
3168       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3169          survives until RTL generation, there will be an error.  */
3170       return exp;
3171     }
3172
3173   /* TREE_LIST is special because we need to look at TREE_VALUE
3174      and TREE_CHAIN, not TREE_OPERANDS.  */
3175   else if (code == TREE_LIST)
3176     {
3177       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3178       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3179       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3180         return exp;
3181
3182       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3183     }
3184   else
3185     switch (TREE_CODE_CLASS (code))
3186       {
3187       case tcc_constant:
3188       case tcc_declaration:
3189         return exp;
3190
3191       case tcc_exceptional:
3192       case tcc_unary:
3193       case tcc_binary:
3194       case tcc_comparison:
3195       case tcc_expression:
3196       case tcc_reference:
3197       case tcc_statement:
3198         switch (TREE_CODE_LENGTH (code))
3199           {
3200           case 0:
3201             return exp;
3202
3203           case 1:
3204             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3205             if (op0 == TREE_OPERAND (exp, 0))
3206               return exp;
3207
3208             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3209             break;
3210
3211           case 2:
3212             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3213             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3214
3215             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3216               return exp;
3217
3218             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3219             break;
3220
3221           case 3:
3222             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3223             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3224             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3225
3226             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3227                 && op2 == TREE_OPERAND (exp, 2))
3228               return exp;
3229
3230             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3231             break;
3232
3233           case 4:
3234             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3235             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3236             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3237             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3238
3239             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3240                 && op2 == TREE_OPERAND (exp, 2)
3241                 && op3 == TREE_OPERAND (exp, 3))
3242               return exp;
3243
3244             new_tree
3245               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3246             break;
3247
3248           default:
3249             gcc_unreachable ();
3250           }
3251         break;
3252
3253       case tcc_vl_exp:
3254         {
3255           int i;
3256
3257           new_tree = NULL_TREE;
3258
3259           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3260             {
3261               tree op = TREE_OPERAND (exp, i);
3262               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3263               if (new_op != op)
3264                 {
3265                   if (!new_tree)
3266                     new_tree = copy_node (exp);
3267                   TREE_OPERAND (new_tree, i) = new_op;
3268                 }
3269             }
3270
3271           if (new_tree)
3272             {
3273               new_tree = fold (new_tree);
3274               if (TREE_CODE (new_tree) == CALL_EXPR)
3275                 process_call_operands (new_tree);
3276             }
3277           else
3278             return exp;
3279         }
3280         break;
3281
3282       default:
3283         gcc_unreachable ();
3284       }
3285
3286   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3287   return new_tree;
3288 }
3289 \f
3290 /* Stabilize a reference so that we can use it any number of times
3291    without causing its operands to be evaluated more than once.
3292    Returns the stabilized reference.  This works by means of save_expr,
3293    so see the caveats in the comments about save_expr.
3294
3295    Also allows conversion expressions whose operands are references.
3296    Any other kind of expression is returned unchanged.  */
3297
3298 tree
3299 stabilize_reference (tree ref)
3300 {
3301   tree result;
3302   enum tree_code code = TREE_CODE (ref);
3303
3304   switch (code)
3305     {
3306     case VAR_DECL:
3307     case PARM_DECL:
3308     case RESULT_DECL:
3309       /* No action is needed in this case.  */
3310       return ref;
3311
3312     CASE_CONVERT:
3313     case FLOAT_EXPR:
3314     case FIX_TRUNC_EXPR:
3315       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3316       break;
3317
3318     case INDIRECT_REF:
3319       result = build_nt (INDIRECT_REF,
3320                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3321       break;
3322
3323     case COMPONENT_REF:
3324       result = build_nt (COMPONENT_REF,
3325                          stabilize_reference (TREE_OPERAND (ref, 0)),
3326                          TREE_OPERAND (ref, 1), NULL_TREE);
3327       break;
3328
3329     case BIT_FIELD_REF:
3330       result = build_nt (BIT_FIELD_REF,
3331                          stabilize_reference (TREE_OPERAND (ref, 0)),
3332                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3333                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3334       break;
3335
3336     case ARRAY_REF:
3337       result = build_nt (ARRAY_REF,
3338                          stabilize_reference (TREE_OPERAND (ref, 0)),
3339                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3340                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3341       break;
3342
3343     case ARRAY_RANGE_REF:
3344       result = build_nt (ARRAY_RANGE_REF,
3345                          stabilize_reference (TREE_OPERAND (ref, 0)),
3346                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3347                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3348       break;
3349
3350     case COMPOUND_EXPR:
3351       /* We cannot wrap the first expression in a SAVE_EXPR, as then
3352          it wouldn't be ignored.  This matters when dealing with
3353          volatiles.  */
3354       return stabilize_reference_1 (ref);
3355
3356       /* If arg isn't a kind of lvalue we recognize, make no change.
3357          Caller should recognize the error for an invalid lvalue.  */
3358     default:
3359       return ref;
3360
3361     case ERROR_MARK:
3362       return error_mark_node;
3363     }
3364
3365   TREE_TYPE (result) = TREE_TYPE (ref);
3366   TREE_READONLY (result) = TREE_READONLY (ref);
3367   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3368   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3369
3370   return result;
3371 }
3372
3373 /* Subroutine of stabilize_reference; this is called for subtrees of
3374    references.  Any expression with side-effects must be put in a SAVE_EXPR
3375    to ensure that it is only evaluated once.
3376
3377    We don't put SAVE_EXPR nodes around everything, because assigning very
3378    simple expressions to temporaries causes us to miss good opportunities
3379    for optimizations.  Among other things, the opportunity to fold in the
3380    addition of a constant into an addressing mode often gets lost, e.g.
3381    "y[i+1] += x;".  In general, we take the approach that we should not make
3382    an assignment unless we are forced into it - i.e., that any non-side effect
3383    operator should be allowed, and that cse should take care of coalescing
3384    multiple utterances of the same expression should that prove fruitful.  */
3385
3386 tree
3387 stabilize_reference_1 (tree e)
3388 {
3389   tree result;
3390   enum tree_code code = TREE_CODE (e);
3391
3392   /* We cannot ignore const expressions because it might be a reference
3393      to a const array but whose index contains side-effects.  But we can
3394      ignore things that are actual constant or that already have been
3395      handled by this function.  */
3396
3397   if (tree_invariant_p (e))
3398     return e;
3399
3400   switch (TREE_CODE_CLASS (code))
3401     {
3402     case tcc_exceptional:
3403     case tcc_type:
3404     case tcc_declaration:
3405     case tcc_comparison:
3406     case tcc_statement:
3407     case tcc_expression:
3408     case tcc_reference:
3409     case tcc_vl_exp:
3410       /* If the expression has side-effects, then encase it in a SAVE_EXPR
3411          so that it will only be evaluated once.  */
3412       /* The reference (r) and comparison (<) classes could be handled as
3413          below, but it is generally faster to only evaluate them once.  */
3414       if (TREE_SIDE_EFFECTS (e))
3415         return save_expr (e);
3416       return e;
3417
3418     case tcc_constant:
3419       /* Constants need no processing.  In fact, we should never reach
3420          here.  */
3421       return e;
3422
3423     case tcc_binary:
3424       /* Division is slow and tends to be compiled with jumps,
3425          especially the division by powers of 2 that is often
3426          found inside of an array reference.  So do it just once.  */
3427       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3428           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3429           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3430           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3431         return save_expr (e);
3432       /* Recursively stabilize each operand.  */
3433       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3434                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
3435       break;
3436
3437     case tcc_unary:
3438       /* Recursively stabilize each operand.  */
3439       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3440       break;
3441
3442     default:
3443       gcc_unreachable ();
3444     }
3445
3446   TREE_TYPE (result) = TREE_TYPE (e);
3447   TREE_READONLY (result) = TREE_READONLY (e);
3448   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3449   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3450
3451   return result;
3452 }
3453 \f
3454 /* Low-level constructors for expressions.  */
3455
3456 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3457    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3458
3459 void
3460 recompute_tree_invariant_for_addr_expr (tree t)
3461 {
3462   tree node;
3463   bool tc = true, se = false;
3464
3465   /* We started out assuming this address is both invariant and constant, but
3466      does not have side effects.  Now go down any handled components and see if
3467      any of them involve offsets that are either non-constant or non-invariant.
3468      Also check for side-effects.
3469
3470      ??? Note that this code makes no attempt to deal with the case where
3471      taking the address of something causes a copy due to misalignment.  */
3472
3473 #define UPDATE_FLAGS(NODE)  \
3474 do { tree _node = (NODE); \
3475      if (_node && !TREE_CONSTANT (_node)) tc = false; \
3476      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3477
3478   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3479        node = TREE_OPERAND (node, 0))
3480     {
3481       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3482          array reference (probably made temporarily by the G++ front end),
3483          so ignore all the operands.  */
3484       if ((TREE_CODE (node) == ARRAY_REF
3485            || TREE_CODE (node) == ARRAY_RANGE_REF)
3486           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3487         {
3488           UPDATE_FLAGS (TREE_OPERAND (node, 1));
3489           if (TREE_OPERAND (node, 2))
3490             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3491           if (TREE_OPERAND (node, 3))
3492             UPDATE_FLAGS (TREE_OPERAND (node, 3));
3493         }
3494       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3495          FIELD_DECL, apparently.  The G++ front end can put something else
3496          there, at least temporarily.  */
3497       else if (TREE_CODE (node) == COMPONENT_REF
3498                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3499         {
3500           if (TREE_OPERAND (node, 2))
3501             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3502         }
3503       else if (TREE_CODE (node) == BIT_FIELD_REF)
3504         UPDATE_FLAGS (TREE_OPERAND (node, 2));
3505     }
3506
3507   node = lang_hooks.expr_to_decl (node, &tc, &se);
3508
3509   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3510      the address, since &(*a)->b is a form of addition.  If it's a constant, the
3511      address is constant too.  If it's a decl, its address is constant if the
3512      decl is static.  Everything else is not constant and, furthermore,
3513      taking the address of a volatile variable is not volatile.  */
3514   if (TREE_CODE (node) == INDIRECT_REF)
3515     UPDATE_FLAGS (TREE_OPERAND (node, 0));
3516   else if (CONSTANT_CLASS_P (node))
3517     ;
3518   else if (DECL_P (node))
3519     tc &= (staticp (node) != NULL_TREE);
3520   else
3521     {
3522       tc = false;
3523       se |= TREE_SIDE_EFFECTS (node);
3524     }
3525
3526
3527   TREE_CONSTANT (t) = tc;
3528   TREE_SIDE_EFFECTS (t) = se;
3529 #undef UPDATE_FLAGS
3530 }
3531
3532 /* Build an expression of code CODE, data type TYPE, and operands as
3533    specified.  Expressions and reference nodes can be created this way.
3534    Constants, decls, types and misc nodes cannot be.
3535
3536    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3537    enough for all extant tree codes.  */
3538
3539 tree
3540 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3541 {
3542   tree t;
3543
3544   gcc_assert (TREE_CODE_LENGTH (code) == 0);
3545
3546   t = make_node_stat (code PASS_MEM_STAT);
3547   TREE_TYPE (t) = tt;
3548
3549   return t;
3550 }
3551
3552 tree
3553 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3554 {
3555   int length = sizeof (struct tree_exp);
3556 #ifdef GATHER_STATISTICS
3557   tree_node_kind kind;
3558 #endif
3559   tree t;
3560
3561 #ifdef GATHER_STATISTICS
3562   switch (TREE_CODE_CLASS (code))
3563     {
3564     case tcc_statement:  /* an expression with side effects */
3565       kind = s_kind;
3566       break;
3567     case tcc_reference:  /* a reference */
3568       kind = r_kind;
3569       break;
3570     default:
3571       kind = e_kind;
3572       break;
3573     }
3574
3575   tree_node_counts[(int) kind]++;
3576   tree_node_sizes[(int) kind] += length;
3577 #endif
3578
3579   gcc_assert (TREE_CODE_LENGTH (code) == 1);
3580
3581   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
3582
3583   memset (t, 0, sizeof (struct tree_common));
3584
3585   TREE_SET_CODE (t, code);
3586
3587   TREE_TYPE (t) = type;
3588   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3589   TREE_OPERAND (t, 0) = node;
3590   TREE_BLOCK (t) = NULL_TREE;
3591   if (node && !TYPE_P (node))
3592     {
3593       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3594       TREE_READONLY (t) = TREE_READONLY (node);
3595     }
3596
3597   if (TREE_CODE_CLASS (code) == tcc_statement)
3598     TREE_SIDE_EFFECTS (t) = 1;
3599   else switch (code)
3600     {
3601     case VA_ARG_EXPR:
3602       /* All of these have side-effects, no matter what their
3603          operands are.  */
3604       TREE_SIDE_EFFECTS (t) = 1;
3605       TREE_READONLY (t) = 0;
3606       break;
3607
3608     case MISALIGNED_INDIRECT_REF:
3609     case ALIGN_INDIRECT_REF:
3610     case INDIRECT_REF:
3611       /* Whether a dereference is readonly has nothing to do with whether
3612          its operand is readonly.  */
3613       TREE_READONLY (t) = 0;
3614       break;
3615
3616     case ADDR_EXPR:
3617       if (node)
3618         recompute_tree_invariant_for_addr_expr (t);
3619       break;
3620
3621     default:
3622       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3623           && node && !TYPE_P (node)
3624           && TREE_CONSTANT (node))
3625         TREE_CONSTANT (t) = 1;
3626       if (TREE_CODE_CLASS (code) == tcc_reference
3627           && node && TREE_THIS_VOLATILE (node))
3628         TREE_THIS_VOLATILE (t) = 1;
3629       break;
3630     }
3631
3632   return t;
3633 }
3634
3635 #define PROCESS_ARG(N)                          \
3636   do {                                          \
3637     TREE_OPERAND (t, N) = arg##N;               \
3638     if (arg##N &&!TYPE_P (arg##N))              \
3639       {                                         \
3640         if (TREE_SIDE_EFFECTS (arg##N))         \
3641           side_effects = 1;                     \
3642         if (!TREE_READONLY (arg##N)             \
3643             && !CONSTANT_CLASS_P (arg##N))      \
3644           (void) (read_only = 0);               \
3645         if (!TREE_CONSTANT (arg##N))            \
3646           (void) (constant = 0);                \
3647       }                                         \
3648   } while (0)
3649
3650 tree
3651 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3652 {
3653   bool constant, read_only, side_effects;
3654   tree t;
3655
3656   gcc_assert (TREE_CODE_LENGTH (code) == 2);
3657
3658   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3659       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3660       /* When sizetype precision doesn't match that of pointers
3661          we need to be able to build explicit extensions or truncations
3662          of the offset argument.  */
3663       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3664     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3665                 && TREE_CODE (arg1) == INTEGER_CST);
3666
3667   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3668     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3669                 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3670                 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3671
3672   t = make_node_stat (code PASS_MEM_STAT);
3673   TREE_TYPE (t) = tt;
3674
3675   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3676      result based on those same flags for the arguments.  But if the
3677      arguments aren't really even `tree' expressions, we shouldn't be trying
3678      to do this.  */
3679
3680   /* Expressions without side effects may be constant if their
3681      arguments are as well.  */
3682   constant = (TREE_CODE_CLASS (code) == tcc_comparison
3683               || TREE_CODE_CLASS (code) == tcc_binary);
3684   read_only = 1;
3685   side_effects = TREE_SIDE_EFFECTS (t);
3686
3687   PROCESS_ARG(0);
3688   PROCESS_ARG(1);
3689
3690   TREE_READONLY (t) = read_only;
3691   TREE_CONSTANT (t) = constant;
3692   TREE_SIDE_EFFECTS (t) = side_effects;
3693   TREE_THIS_VOLATILE (t)
3694     = (TREE_CODE_CLASS (code) == tcc_reference
3695        && arg0 && TREE_THIS_VOLATILE (arg0));
3696
3697   return t;
3698 }
3699
3700
3701 tree
3702 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3703              tree arg2 MEM_STAT_DECL)
3704 {
3705   bool constant, read_only, side_effects;
3706   tree t;
3707
3708   gcc_assert (TREE_CODE_LENGTH (code) == 3);
3709   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3710
3711   t = make_node_stat (code PASS_MEM_STAT);
3712   TREE_TYPE (t) = tt;
3713
3714   read_only = 1;
3715
3716   /* As a special exception, if COND_EXPR has NULL branches, we
3717      assume that it is a gimple statement and always consider
3718      it to have side effects.  */
3719   if (code == COND_EXPR
3720       && tt == void_type_node
3721       && arg1 == NULL_TREE
3722       && arg2 == NULL_TREE)
3723     side_effects = true;
3724   else
3725     side_effects = TREE_SIDE_EFFECTS (t);
3726
3727   PROCESS_ARG(0);
3728   PROCESS_ARG(1);
3729   PROCESS_ARG(2);
3730
3731   if (code == COND_EXPR)
3732     TREE_READONLY (t) = read_only;
3733
3734   TREE_SIDE_EFFECTS (t) = side_effects;
3735   TREE_THIS_VOLATILE (t)
3736     = (TREE_CODE_CLASS (code) == tcc_reference
3737        && arg0 && TREE_THIS_VOLATILE (arg0));
3738
3739   return t;
3740 }
3741
3742 tree
3743 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3744              tree arg2, tree arg3 MEM_STAT_DECL)
3745 {
3746   bool constant, read_only, side_effects;
3747   tree t;
3748
3749   gcc_assert (TREE_CODE_LENGTH (code) == 4);
3750
3751   t = make_node_stat (code PASS_MEM_STAT);
3752   TREE_TYPE (t) = tt;
3753
3754   side_effects = TREE_SIDE_EFFECTS (t);
3755
3756   PROCESS_ARG(0);
3757   PROCESS_ARG(1);
3758   PROCESS_ARG(2);
3759   PROCESS_ARG(3);
3760
3761   TREE_SIDE_EFFECTS (t) = side_effects;
3762   TREE_THIS_VOLATILE (t)
3763     = (TREE_CODE_CLASS (code) == tcc_reference
3764        && arg0 && TREE_THIS_VOLATILE (arg0));
3765
3766   return t;
3767 }
3768
3769 tree
3770 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3771              tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3772 {
3773   bool constant, read_only, side_effects;
3774   tree t;
3775
3776   gcc_assert (TREE_CODE_LENGTH (code) == 5);
3777
3778   t = make_node_stat (code PASS_MEM_STAT);
3779   TREE_TYPE (t) = tt;
3780
3781   side_effects = TREE_SIDE_EFFECTS (t);
3782
3783   PROCESS_ARG(0);
3784   PROCESS_ARG(1);
3785   PROCESS_ARG(2);
3786   PROCESS_ARG(3);
3787   PROCESS_ARG(4);
3788
3789   TREE_SIDE_EFFECTS (t) = side_effects;
3790   TREE_THIS_VOLATILE (t)
3791     = (TREE_CODE_CLASS (code) == tcc_reference
3792        && arg0 && TREE_THIS_VOLATILE (arg0));
3793
3794   return t;
3795 }
3796
3797 tree
3798 build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3799              tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
3800 {
3801   bool constant, read_only, side_effects;
3802   tree t;
3803
3804   gcc_assert (code == TARGET_MEM_REF);
3805
3806   t = make_node_stat (code PASS_MEM_STAT);
3807   TREE_TYPE (t) = tt;
3808
3809   side_effects = TREE_SIDE_EFFECTS (t);
3810
3811   PROCESS_ARG(0);
3812   PROCESS_ARG(1);
3813   PROCESS_ARG(2);
3814   PROCESS_ARG(3);
3815   PROCESS_ARG(4);
3816   if (code == TARGET_MEM_REF)
3817     side_effects = 0;
3818   PROCESS_ARG(5);
3819
3820   TREE_SIDE_EFFECTS (t) = side_effects;
3821   TREE_THIS_VOLATILE (t)
3822     = (code == TARGET_MEM_REF
3823        && arg5 && TREE_THIS_VOLATILE (arg5));
3824
3825   return t;
3826 }
3827
3828 /* Similar except don't specify the TREE_TYPE
3829    and leave the TREE_SIDE_EFFECTS as 0.
3830    It is permissible for arguments to be null,
3831    or even garbage if their values do not matter.  */
3832
3833 tree
3834 build_nt (enum tree_code code, ...)
3835 {
3836   tree t;
3837   int length;
3838   int i;
3839   va_list p;
3840
3841   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3842
3843   va_start (p, code);
3844
3845   t = make_node (code);
3846   length = TREE_CODE_LENGTH (code);
3847
3848   for (i = 0; i < length; i++)
3849     TREE_OPERAND (t, i) = va_arg (p, tree);
3850
3851   va_end (p);
3852   return t;
3853 }
3854
3855 /* Similar to build_nt, but for creating a CALL_EXPR object with
3856    ARGLIST passed as a list.  */
3857
3858 tree
3859 build_nt_call_list (tree fn, tree arglist)
3860 {
3861   tree t;
3862   int i;
3863
3864   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
3865   CALL_EXPR_FN (t) = fn;
3866   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
3867   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
3868     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
3869   return t;
3870 }
3871
3872 /* Similar to build_nt, but for creating a CALL_EXPR object with a
3873    tree VEC.  */
3874
3875 tree
3876 build_nt_call_vec (tree fn, VEC(tree,gc) *args)
3877 {
3878   tree ret, t;
3879   unsigned int ix;
3880
3881   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
3882   CALL_EXPR_FN (ret) = fn;
3883   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3884   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
3885     CALL_EXPR_ARG (ret, ix) = t;
3886   return ret;
3887 }
3888 \f
3889 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3890    We do NOT enter this node in any sort of symbol table.
3891
3892    LOC is the location of the decl.
3893
3894    layout_decl is used to set up the decl's storage layout.
3895    Other slots are initialized to 0 or null pointers.  */
3896
3897 tree
3898 build_decl_stat (location_t loc, enum tree_code code, tree name,
3899                  tree type MEM_STAT_DECL)
3900 {
3901   tree t;
3902
3903   t = make_node_stat (code PASS_MEM_STAT);
3904   DECL_SOURCE_LOCATION (t) = loc;
3905
3906 /*  if (type == error_mark_node)
3907     type = integer_type_node; */
3908 /* That is not done, deliberately, so that having error_mark_node
3909    as the type can suppress useless errors in the use of this variable.  */
3910
3911   DECL_NAME (t) = name;
3912   TREE_TYPE (t) = type;
3913
3914   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3915     layout_decl (t, 0);
3916
3917   return t;
3918 }
3919
3920 /* Builds and returns function declaration with NAME and TYPE.  */
3921
3922 tree
3923 build_fn_decl (const char *name, tree type)
3924 {
3925   tree id = get_identifier (name);
3926   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
3927
3928   DECL_EXTERNAL (decl) = 1;
3929   TREE_PUBLIC (decl) = 1;
3930   DECL_ARTIFICIAL (decl) = 1;
3931   TREE_NOTHROW (decl) = 1;
3932
3933   return decl;
3934 }
3935
3936 \f
3937 /* BLOCK nodes are used to represent the structure of binding contours
3938    and declarations, once those contours have been exited and their contents
3939    compiled.  This information is used for outputting debugging info.  */
3940
3941 tree
3942 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
3943 {
3944   tree block = make_node (BLOCK);
3945
3946   BLOCK_VARS (block) = vars;
3947   BLOCK_SUBBLOCKS (block) = subblocks;
3948   BLOCK_SUPERCONTEXT (block) = supercontext;
3949   BLOCK_CHAIN (block) = chain;
3950   return block;
3951 }
3952
3953 \f
3954 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
3955
3956    LOC is the location to use in tree T.  */
3957
3958 void
3959 protected_set_expr_location (tree t, location_t loc)
3960 {
3961   if (t && CAN_HAVE_LOCATION_P (t))
3962     SET_EXPR_LOCATION (t, loc);
3963 }
3964 \f
3965 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
3966    is ATTRIBUTE.  */
3967
3968 tree
3969 build_decl_attribute_variant (tree ddecl, tree attribute)
3970 {
3971   DECL_ATTRIBUTES (ddecl) = attribute;
3972   return ddecl;
3973 }
3974
3975 /* Borrowed from hashtab.c iterative_hash implementation.  */
3976 #define mix(a,b,c) \
3977 { \
3978   a -= b; a -= c; a ^= (c>>13); \
3979   b -= c; b -= a; b ^= (a<< 8); \
3980   c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
3981   a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
3982   b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
3983   c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
3984   a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
3985   b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
3986   c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
3987 }
3988
3989
3990 /* Produce good hash value combining VAL and VAL2.  */
3991 hashval_t
3992 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
3993 {
3994   /* the golden ratio; an arbitrary value.  */
3995   hashval_t a = 0x9e3779b9;
3996
3997   mix (a, val, val2);
3998   return val2;
3999 }
4000
4001 /* Produce good hash value combining VAL and VAL2.  */
4002 hashval_t
4003 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4004 {
4005   if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4006     return iterative_hash_hashval_t (val, val2);
4007   else
4008     {
4009       hashval_t a = (hashval_t) val;
4010       /* Avoid warnings about shifting of more than the width of the type on
4011          hosts that won't execute this path.  */
4012       int zero = 0;
4013       hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4014       mix (a, b, val2);
4015       if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4016         {
4017           hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4018           hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4019           mix (a, b, val2);
4020         }
4021       return val2;
4022     }
4023 }
4024
4025 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4026    is ATTRIBUTE and its qualifiers are QUALS.
4027
4028    Record such modified types already made so we don't make duplicates.  */
4029
4030 tree
4031 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4032 {
4033   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4034     {
4035       hashval_t hashcode = 0;
4036       tree ntype;
4037       enum tree_code code = TREE_CODE (ttype);
4038
4039       /* Building a distinct copy of a tagged type is inappropriate; it
4040          causes breakage in code that expects there to be a one-to-one
4041          relationship between a struct and its fields.
4042          build_duplicate_type is another solution (as used in
4043          handle_transparent_union_attribute), but that doesn't play well
4044          with the stronger C++ type identity model.  */
4045       if (TREE_CODE (ttype) == RECORD_TYPE
4046           || TREE_CODE (ttype) == UNION_TYPE
4047           || TREE_CODE (ttype) == QUAL_UNION_TYPE
4048           || TREE_CODE (ttype) == ENUMERAL_TYPE)
4049         {
4050           warning (OPT_Wattributes,
4051                    "ignoring attributes applied to %qT after definition",
4052                    TYPE_MAIN_VARIANT (ttype));
4053           return build_qualified_type (ttype, quals);
4054         }
4055
4056       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4057       ntype = build_distinct_type_copy (ttype);
4058
4059       TYPE_ATTRIBUTES (ntype) = attribute;
4060
4061       hashcode = iterative_hash_object (code, hashcode);
4062       if (TREE_TYPE (ntype))
4063         hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4064                                           hashcode);
4065       hashcode = attribute_hash_list (attribute, hashcode);
4066
4067       switch (TREE_CODE (ntype))
4068         {
4069         case FUNCTION_TYPE:
4070           hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4071           break;
4072         case ARRAY_TYPE:
4073           if (TYPE_DOMAIN (ntype))
4074             hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4075                                               hashcode);
4076           break;
4077         case INTEGER_TYPE:
4078           hashcode = iterative_hash_object
4079             (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4080           hashcode = iterative_hash_object
4081             (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4082           break;
4083         case REAL_TYPE:
4084         case FIXED_POINT_TYPE:
4085           {
4086             unsigned int precision = TYPE_PRECISION (ntype);
4087             hashcode = iterative_hash_object (precision, hashcode);
4088           }
4089           break;
4090         default:
4091           break;
4092         }
4093
4094       ntype = type_hash_canon (hashcode, ntype);
4095
4096       /* If the target-dependent attributes make NTYPE different from
4097          its canonical type, we will need to use structural equality
4098          checks for this type. */
4099       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4100           || !targetm.comp_type_attributes (ntype, ttype))
4101         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4102       else if (TYPE_CANONICAL (ntype) == ntype)
4103         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4104
4105       ttype = build_qualified_type (ntype, quals);
4106     }
4107   else if (TYPE_QUALS (ttype) != quals)
4108     ttype = build_qualified_type (ttype, quals);
4109
4110   return ttype;
4111 }
4112
4113
4114 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4115    is ATTRIBUTE.
4116
4117    Record such modified types already made so we don't make duplicates.  */
4118
4119 tree
4120 build_type_attribute_variant (tree ttype, tree attribute)
4121 {
4122   return build_type_attribute_qual_variant (ttype, attribute,
4123                                             TYPE_QUALS (ttype));
4124 }
4125
4126
4127 /* Reset the expression *EXPR_P, a size or position.
4128
4129    ??? We could reset all non-constant sizes or positions.  But it's cheap
4130    enough to not do so and refrain from adding workarounds to dwarf2out.c.
4131
4132    We need to reset self-referential sizes or positions because they cannot
4133    be gimplified and thus can contain a CALL_EXPR after the gimplification
4134    is finished, which will run afoul of LTO streaming.  And they need to be
4135    reset to something essentially dummy but not constant, so as to preserve
4136    the properties of the object they are attached to.  */
4137
4138 static inline void
4139 free_lang_data_in_one_sizepos (tree *expr_p)
4140 {
4141   tree expr = *expr_p;
4142   if (CONTAINS_PLACEHOLDER_P (expr))
4143     *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4144 }
4145
4146
4147 /* Reset all the fields in a binfo node BINFO.  We only keep
4148    BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
4149
4150 static void
4151 free_lang_data_in_binfo (tree binfo)
4152 {
4153   unsigned i;
4154   tree t;
4155
4156   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4157
4158   BINFO_VTABLE (binfo) = NULL_TREE;
4159   BINFO_BASE_ACCESSES (binfo) = NULL;
4160   BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4161   BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4162
4163   for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (binfo), i, t); i++)
4164     free_lang_data_in_binfo (t);
4165 }
4166
4167
4168 /* Reset all language specific information still present in TYPE.  */
4169
4170 static void
4171 free_lang_data_in_type (tree type)
4172 {
4173   gcc_assert (TYPE_P (type));
4174
4175   /* Give the FE a chance to remove its own data first.  */
4176   lang_hooks.free_lang_data (type);
4177
4178   TREE_LANG_FLAG_0 (type) = 0;
4179   TREE_LANG_FLAG_1 (type) = 0;
4180   TREE_LANG_FLAG_2 (type) = 0;
4181   TREE_LANG_FLAG_3 (type) = 0;
4182   TREE_LANG_FLAG_4 (type) = 0;
4183   TREE_LANG_FLAG_5 (type) = 0;
4184   TREE_LANG_FLAG_6 (type) = 0;
4185
4186   if (TREE_CODE (type) == FUNCTION_TYPE)
4187     {
4188       /* Remove the const and volatile qualifiers from arguments.  The
4189          C++ front end removes them, but the C front end does not,
4190          leading to false ODR violation errors when merging two
4191          instances of the same function signature compiled by
4192          different front ends.  */
4193       tree p;
4194
4195       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4196         {
4197           tree arg_type = TREE_VALUE (p);
4198
4199           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4200             {
4201               int quals = TYPE_QUALS (arg_type)
4202                           & ~TYPE_QUAL_CONST
4203                           & ~TYPE_QUAL_VOLATILE;
4204               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4205               free_lang_data_in_type (TREE_VALUE (p));
4206             }
4207         }
4208     }
4209
4210   /* Remove members that are not actually FIELD_DECLs from the field
4211      list of an aggregate.  These occur in C++.  */
4212   if (RECORD_OR_UNION_TYPE_P (type))
4213     {
4214       tree prev, member;
4215
4216       /* Note that TYPE_FIELDS can be shared across distinct
4217          TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
4218          to be removed, we cannot set its TREE_CHAIN to NULL.
4219          Otherwise, we would not be able to find all the other fields
4220          in the other instances of this TREE_TYPE.
4221
4222          This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
4223       prev = NULL_TREE;
4224       member = TYPE_FIELDS (type);
4225       while (member)
4226         {
4227           if (TREE_CODE (member) == FIELD_DECL)
4228             {
4229               if (prev)
4230                 TREE_CHAIN (prev) = member;
4231               else
4232                 TYPE_FIELDS (type) = member;
4233               prev = member;
4234             }
4235
4236           member = TREE_CHAIN (member);
4237         }
4238
4239       if (prev)
4240         TREE_CHAIN (prev) = NULL_TREE;
4241       else
4242         TYPE_FIELDS (type) = NULL_TREE;
4243
4244       TYPE_METHODS (type) = NULL_TREE;
4245       if (TYPE_BINFO (type))
4246         free_lang_data_in_binfo (TYPE_BINFO (type));
4247     }
4248   else
4249     {
4250       /* For non-aggregate types, clear out the language slot (which
4251          overloads TYPE_BINFO).  */
4252       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4253
4254       if (INTEGRAL_TYPE_P (type)
4255           || SCALAR_FLOAT_TYPE_P (type)
4256           || FIXED_POINT_TYPE_P (type))
4257         {
4258           free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
4259           free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
4260         }
4261     }
4262
4263   free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
4264   free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
4265
4266   if (debug_info_level < DINFO_LEVEL_TERSE
4267       || (TYPE_CONTEXT (type)
4268           && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
4269           && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
4270     TYPE_CONTEXT (type) = NULL_TREE;
4271
4272   if (debug_info_level < DINFO_LEVEL_TERSE)
4273     TYPE_STUB_DECL (type) = NULL_TREE;
4274 }
4275
4276
4277 /* Return true if DECL may need an assembler name to be set.  */
4278
4279 static inline bool
4280 need_assembler_name_p (tree decl)
4281 {
4282   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
4283   if (TREE_CODE (decl) != FUNCTION_DECL
4284       && TREE_CODE (decl) != VAR_DECL)
4285     return false;
4286
4287   /* If DECL already has its assembler name set, it does not need a
4288      new one.  */
4289   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4290       || DECL_ASSEMBLER_NAME_SET_P (decl))
4291     return false;
4292
4293   /* Abstract decls do not need an assembler name.  */
4294   if (DECL_ABSTRACT (decl))
4295     return false;
4296
4297   /* For VAR_DECLs, only static, public and external symbols need an
4298      assembler name.  */
4299   if (TREE_CODE (decl) == VAR_DECL
4300       && !TREE_STATIC (decl)
4301       && !TREE_PUBLIC (decl)
4302       && !DECL_EXTERNAL (decl))
4303     return false;
4304
4305   if (TREE_CODE (decl) == FUNCTION_DECL)
4306     {
4307       /* Do not set assembler name on builtins.  Allow RTL expansion to
4308          decide whether to expand inline or via a regular call.  */
4309       if (DECL_BUILT_IN (decl)
4310           && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4311         return false;
4312
4313       /* Functions represented in the callgraph need an assembler name.  */
4314       if (cgraph_get_node (decl) != NULL)
4315         return true;
4316
4317       /* Unused and not public functions don't need an assembler name.  */
4318       if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4319         return false;
4320     }
4321
4322   return true;
4323 }
4324
4325
4326 /* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
4327    variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
4328    in BLOCK that is not in LOCALS is removed.  */
4329
4330 static void
4331 free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
4332 {
4333   tree *tp, t;
4334
4335   tp = &BLOCK_VARS (block);
4336   while (*tp)
4337     {
4338       if (!pointer_set_contains (locals, *tp))
4339         *tp = TREE_CHAIN (*tp);
4340       else
4341         tp = &TREE_CHAIN (*tp);
4342     }
4343
4344   for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4345     free_lang_data_in_block (fn, t, locals);
4346 }
4347
4348
4349 /* Reset all language specific information still present in symbol
4350    DECL.  */
4351
4352 static void
4353 free_lang_data_in_decl (tree decl)
4354 {
4355   gcc_assert (DECL_P (decl));
4356
4357   /* Give the FE a chance to remove its own data first.  */
4358   lang_hooks.free_lang_data (decl);
4359
4360   TREE_LANG_FLAG_0 (decl) = 0;
4361   TREE_LANG_FLAG_1 (decl) = 0;
4362   TREE_LANG_FLAG_2 (decl) = 0;
4363   TREE_LANG_FLAG_3 (decl) = 0;
4364   TREE_LANG_FLAG_4 (decl) = 0;
4365   TREE_LANG_FLAG_5 (decl) = 0;
4366   TREE_LANG_FLAG_6 (decl) = 0;
4367
4368   /* Identifiers need not have a type.  */
4369   if (DECL_NAME (decl))
4370     TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4371
4372   /* Ignore any intervening types, because we are going to clear their
4373      TYPE_CONTEXT fields.  */
4374   if (TREE_CODE (decl) != FIELD_DECL
4375       && TREE_CODE (decl) != FUNCTION_DECL)
4376     DECL_CONTEXT (decl) = decl_function_context (decl);
4377
4378   if (DECL_CONTEXT (decl)
4379       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
4380     DECL_CONTEXT (decl) = NULL_TREE;
4381
4382  if (TREE_CODE (decl) == VAR_DECL)
4383    {
4384      tree context = DECL_CONTEXT (decl);
4385
4386      if (context)
4387        {
4388          enum tree_code code = TREE_CODE (context);
4389          if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
4390            {
4391              /* Do not clear the decl context here, that will promote
4392                 all vars to global ones.  */
4393              DECL_INITIAL (decl) = NULL_TREE;
4394            }
4395
4396          if (TREE_STATIC (decl))
4397            DECL_CONTEXT (decl) = NULL_TREE;
4398        }
4399    }
4400
4401   free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
4402   free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
4403   if (TREE_CODE (decl) == FIELD_DECL)
4404     free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
4405
4406  /* DECL_FCONTEXT is only used for debug info generation.  */
4407  if (TREE_CODE (decl) == FIELD_DECL
4408      && debug_info_level < DINFO_LEVEL_TERSE)
4409    DECL_FCONTEXT (decl) = NULL_TREE;
4410
4411  if (TREE_CODE (decl) == FUNCTION_DECL)
4412     {
4413       if (gimple_has_body_p (decl))
4414         {
4415           tree t;
4416           struct pointer_set_t *locals;
4417
4418           /* If DECL has a gimple body, then the context for its
4419              arguments must be DECL.  Otherwise, it doesn't really
4420              matter, as we will not be emitting any code for DECL.  In
4421              general, there may be other instances of DECL created by
4422              the front end and since PARM_DECLs are generally shared,
4423              their DECL_CONTEXT changes as the replicas of DECL are
4424              created.  The only time where DECL_CONTEXT is important
4425              is for the FUNCTION_DECLs that have a gimple body (since
4426              the PARM_DECL will be used in the function's body).  */
4427           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4428             DECL_CONTEXT (t) = decl;
4429
4430           /* Collect all the symbols declared in DECL.  */
4431           locals = pointer_set_create ();
4432           t = DECL_STRUCT_FUNCTION (decl)->local_decls;
4433           for (; t; t = TREE_CHAIN (t))
4434             {
4435               pointer_set_insert (locals, TREE_VALUE (t));
4436
4437               /* All the local symbols should have DECL as their
4438                  context.  */
4439               DECL_CONTEXT (TREE_VALUE (t)) = decl;
4440             }
4441
4442           /* Get rid of any decl not in local_decls.  */
4443           free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
4444
4445           pointer_set_destroy (locals);
4446         }
4447
4448       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4449          At this point, it is not needed anymore.  */
4450       DECL_SAVED_TREE (decl) = NULL_TREE;
4451     }
4452   else if (TREE_CODE (decl) == VAR_DECL)
4453     {
4454       tree expr = DECL_DEBUG_EXPR (decl);
4455       if (expr
4456           && TREE_CODE (expr) == VAR_DECL
4457           && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
4458         SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
4459
4460       if (DECL_EXTERNAL (decl)
4461           && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
4462