OSDN Git Service

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