OSDN Git Service

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