OSDN Git Service

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