OSDN Git Service

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