* gcc.dg/store-motion-fgcse-sm.c (dg-final): Cleanup
[official-gcc.git] / gcc / tree.c
blob1d5e4f6cd1eca5189ded8f9a40d1d6e15d74d8b4
1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains the low level primitives for operating on tree nodes,
21 including allocation, list operations, interning of identifiers,
22 construction of data type nodes and statement nodes,
23 and construction of type conversion nodes. It also contains
24 tables index by tree code that describe how to take apart
25 nodes of that code.
27 It is intended to be language-independent, but occasionally
28 calls language-dependent routines defined (for C) in typecheck.c. */
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "flags.h"
35 #include "tree.h"
36 #include "stor-layout.h"
37 #include "calls.h"
38 #include "attribs.h"
39 #include "varasm.h"
40 #include "tm_p.h"
41 #include "hashtab.h"
42 #include "hash-set.h"
43 #include "vec.h"
44 #include "machmode.h"
45 #include "hard-reg-set.h"
46 #include "input.h"
47 #include "function.h"
48 #include "obstack.h"
49 #include "toplev.h" /* get_random_seed */
50 #include "inchash.h"
51 #include "filenames.h"
52 #include "output.h"
53 #include "target.h"
54 #include "common/common-target.h"
55 #include "langhooks.h"
56 #include "tree-inline.h"
57 #include "tree-iterator.h"
58 #include "predict.h"
59 #include "dominance.h"
60 #include "cfg.h"
61 #include "basic-block.h"
62 #include "bitmap.h"
63 #include "tree-ssa-alias.h"
64 #include "internal-fn.h"
65 #include "gimple-expr.h"
66 #include "is-a.h"
67 #include "gimple.h"
68 #include "gimple-iterator.h"
69 #include "gimplify.h"
70 #include "gimple-ssa.h"
71 #include "hash-map.h"
72 #include "plugin-api.h"
73 #include "ipa-ref.h"
74 #include "cgraph.h"
75 #include "tree-phinodes.h"
76 #include "stringpool.h"
77 #include "tree-ssanames.h"
78 #include "expr.h"
79 #include "tree-dfa.h"
80 #include "params.h"
81 #include "tree-pass.h"
82 #include "langhooks-def.h"
83 #include "diagnostic.h"
84 #include "tree-diagnostic.h"
85 #include "tree-pretty-print.h"
86 #include "except.h"
87 #include "debug.h"
88 #include "intl.h"
89 #include "wide-int.h"
90 #include "builtins.h"
92 /* Tree code classes. */
94 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
95 #define END_OF_BASE_TREE_CODES tcc_exceptional,
97 const enum tree_code_class tree_code_type[] = {
98 #include "all-tree.def"
101 #undef DEFTREECODE
102 #undef END_OF_BASE_TREE_CODES
104 /* Table indexed by tree code giving number of expression
105 operands beyond the fixed part of the node structure.
106 Not used for types or decls. */
108 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
109 #define END_OF_BASE_TREE_CODES 0,
111 const unsigned char tree_code_length[] = {
112 #include "all-tree.def"
115 #undef DEFTREECODE
116 #undef END_OF_BASE_TREE_CODES
118 /* Names of tree components.
119 Used for printing out the tree and error messages. */
120 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
121 #define END_OF_BASE_TREE_CODES "@dummy",
123 static const char *const tree_code_name[] = {
124 #include "all-tree.def"
127 #undef DEFTREECODE
128 #undef END_OF_BASE_TREE_CODES
130 /* Each tree code class has an associated string representation.
131 These must correspond to the tree_code_class entries. */
133 const char *const tree_code_class_strings[] =
135 "exceptional",
136 "constant",
137 "type",
138 "declaration",
139 "reference",
140 "comparison",
141 "unary",
142 "binary",
143 "statement",
144 "vl_exp",
145 "expression"
148 /* obstack.[ch] explicitly declined to prototype this. */
149 extern int _obstack_allocated_p (struct obstack *h, void *obj);
151 /* Statistics-gathering stuff. */
153 static int tree_code_counts[MAX_TREE_CODES];
154 int tree_node_counts[(int) all_kinds];
155 int tree_node_sizes[(int) all_kinds];
157 /* Keep in sync with tree.h:enum tree_node_kind. */
158 static const char * const tree_node_kind_names[] = {
159 "decls",
160 "types",
161 "blocks",
162 "stmts",
163 "refs",
164 "exprs",
165 "constants",
166 "identifiers",
167 "vecs",
168 "binfos",
169 "ssa names",
170 "constructors",
171 "random kinds",
172 "lang_decl kinds",
173 "lang_type kinds",
174 "omp clauses",
177 /* Unique id for next decl created. */
178 static GTY(()) int next_decl_uid;
179 /* Unique id for next type created. */
180 static GTY(()) int next_type_uid = 1;
181 /* Unique id for next debug decl created. Use negative numbers,
182 to catch erroneous uses. */
183 static GTY(()) int next_debug_decl_uid;
185 /* Since we cannot rehash a type after it is in the table, we have to
186 keep the hash code. */
188 struct GTY((for_user)) type_hash {
189 unsigned long hash;
190 tree type;
193 /* Initial size of the hash table (rounded to next prime). */
194 #define TYPE_HASH_INITIAL_SIZE 1000
196 struct type_cache_hasher : ggc_cache_hasher<type_hash *>
198 static hashval_t hash (type_hash *t) { return t->hash; }
199 static bool equal (type_hash *a, type_hash *b);
201 static void
202 handle_cache_entry (type_hash *&t)
204 extern void gt_ggc_mx (type_hash *&);
205 if (t == HTAB_DELETED_ENTRY || t == HTAB_EMPTY_ENTRY)
206 return;
207 else if (ggc_marked_p (t->type))
208 gt_ggc_mx (t);
209 else
210 t = static_cast<type_hash *> (HTAB_DELETED_ENTRY);
214 /* Now here is the hash table. When recording a type, it is added to
215 the slot whose index is the hash code. Note that the hash table is
216 used for several kinds of types (function types, array types and
217 array index range types, for now). While all these live in the
218 same table, they are completely independent, and the hash code is
219 computed differently for each of these. */
221 static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table;
223 /* Hash table and temporary node for larger integer const values. */
224 static GTY (()) tree int_cst_node;
226 struct int_cst_hasher : ggc_cache_hasher<tree>
228 static hashval_t hash (tree t);
229 static bool equal (tree x, tree y);
232 static GTY ((cache)) hash_table<int_cst_hasher> *int_cst_hash_table;
234 /* Hash table for optimization flags and target option flags. Use the same
235 hash table for both sets of options. Nodes for building the current
236 optimization and target option nodes. The assumption is most of the time
237 the options created will already be in the hash table, so we avoid
238 allocating and freeing up a node repeatably. */
239 static GTY (()) tree cl_optimization_node;
240 static GTY (()) tree cl_target_option_node;
242 struct cl_option_hasher : ggc_cache_hasher<tree>
244 static hashval_t hash (tree t);
245 static bool equal (tree x, tree y);
248 static GTY ((cache)) hash_table<cl_option_hasher> *cl_option_hash_table;
250 /* General tree->tree mapping structure for use in hash tables. */
253 static GTY ((cache))
254 hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl;
256 static GTY ((cache))
257 hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl;
259 struct tree_vec_map_cache_hasher : ggc_cache_hasher<tree_vec_map *>
261 static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
263 static bool
264 equal (tree_vec_map *a, tree_vec_map *b)
266 return a->base.from == b->base.from;
269 static void
270 handle_cache_entry (tree_vec_map *&m)
272 extern void gt_ggc_mx (tree_vec_map *&);
273 if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
274 return;
275 else if (ggc_marked_p (m->base.from))
276 gt_ggc_mx (m);
277 else
278 m = static_cast<tree_vec_map *> (HTAB_DELETED_ENTRY);
282 static GTY ((cache))
283 hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl;
285 static void set_type_quals (tree, int);
286 static void print_type_hash_statistics (void);
287 static void print_debug_expr_statistics (void);
288 static void print_value_expr_statistics (void);
289 static void type_hash_list (const_tree, inchash::hash &);
290 static void attribute_hash_list (const_tree, inchash::hash &);
292 tree global_trees[TI_MAX];
293 tree integer_types[itk_none];
295 bool int_n_enabled_p[NUM_INT_N_ENTS];
296 struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS];
298 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
300 /* Number of operands for each OpenMP clause. */
301 unsigned const char omp_clause_num_ops[] =
303 0, /* OMP_CLAUSE_ERROR */
304 1, /* OMP_CLAUSE_PRIVATE */
305 1, /* OMP_CLAUSE_SHARED */
306 1, /* OMP_CLAUSE_FIRSTPRIVATE */
307 2, /* OMP_CLAUSE_LASTPRIVATE */
308 4, /* OMP_CLAUSE_REDUCTION */
309 1, /* OMP_CLAUSE_COPYIN */
310 1, /* OMP_CLAUSE_COPYPRIVATE */
311 3, /* OMP_CLAUSE_LINEAR */
312 2, /* OMP_CLAUSE_ALIGNED */
313 1, /* OMP_CLAUSE_DEPEND */
314 1, /* OMP_CLAUSE_UNIFORM */
315 2, /* OMP_CLAUSE_FROM */
316 2, /* OMP_CLAUSE_TO */
317 2, /* OMP_CLAUSE_MAP */
318 1, /* OMP_CLAUSE__LOOPTEMP_ */
319 1, /* OMP_CLAUSE_IF */
320 1, /* OMP_CLAUSE_NUM_THREADS */
321 1, /* OMP_CLAUSE_SCHEDULE */
322 0, /* OMP_CLAUSE_NOWAIT */
323 0, /* OMP_CLAUSE_ORDERED */
324 0, /* OMP_CLAUSE_DEFAULT */
325 3, /* OMP_CLAUSE_COLLAPSE */
326 0, /* OMP_CLAUSE_UNTIED */
327 1, /* OMP_CLAUSE_FINAL */
328 0, /* OMP_CLAUSE_MERGEABLE */
329 1, /* OMP_CLAUSE_DEVICE */
330 1, /* OMP_CLAUSE_DIST_SCHEDULE */
331 0, /* OMP_CLAUSE_INBRANCH */
332 0, /* OMP_CLAUSE_NOTINBRANCH */
333 1, /* OMP_CLAUSE_NUM_TEAMS */
334 1, /* OMP_CLAUSE_THREAD_LIMIT */
335 0, /* OMP_CLAUSE_PROC_BIND */
336 1, /* OMP_CLAUSE_SAFELEN */
337 1, /* OMP_CLAUSE_SIMDLEN */
338 0, /* OMP_CLAUSE_FOR */
339 0, /* OMP_CLAUSE_PARALLEL */
340 0, /* OMP_CLAUSE_SECTIONS */
341 0, /* OMP_CLAUSE_TASKGROUP */
342 1, /* OMP_CLAUSE__SIMDUID_ */
343 1, /* OMP_CLAUSE__CILK_FOR_COUNT_ */
346 const char * const omp_clause_code_name[] =
348 "error_clause",
349 "private",
350 "shared",
351 "firstprivate",
352 "lastprivate",
353 "reduction",
354 "copyin",
355 "copyprivate",
356 "linear",
357 "aligned",
358 "depend",
359 "uniform",
360 "from",
361 "to",
362 "map",
363 "_looptemp_",
364 "if",
365 "num_threads",
366 "schedule",
367 "nowait",
368 "ordered",
369 "default",
370 "collapse",
371 "untied",
372 "final",
373 "mergeable",
374 "device",
375 "dist_schedule",
376 "inbranch",
377 "notinbranch",
378 "num_teams",
379 "thread_limit",
380 "proc_bind",
381 "safelen",
382 "simdlen",
383 "for",
384 "parallel",
385 "sections",
386 "taskgroup",
387 "_simduid_",
388 "_Cilk_for_count_"
392 /* Return the tree node structure used by tree code CODE. */
394 static inline enum tree_node_structure_enum
395 tree_node_structure_for_code (enum tree_code code)
397 switch (TREE_CODE_CLASS (code))
399 case tcc_declaration:
401 switch (code)
403 case FIELD_DECL:
404 return TS_FIELD_DECL;
405 case PARM_DECL:
406 return TS_PARM_DECL;
407 case VAR_DECL:
408 return TS_VAR_DECL;
409 case LABEL_DECL:
410 return TS_LABEL_DECL;
411 case RESULT_DECL:
412 return TS_RESULT_DECL;
413 case DEBUG_EXPR_DECL:
414 return TS_DECL_WRTL;
415 case CONST_DECL:
416 return TS_CONST_DECL;
417 case TYPE_DECL:
418 return TS_TYPE_DECL;
419 case FUNCTION_DECL:
420 return TS_FUNCTION_DECL;
421 case TRANSLATION_UNIT_DECL:
422 return TS_TRANSLATION_UNIT_DECL;
423 default:
424 return TS_DECL_NON_COMMON;
427 case tcc_type:
428 return TS_TYPE_NON_COMMON;
429 case tcc_reference:
430 case tcc_comparison:
431 case tcc_unary:
432 case tcc_binary:
433 case tcc_expression:
434 case tcc_statement:
435 case tcc_vl_exp:
436 return TS_EXP;
437 default: /* tcc_constant and tcc_exceptional */
438 break;
440 switch (code)
442 /* tcc_constant cases. */
443 case VOID_CST: return TS_TYPED;
444 case INTEGER_CST: return TS_INT_CST;
445 case REAL_CST: return TS_REAL_CST;
446 case FIXED_CST: return TS_FIXED_CST;
447 case COMPLEX_CST: return TS_COMPLEX;
448 case VECTOR_CST: return TS_VECTOR;
449 case STRING_CST: return TS_STRING;
450 /* tcc_exceptional cases. */
451 case ERROR_MARK: return TS_COMMON;
452 case IDENTIFIER_NODE: return TS_IDENTIFIER;
453 case TREE_LIST: return TS_LIST;
454 case TREE_VEC: return TS_VEC;
455 case SSA_NAME: return TS_SSA_NAME;
456 case PLACEHOLDER_EXPR: return TS_COMMON;
457 case STATEMENT_LIST: return TS_STATEMENT_LIST;
458 case BLOCK: return TS_BLOCK;
459 case CONSTRUCTOR: return TS_CONSTRUCTOR;
460 case TREE_BINFO: return TS_BINFO;
461 case OMP_CLAUSE: return TS_OMP_CLAUSE;
462 case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
463 case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
465 default:
466 gcc_unreachable ();
471 /* Initialize tree_contains_struct to describe the hierarchy of tree
472 nodes. */
474 static void
475 initialize_tree_contains_struct (void)
477 unsigned i;
479 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
481 enum tree_code code;
482 enum tree_node_structure_enum ts_code;
484 code = (enum tree_code) i;
485 ts_code = tree_node_structure_for_code (code);
487 /* Mark the TS structure itself. */
488 tree_contains_struct[code][ts_code] = 1;
490 /* Mark all the structures that TS is derived from. */
491 switch (ts_code)
493 case TS_TYPED:
494 case TS_BLOCK:
495 MARK_TS_BASE (code);
496 break;
498 case TS_COMMON:
499 case TS_INT_CST:
500 case TS_REAL_CST:
501 case TS_FIXED_CST:
502 case TS_VECTOR:
503 case TS_STRING:
504 case TS_COMPLEX:
505 case TS_SSA_NAME:
506 case TS_CONSTRUCTOR:
507 case TS_EXP:
508 case TS_STATEMENT_LIST:
509 MARK_TS_TYPED (code);
510 break;
512 case TS_IDENTIFIER:
513 case TS_DECL_MINIMAL:
514 case TS_TYPE_COMMON:
515 case TS_LIST:
516 case TS_VEC:
517 case TS_BINFO:
518 case TS_OMP_CLAUSE:
519 case TS_OPTIMIZATION:
520 case TS_TARGET_OPTION:
521 MARK_TS_COMMON (code);
522 break;
524 case TS_TYPE_WITH_LANG_SPECIFIC:
525 MARK_TS_TYPE_COMMON (code);
526 break;
528 case TS_TYPE_NON_COMMON:
529 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
530 break;
532 case TS_DECL_COMMON:
533 MARK_TS_DECL_MINIMAL (code);
534 break;
536 case TS_DECL_WRTL:
537 case TS_CONST_DECL:
538 MARK_TS_DECL_COMMON (code);
539 break;
541 case TS_DECL_NON_COMMON:
542 MARK_TS_DECL_WITH_VIS (code);
543 break;
545 case TS_DECL_WITH_VIS:
546 case TS_PARM_DECL:
547 case TS_LABEL_DECL:
548 case TS_RESULT_DECL:
549 MARK_TS_DECL_WRTL (code);
550 break;
552 case TS_FIELD_DECL:
553 MARK_TS_DECL_COMMON (code);
554 break;
556 case TS_VAR_DECL:
557 MARK_TS_DECL_WITH_VIS (code);
558 break;
560 case TS_TYPE_DECL:
561 case TS_FUNCTION_DECL:
562 MARK_TS_DECL_NON_COMMON (code);
563 break;
565 case TS_TRANSLATION_UNIT_DECL:
566 MARK_TS_DECL_COMMON (code);
567 break;
569 default:
570 gcc_unreachable ();
574 /* Basic consistency checks for attributes used in fold. */
575 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
576 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
577 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
578 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
579 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
580 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
581 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
582 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
583 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
584 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
585 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
586 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
587 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
588 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
589 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
590 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
591 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
592 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
593 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
594 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
595 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
596 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
597 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
598 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
599 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
600 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
601 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
602 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
603 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
604 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
605 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
606 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
607 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
608 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
609 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
610 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
611 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
612 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
613 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
614 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
618 /* Init tree.c. */
620 void
621 init_ttree (void)
623 /* Initialize the hash table of types. */
624 type_hash_table
625 = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE);
627 debug_expr_for_decl
628 = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
630 value_expr_for_decl
631 = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
633 int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024);
635 int_cst_node = make_int_cst (1, 1);
637 cl_option_hash_table = hash_table<cl_option_hasher>::create_ggc (64);
639 cl_optimization_node = make_node (OPTIMIZATION_NODE);
640 cl_target_option_node = make_node (TARGET_OPTION_NODE);
642 /* Initialize the tree_contains_struct array. */
643 initialize_tree_contains_struct ();
644 lang_hooks.init_ts ();
648 /* The name of the object as the assembler will see it (but before any
649 translations made by ASM_OUTPUT_LABELREF). Often this is the same
650 as DECL_NAME. It is an IDENTIFIER_NODE. */
651 tree
652 decl_assembler_name (tree decl)
654 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
655 lang_hooks.set_decl_assembler_name (decl);
656 return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
659 /* When the target supports COMDAT groups, this indicates which group the
660 DECL is associated with. This can be either an IDENTIFIER_NODE or a
661 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
662 tree
663 decl_comdat_group (const_tree node)
665 struct symtab_node *snode = symtab_node::get (node);
666 if (!snode)
667 return NULL;
668 return snode->get_comdat_group ();
671 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
672 tree
673 decl_comdat_group_id (const_tree node)
675 struct symtab_node *snode = symtab_node::get (node);
676 if (!snode)
677 return NULL;
678 return snode->get_comdat_group_id ();
681 /* When the target supports named section, return its name as IDENTIFIER_NODE
682 or NULL if it is in no section. */
683 const char *
684 decl_section_name (const_tree node)
686 struct symtab_node *snode = symtab_node::get (node);
687 if (!snode)
688 return NULL;
689 return snode->get_section ();
692 /* Set section section name of NODE to VALUE (that is expected to
693 be identifier node) */
694 void
695 set_decl_section_name (tree node, const char *value)
697 struct symtab_node *snode;
699 if (value == NULL)
701 snode = symtab_node::get (node);
702 if (!snode)
703 return;
705 else if (TREE_CODE (node) == VAR_DECL)
706 snode = varpool_node::get_create (node);
707 else
708 snode = cgraph_node::get_create (node);
709 snode->set_section (value);
712 /* Return TLS model of a variable NODE. */
713 enum tls_model
714 decl_tls_model (const_tree node)
716 struct varpool_node *snode = varpool_node::get (node);
717 if (!snode)
718 return TLS_MODEL_NONE;
719 return snode->tls_model;
722 /* Set TLS model of variable NODE to MODEL. */
723 void
724 set_decl_tls_model (tree node, enum tls_model model)
726 struct varpool_node *vnode;
728 if (model == TLS_MODEL_NONE)
730 vnode = varpool_node::get (node);
731 if (!vnode)
732 return;
734 else
735 vnode = varpool_node::get_create (node);
736 vnode->tls_model = model;
739 /* Compute the number of bytes occupied by a tree with code CODE.
740 This function cannot be used for nodes that have variable sizes,
741 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
742 size_t
743 tree_code_size (enum tree_code code)
745 switch (TREE_CODE_CLASS (code))
747 case tcc_declaration: /* A decl node */
749 switch (code)
751 case FIELD_DECL:
752 return sizeof (struct tree_field_decl);
753 case PARM_DECL:
754 return sizeof (struct tree_parm_decl);
755 case VAR_DECL:
756 return sizeof (struct tree_var_decl);
757 case LABEL_DECL:
758 return sizeof (struct tree_label_decl);
759 case RESULT_DECL:
760 return sizeof (struct tree_result_decl);
761 case CONST_DECL:
762 return sizeof (struct tree_const_decl);
763 case TYPE_DECL:
764 return sizeof (struct tree_type_decl);
765 case FUNCTION_DECL:
766 return sizeof (struct tree_function_decl);
767 case DEBUG_EXPR_DECL:
768 return sizeof (struct tree_decl_with_rtl);
769 case TRANSLATION_UNIT_DECL:
770 return sizeof (struct tree_translation_unit_decl);
771 case NAMESPACE_DECL:
772 case IMPORTED_DECL:
773 case NAMELIST_DECL:
774 return sizeof (struct tree_decl_non_common);
775 default:
776 return lang_hooks.tree_size (code);
780 case tcc_type: /* a type node */
781 return sizeof (struct tree_type_non_common);
783 case tcc_reference: /* a reference */
784 case tcc_expression: /* an expression */
785 case tcc_statement: /* an expression with side effects */
786 case tcc_comparison: /* a comparison expression */
787 case tcc_unary: /* a unary arithmetic expression */
788 case tcc_binary: /* a binary arithmetic expression */
789 return (sizeof (struct tree_exp)
790 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
792 case tcc_constant: /* a constant */
793 switch (code)
795 case VOID_CST: return sizeof (struct tree_typed);
796 case INTEGER_CST: gcc_unreachable ();
797 case REAL_CST: return sizeof (struct tree_real_cst);
798 case FIXED_CST: return sizeof (struct tree_fixed_cst);
799 case COMPLEX_CST: return sizeof (struct tree_complex);
800 case VECTOR_CST: return sizeof (struct tree_vector);
801 case STRING_CST: gcc_unreachable ();
802 default:
803 return lang_hooks.tree_size (code);
806 case tcc_exceptional: /* something random, like an identifier. */
807 switch (code)
809 case IDENTIFIER_NODE: return lang_hooks.identifier_size;
810 case TREE_LIST: return sizeof (struct tree_list);
812 case ERROR_MARK:
813 case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
815 case TREE_VEC:
816 case OMP_CLAUSE: gcc_unreachable ();
818 case SSA_NAME: return sizeof (struct tree_ssa_name);
820 case STATEMENT_LIST: return sizeof (struct tree_statement_list);
821 case BLOCK: return sizeof (struct tree_block);
822 case CONSTRUCTOR: return sizeof (struct tree_constructor);
823 case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
824 case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
826 default:
827 return lang_hooks.tree_size (code);
830 default:
831 gcc_unreachable ();
835 /* Compute the number of bytes occupied by NODE. This routine only
836 looks at TREE_CODE, except for those nodes that have variable sizes. */
837 size_t
838 tree_size (const_tree node)
840 const enum tree_code code = TREE_CODE (node);
841 switch (code)
843 case INTEGER_CST:
844 return (sizeof (struct tree_int_cst)
845 + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT));
847 case TREE_BINFO:
848 return (offsetof (struct tree_binfo, base_binfos)
849 + vec<tree, va_gc>
850 ::embedded_size (BINFO_N_BASE_BINFOS (node)));
852 case TREE_VEC:
853 return (sizeof (struct tree_vec)
854 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
856 case VECTOR_CST:
857 return (sizeof (struct tree_vector)
858 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node)) - 1) * sizeof (tree));
860 case STRING_CST:
861 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
863 case OMP_CLAUSE:
864 return (sizeof (struct tree_omp_clause)
865 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
866 * sizeof (tree));
868 default:
869 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
870 return (sizeof (struct tree_exp)
871 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
872 else
873 return tree_code_size (code);
877 /* Record interesting allocation statistics for a tree node with CODE
878 and LENGTH. */
880 static void
881 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
882 size_t length ATTRIBUTE_UNUSED)
884 enum tree_code_class type = TREE_CODE_CLASS (code);
885 tree_node_kind kind;
887 if (!GATHER_STATISTICS)
888 return;
890 switch (type)
892 case tcc_declaration: /* A decl node */
893 kind = d_kind;
894 break;
896 case tcc_type: /* a type node */
897 kind = t_kind;
898 break;
900 case tcc_statement: /* an expression with side effects */
901 kind = s_kind;
902 break;
904 case tcc_reference: /* a reference */
905 kind = r_kind;
906 break;
908 case tcc_expression: /* an expression */
909 case tcc_comparison: /* a comparison expression */
910 case tcc_unary: /* a unary arithmetic expression */
911 case tcc_binary: /* a binary arithmetic expression */
912 kind = e_kind;
913 break;
915 case tcc_constant: /* a constant */
916 kind = c_kind;
917 break;
919 case tcc_exceptional: /* something random, like an identifier. */
920 switch (code)
922 case IDENTIFIER_NODE:
923 kind = id_kind;
924 break;
926 case TREE_VEC:
927 kind = vec_kind;
928 break;
930 case TREE_BINFO:
931 kind = binfo_kind;
932 break;
934 case SSA_NAME:
935 kind = ssa_name_kind;
936 break;
938 case BLOCK:
939 kind = b_kind;
940 break;
942 case CONSTRUCTOR:
943 kind = constr_kind;
944 break;
946 case OMP_CLAUSE:
947 kind = omp_clause_kind;
948 break;
950 default:
951 kind = x_kind;
952 break;
954 break;
956 case tcc_vl_exp:
957 kind = e_kind;
958 break;
960 default:
961 gcc_unreachable ();
964 tree_code_counts[(int) code]++;
965 tree_node_counts[(int) kind]++;
966 tree_node_sizes[(int) kind] += length;
969 /* Allocate and return a new UID from the DECL_UID namespace. */
972 allocate_decl_uid (void)
974 return next_decl_uid++;
977 /* Return a newly allocated node of code CODE. For decl and type
978 nodes, some other fields are initialized. The rest of the node is
979 initialized to zero. This function cannot be used for TREE_VEC,
980 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
981 tree_code_size.
983 Achoo! I got a code in the node. */
985 tree
986 make_node_stat (enum tree_code code MEM_STAT_DECL)
988 tree t;
989 enum tree_code_class type = TREE_CODE_CLASS (code);
990 size_t length = tree_code_size (code);
992 record_node_allocation_statistics (code, length);
994 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
995 TREE_SET_CODE (t, code);
997 switch (type)
999 case tcc_statement:
1000 TREE_SIDE_EFFECTS (t) = 1;
1001 break;
1003 case tcc_declaration:
1004 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1006 if (code == FUNCTION_DECL)
1008 DECL_ALIGN (t) = FUNCTION_BOUNDARY;
1009 DECL_MODE (t) = FUNCTION_MODE;
1011 else
1012 DECL_ALIGN (t) = 1;
1014 DECL_SOURCE_LOCATION (t) = input_location;
1015 if (TREE_CODE (t) == DEBUG_EXPR_DECL)
1016 DECL_UID (t) = --next_debug_decl_uid;
1017 else
1019 DECL_UID (t) = allocate_decl_uid ();
1020 SET_DECL_PT_UID (t, -1);
1022 if (TREE_CODE (t) == LABEL_DECL)
1023 LABEL_DECL_UID (t) = -1;
1025 break;
1027 case tcc_type:
1028 TYPE_UID (t) = next_type_uid++;
1029 TYPE_ALIGN (t) = BITS_PER_UNIT;
1030 TYPE_USER_ALIGN (t) = 0;
1031 TYPE_MAIN_VARIANT (t) = t;
1032 TYPE_CANONICAL (t) = t;
1034 /* Default to no attributes for type, but let target change that. */
1035 TYPE_ATTRIBUTES (t) = NULL_TREE;
1036 targetm.set_default_type_attributes (t);
1038 /* We have not yet computed the alias set for this type. */
1039 TYPE_ALIAS_SET (t) = -1;
1040 break;
1042 case tcc_constant:
1043 TREE_CONSTANT (t) = 1;
1044 break;
1046 case tcc_expression:
1047 switch (code)
1049 case INIT_EXPR:
1050 case MODIFY_EXPR:
1051 case VA_ARG_EXPR:
1052 case PREDECREMENT_EXPR:
1053 case PREINCREMENT_EXPR:
1054 case POSTDECREMENT_EXPR:
1055 case POSTINCREMENT_EXPR:
1056 /* All of these have side-effects, no matter what their
1057 operands are. */
1058 TREE_SIDE_EFFECTS (t) = 1;
1059 break;
1061 default:
1062 break;
1064 break;
1066 default:
1067 /* Other classes need no special treatment. */
1068 break;
1071 return t;
1074 /* Return a new node with the same contents as NODE except that its
1075 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1077 tree
1078 copy_node_stat (tree node MEM_STAT_DECL)
1080 tree t;
1081 enum tree_code code = TREE_CODE (node);
1082 size_t length;
1084 gcc_assert (code != STATEMENT_LIST);
1086 length = tree_size (node);
1087 record_node_allocation_statistics (code, length);
1088 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
1089 memcpy (t, node, length);
1091 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1092 TREE_CHAIN (t) = 0;
1093 TREE_ASM_WRITTEN (t) = 0;
1094 TREE_VISITED (t) = 0;
1096 if (TREE_CODE_CLASS (code) == tcc_declaration)
1098 if (code == DEBUG_EXPR_DECL)
1099 DECL_UID (t) = --next_debug_decl_uid;
1100 else
1102 DECL_UID (t) = allocate_decl_uid ();
1103 if (DECL_PT_UID_SET_P (node))
1104 SET_DECL_PT_UID (t, DECL_PT_UID (node));
1106 if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
1107 && DECL_HAS_VALUE_EXPR_P (node))
1109 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
1110 DECL_HAS_VALUE_EXPR_P (t) = 1;
1112 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1113 if (TREE_CODE (node) == VAR_DECL)
1115 DECL_HAS_DEBUG_EXPR_P (t) = 0;
1116 t->decl_with_vis.symtab_node = NULL;
1118 if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
1120 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
1121 DECL_HAS_INIT_PRIORITY_P (t) = 1;
1123 if (TREE_CODE (node) == FUNCTION_DECL)
1125 DECL_STRUCT_FUNCTION (t) = NULL;
1126 t->decl_with_vis.symtab_node = NULL;
1129 else if (TREE_CODE_CLASS (code) == tcc_type)
1131 TYPE_UID (t) = next_type_uid++;
1132 /* The following is so that the debug code for
1133 the copy is different from the original type.
1134 The two statements usually duplicate each other
1135 (because they clear fields of the same union),
1136 but the optimizer should catch that. */
1137 TYPE_SYMTAB_POINTER (t) = 0;
1138 TYPE_SYMTAB_ADDRESS (t) = 0;
1140 /* Do not copy the values cache. */
1141 if (TYPE_CACHED_VALUES_P (t))
1143 TYPE_CACHED_VALUES_P (t) = 0;
1144 TYPE_CACHED_VALUES (t) = NULL_TREE;
1148 return t;
1151 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1152 For example, this can copy a list made of TREE_LIST nodes. */
1154 tree
1155 copy_list (tree list)
1157 tree head;
1158 tree prev, next;
1160 if (list == 0)
1161 return 0;
1163 head = prev = copy_node (list);
1164 next = TREE_CHAIN (list);
1165 while (next)
1167 TREE_CHAIN (prev) = copy_node (next);
1168 prev = TREE_CHAIN (prev);
1169 next = TREE_CHAIN (next);
1171 return head;
1175 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1176 INTEGER_CST with value CST and type TYPE. */
1178 static unsigned int
1179 get_int_cst_ext_nunits (tree type, const wide_int &cst)
1181 gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
1182 /* We need an extra zero HWI if CST is an unsigned integer with its
1183 upper bit set, and if CST occupies a whole number of HWIs. */
1184 if (TYPE_UNSIGNED (type)
1185 && wi::neg_p (cst)
1186 && (cst.get_precision () % HOST_BITS_PER_WIDE_INT) == 0)
1187 return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
1188 return cst.get_len ();
1191 /* Return a new INTEGER_CST with value CST and type TYPE. */
1193 static tree
1194 build_new_int_cst (tree type, const wide_int &cst)
1196 unsigned int len = cst.get_len ();
1197 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1198 tree nt = make_int_cst (len, ext_len);
1200 if (len < ext_len)
1202 --ext_len;
1203 TREE_INT_CST_ELT (nt, ext_len) = 0;
1204 for (unsigned int i = len; i < ext_len; ++i)
1205 TREE_INT_CST_ELT (nt, i) = -1;
1207 else if (TYPE_UNSIGNED (type)
1208 && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT)
1210 len--;
1211 TREE_INT_CST_ELT (nt, len)
1212 = zext_hwi (cst.elt (len),
1213 cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1216 for (unsigned int i = 0; i < len; i++)
1217 TREE_INT_CST_ELT (nt, i) = cst.elt (i);
1218 TREE_TYPE (nt) = type;
1219 return nt;
1222 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1224 tree
1225 build_int_cst (tree type, HOST_WIDE_INT low)
1227 /* Support legacy code. */
1228 if (!type)
1229 type = integer_type_node;
1231 return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1234 tree
1235 build_int_cstu (tree type, unsigned HOST_WIDE_INT cst)
1237 return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
1240 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1242 tree
1243 build_int_cst_type (tree type, HOST_WIDE_INT low)
1245 gcc_assert (type);
1246 return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1249 /* Constructs tree in type TYPE from with value given by CST. Signedness
1250 of CST is assumed to be the same as the signedness of TYPE. */
1252 tree
1253 double_int_to_tree (tree type, double_int cst)
1255 return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type)));
1258 /* We force the wide_int CST to the range of the type TYPE by sign or
1259 zero extending it. OVERFLOWABLE indicates if we are interested in
1260 overflow of the value, when >0 we are only interested in signed
1261 overflow, for <0 we are interested in any overflow. OVERFLOWED
1262 indicates whether overflow has already occurred. CONST_OVERFLOWED
1263 indicates whether constant overflow has already occurred. We force
1264 T's value to be within range of T's type (by setting to 0 or 1 all
1265 the bits outside the type's range). We set TREE_OVERFLOWED if,
1266 OVERFLOWED is nonzero,
1267 or OVERFLOWABLE is >0 and signed overflow occurs
1268 or OVERFLOWABLE is <0 and any overflow occurs
1269 We return a new tree node for the extended wide_int. The node
1270 is shared if no overflow flags are set. */
1273 tree
1274 force_fit_type (tree type, const wide_int_ref &cst,
1275 int overflowable, bool overflowed)
1277 signop sign = TYPE_SIGN (type);
1279 /* If we need to set overflow flags, return a new unshared node. */
1280 if (overflowed || !wi::fits_to_tree_p (cst, type))
1282 if (overflowed
1283 || overflowable < 0
1284 || (overflowable > 0 && sign == SIGNED))
1286 wide_int tmp = wide_int::from (cst, TYPE_PRECISION (type), sign);
1287 tree t = build_new_int_cst (type, tmp);
1288 TREE_OVERFLOW (t) = 1;
1289 return t;
1293 /* Else build a shared node. */
1294 return wide_int_to_tree (type, cst);
1297 /* These are the hash table functions for the hash table of INTEGER_CST
1298 nodes of a sizetype. */
1300 /* Return the hash code code X, an INTEGER_CST. */
1302 hashval_t
1303 int_cst_hasher::hash (tree x)
1305 const_tree const t = x;
1306 hashval_t code = htab_hash_pointer (TREE_TYPE (t));
1307 int i;
1309 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
1310 code ^= TREE_INT_CST_ELT (t, i);
1312 return code;
1315 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1316 is the same as that given by *Y, which is the same. */
1318 bool
1319 int_cst_hasher::equal (tree x, tree y)
1321 const_tree const xt = x;
1322 const_tree const yt = y;
1324 if (TREE_TYPE (xt) != TREE_TYPE (yt)
1325 || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt)
1326 || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt))
1327 return false;
1329 for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++)
1330 if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i))
1331 return false;
1333 return true;
1336 /* Create an INT_CST node of TYPE and value CST.
1337 The returned node is always shared. For small integers we use a
1338 per-type vector cache, for larger ones we use a single hash table.
1339 The value is extended from its precision according to the sign of
1340 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1341 the upper bits and ensures that hashing and value equality based
1342 upon the underlying HOST_WIDE_INTs works without masking. */
1344 tree
1345 wide_int_to_tree (tree type, const wide_int_ref &pcst)
1347 tree t;
1348 int ix = -1;
1349 int limit = 0;
1351 gcc_assert (type);
1352 unsigned int prec = TYPE_PRECISION (type);
1353 signop sgn = TYPE_SIGN (type);
1355 /* Verify that everything is canonical. */
1356 int l = pcst.get_len ();
1357 if (l > 1)
1359 if (pcst.elt (l - 1) == 0)
1360 gcc_checking_assert (pcst.elt (l - 2) < 0);
1361 if (pcst.elt (l - 1) == (HOST_WIDE_INT) -1)
1362 gcc_checking_assert (pcst.elt (l - 2) >= 0);
1365 wide_int cst = wide_int::from (pcst, prec, sgn);
1366 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1368 if (ext_len == 1)
1370 /* We just need to store a single HOST_WIDE_INT. */
1371 HOST_WIDE_INT hwi;
1372 if (TYPE_UNSIGNED (type))
1373 hwi = cst.to_uhwi ();
1374 else
1375 hwi = cst.to_shwi ();
1377 switch (TREE_CODE (type))
1379 case NULLPTR_TYPE:
1380 gcc_assert (hwi == 0);
1381 /* Fallthru. */
1383 case POINTER_TYPE:
1384 case REFERENCE_TYPE:
1385 case POINTER_BOUNDS_TYPE:
1386 /* Cache NULL pointer and zero bounds. */
1387 if (hwi == 0)
1389 limit = 1;
1390 ix = 0;
1392 break;
1394 case BOOLEAN_TYPE:
1395 /* Cache false or true. */
1396 limit = 2;
1397 if (hwi < 2)
1398 ix = hwi;
1399 break;
1401 case INTEGER_TYPE:
1402 case OFFSET_TYPE:
1403 if (TYPE_SIGN (type) == UNSIGNED)
1405 /* Cache [0, N). */
1406 limit = INTEGER_SHARE_LIMIT;
1407 if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1))
1408 ix = hwi;
1410 else
1412 /* Cache [-1, N). */
1413 limit = INTEGER_SHARE_LIMIT + 1;
1414 if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1))
1415 ix = hwi + 1;
1417 break;
1419 case ENUMERAL_TYPE:
1420 break;
1422 default:
1423 gcc_unreachable ();
1426 if (ix >= 0)
1428 /* Look for it in the type's vector of small shared ints. */
1429 if (!TYPE_CACHED_VALUES_P (type))
1431 TYPE_CACHED_VALUES_P (type) = 1;
1432 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1435 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1436 if (t)
1437 /* Make sure no one is clobbering the shared constant. */
1438 gcc_checking_assert (TREE_TYPE (t) == type
1439 && TREE_INT_CST_NUNITS (t) == 1
1440 && TREE_INT_CST_OFFSET_NUNITS (t) == 1
1441 && TREE_INT_CST_EXT_NUNITS (t) == 1
1442 && TREE_INT_CST_ELT (t, 0) == hwi);
1443 else
1445 /* Create a new shared int. */
1446 t = build_new_int_cst (type, cst);
1447 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1450 else
1452 /* Use the cache of larger shared ints, using int_cst_node as
1453 a temporary. */
1455 TREE_INT_CST_ELT (int_cst_node, 0) = hwi;
1456 TREE_TYPE (int_cst_node) = type;
1458 tree *slot = int_cst_hash_table->find_slot (int_cst_node, INSERT);
1459 t = *slot;
1460 if (!t)
1462 /* Insert this one into the hash table. */
1463 t = int_cst_node;
1464 *slot = t;
1465 /* Make a new node for next time round. */
1466 int_cst_node = make_int_cst (1, 1);
1470 else
1472 /* The value either hashes properly or we drop it on the floor
1473 for the gc to take care of. There will not be enough of them
1474 to worry about. */
1476 tree nt = build_new_int_cst (type, cst);
1477 tree *slot = int_cst_hash_table->find_slot (nt, INSERT);
1478 t = *slot;
1479 if (!t)
1481 /* Insert this one into the hash table. */
1482 t = nt;
1483 *slot = t;
1487 return t;
1490 void
1491 cache_integer_cst (tree t)
1493 tree type = TREE_TYPE (t);
1494 int ix = -1;
1495 int limit = 0;
1496 int prec = TYPE_PRECISION (type);
1498 gcc_assert (!TREE_OVERFLOW (t));
1500 switch (TREE_CODE (type))
1502 case NULLPTR_TYPE:
1503 gcc_assert (integer_zerop (t));
1504 /* Fallthru. */
1506 case POINTER_TYPE:
1507 case REFERENCE_TYPE:
1508 /* Cache NULL pointer. */
1509 if (integer_zerop (t))
1511 limit = 1;
1512 ix = 0;
1514 break;
1516 case BOOLEAN_TYPE:
1517 /* Cache false or true. */
1518 limit = 2;
1519 if (wi::ltu_p (t, 2))
1520 ix = TREE_INT_CST_ELT (t, 0);
1521 break;
1523 case INTEGER_TYPE:
1524 case OFFSET_TYPE:
1525 if (TYPE_UNSIGNED (type))
1527 /* Cache 0..N */
1528 limit = INTEGER_SHARE_LIMIT;
1530 /* This is a little hokie, but if the prec is smaller than
1531 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1532 obvious test will not get the correct answer. */
1533 if (prec < HOST_BITS_PER_WIDE_INT)
1535 if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
1536 ix = tree_to_uhwi (t);
1538 else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1539 ix = tree_to_uhwi (t);
1541 else
1543 /* Cache -1..N */
1544 limit = INTEGER_SHARE_LIMIT + 1;
1546 if (integer_minus_onep (t))
1547 ix = 0;
1548 else if (!wi::neg_p (t))
1550 if (prec < HOST_BITS_PER_WIDE_INT)
1552 if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
1553 ix = tree_to_shwi (t) + 1;
1555 else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1556 ix = tree_to_shwi (t) + 1;
1559 break;
1561 case ENUMERAL_TYPE:
1562 break;
1564 default:
1565 gcc_unreachable ();
1568 if (ix >= 0)
1570 /* Look for it in the type's vector of small shared ints. */
1571 if (!TYPE_CACHED_VALUES_P (type))
1573 TYPE_CACHED_VALUES_P (type) = 1;
1574 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1577 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
1578 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1580 else
1582 /* Use the cache of larger shared ints. */
1583 tree *slot = int_cst_hash_table->find_slot (t, INSERT);
1584 /* If there is already an entry for the number verify it's the
1585 same. */
1586 if (*slot)
1587 gcc_assert (wi::eq_p (tree (*slot), t));
1588 else
1589 /* Otherwise insert this one into the hash table. */
1590 *slot = t;
1595 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1596 and the rest are zeros. */
1598 tree
1599 build_low_bits_mask (tree type, unsigned bits)
1601 gcc_assert (bits <= TYPE_PRECISION (type));
1603 return wide_int_to_tree (type, wi::mask (bits, false,
1604 TYPE_PRECISION (type)));
1607 /* Checks that X is integer constant that can be expressed in (unsigned)
1608 HOST_WIDE_INT without loss of precision. */
1610 bool
1611 cst_and_fits_in_hwi (const_tree x)
1613 if (TREE_CODE (x) != INTEGER_CST)
1614 return false;
1616 if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1617 return false;
1619 return TREE_INT_CST_NUNITS (x) == 1;
1622 /* Build a newly constructed TREE_VEC node of length LEN. */
1624 tree
1625 make_vector_stat (unsigned len MEM_STAT_DECL)
1627 tree t;
1628 unsigned length = (len - 1) * sizeof (tree) + sizeof (struct tree_vector);
1630 record_node_allocation_statistics (VECTOR_CST, length);
1632 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1634 TREE_SET_CODE (t, VECTOR_CST);
1635 TREE_CONSTANT (t) = 1;
1637 return t;
1640 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1641 are in a list pointed to by VALS. */
1643 tree
1644 build_vector_stat (tree type, tree *vals MEM_STAT_DECL)
1646 int over = 0;
1647 unsigned cnt = 0;
1648 tree v = make_vector (TYPE_VECTOR_SUBPARTS (type));
1649 TREE_TYPE (v) = type;
1651 /* Iterate through elements and check for overflow. */
1652 for (cnt = 0; cnt < TYPE_VECTOR_SUBPARTS (type); ++cnt)
1654 tree value = vals[cnt];
1656 VECTOR_CST_ELT (v, cnt) = value;
1658 /* Don't crash if we get an address constant. */
1659 if (!CONSTANT_CLASS_P (value))
1660 continue;
1662 over |= TREE_OVERFLOW (value);
1665 TREE_OVERFLOW (v) = over;
1666 return v;
1669 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1670 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1672 tree
1673 build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
1675 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
1676 unsigned HOST_WIDE_INT idx;
1677 tree value;
1679 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1680 vec[idx] = value;
1681 for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx)
1682 vec[idx] = build_zero_cst (TREE_TYPE (type));
1684 return build_vector (type, vec);
1687 /* Build a vector of type VECTYPE where all the elements are SCs. */
1688 tree
1689 build_vector_from_val (tree vectype, tree sc)
1691 int i, nunits = TYPE_VECTOR_SUBPARTS (vectype);
1693 if (sc == error_mark_node)
1694 return sc;
1696 /* Verify that the vector type is suitable for SC. Note that there
1697 is some inconsistency in the type-system with respect to restrict
1698 qualifications of pointers. Vector types always have a main-variant
1699 element type and the qualification is applied to the vector-type.
1700 So TREE_TYPE (vector-type) does not return a properly qualified
1701 vector element-type. */
1702 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
1703 TREE_TYPE (vectype)));
1705 if (CONSTANT_CLASS_P (sc))
1707 tree *v = XALLOCAVEC (tree, nunits);
1708 for (i = 0; i < nunits; ++i)
1709 v[i] = sc;
1710 return build_vector (vectype, v);
1712 else
1714 vec<constructor_elt, va_gc> *v;
1715 vec_alloc (v, nunits);
1716 for (i = 0; i < nunits; ++i)
1717 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1718 return build_constructor (vectype, v);
1722 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1723 are in the vec pointed to by VALS. */
1724 tree
1725 build_constructor (tree type, vec<constructor_elt, va_gc> *vals)
1727 tree c = make_node (CONSTRUCTOR);
1728 unsigned int i;
1729 constructor_elt *elt;
1730 bool constant_p = true;
1731 bool side_effects_p = false;
1733 TREE_TYPE (c) = type;
1734 CONSTRUCTOR_ELTS (c) = vals;
1736 FOR_EACH_VEC_SAFE_ELT (vals, i, elt)
1738 /* Mostly ctors will have elts that don't have side-effects, so
1739 the usual case is to scan all the elements. Hence a single
1740 loop for both const and side effects, rather than one loop
1741 each (with early outs). */
1742 if (!TREE_CONSTANT (elt->value))
1743 constant_p = false;
1744 if (TREE_SIDE_EFFECTS (elt->value))
1745 side_effects_p = true;
1748 TREE_SIDE_EFFECTS (c) = side_effects_p;
1749 TREE_CONSTANT (c) = constant_p;
1751 return c;
1754 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1755 INDEX and VALUE. */
1756 tree
1757 build_constructor_single (tree type, tree index, tree value)
1759 vec<constructor_elt, va_gc> *v;
1760 constructor_elt elt = {index, value};
1762 vec_alloc (v, 1);
1763 v->quick_push (elt);
1765 return build_constructor (type, v);
1769 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1770 are in a list pointed to by VALS. */
1771 tree
1772 build_constructor_from_list (tree type, tree vals)
1774 tree t;
1775 vec<constructor_elt, va_gc> *v = NULL;
1777 if (vals)
1779 vec_alloc (v, list_length (vals));
1780 for (t = vals; t; t = TREE_CHAIN (t))
1781 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1784 return build_constructor (type, v);
1787 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1788 of elements, provided as index/value pairs. */
1790 tree
1791 build_constructor_va (tree type, int nelts, ...)
1793 vec<constructor_elt, va_gc> *v = NULL;
1794 va_list p;
1796 va_start (p, nelts);
1797 vec_alloc (v, nelts);
1798 while (nelts--)
1800 tree index = va_arg (p, tree);
1801 tree value = va_arg (p, tree);
1802 CONSTRUCTOR_APPEND_ELT (v, index, value);
1804 va_end (p);
1805 return build_constructor (type, v);
1808 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1810 tree
1811 build_fixed (tree type, FIXED_VALUE_TYPE f)
1813 tree v;
1814 FIXED_VALUE_TYPE *fp;
1816 v = make_node (FIXED_CST);
1817 fp = ggc_alloc<fixed_value> ();
1818 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1820 TREE_TYPE (v) = type;
1821 TREE_FIXED_CST_PTR (v) = fp;
1822 return v;
1825 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1827 tree
1828 build_real (tree type, REAL_VALUE_TYPE d)
1830 tree v;
1831 REAL_VALUE_TYPE *dp;
1832 int overflow = 0;
1834 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1835 Consider doing it via real_convert now. */
1837 v = make_node (REAL_CST);
1838 dp = ggc_alloc<real_value> ();
1839 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1841 TREE_TYPE (v) = type;
1842 TREE_REAL_CST_PTR (v) = dp;
1843 TREE_OVERFLOW (v) = overflow;
1844 return v;
1847 /* Return a new REAL_CST node whose type is TYPE
1848 and whose value is the integer value of the INTEGER_CST node I. */
1850 REAL_VALUE_TYPE
1851 real_value_from_int_cst (const_tree type, const_tree i)
1853 REAL_VALUE_TYPE d;
1855 /* Clear all bits of the real value type so that we can later do
1856 bitwise comparisons to see if two values are the same. */
1857 memset (&d, 0, sizeof d);
1859 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, i,
1860 TYPE_SIGN (TREE_TYPE (i)));
1861 return d;
1864 /* Given a tree representing an integer constant I, return a tree
1865 representing the same value as a floating-point constant of type TYPE. */
1867 tree
1868 build_real_from_int_cst (tree type, const_tree i)
1870 tree v;
1871 int overflow = TREE_OVERFLOW (i);
1873 v = build_real (type, real_value_from_int_cst (type, i));
1875 TREE_OVERFLOW (v) |= overflow;
1876 return v;
1879 /* Return a newly constructed STRING_CST node whose value is
1880 the LEN characters at STR.
1881 Note that for a C string literal, LEN should include the trailing NUL.
1882 The TREE_TYPE is not initialized. */
1884 tree
1885 build_string (int len, const char *str)
1887 tree s;
1888 size_t length;
1890 /* Do not waste bytes provided by padding of struct tree_string. */
1891 length = len + offsetof (struct tree_string, str) + 1;
1893 record_node_allocation_statistics (STRING_CST, length);
1895 s = (tree) ggc_internal_alloc (length);
1897 memset (s, 0, sizeof (struct tree_typed));
1898 TREE_SET_CODE (s, STRING_CST);
1899 TREE_CONSTANT (s) = 1;
1900 TREE_STRING_LENGTH (s) = len;
1901 memcpy (s->string.str, str, len);
1902 s->string.str[len] = '\0';
1904 return s;
1907 /* Return a newly constructed COMPLEX_CST node whose value is
1908 specified by the real and imaginary parts REAL and IMAG.
1909 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1910 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1912 tree
1913 build_complex (tree type, tree real, tree imag)
1915 tree t = make_node (COMPLEX_CST);
1917 TREE_REALPART (t) = real;
1918 TREE_IMAGPART (t) = imag;
1919 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1920 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1921 return t;
1924 /* Return a constant of arithmetic type TYPE which is the
1925 multiplicative identity of the set TYPE. */
1927 tree
1928 build_one_cst (tree type)
1930 switch (TREE_CODE (type))
1932 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1933 case POINTER_TYPE: case REFERENCE_TYPE:
1934 case OFFSET_TYPE:
1935 return build_int_cst (type, 1);
1937 case REAL_TYPE:
1938 return build_real (type, dconst1);
1940 case FIXED_POINT_TYPE:
1941 /* We can only generate 1 for accum types. */
1942 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1943 return build_fixed (type, FCONST1 (TYPE_MODE (type)));
1945 case VECTOR_TYPE:
1947 tree scalar = build_one_cst (TREE_TYPE (type));
1949 return build_vector_from_val (type, scalar);
1952 case COMPLEX_TYPE:
1953 return build_complex (type,
1954 build_one_cst (TREE_TYPE (type)),
1955 build_zero_cst (TREE_TYPE (type)));
1957 default:
1958 gcc_unreachable ();
1962 /* Return an integer of type TYPE containing all 1's in as much precision as
1963 it contains, or a complex or vector whose subparts are such integers. */
1965 tree
1966 build_all_ones_cst (tree type)
1968 if (TREE_CODE (type) == COMPLEX_TYPE)
1970 tree scalar = build_all_ones_cst (TREE_TYPE (type));
1971 return build_complex (type, scalar, scalar);
1973 else
1974 return build_minus_one_cst (type);
1977 /* Return a constant of arithmetic type TYPE which is the
1978 opposite of the multiplicative identity of the set TYPE. */
1980 tree
1981 build_minus_one_cst (tree type)
1983 switch (TREE_CODE (type))
1985 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1986 case POINTER_TYPE: case REFERENCE_TYPE:
1987 case OFFSET_TYPE:
1988 return build_int_cst (type, -1);
1990 case REAL_TYPE:
1991 return build_real (type, dconstm1);
1993 case FIXED_POINT_TYPE:
1994 /* We can only generate 1 for accum types. */
1995 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1996 return build_fixed (type, fixed_from_double_int (double_int_minus_one,
1997 TYPE_MODE (type)));
1999 case VECTOR_TYPE:
2001 tree scalar = build_minus_one_cst (TREE_TYPE (type));
2003 return build_vector_from_val (type, scalar);
2006 case COMPLEX_TYPE:
2007 return build_complex (type,
2008 build_minus_one_cst (TREE_TYPE (type)),
2009 build_zero_cst (TREE_TYPE (type)));
2011 default:
2012 gcc_unreachable ();
2016 /* Build 0 constant of type TYPE. This is used by constructor folding
2017 and thus the constant should be represented in memory by
2018 zero(es). */
2020 tree
2021 build_zero_cst (tree type)
2023 switch (TREE_CODE (type))
2025 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2026 case POINTER_TYPE: case REFERENCE_TYPE:
2027 case OFFSET_TYPE: case NULLPTR_TYPE:
2028 return build_int_cst (type, 0);
2030 case REAL_TYPE:
2031 return build_real (type, dconst0);
2033 case FIXED_POINT_TYPE:
2034 return build_fixed (type, FCONST0 (TYPE_MODE (type)));
2036 case VECTOR_TYPE:
2038 tree scalar = build_zero_cst (TREE_TYPE (type));
2040 return build_vector_from_val (type, scalar);
2043 case COMPLEX_TYPE:
2045 tree zero = build_zero_cst (TREE_TYPE (type));
2047 return build_complex (type, zero, zero);
2050 default:
2051 if (!AGGREGATE_TYPE_P (type))
2052 return fold_convert (type, integer_zero_node);
2053 return build_constructor (type, NULL);
2058 /* Build a BINFO with LEN language slots. */
2060 tree
2061 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
2063 tree t;
2064 size_t length = (offsetof (struct tree_binfo, base_binfos)
2065 + vec<tree, va_gc>::embedded_size (base_binfos));
2067 record_node_allocation_statistics (TREE_BINFO, length);
2069 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
2071 memset (t, 0, offsetof (struct tree_binfo, base_binfos));
2073 TREE_SET_CODE (t, TREE_BINFO);
2075 BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
2077 return t;
2080 /* Create a CASE_LABEL_EXPR tree node and return it. */
2082 tree
2083 build_case_label (tree low_value, tree high_value, tree label_decl)
2085 tree t = make_node (CASE_LABEL_EXPR);
2087 TREE_TYPE (t) = void_type_node;
2088 SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
2090 CASE_LOW (t) = low_value;
2091 CASE_HIGH (t) = high_value;
2092 CASE_LABEL (t) = label_decl;
2093 CASE_CHAIN (t) = NULL_TREE;
2095 return t;
2098 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2099 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2100 The latter determines the length of the HOST_WIDE_INT vector. */
2102 tree
2103 make_int_cst_stat (int len, int ext_len MEM_STAT_DECL)
2105 tree t;
2106 int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT)
2107 + sizeof (struct tree_int_cst));
2109 gcc_assert (len);
2110 record_node_allocation_statistics (INTEGER_CST, length);
2112 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2114 TREE_SET_CODE (t, INTEGER_CST);
2115 TREE_INT_CST_NUNITS (t) = len;
2116 TREE_INT_CST_EXT_NUNITS (t) = ext_len;
2117 /* to_offset can only be applied to trees that are offset_int-sized
2118 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2119 must be exactly the precision of offset_int and so LEN is correct. */
2120 if (ext_len <= OFFSET_INT_ELTS)
2121 TREE_INT_CST_OFFSET_NUNITS (t) = ext_len;
2122 else
2123 TREE_INT_CST_OFFSET_NUNITS (t) = len;
2125 TREE_CONSTANT (t) = 1;
2127 return t;
2130 /* Build a newly constructed TREE_VEC node of length LEN. */
2132 tree
2133 make_tree_vec_stat (int len MEM_STAT_DECL)
2135 tree t;
2136 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2138 record_node_allocation_statistics (TREE_VEC, length);
2140 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2142 TREE_SET_CODE (t, TREE_VEC);
2143 TREE_VEC_LENGTH (t) = len;
2145 return t;
2148 /* Grow a TREE_VEC node to new length LEN. */
2150 tree
2151 grow_tree_vec_stat (tree v, int len MEM_STAT_DECL)
2153 gcc_assert (TREE_CODE (v) == TREE_VEC);
2155 int oldlen = TREE_VEC_LENGTH (v);
2156 gcc_assert (len > oldlen);
2158 int oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
2159 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2161 record_node_allocation_statistics (TREE_VEC, length - oldlength);
2163 v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
2165 TREE_VEC_LENGTH (v) = len;
2167 return v;
2170 /* Return 1 if EXPR is the integer constant zero or a complex constant
2171 of zero. */
2174 integer_zerop (const_tree expr)
2176 STRIP_NOPS (expr);
2178 switch (TREE_CODE (expr))
2180 case INTEGER_CST:
2181 return wi::eq_p (expr, 0);
2182 case COMPLEX_CST:
2183 return (integer_zerop (TREE_REALPART (expr))
2184 && integer_zerop (TREE_IMAGPART (expr)));
2185 case VECTOR_CST:
2187 unsigned i;
2188 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2189 if (!integer_zerop (VECTOR_CST_ELT (expr, i)))
2190 return false;
2191 return true;
2193 default:
2194 return false;
2198 /* Return 1 if EXPR is the integer constant one or the corresponding
2199 complex constant. */
2202 integer_onep (const_tree expr)
2204 STRIP_NOPS (expr);
2206 switch (TREE_CODE (expr))
2208 case INTEGER_CST:
2209 return wi::eq_p (wi::to_widest (expr), 1);
2210 case COMPLEX_CST:
2211 return (integer_onep (TREE_REALPART (expr))
2212 && integer_zerop (TREE_IMAGPART (expr)));
2213 case VECTOR_CST:
2215 unsigned i;
2216 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2217 if (!integer_onep (VECTOR_CST_ELT (expr, i)))
2218 return false;
2219 return true;
2221 default:
2222 return false;
2226 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2227 return 1 if every piece is the integer constant one. */
2230 integer_each_onep (const_tree expr)
2232 STRIP_NOPS (expr);
2234 if (TREE_CODE (expr) == COMPLEX_CST)
2235 return (integer_onep (TREE_REALPART (expr))
2236 && integer_onep (TREE_IMAGPART (expr)));
2237 else
2238 return integer_onep (expr);
2241 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2242 it contains, or a complex or vector whose subparts are such integers. */
2245 integer_all_onesp (const_tree expr)
2247 STRIP_NOPS (expr);
2249 if (TREE_CODE (expr) == COMPLEX_CST
2250 && integer_all_onesp (TREE_REALPART (expr))
2251 && integer_all_onesp (TREE_IMAGPART (expr)))
2252 return 1;
2254 else if (TREE_CODE (expr) == VECTOR_CST)
2256 unsigned i;
2257 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2258 if (!integer_all_onesp (VECTOR_CST_ELT (expr, i)))
2259 return 0;
2260 return 1;
2263 else if (TREE_CODE (expr) != INTEGER_CST)
2264 return 0;
2266 return wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED) == expr;
2269 /* Return 1 if EXPR is the integer constant minus one. */
2272 integer_minus_onep (const_tree expr)
2274 STRIP_NOPS (expr);
2276 if (TREE_CODE (expr) == COMPLEX_CST)
2277 return (integer_all_onesp (TREE_REALPART (expr))
2278 && integer_zerop (TREE_IMAGPART (expr)));
2279 else
2280 return integer_all_onesp (expr);
2283 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2284 one bit on). */
2287 integer_pow2p (const_tree expr)
2289 STRIP_NOPS (expr);
2291 if (TREE_CODE (expr) == COMPLEX_CST
2292 && integer_pow2p (TREE_REALPART (expr))
2293 && integer_zerop (TREE_IMAGPART (expr)))
2294 return 1;
2296 if (TREE_CODE (expr) != INTEGER_CST)
2297 return 0;
2299 return wi::popcount (expr) == 1;
2302 /* Return 1 if EXPR is an integer constant other than zero or a
2303 complex constant other than zero. */
2306 integer_nonzerop (const_tree expr)
2308 STRIP_NOPS (expr);
2310 return ((TREE_CODE (expr) == INTEGER_CST
2311 && !wi::eq_p (expr, 0))
2312 || (TREE_CODE (expr) == COMPLEX_CST
2313 && (integer_nonzerop (TREE_REALPART (expr))
2314 || integer_nonzerop (TREE_IMAGPART (expr)))));
2317 /* Return 1 if EXPR is the integer constant one. For vector,
2318 return 1 if every piece is the integer constant minus one
2319 (representing the value TRUE). */
2322 integer_truep (const_tree expr)
2324 STRIP_NOPS (expr);
2326 if (TREE_CODE (expr) == VECTOR_CST)
2327 return integer_all_onesp (expr);
2328 return integer_onep (expr);
2331 /* Return 1 if EXPR is the fixed-point constant zero. */
2334 fixed_zerop (const_tree expr)
2336 return (TREE_CODE (expr) == FIXED_CST
2337 && TREE_FIXED_CST (expr).data.is_zero ());
2340 /* Return the power of two represented by a tree node known to be a
2341 power of two. */
2344 tree_log2 (const_tree expr)
2346 STRIP_NOPS (expr);
2348 if (TREE_CODE (expr) == COMPLEX_CST)
2349 return tree_log2 (TREE_REALPART (expr));
2351 return wi::exact_log2 (expr);
2354 /* Similar, but return the largest integer Y such that 2 ** Y is less
2355 than or equal to EXPR. */
2358 tree_floor_log2 (const_tree expr)
2360 STRIP_NOPS (expr);
2362 if (TREE_CODE (expr) == COMPLEX_CST)
2363 return tree_log2 (TREE_REALPART (expr));
2365 return wi::floor_log2 (expr);
2368 /* Return number of known trailing zero bits in EXPR, or, if the value of
2369 EXPR is known to be zero, the precision of it's type. */
2371 unsigned int
2372 tree_ctz (const_tree expr)
2374 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
2375 && !POINTER_TYPE_P (TREE_TYPE (expr)))
2376 return 0;
2378 unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
2379 switch (TREE_CODE (expr))
2381 case INTEGER_CST:
2382 ret1 = wi::ctz (expr);
2383 return MIN (ret1, prec);
2384 case SSA_NAME:
2385 ret1 = wi::ctz (get_nonzero_bits (expr));
2386 return MIN (ret1, prec);
2387 case PLUS_EXPR:
2388 case MINUS_EXPR:
2389 case BIT_IOR_EXPR:
2390 case BIT_XOR_EXPR:
2391 case MIN_EXPR:
2392 case MAX_EXPR:
2393 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2394 if (ret1 == 0)
2395 return ret1;
2396 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2397 return MIN (ret1, ret2);
2398 case POINTER_PLUS_EXPR:
2399 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2400 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2401 /* Second operand is sizetype, which could be in theory
2402 wider than pointer's precision. Make sure we never
2403 return more than prec. */
2404 ret2 = MIN (ret2, prec);
2405 return MIN (ret1, ret2);
2406 case BIT_AND_EXPR:
2407 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2408 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2409 return MAX (ret1, ret2);
2410 case MULT_EXPR:
2411 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2412 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2413 return MIN (ret1 + ret2, prec);
2414 case LSHIFT_EXPR:
2415 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2416 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2417 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2419 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2420 return MIN (ret1 + ret2, prec);
2422 return ret1;
2423 case RSHIFT_EXPR:
2424 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2425 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2427 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2428 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2429 if (ret1 > ret2)
2430 return ret1 - ret2;
2432 return 0;
2433 case TRUNC_DIV_EXPR:
2434 case CEIL_DIV_EXPR:
2435 case FLOOR_DIV_EXPR:
2436 case ROUND_DIV_EXPR:
2437 case EXACT_DIV_EXPR:
2438 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
2439 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
2441 int l = tree_log2 (TREE_OPERAND (expr, 1));
2442 if (l >= 0)
2444 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2445 ret2 = l;
2446 if (ret1 > ret2)
2447 return ret1 - ret2;
2450 return 0;
2451 CASE_CONVERT:
2452 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2453 if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2454 ret1 = prec;
2455 return MIN (ret1, prec);
2456 case SAVE_EXPR:
2457 return tree_ctz (TREE_OPERAND (expr, 0));
2458 case COND_EXPR:
2459 ret1 = tree_ctz (TREE_OPERAND (expr, 1));
2460 if (ret1 == 0)
2461 return 0;
2462 ret2 = tree_ctz (TREE_OPERAND (expr, 2));
2463 return MIN (ret1, ret2);
2464 case COMPOUND_EXPR:
2465 return tree_ctz (TREE_OPERAND (expr, 1));
2466 case ADDR_EXPR:
2467 ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
2468 if (ret1 > BITS_PER_UNIT)
2470 ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
2471 return MIN (ret1, prec);
2473 return 0;
2474 default:
2475 return 0;
2479 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2480 decimal float constants, so don't return 1 for them. */
2483 real_zerop (const_tree expr)
2485 STRIP_NOPS (expr);
2487 switch (TREE_CODE (expr))
2489 case REAL_CST:
2490 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
2491 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2492 case COMPLEX_CST:
2493 return real_zerop (TREE_REALPART (expr))
2494 && real_zerop (TREE_IMAGPART (expr));
2495 case VECTOR_CST:
2497 unsigned i;
2498 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2499 if (!real_zerop (VECTOR_CST_ELT (expr, i)))
2500 return false;
2501 return true;
2503 default:
2504 return false;
2508 /* Return 1 if EXPR is the real constant one in real or complex form.
2509 Trailing zeroes matter for decimal float constants, so don't return
2510 1 for them. */
2513 real_onep (const_tree expr)
2515 STRIP_NOPS (expr);
2517 switch (TREE_CODE (expr))
2519 case REAL_CST:
2520 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
2521 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2522 case COMPLEX_CST:
2523 return real_onep (TREE_REALPART (expr))
2524 && real_zerop (TREE_IMAGPART (expr));
2525 case VECTOR_CST:
2527 unsigned i;
2528 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2529 if (!real_onep (VECTOR_CST_ELT (expr, i)))
2530 return false;
2531 return true;
2533 default:
2534 return false;
2538 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2539 matter for decimal float constants, so don't return 1 for them. */
2542 real_minus_onep (const_tree expr)
2544 STRIP_NOPS (expr);
2546 switch (TREE_CODE (expr))
2548 case REAL_CST:
2549 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
2550 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2551 case COMPLEX_CST:
2552 return real_minus_onep (TREE_REALPART (expr))
2553 && real_zerop (TREE_IMAGPART (expr));
2554 case VECTOR_CST:
2556 unsigned i;
2557 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2558 if (!real_minus_onep (VECTOR_CST_ELT (expr, i)))
2559 return false;
2560 return true;
2562 default:
2563 return false;
2567 /* Nonzero if EXP is a constant or a cast of a constant. */
2570 really_constant_p (const_tree exp)
2572 /* This is not quite the same as STRIP_NOPS. It does more. */
2573 while (CONVERT_EXPR_P (exp)
2574 || TREE_CODE (exp) == NON_LVALUE_EXPR)
2575 exp = TREE_OPERAND (exp, 0);
2576 return TREE_CONSTANT (exp);
2579 /* Return first list element whose TREE_VALUE is ELEM.
2580 Return 0 if ELEM is not in LIST. */
2582 tree
2583 value_member (tree elem, tree list)
2585 while (list)
2587 if (elem == TREE_VALUE (list))
2588 return list;
2589 list = TREE_CHAIN (list);
2591 return NULL_TREE;
2594 /* Return first list element whose TREE_PURPOSE is ELEM.
2595 Return 0 if ELEM is not in LIST. */
2597 tree
2598 purpose_member (const_tree elem, tree list)
2600 while (list)
2602 if (elem == TREE_PURPOSE (list))
2603 return list;
2604 list = TREE_CHAIN (list);
2606 return NULL_TREE;
2609 /* Return true if ELEM is in V. */
2611 bool
2612 vec_member (const_tree elem, vec<tree, va_gc> *v)
2614 unsigned ix;
2615 tree t;
2616 FOR_EACH_VEC_SAFE_ELT (v, ix, t)
2617 if (elem == t)
2618 return true;
2619 return false;
2622 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2623 NULL_TREE. */
2625 tree
2626 chain_index (int idx, tree chain)
2628 for (; chain && idx > 0; --idx)
2629 chain = TREE_CHAIN (chain);
2630 return chain;
2633 /* Return nonzero if ELEM is part of the chain CHAIN. */
2636 chain_member (const_tree elem, const_tree chain)
2638 while (chain)
2640 if (elem == chain)
2641 return 1;
2642 chain = DECL_CHAIN (chain);
2645 return 0;
2648 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2649 We expect a null pointer to mark the end of the chain.
2650 This is the Lisp primitive `length'. */
2653 list_length (const_tree t)
2655 const_tree p = t;
2656 #ifdef ENABLE_TREE_CHECKING
2657 const_tree q = t;
2658 #endif
2659 int len = 0;
2661 while (p)
2663 p = TREE_CHAIN (p);
2664 #ifdef ENABLE_TREE_CHECKING
2665 if (len % 2)
2666 q = TREE_CHAIN (q);
2667 gcc_assert (p != q);
2668 #endif
2669 len++;
2672 return len;
2675 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2676 UNION_TYPE TYPE, or NULL_TREE if none. */
2678 tree
2679 first_field (const_tree type)
2681 tree t = TYPE_FIELDS (type);
2682 while (t && TREE_CODE (t) != FIELD_DECL)
2683 t = TREE_CHAIN (t);
2684 return t;
2687 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2688 by modifying the last node in chain 1 to point to chain 2.
2689 This is the Lisp primitive `nconc'. */
2691 tree
2692 chainon (tree op1, tree op2)
2694 tree t1;
2696 if (!op1)
2697 return op2;
2698 if (!op2)
2699 return op1;
2701 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2702 continue;
2703 TREE_CHAIN (t1) = op2;
2705 #ifdef ENABLE_TREE_CHECKING
2707 tree t2;
2708 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2709 gcc_assert (t2 != t1);
2711 #endif
2713 return op1;
2716 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2718 tree
2719 tree_last (tree chain)
2721 tree next;
2722 if (chain)
2723 while ((next = TREE_CHAIN (chain)))
2724 chain = next;
2725 return chain;
2728 /* Reverse the order of elements in the chain T,
2729 and return the new head of the chain (old last element). */
2731 tree
2732 nreverse (tree t)
2734 tree prev = 0, decl, next;
2735 for (decl = t; decl; decl = next)
2737 /* We shouldn't be using this function to reverse BLOCK chains; we
2738 have blocks_nreverse for that. */
2739 gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2740 next = TREE_CHAIN (decl);
2741 TREE_CHAIN (decl) = prev;
2742 prev = decl;
2744 return prev;
2747 /* Return a newly created TREE_LIST node whose
2748 purpose and value fields are PARM and VALUE. */
2750 tree
2751 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2753 tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2754 TREE_PURPOSE (t) = parm;
2755 TREE_VALUE (t) = value;
2756 return t;
2759 /* Build a chain of TREE_LIST nodes from a vector. */
2761 tree
2762 build_tree_list_vec_stat (const vec<tree, va_gc> *vec MEM_STAT_DECL)
2764 tree ret = NULL_TREE;
2765 tree *pp = &ret;
2766 unsigned int i;
2767 tree t;
2768 FOR_EACH_VEC_SAFE_ELT (vec, i, t)
2770 *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2771 pp = &TREE_CHAIN (*pp);
2773 return ret;
2776 /* Return a newly created TREE_LIST node whose
2777 purpose and value fields are PURPOSE and VALUE
2778 and whose TREE_CHAIN is CHAIN. */
2780 tree
2781 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2783 tree node;
2785 node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
2786 memset (node, 0, sizeof (struct tree_common));
2788 record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
2790 TREE_SET_CODE (node, TREE_LIST);
2791 TREE_CHAIN (node) = chain;
2792 TREE_PURPOSE (node) = purpose;
2793 TREE_VALUE (node) = value;
2794 return node;
2797 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2798 trees. */
2800 vec<tree, va_gc> *
2801 ctor_to_vec (tree ctor)
2803 vec<tree, va_gc> *vec;
2804 vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
2805 unsigned int ix;
2806 tree val;
2808 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2809 vec->quick_push (val);
2811 return vec;
2814 /* Return the size nominally occupied by an object of type TYPE
2815 when it resides in memory. The value is measured in units of bytes,
2816 and its data type is that normally used for type sizes
2817 (which is the first type created by make_signed_type or
2818 make_unsigned_type). */
2820 tree
2821 size_in_bytes (const_tree type)
2823 tree t;
2825 if (type == error_mark_node)
2826 return integer_zero_node;
2828 type = TYPE_MAIN_VARIANT (type);
2829 t = TYPE_SIZE_UNIT (type);
2831 if (t == 0)
2833 lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2834 return size_zero_node;
2837 return t;
2840 /* Return the size of TYPE (in bytes) as a wide integer
2841 or return -1 if the size can vary or is larger than an integer. */
2843 HOST_WIDE_INT
2844 int_size_in_bytes (const_tree type)
2846 tree t;
2848 if (type == error_mark_node)
2849 return 0;
2851 type = TYPE_MAIN_VARIANT (type);
2852 t = TYPE_SIZE_UNIT (type);
2854 if (t && tree_fits_uhwi_p (t))
2855 return TREE_INT_CST_LOW (t);
2856 else
2857 return -1;
2860 /* Return the maximum size of TYPE (in bytes) as a wide integer
2861 or return -1 if the size can vary or is larger than an integer. */
2863 HOST_WIDE_INT
2864 max_int_size_in_bytes (const_tree type)
2866 HOST_WIDE_INT size = -1;
2867 tree size_tree;
2869 /* If this is an array type, check for a possible MAX_SIZE attached. */
2871 if (TREE_CODE (type) == ARRAY_TYPE)
2873 size_tree = TYPE_ARRAY_MAX_SIZE (type);
2875 if (size_tree && tree_fits_uhwi_p (size_tree))
2876 size = tree_to_uhwi (size_tree);
2879 /* If we still haven't been able to get a size, see if the language
2880 can compute a maximum size. */
2882 if (size == -1)
2884 size_tree = lang_hooks.types.max_size (type);
2886 if (size_tree && tree_fits_uhwi_p (size_tree))
2887 size = tree_to_uhwi (size_tree);
2890 return size;
2893 /* Return the bit position of FIELD, in bits from the start of the record.
2894 This is a tree of type bitsizetype. */
2896 tree
2897 bit_position (const_tree field)
2899 return bit_from_pos (DECL_FIELD_OFFSET (field),
2900 DECL_FIELD_BIT_OFFSET (field));
2903 /* Return the byte position of FIELD, in bytes from the start of the record.
2904 This is a tree of type sizetype. */
2906 tree
2907 byte_position (const_tree field)
2909 return byte_from_pos (DECL_FIELD_OFFSET (field),
2910 DECL_FIELD_BIT_OFFSET (field));
2913 /* Likewise, but return as an integer. It must be representable in
2914 that way (since it could be a signed value, we don't have the
2915 option of returning -1 like int_size_in_byte can. */
2917 HOST_WIDE_INT
2918 int_byte_position (const_tree field)
2920 return tree_to_shwi (byte_position (field));
2923 /* Return the strictest alignment, in bits, that T is known to have. */
2925 unsigned int
2926 expr_align (const_tree t)
2928 unsigned int align0, align1;
2930 switch (TREE_CODE (t))
2932 CASE_CONVERT: case NON_LVALUE_EXPR:
2933 /* If we have conversions, we know that the alignment of the
2934 object must meet each of the alignments of the types. */
2935 align0 = expr_align (TREE_OPERAND (t, 0));
2936 align1 = TYPE_ALIGN (TREE_TYPE (t));
2937 return MAX (align0, align1);
2939 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
2940 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
2941 case CLEANUP_POINT_EXPR:
2942 /* These don't change the alignment of an object. */
2943 return expr_align (TREE_OPERAND (t, 0));
2945 case COND_EXPR:
2946 /* The best we can do is say that the alignment is the least aligned
2947 of the two arms. */
2948 align0 = expr_align (TREE_OPERAND (t, 1));
2949 align1 = expr_align (TREE_OPERAND (t, 2));
2950 return MIN (align0, align1);
2952 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2953 meaningfully, it's always 1. */
2954 case LABEL_DECL: case CONST_DECL:
2955 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
2956 case FUNCTION_DECL:
2957 gcc_assert (DECL_ALIGN (t) != 0);
2958 return DECL_ALIGN (t);
2960 default:
2961 break;
2964 /* Otherwise take the alignment from that of the type. */
2965 return TYPE_ALIGN (TREE_TYPE (t));
2968 /* Return, as a tree node, the number of elements for TYPE (which is an
2969 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2971 tree
2972 array_type_nelts (const_tree type)
2974 tree index_type, min, max;
2976 /* If they did it with unspecified bounds, then we should have already
2977 given an error about it before we got here. */
2978 if (! TYPE_DOMAIN (type))
2979 return error_mark_node;
2981 index_type = TYPE_DOMAIN (type);
2982 min = TYPE_MIN_VALUE (index_type);
2983 max = TYPE_MAX_VALUE (index_type);
2985 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2986 if (!max)
2987 return error_mark_node;
2989 return (integer_zerop (min)
2990 ? max
2991 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2994 /* If arg is static -- a reference to an object in static storage -- then
2995 return the object. This is not the same as the C meaning of `static'.
2996 If arg isn't static, return NULL. */
2998 tree
2999 staticp (tree arg)
3001 switch (TREE_CODE (arg))
3003 case FUNCTION_DECL:
3004 /* Nested functions are static, even though taking their address will
3005 involve a trampoline as we unnest the nested function and create
3006 the trampoline on the tree level. */
3007 return arg;
3009 case VAR_DECL:
3010 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3011 && ! DECL_THREAD_LOCAL_P (arg)
3012 && ! DECL_DLLIMPORT_P (arg)
3013 ? arg : NULL);
3015 case CONST_DECL:
3016 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3017 ? arg : NULL);
3019 case CONSTRUCTOR:
3020 return TREE_STATIC (arg) ? arg : NULL;
3022 case LABEL_DECL:
3023 case STRING_CST:
3024 return arg;
3026 case COMPONENT_REF:
3027 /* If the thing being referenced is not a field, then it is
3028 something language specific. */
3029 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
3031 /* If we are referencing a bitfield, we can't evaluate an
3032 ADDR_EXPR at compile time and so it isn't a constant. */
3033 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
3034 return NULL;
3036 return staticp (TREE_OPERAND (arg, 0));
3038 case BIT_FIELD_REF:
3039 return NULL;
3041 case INDIRECT_REF:
3042 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
3044 case ARRAY_REF:
3045 case ARRAY_RANGE_REF:
3046 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
3047 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
3048 return staticp (TREE_OPERAND (arg, 0));
3049 else
3050 return NULL;
3052 case COMPOUND_LITERAL_EXPR:
3053 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
3055 default:
3056 return NULL;
3063 /* Return whether OP is a DECL whose address is function-invariant. */
3065 bool
3066 decl_address_invariant_p (const_tree op)
3068 /* The conditions below are slightly less strict than the one in
3069 staticp. */
3071 switch (TREE_CODE (op))
3073 case PARM_DECL:
3074 case RESULT_DECL:
3075 case LABEL_DECL:
3076 case FUNCTION_DECL:
3077 return true;
3079 case VAR_DECL:
3080 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3081 || DECL_THREAD_LOCAL_P (op)
3082 || DECL_CONTEXT (op) == current_function_decl
3083 || decl_function_context (op) == current_function_decl)
3084 return true;
3085 break;
3087 case CONST_DECL:
3088 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3089 || decl_function_context (op) == current_function_decl)
3090 return true;
3091 break;
3093 default:
3094 break;
3097 return false;
3100 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3102 bool
3103 decl_address_ip_invariant_p (const_tree op)
3105 /* The conditions below are slightly less strict than the one in
3106 staticp. */
3108 switch (TREE_CODE (op))
3110 case LABEL_DECL:
3111 case FUNCTION_DECL:
3112 case STRING_CST:
3113 return true;
3115 case VAR_DECL:
3116 if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
3117 && !DECL_DLLIMPORT_P (op))
3118 || DECL_THREAD_LOCAL_P (op))
3119 return true;
3120 break;
3122 case CONST_DECL:
3123 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
3124 return true;
3125 break;
3127 default:
3128 break;
3131 return false;
3135 /* Return true if T is function-invariant (internal function, does
3136 not handle arithmetic; that's handled in skip_simple_arithmetic and
3137 tree_invariant_p). */
3139 static bool tree_invariant_p (tree t);
3141 static bool
3142 tree_invariant_p_1 (tree t)
3144 tree op;
3146 if (TREE_CONSTANT (t)
3147 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
3148 return true;
3150 switch (TREE_CODE (t))
3152 case SAVE_EXPR:
3153 return true;
3155 case ADDR_EXPR:
3156 op = TREE_OPERAND (t, 0);
3157 while (handled_component_p (op))
3159 switch (TREE_CODE (op))
3161 case ARRAY_REF:
3162 case ARRAY_RANGE_REF:
3163 if (!tree_invariant_p (TREE_OPERAND (op, 1))
3164 || TREE_OPERAND (op, 2) != NULL_TREE
3165 || TREE_OPERAND (op, 3) != NULL_TREE)
3166 return false;
3167 break;
3169 case COMPONENT_REF:
3170 if (TREE_OPERAND (op, 2) != NULL_TREE)
3171 return false;
3172 break;
3174 default:;
3176 op = TREE_OPERAND (op, 0);
3179 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
3181 default:
3182 break;
3185 return false;
3188 /* Return true if T is function-invariant. */
3190 static bool
3191 tree_invariant_p (tree t)
3193 tree inner = skip_simple_arithmetic (t);
3194 return tree_invariant_p_1 (inner);
3197 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3198 Do this to any expression which may be used in more than one place,
3199 but must be evaluated only once.
3201 Normally, expand_expr would reevaluate the expression each time.
3202 Calling save_expr produces something that is evaluated and recorded
3203 the first time expand_expr is called on it. Subsequent calls to
3204 expand_expr just reuse the recorded value.
3206 The call to expand_expr that generates code that actually computes
3207 the value is the first call *at compile time*. Subsequent calls
3208 *at compile time* generate code to use the saved value.
3209 This produces correct result provided that *at run time* control
3210 always flows through the insns made by the first expand_expr
3211 before reaching the other places where the save_expr was evaluated.
3212 You, the caller of save_expr, must make sure this is so.
3214 Constants, and certain read-only nodes, are returned with no
3215 SAVE_EXPR because that is safe. Expressions containing placeholders
3216 are not touched; see tree.def for an explanation of what these
3217 are used for. */
3219 tree
3220 save_expr (tree expr)
3222 tree t = fold (expr);
3223 tree inner;
3225 /* If the tree evaluates to a constant, then we don't want to hide that
3226 fact (i.e. this allows further folding, and direct checks for constants).
3227 However, a read-only object that has side effects cannot be bypassed.
3228 Since it is no problem to reevaluate literals, we just return the
3229 literal node. */
3230 inner = skip_simple_arithmetic (t);
3231 if (TREE_CODE (inner) == ERROR_MARK)
3232 return inner;
3234 if (tree_invariant_p_1 (inner))
3235 return t;
3237 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3238 it means that the size or offset of some field of an object depends on
3239 the value within another field.
3241 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3242 and some variable since it would then need to be both evaluated once and
3243 evaluated more than once. Front-ends must assure this case cannot
3244 happen by surrounding any such subexpressions in their own SAVE_EXPR
3245 and forcing evaluation at the proper time. */
3246 if (contains_placeholder_p (inner))
3247 return t;
3249 t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
3250 SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
3252 /* This expression might be placed ahead of a jump to ensure that the
3253 value was computed on both sides of the jump. So make sure it isn't
3254 eliminated as dead. */
3255 TREE_SIDE_EFFECTS (t) = 1;
3256 return t;
3259 /* Look inside EXPR into any simple arithmetic operations. Return the
3260 outermost non-arithmetic or non-invariant node. */
3262 tree
3263 skip_simple_arithmetic (tree expr)
3265 /* We don't care about whether this can be used as an lvalue in this
3266 context. */
3267 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3268 expr = TREE_OPERAND (expr, 0);
3270 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3271 a constant, it will be more efficient to not make another SAVE_EXPR since
3272 it will allow better simplification and GCSE will be able to merge the
3273 computations if they actually occur. */
3274 while (true)
3276 if (UNARY_CLASS_P (expr))
3277 expr = TREE_OPERAND (expr, 0);
3278 else if (BINARY_CLASS_P (expr))
3280 if (tree_invariant_p (TREE_OPERAND (expr, 1)))
3281 expr = TREE_OPERAND (expr, 0);
3282 else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
3283 expr = TREE_OPERAND (expr, 1);
3284 else
3285 break;
3287 else
3288 break;
3291 return expr;
3294 /* Look inside EXPR into simple arithmetic operations involving constants.
3295 Return the outermost non-arithmetic or non-constant node. */
3297 tree
3298 skip_simple_constant_arithmetic (tree expr)
3300 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3301 expr = TREE_OPERAND (expr, 0);
3303 while (true)
3305 if (UNARY_CLASS_P (expr))
3306 expr = TREE_OPERAND (expr, 0);
3307 else if (BINARY_CLASS_P (expr))
3309 if (TREE_CONSTANT (TREE_OPERAND (expr, 1)))
3310 expr = TREE_OPERAND (expr, 0);
3311 else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
3312 expr = TREE_OPERAND (expr, 1);
3313 else
3314 break;
3316 else
3317 break;
3320 return expr;
3323 /* Return which tree structure is used by T. */
3325 enum tree_node_structure_enum
3326 tree_node_structure (const_tree t)
3328 const enum tree_code code = TREE_CODE (t);
3329 return tree_node_structure_for_code (code);
3332 /* Set various status flags when building a CALL_EXPR object T. */
3334 static void
3335 process_call_operands (tree t)
3337 bool side_effects = TREE_SIDE_EFFECTS (t);
3338 bool read_only = false;
3339 int i = call_expr_flags (t);
3341 /* Calls have side-effects, except those to const or pure functions. */
3342 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
3343 side_effects = true;
3344 /* Propagate TREE_READONLY of arguments for const functions. */
3345 if (i & ECF_CONST)
3346 read_only = true;
3348 if (!side_effects || read_only)
3349 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
3351 tree op = TREE_OPERAND (t, i);
3352 if (op && TREE_SIDE_EFFECTS (op))
3353 side_effects = true;
3354 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
3355 read_only = false;
3358 TREE_SIDE_EFFECTS (t) = side_effects;
3359 TREE_READONLY (t) = read_only;
3362 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3363 size or offset that depends on a field within a record. */
3365 bool
3366 contains_placeholder_p (const_tree exp)
3368 enum tree_code code;
3370 if (!exp)
3371 return 0;
3373 code = TREE_CODE (exp);
3374 if (code == PLACEHOLDER_EXPR)
3375 return 1;
3377 switch (TREE_CODE_CLASS (code))
3379 case tcc_reference:
3380 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3381 position computations since they will be converted into a
3382 WITH_RECORD_EXPR involving the reference, which will assume
3383 here will be valid. */
3384 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3386 case tcc_exceptional:
3387 if (code == TREE_LIST)
3388 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
3389 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
3390 break;
3392 case tcc_unary:
3393 case tcc_binary:
3394 case tcc_comparison:
3395 case tcc_expression:
3396 switch (code)
3398 case COMPOUND_EXPR:
3399 /* Ignoring the first operand isn't quite right, but works best. */
3400 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
3402 case COND_EXPR:
3403 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3404 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
3405 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
3407 case SAVE_EXPR:
3408 /* The save_expr function never wraps anything containing
3409 a PLACEHOLDER_EXPR. */
3410 return 0;
3412 default:
3413 break;
3416 switch (TREE_CODE_LENGTH (code))
3418 case 1:
3419 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3420 case 2:
3421 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3422 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
3423 default:
3424 return 0;
3427 case tcc_vl_exp:
3428 switch (code)
3430 case CALL_EXPR:
3432 const_tree arg;
3433 const_call_expr_arg_iterator iter;
3434 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
3435 if (CONTAINS_PLACEHOLDER_P (arg))
3436 return 1;
3437 return 0;
3439 default:
3440 return 0;
3443 default:
3444 return 0;
3446 return 0;
3449 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3450 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3451 field positions. */
3453 static bool
3454 type_contains_placeholder_1 (const_tree type)
3456 /* If the size contains a placeholder or the parent type (component type in
3457 the case of arrays) type involves a placeholder, this type does. */
3458 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
3459 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
3460 || (!POINTER_TYPE_P (type)
3461 && TREE_TYPE (type)
3462 && type_contains_placeholder_p (TREE_TYPE (type))))
3463 return true;
3465 /* Now do type-specific checks. Note that the last part of the check above
3466 greatly limits what we have to do below. */
3467 switch (TREE_CODE (type))
3469 case VOID_TYPE:
3470 case POINTER_BOUNDS_TYPE:
3471 case COMPLEX_TYPE:
3472 case ENUMERAL_TYPE:
3473 case BOOLEAN_TYPE:
3474 case POINTER_TYPE:
3475 case OFFSET_TYPE:
3476 case REFERENCE_TYPE:
3477 case METHOD_TYPE:
3478 case FUNCTION_TYPE:
3479 case VECTOR_TYPE:
3480 case NULLPTR_TYPE:
3481 return false;
3483 case INTEGER_TYPE:
3484 case REAL_TYPE:
3485 case FIXED_POINT_TYPE:
3486 /* Here we just check the bounds. */
3487 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
3488 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
3490 case ARRAY_TYPE:
3491 /* We have already checked the component type above, so just check the
3492 domain type. */
3493 return type_contains_placeholder_p (TYPE_DOMAIN (type));
3495 case RECORD_TYPE:
3496 case UNION_TYPE:
3497 case QUAL_UNION_TYPE:
3499 tree field;
3501 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3502 if (TREE_CODE (field) == FIELD_DECL
3503 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
3504 || (TREE_CODE (type) == QUAL_UNION_TYPE
3505 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
3506 || type_contains_placeholder_p (TREE_TYPE (field))))
3507 return true;
3509 return false;
3512 default:
3513 gcc_unreachable ();
3517 /* Wrapper around above function used to cache its result. */
3519 bool
3520 type_contains_placeholder_p (tree type)
3522 bool result;
3524 /* If the contains_placeholder_bits field has been initialized,
3525 then we know the answer. */
3526 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
3527 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
3529 /* Indicate that we've seen this type node, and the answer is false.
3530 This is what we want to return if we run into recursion via fields. */
3531 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
3533 /* Compute the real value. */
3534 result = type_contains_placeholder_1 (type);
3536 /* Store the real value. */
3537 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
3539 return result;
3542 /* Push tree EXP onto vector QUEUE if it is not already present. */
3544 static void
3545 push_without_duplicates (tree exp, vec<tree> *queue)
3547 unsigned int i;
3548 tree iter;
3550 FOR_EACH_VEC_ELT (*queue, i, iter)
3551 if (simple_cst_equal (iter, exp) == 1)
3552 break;
3554 if (!iter)
3555 queue->safe_push (exp);
3558 /* Given a tree EXP, find all occurrences of references to fields
3559 in a PLACEHOLDER_EXPR and place them in vector REFS without
3560 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3561 we assume here that EXP contains only arithmetic expressions
3562 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3563 argument list. */
3565 void
3566 find_placeholder_in_expr (tree exp, vec<tree> *refs)
3568 enum tree_code code = TREE_CODE (exp);
3569 tree inner;
3570 int i;
3572 /* We handle TREE_LIST and COMPONENT_REF separately. */
3573 if (code == TREE_LIST)
3575 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
3576 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
3578 else if (code == COMPONENT_REF)
3580 for (inner = TREE_OPERAND (exp, 0);
3581 REFERENCE_CLASS_P (inner);
3582 inner = TREE_OPERAND (inner, 0))
3585 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
3586 push_without_duplicates (exp, refs);
3587 else
3588 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
3590 else
3591 switch (TREE_CODE_CLASS (code))
3593 case tcc_constant:
3594 break;
3596 case tcc_declaration:
3597 /* Variables allocated to static storage can stay. */
3598 if (!TREE_STATIC (exp))
3599 push_without_duplicates (exp, refs);
3600 break;
3602 case tcc_expression:
3603 /* This is the pattern built in ada/make_aligning_type. */
3604 if (code == ADDR_EXPR
3605 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3607 push_without_duplicates (exp, refs);
3608 break;
3611 /* Fall through... */
3613 case tcc_exceptional:
3614 case tcc_unary:
3615 case tcc_binary:
3616 case tcc_comparison:
3617 case tcc_reference:
3618 for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3619 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3620 break;
3622 case tcc_vl_exp:
3623 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3624 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3625 break;
3627 default:
3628 gcc_unreachable ();
3632 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3633 return a tree with all occurrences of references to F in a
3634 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3635 CONST_DECLs. Note that we assume here that EXP contains only
3636 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3637 occurring only in their argument list. */
3639 tree
3640 substitute_in_expr (tree exp, tree f, tree r)
3642 enum tree_code code = TREE_CODE (exp);
3643 tree op0, op1, op2, op3;
3644 tree new_tree;
3646 /* We handle TREE_LIST and COMPONENT_REF separately. */
3647 if (code == TREE_LIST)
3649 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3650 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3651 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3652 return exp;
3654 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3656 else if (code == COMPONENT_REF)
3658 tree inner;
3660 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3661 and it is the right field, replace it with R. */
3662 for (inner = TREE_OPERAND (exp, 0);
3663 REFERENCE_CLASS_P (inner);
3664 inner = TREE_OPERAND (inner, 0))
3667 /* The field. */
3668 op1 = TREE_OPERAND (exp, 1);
3670 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3671 return r;
3673 /* If this expression hasn't been completed let, leave it alone. */
3674 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3675 return exp;
3677 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3678 if (op0 == TREE_OPERAND (exp, 0))
3679 return exp;
3681 new_tree
3682 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3684 else
3685 switch (TREE_CODE_CLASS (code))
3687 case tcc_constant:
3688 return exp;
3690 case tcc_declaration:
3691 if (exp == f)
3692 return r;
3693 else
3694 return exp;
3696 case tcc_expression:
3697 if (exp == f)
3698 return r;
3700 /* Fall through... */
3702 case tcc_exceptional:
3703 case tcc_unary:
3704 case tcc_binary:
3705 case tcc_comparison:
3706 case tcc_reference:
3707 switch (TREE_CODE_LENGTH (code))
3709 case 0:
3710 return exp;
3712 case 1:
3713 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3714 if (op0 == TREE_OPERAND (exp, 0))
3715 return exp;
3717 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3718 break;
3720 case 2:
3721 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3722 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3724 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3725 return exp;
3727 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3728 break;
3730 case 3:
3731 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3732 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3733 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3735 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3736 && op2 == TREE_OPERAND (exp, 2))
3737 return exp;
3739 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3740 break;
3742 case 4:
3743 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3744 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3745 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3746 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3748 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3749 && op2 == TREE_OPERAND (exp, 2)
3750 && op3 == TREE_OPERAND (exp, 3))
3751 return exp;
3753 new_tree
3754 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3755 break;
3757 default:
3758 gcc_unreachable ();
3760 break;
3762 case tcc_vl_exp:
3764 int i;
3766 new_tree = NULL_TREE;
3768 /* If we are trying to replace F with a constant, inline back
3769 functions which do nothing else than computing a value from
3770 the arguments they are passed. This makes it possible to
3771 fold partially or entirely the replacement expression. */
3772 if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3774 tree t = maybe_inline_call_in_expr (exp);
3775 if (t)
3776 return SUBSTITUTE_IN_EXPR (t, f, r);
3779 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3781 tree op = TREE_OPERAND (exp, i);
3782 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3783 if (new_op != op)
3785 if (!new_tree)
3786 new_tree = copy_node (exp);
3787 TREE_OPERAND (new_tree, i) = new_op;
3791 if (new_tree)
3793 new_tree = fold (new_tree);
3794 if (TREE_CODE (new_tree) == CALL_EXPR)
3795 process_call_operands (new_tree);
3797 else
3798 return exp;
3800 break;
3802 default:
3803 gcc_unreachable ();
3806 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3808 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3809 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3811 return new_tree;
3814 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3815 for it within OBJ, a tree that is an object or a chain of references. */
3817 tree
3818 substitute_placeholder_in_expr (tree exp, tree obj)
3820 enum tree_code code = TREE_CODE (exp);
3821 tree op0, op1, op2, op3;
3822 tree new_tree;
3824 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3825 in the chain of OBJ. */
3826 if (code == PLACEHOLDER_EXPR)
3828 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3829 tree elt;
3831 for (elt = obj; elt != 0;
3832 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3833 || TREE_CODE (elt) == COND_EXPR)
3834 ? TREE_OPERAND (elt, 1)
3835 : (REFERENCE_CLASS_P (elt)
3836 || UNARY_CLASS_P (elt)
3837 || BINARY_CLASS_P (elt)
3838 || VL_EXP_CLASS_P (elt)
3839 || EXPRESSION_CLASS_P (elt))
3840 ? TREE_OPERAND (elt, 0) : 0))
3841 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3842 return elt;
3844 for (elt = obj; elt != 0;
3845 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3846 || TREE_CODE (elt) == COND_EXPR)
3847 ? TREE_OPERAND (elt, 1)
3848 : (REFERENCE_CLASS_P (elt)
3849 || UNARY_CLASS_P (elt)
3850 || BINARY_CLASS_P (elt)
3851 || VL_EXP_CLASS_P (elt)
3852 || EXPRESSION_CLASS_P (elt))
3853 ? TREE_OPERAND (elt, 0) : 0))
3854 if (POINTER_TYPE_P (TREE_TYPE (elt))
3855 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3856 == need_type))
3857 return fold_build1 (INDIRECT_REF, need_type, elt);
3859 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3860 survives until RTL generation, there will be an error. */
3861 return exp;
3864 /* TREE_LIST is special because we need to look at TREE_VALUE
3865 and TREE_CHAIN, not TREE_OPERANDS. */
3866 else if (code == TREE_LIST)
3868 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3869 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3870 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3871 return exp;
3873 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3875 else
3876 switch (TREE_CODE_CLASS (code))
3878 case tcc_constant:
3879 case tcc_declaration:
3880 return exp;
3882 case tcc_exceptional:
3883 case tcc_unary:
3884 case tcc_binary:
3885 case tcc_comparison:
3886 case tcc_expression:
3887 case tcc_reference:
3888 case tcc_statement:
3889 switch (TREE_CODE_LENGTH (code))
3891 case 0:
3892 return exp;
3894 case 1:
3895 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3896 if (op0 == TREE_OPERAND (exp, 0))
3897 return exp;
3899 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3900 break;
3902 case 2:
3903 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3904 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3906 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3907 return exp;
3909 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3910 break;
3912 case 3:
3913 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3914 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3915 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3917 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3918 && op2 == TREE_OPERAND (exp, 2))
3919 return exp;
3921 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3922 break;
3924 case 4:
3925 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3926 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3927 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3928 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3930 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3931 && op2 == TREE_OPERAND (exp, 2)
3932 && op3 == TREE_OPERAND (exp, 3))
3933 return exp;
3935 new_tree
3936 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3937 break;
3939 default:
3940 gcc_unreachable ();
3942 break;
3944 case tcc_vl_exp:
3946 int i;
3948 new_tree = NULL_TREE;
3950 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3952 tree op = TREE_OPERAND (exp, i);
3953 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3954 if (new_op != op)
3956 if (!new_tree)
3957 new_tree = copy_node (exp);
3958 TREE_OPERAND (new_tree, i) = new_op;
3962 if (new_tree)
3964 new_tree = fold (new_tree);
3965 if (TREE_CODE (new_tree) == CALL_EXPR)
3966 process_call_operands (new_tree);
3968 else
3969 return exp;
3971 break;
3973 default:
3974 gcc_unreachable ();
3977 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3979 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3980 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3982 return new_tree;
3986 /* Subroutine of stabilize_reference; this is called for subtrees of
3987 references. Any expression with side-effects must be put in a SAVE_EXPR
3988 to ensure that it is only evaluated once.
3990 We don't put SAVE_EXPR nodes around everything, because assigning very
3991 simple expressions to temporaries causes us to miss good opportunities
3992 for optimizations. Among other things, the opportunity to fold in the
3993 addition of a constant into an addressing mode often gets lost, e.g.
3994 "y[i+1] += x;". In general, we take the approach that we should not make
3995 an assignment unless we are forced into it - i.e., that any non-side effect
3996 operator should be allowed, and that cse should take care of coalescing
3997 multiple utterances of the same expression should that prove fruitful. */
3999 static tree
4000 stabilize_reference_1 (tree e)
4002 tree result;
4003 enum tree_code code = TREE_CODE (e);
4005 /* We cannot ignore const expressions because it might be a reference
4006 to a const array but whose index contains side-effects. But we can
4007 ignore things that are actual constant or that already have been
4008 handled by this function. */
4010 if (tree_invariant_p (e))
4011 return e;
4013 switch (TREE_CODE_CLASS (code))
4015 case tcc_exceptional:
4016 case tcc_type:
4017 case tcc_declaration:
4018 case tcc_comparison:
4019 case tcc_statement:
4020 case tcc_expression:
4021 case tcc_reference:
4022 case tcc_vl_exp:
4023 /* If the expression has side-effects, then encase it in a SAVE_EXPR
4024 so that it will only be evaluated once. */
4025 /* The reference (r) and comparison (<) classes could be handled as
4026 below, but it is generally faster to only evaluate them once. */
4027 if (TREE_SIDE_EFFECTS (e))
4028 return save_expr (e);
4029 return e;
4031 case tcc_constant:
4032 /* Constants need no processing. In fact, we should never reach
4033 here. */
4034 return e;
4036 case tcc_binary:
4037 /* Division is slow and tends to be compiled with jumps,
4038 especially the division by powers of 2 that is often
4039 found inside of an array reference. So do it just once. */
4040 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
4041 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
4042 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
4043 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
4044 return save_expr (e);
4045 /* Recursively stabilize each operand. */
4046 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
4047 stabilize_reference_1 (TREE_OPERAND (e, 1)));
4048 break;
4050 case tcc_unary:
4051 /* Recursively stabilize each operand. */
4052 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
4053 break;
4055 default:
4056 gcc_unreachable ();
4059 TREE_TYPE (result) = TREE_TYPE (e);
4060 TREE_READONLY (result) = TREE_READONLY (e);
4061 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
4062 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
4064 return result;
4067 /* Stabilize a reference so that we can use it any number of times
4068 without causing its operands to be evaluated more than once.
4069 Returns the stabilized reference. This works by means of save_expr,
4070 so see the caveats in the comments about save_expr.
4072 Also allows conversion expressions whose operands are references.
4073 Any other kind of expression is returned unchanged. */
4075 tree
4076 stabilize_reference (tree ref)
4078 tree result;
4079 enum tree_code code = TREE_CODE (ref);
4081 switch (code)
4083 case VAR_DECL:
4084 case PARM_DECL:
4085 case RESULT_DECL:
4086 /* No action is needed in this case. */
4087 return ref;
4089 CASE_CONVERT:
4090 case FLOAT_EXPR:
4091 case FIX_TRUNC_EXPR:
4092 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
4093 break;
4095 case INDIRECT_REF:
4096 result = build_nt (INDIRECT_REF,
4097 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
4098 break;
4100 case COMPONENT_REF:
4101 result = build_nt (COMPONENT_REF,
4102 stabilize_reference (TREE_OPERAND (ref, 0)),
4103 TREE_OPERAND (ref, 1), NULL_TREE);
4104 break;
4106 case BIT_FIELD_REF:
4107 result = build_nt (BIT_FIELD_REF,
4108 stabilize_reference (TREE_OPERAND (ref, 0)),
4109 TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
4110 break;
4112 case ARRAY_REF:
4113 result = build_nt (ARRAY_REF,
4114 stabilize_reference (TREE_OPERAND (ref, 0)),
4115 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4116 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4117 break;
4119 case ARRAY_RANGE_REF:
4120 result = build_nt (ARRAY_RANGE_REF,
4121 stabilize_reference (TREE_OPERAND (ref, 0)),
4122 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4123 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4124 break;
4126 case COMPOUND_EXPR:
4127 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4128 it wouldn't be ignored. This matters when dealing with
4129 volatiles. */
4130 return stabilize_reference_1 (ref);
4132 /* If arg isn't a kind of lvalue we recognize, make no change.
4133 Caller should recognize the error for an invalid lvalue. */
4134 default:
4135 return ref;
4137 case ERROR_MARK:
4138 return error_mark_node;
4141 TREE_TYPE (result) = TREE_TYPE (ref);
4142 TREE_READONLY (result) = TREE_READONLY (ref);
4143 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
4144 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
4146 return result;
4149 /* Low-level constructors for expressions. */
4151 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4152 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4154 void
4155 recompute_tree_invariant_for_addr_expr (tree t)
4157 tree node;
4158 bool tc = true, se = false;
4160 /* We started out assuming this address is both invariant and constant, but
4161 does not have side effects. Now go down any handled components and see if
4162 any of them involve offsets that are either non-constant or non-invariant.
4163 Also check for side-effects.
4165 ??? Note that this code makes no attempt to deal with the case where
4166 taking the address of something causes a copy due to misalignment. */
4168 #define UPDATE_FLAGS(NODE) \
4169 do { tree _node = (NODE); \
4170 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4171 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4173 for (node = TREE_OPERAND (t, 0); handled_component_p (node);
4174 node = TREE_OPERAND (node, 0))
4176 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4177 array reference (probably made temporarily by the G++ front end),
4178 so ignore all the operands. */
4179 if ((TREE_CODE (node) == ARRAY_REF
4180 || TREE_CODE (node) == ARRAY_RANGE_REF)
4181 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
4183 UPDATE_FLAGS (TREE_OPERAND (node, 1));
4184 if (TREE_OPERAND (node, 2))
4185 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4186 if (TREE_OPERAND (node, 3))
4187 UPDATE_FLAGS (TREE_OPERAND (node, 3));
4189 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4190 FIELD_DECL, apparently. The G++ front end can put something else
4191 there, at least temporarily. */
4192 else if (TREE_CODE (node) == COMPONENT_REF
4193 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
4195 if (TREE_OPERAND (node, 2))
4196 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4200 node = lang_hooks.expr_to_decl (node, &tc, &se);
4202 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4203 the address, since &(*a)->b is a form of addition. If it's a constant, the
4204 address is constant too. If it's a decl, its address is constant if the
4205 decl is static. Everything else is not constant and, furthermore,
4206 taking the address of a volatile variable is not volatile. */
4207 if (TREE_CODE (node) == INDIRECT_REF
4208 || TREE_CODE (node) == MEM_REF)
4209 UPDATE_FLAGS (TREE_OPERAND (node, 0));
4210 else if (CONSTANT_CLASS_P (node))
4212 else if (DECL_P (node))
4213 tc &= (staticp (node) != NULL_TREE);
4214 else
4216 tc = false;
4217 se |= TREE_SIDE_EFFECTS (node);
4221 TREE_CONSTANT (t) = tc;
4222 TREE_SIDE_EFFECTS (t) = se;
4223 #undef UPDATE_FLAGS
4226 /* Build an expression of code CODE, data type TYPE, and operands as
4227 specified. Expressions and reference nodes can be created this way.
4228 Constants, decls, types and misc nodes cannot be.
4230 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4231 enough for all extant tree codes. */
4233 tree
4234 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
4236 tree t;
4238 gcc_assert (TREE_CODE_LENGTH (code) == 0);
4240 t = make_node_stat (code PASS_MEM_STAT);
4241 TREE_TYPE (t) = tt;
4243 return t;
4246 tree
4247 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
4249 int length = sizeof (struct tree_exp);
4250 tree t;
4252 record_node_allocation_statistics (code, length);
4254 gcc_assert (TREE_CODE_LENGTH (code) == 1);
4256 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
4258 memset (t, 0, sizeof (struct tree_common));
4260 TREE_SET_CODE (t, code);
4262 TREE_TYPE (t) = type;
4263 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
4264 TREE_OPERAND (t, 0) = node;
4265 if (node && !TYPE_P (node))
4267 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
4268 TREE_READONLY (t) = TREE_READONLY (node);
4271 if (TREE_CODE_CLASS (code) == tcc_statement)
4272 TREE_SIDE_EFFECTS (t) = 1;
4273 else switch (code)
4275 case VA_ARG_EXPR:
4276 /* All of these have side-effects, no matter what their
4277 operands are. */
4278 TREE_SIDE_EFFECTS (t) = 1;
4279 TREE_READONLY (t) = 0;
4280 break;
4282 case INDIRECT_REF:
4283 /* Whether a dereference is readonly has nothing to do with whether
4284 its operand is readonly. */
4285 TREE_READONLY (t) = 0;
4286 break;
4288 case ADDR_EXPR:
4289 if (node)
4290 recompute_tree_invariant_for_addr_expr (t);
4291 break;
4293 default:
4294 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
4295 && node && !TYPE_P (node)
4296 && TREE_CONSTANT (node))
4297 TREE_CONSTANT (t) = 1;
4298 if (TREE_CODE_CLASS (code) == tcc_reference
4299 && node && TREE_THIS_VOLATILE (node))
4300 TREE_THIS_VOLATILE (t) = 1;
4301 break;
4304 return t;
4307 #define PROCESS_ARG(N) \
4308 do { \
4309 TREE_OPERAND (t, N) = arg##N; \
4310 if (arg##N &&!TYPE_P (arg##N)) \
4312 if (TREE_SIDE_EFFECTS (arg##N)) \
4313 side_effects = 1; \
4314 if (!TREE_READONLY (arg##N) \
4315 && !CONSTANT_CLASS_P (arg##N)) \
4316 (void) (read_only = 0); \
4317 if (!TREE_CONSTANT (arg##N)) \
4318 (void) (constant = 0); \
4320 } while (0)
4322 tree
4323 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
4325 bool constant, read_only, side_effects;
4326 tree t;
4328 gcc_assert (TREE_CODE_LENGTH (code) == 2);
4330 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
4331 && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
4332 /* When sizetype precision doesn't match that of pointers
4333 we need to be able to build explicit extensions or truncations
4334 of the offset argument. */
4335 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
4336 gcc_assert (TREE_CODE (arg0) == INTEGER_CST
4337 && TREE_CODE (arg1) == INTEGER_CST);
4339 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
4340 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
4341 && ptrofftype_p (TREE_TYPE (arg1)));
4343 t = make_node_stat (code PASS_MEM_STAT);
4344 TREE_TYPE (t) = tt;
4346 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4347 result based on those same flags for the arguments. But if the
4348 arguments aren't really even `tree' expressions, we shouldn't be trying
4349 to do this. */
4351 /* Expressions without side effects may be constant if their
4352 arguments are as well. */
4353 constant = (TREE_CODE_CLASS (code) == tcc_comparison
4354 || TREE_CODE_CLASS (code) == tcc_binary);
4355 read_only = 1;
4356 side_effects = TREE_SIDE_EFFECTS (t);
4358 PROCESS_ARG (0);
4359 PROCESS_ARG (1);
4361 TREE_READONLY (t) = read_only;
4362 TREE_CONSTANT (t) = constant;
4363 TREE_SIDE_EFFECTS (t) = side_effects;
4364 TREE_THIS_VOLATILE (t)
4365 = (TREE_CODE_CLASS (code) == tcc_reference
4366 && arg0 && TREE_THIS_VOLATILE (arg0));
4368 return t;
4372 tree
4373 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4374 tree arg2 MEM_STAT_DECL)
4376 bool constant, read_only, side_effects;
4377 tree t;
4379 gcc_assert (TREE_CODE_LENGTH (code) == 3);
4380 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4382 t = make_node_stat (code PASS_MEM_STAT);
4383 TREE_TYPE (t) = tt;
4385 read_only = 1;
4387 /* As a special exception, if COND_EXPR has NULL branches, we
4388 assume that it is a gimple statement and always consider
4389 it to have side effects. */
4390 if (code == COND_EXPR
4391 && tt == void_type_node
4392 && arg1 == NULL_TREE
4393 && arg2 == NULL_TREE)
4394 side_effects = true;
4395 else
4396 side_effects = TREE_SIDE_EFFECTS (t);
4398 PROCESS_ARG (0);
4399 PROCESS_ARG (1);
4400 PROCESS_ARG (2);
4402 if (code == COND_EXPR)
4403 TREE_READONLY (t) = read_only;
4405 TREE_SIDE_EFFECTS (t) = side_effects;
4406 TREE_THIS_VOLATILE (t)
4407 = (TREE_CODE_CLASS (code) == tcc_reference
4408 && arg0 && TREE_THIS_VOLATILE (arg0));
4410 return t;
4413 tree
4414 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4415 tree arg2, tree arg3 MEM_STAT_DECL)
4417 bool constant, read_only, side_effects;
4418 tree t;
4420 gcc_assert (TREE_CODE_LENGTH (code) == 4);
4422 t = make_node_stat (code PASS_MEM_STAT);
4423 TREE_TYPE (t) = tt;
4425 side_effects = TREE_SIDE_EFFECTS (t);
4427 PROCESS_ARG (0);
4428 PROCESS_ARG (1);
4429 PROCESS_ARG (2);
4430 PROCESS_ARG (3);
4432 TREE_SIDE_EFFECTS (t) = side_effects;
4433 TREE_THIS_VOLATILE (t)
4434 = (TREE_CODE_CLASS (code) == tcc_reference
4435 && arg0 && TREE_THIS_VOLATILE (arg0));
4437 return t;
4440 tree
4441 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4442 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
4444 bool constant, read_only, side_effects;
4445 tree t;
4447 gcc_assert (TREE_CODE_LENGTH (code) == 5);
4449 t = make_node_stat (code PASS_MEM_STAT);
4450 TREE_TYPE (t) = tt;
4452 side_effects = TREE_SIDE_EFFECTS (t);
4454 PROCESS_ARG (0);
4455 PROCESS_ARG (1);
4456 PROCESS_ARG (2);
4457 PROCESS_ARG (3);
4458 PROCESS_ARG (4);
4460 TREE_SIDE_EFFECTS (t) = side_effects;
4461 TREE_THIS_VOLATILE (t)
4462 = (TREE_CODE_CLASS (code) == tcc_reference
4463 && arg0 && TREE_THIS_VOLATILE (arg0));
4465 return t;
4468 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4469 on the pointer PTR. */
4471 tree
4472 build_simple_mem_ref_loc (location_t loc, tree ptr)
4474 HOST_WIDE_INT offset = 0;
4475 tree ptype = TREE_TYPE (ptr);
4476 tree tem;
4477 /* For convenience allow addresses that collapse to a simple base
4478 and offset. */
4479 if (TREE_CODE (ptr) == ADDR_EXPR
4480 && (handled_component_p (TREE_OPERAND (ptr, 0))
4481 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
4483 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
4484 gcc_assert (ptr);
4485 ptr = build_fold_addr_expr (ptr);
4486 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
4488 tem = build2 (MEM_REF, TREE_TYPE (ptype),
4489 ptr, build_int_cst (ptype, offset));
4490 SET_EXPR_LOCATION (tem, loc);
4491 return tem;
4494 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4496 offset_int
4497 mem_ref_offset (const_tree t)
4499 return offset_int::from (TREE_OPERAND (t, 1), SIGNED);
4502 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4503 offsetted by OFFSET units. */
4505 tree
4506 build_invariant_address (tree type, tree base, HOST_WIDE_INT offset)
4508 tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
4509 build_fold_addr_expr (base),
4510 build_int_cst (ptr_type_node, offset));
4511 tree addr = build1 (ADDR_EXPR, type, ref);
4512 recompute_tree_invariant_for_addr_expr (addr);
4513 return addr;
4516 /* Similar except don't specify the TREE_TYPE
4517 and leave the TREE_SIDE_EFFECTS as 0.
4518 It is permissible for arguments to be null,
4519 or even garbage if their values do not matter. */
4521 tree
4522 build_nt (enum tree_code code, ...)
4524 tree t;
4525 int length;
4526 int i;
4527 va_list p;
4529 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4531 va_start (p, code);
4533 t = make_node (code);
4534 length = TREE_CODE_LENGTH (code);
4536 for (i = 0; i < length; i++)
4537 TREE_OPERAND (t, i) = va_arg (p, tree);
4539 va_end (p);
4540 return t;
4543 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4544 tree vec. */
4546 tree
4547 build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
4549 tree ret, t;
4550 unsigned int ix;
4552 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
4553 CALL_EXPR_FN (ret) = fn;
4554 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4555 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
4556 CALL_EXPR_ARG (ret, ix) = t;
4557 return ret;
4560 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4561 We do NOT enter this node in any sort of symbol table.
4563 LOC is the location of the decl.
4565 layout_decl is used to set up the decl's storage layout.
4566 Other slots are initialized to 0 or null pointers. */
4568 tree
4569 build_decl_stat (location_t loc, enum tree_code code, tree name,
4570 tree type MEM_STAT_DECL)
4572 tree t;
4574 t = make_node_stat (code PASS_MEM_STAT);
4575 DECL_SOURCE_LOCATION (t) = loc;
4577 /* if (type == error_mark_node)
4578 type = integer_type_node; */
4579 /* That is not done, deliberately, so that having error_mark_node
4580 as the type can suppress useless errors in the use of this variable. */
4582 DECL_NAME (t) = name;
4583 TREE_TYPE (t) = type;
4585 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4586 layout_decl (t, 0);
4588 return t;
4591 /* Builds and returns function declaration with NAME and TYPE. */
4593 tree
4594 build_fn_decl (const char *name, tree type)
4596 tree id = get_identifier (name);
4597 tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4599 DECL_EXTERNAL (decl) = 1;
4600 TREE_PUBLIC (decl) = 1;
4601 DECL_ARTIFICIAL (decl) = 1;
4602 TREE_NOTHROW (decl) = 1;
4604 return decl;
4607 vec<tree, va_gc> *all_translation_units;
4609 /* Builds a new translation-unit decl with name NAME, queues it in the
4610 global list of translation-unit decls and returns it. */
4612 tree
4613 build_translation_unit_decl (tree name)
4615 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4616 name, NULL_TREE);
4617 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4618 vec_safe_push (all_translation_units, tu);
4619 return tu;
4623 /* BLOCK nodes are used to represent the structure of binding contours
4624 and declarations, once those contours have been exited and their contents
4625 compiled. This information is used for outputting debugging info. */
4627 tree
4628 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4630 tree block = make_node (BLOCK);
4632 BLOCK_VARS (block) = vars;
4633 BLOCK_SUBBLOCKS (block) = subblocks;
4634 BLOCK_SUPERCONTEXT (block) = supercontext;
4635 BLOCK_CHAIN (block) = chain;
4636 return block;
4640 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4642 LOC is the location to use in tree T. */
4644 void
4645 protected_set_expr_location (tree t, location_t loc)
4647 if (CAN_HAVE_LOCATION_P (t))
4648 SET_EXPR_LOCATION (t, loc);
4651 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4652 is ATTRIBUTE. */
4654 tree
4655 build_decl_attribute_variant (tree ddecl, tree attribute)
4657 DECL_ATTRIBUTES (ddecl) = attribute;
4658 return ddecl;
4661 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4662 is ATTRIBUTE and its qualifiers are QUALS.
4664 Record such modified types already made so we don't make duplicates. */
4666 tree
4667 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4669 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4671 inchash::hash hstate;
4672 tree ntype;
4673 int i;
4674 tree t;
4675 enum tree_code code = TREE_CODE (ttype);
4677 /* Building a distinct copy of a tagged type is inappropriate; it
4678 causes breakage in code that expects there to be a one-to-one
4679 relationship between a struct and its fields.
4680 build_duplicate_type is another solution (as used in
4681 handle_transparent_union_attribute), but that doesn't play well
4682 with the stronger C++ type identity model. */
4683 if (TREE_CODE (ttype) == RECORD_TYPE
4684 || TREE_CODE (ttype) == UNION_TYPE
4685 || TREE_CODE (ttype) == QUAL_UNION_TYPE
4686 || TREE_CODE (ttype) == ENUMERAL_TYPE)
4688 warning (OPT_Wattributes,
4689 "ignoring attributes applied to %qT after definition",
4690 TYPE_MAIN_VARIANT (ttype));
4691 return build_qualified_type (ttype, quals);
4694 ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4695 ntype = build_distinct_type_copy (ttype);
4697 TYPE_ATTRIBUTES (ntype) = attribute;
4699 hstate.add_int (code);
4700 if (TREE_TYPE (ntype))
4701 hstate.add_object (TYPE_HASH (TREE_TYPE (ntype)));
4702 attribute_hash_list (attribute, hstate);
4704 switch (TREE_CODE (ntype))
4706 case FUNCTION_TYPE:
4707 type_hash_list (TYPE_ARG_TYPES (ntype), hstate);
4708 break;
4709 case ARRAY_TYPE:
4710 if (TYPE_DOMAIN (ntype))
4711 hstate.add_object (TYPE_HASH (TYPE_DOMAIN (ntype)));
4712 break;
4713 case INTEGER_TYPE:
4714 t = TYPE_MAX_VALUE (ntype);
4715 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
4716 hstate.add_object (TREE_INT_CST_ELT (t, i));
4717 break;
4718 case REAL_TYPE:
4719 case FIXED_POINT_TYPE:
4721 unsigned int precision = TYPE_PRECISION (ntype);
4722 hstate.add_object (precision);
4724 break;
4725 default:
4726 break;
4729 ntype = type_hash_canon (hstate.end(), ntype);
4731 /* If the target-dependent attributes make NTYPE different from
4732 its canonical type, we will need to use structural equality
4733 checks for this type. */
4734 if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4735 || !comp_type_attributes (ntype, ttype))
4736 SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4737 else if (TYPE_CANONICAL (ntype) == ntype)
4738 TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4740 ttype = build_qualified_type (ntype, quals);
4742 else if (TYPE_QUALS (ttype) != quals)
4743 ttype = build_qualified_type (ttype, quals);
4745 return ttype;
4748 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4749 the same. */
4751 static bool
4752 omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
4754 tree cl1, cl2;
4755 for (cl1 = clauses1, cl2 = clauses2;
4756 cl1 && cl2;
4757 cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
4759 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
4760 return false;
4761 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
4763 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
4764 OMP_CLAUSE_DECL (cl2)) != 1)
4765 return false;
4767 switch (OMP_CLAUSE_CODE (cl1))
4769 case OMP_CLAUSE_ALIGNED:
4770 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
4771 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
4772 return false;
4773 break;
4774 case OMP_CLAUSE_LINEAR:
4775 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
4776 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
4777 return false;
4778 break;
4779 case OMP_CLAUSE_SIMDLEN:
4780 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
4781 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
4782 return false;
4783 default:
4784 break;
4787 return true;
4790 /* Compare two constructor-element-type constants. Return 1 if the lists
4791 are known to be equal; otherwise return 0. */
4793 static bool
4794 simple_cst_list_equal (const_tree l1, const_tree l2)
4796 while (l1 != NULL_TREE && l2 != NULL_TREE)
4798 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
4799 return false;
4801 l1 = TREE_CHAIN (l1);
4802 l2 = TREE_CHAIN (l2);
4805 return l1 == l2;
4808 /* Compare two attributes for their value identity. Return true if the
4809 attribute values are known to be equal; otherwise return false.
4812 static bool
4813 attribute_value_equal (const_tree attr1, const_tree attr2)
4815 if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
4816 return true;
4818 if (TREE_VALUE (attr1) != NULL_TREE
4819 && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
4820 && TREE_VALUE (attr2) != NULL
4821 && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
4822 return (simple_cst_list_equal (TREE_VALUE (attr1),
4823 TREE_VALUE (attr2)) == 1);
4825 if ((flag_openmp || flag_openmp_simd)
4826 && TREE_VALUE (attr1) && TREE_VALUE (attr2)
4827 && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
4828 && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
4829 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
4830 TREE_VALUE (attr2));
4832 return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
4835 /* Return 0 if the attributes for two types are incompatible, 1 if they
4836 are compatible, and 2 if they are nearly compatible (which causes a
4837 warning to be generated). */
4839 comp_type_attributes (const_tree type1, const_tree type2)
4841 const_tree a1 = TYPE_ATTRIBUTES (type1);
4842 const_tree a2 = TYPE_ATTRIBUTES (type2);
4843 const_tree a;
4845 if (a1 == a2)
4846 return 1;
4847 for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
4849 const struct attribute_spec *as;
4850 const_tree attr;
4852 as = lookup_attribute_spec (get_attribute_name (a));
4853 if (!as || as->affects_type_identity == false)
4854 continue;
4856 attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
4857 if (!attr || !attribute_value_equal (a, attr))
4858 break;
4860 if (!a)
4862 for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
4864 const struct attribute_spec *as;
4866 as = lookup_attribute_spec (get_attribute_name (a));
4867 if (!as || as->affects_type_identity == false)
4868 continue;
4870 if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
4871 break;
4872 /* We don't need to compare trees again, as we did this
4873 already in first loop. */
4875 /* All types - affecting identity - are equal, so
4876 there is no need to call target hook for comparison. */
4877 if (!a)
4878 return 1;
4880 /* As some type combinations - like default calling-convention - might
4881 be compatible, we have to call the target hook to get the final result. */
4882 return targetm.comp_type_attributes (type1, type2);
4885 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4886 is ATTRIBUTE.
4888 Record such modified types already made so we don't make duplicates. */
4890 tree
4891 build_type_attribute_variant (tree ttype, tree attribute)
4893 return build_type_attribute_qual_variant (ttype, attribute,
4894 TYPE_QUALS (ttype));
4898 /* Reset the expression *EXPR_P, a size or position.
4900 ??? We could reset all non-constant sizes or positions. But it's cheap
4901 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4903 We need to reset self-referential sizes or positions because they cannot
4904 be gimplified and thus can contain a CALL_EXPR after the gimplification
4905 is finished, which will run afoul of LTO streaming. And they need to be
4906 reset to something essentially dummy but not constant, so as to preserve
4907 the properties of the object they are attached to. */
4909 static inline void
4910 free_lang_data_in_one_sizepos (tree *expr_p)
4912 tree expr = *expr_p;
4913 if (CONTAINS_PLACEHOLDER_P (expr))
4914 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4918 /* Reset all the fields in a binfo node BINFO. We only keep
4919 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4921 static void
4922 free_lang_data_in_binfo (tree binfo)
4924 unsigned i;
4925 tree t;
4927 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4929 BINFO_VIRTUALS (binfo) = NULL_TREE;
4930 BINFO_BASE_ACCESSES (binfo) = NULL;
4931 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4932 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4934 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
4935 free_lang_data_in_binfo (t);
4939 /* Reset all language specific information still present in TYPE. */
4941 static void
4942 free_lang_data_in_type (tree type)
4944 gcc_assert (TYPE_P (type));
4946 /* Give the FE a chance to remove its own data first. */
4947 lang_hooks.free_lang_data (type);
4949 TREE_LANG_FLAG_0 (type) = 0;
4950 TREE_LANG_FLAG_1 (type) = 0;
4951 TREE_LANG_FLAG_2 (type) = 0;
4952 TREE_LANG_FLAG_3 (type) = 0;
4953 TREE_LANG_FLAG_4 (type) = 0;
4954 TREE_LANG_FLAG_5 (type) = 0;
4955 TREE_LANG_FLAG_6 (type) = 0;
4957 if (TREE_CODE (type) == FUNCTION_TYPE)
4959 /* Remove the const and volatile qualifiers from arguments. The
4960 C++ front end removes them, but the C front end does not,
4961 leading to false ODR violation errors when merging two
4962 instances of the same function signature compiled by
4963 different front ends. */
4964 tree p;
4966 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4968 tree arg_type = TREE_VALUE (p);
4970 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4972 int quals = TYPE_QUALS (arg_type)
4973 & ~TYPE_QUAL_CONST
4974 & ~TYPE_QUAL_VOLATILE;
4975 TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4976 free_lang_data_in_type (TREE_VALUE (p));
4981 /* Remove members that are not actually FIELD_DECLs from the field
4982 list of an aggregate. These occur in C++. */
4983 if (RECORD_OR_UNION_TYPE_P (type))
4985 tree prev, member;
4987 /* Note that TYPE_FIELDS can be shared across distinct
4988 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4989 to be removed, we cannot set its TREE_CHAIN to NULL.
4990 Otherwise, we would not be able to find all the other fields
4991 in the other instances of this TREE_TYPE.
4993 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4994 prev = NULL_TREE;
4995 member = TYPE_FIELDS (type);
4996 while (member)
4998 if (TREE_CODE (member) == FIELD_DECL
4999 || TREE_CODE (member) == TYPE_DECL)
5001 if (prev)
5002 TREE_CHAIN (prev) = member;
5003 else
5004 TYPE_FIELDS (type) = member;
5005 prev = member;
5008 member = TREE_CHAIN (member);
5011 if (prev)
5012 TREE_CHAIN (prev) = NULL_TREE;
5013 else
5014 TYPE_FIELDS (type) = NULL_TREE;
5016 TYPE_METHODS (type) = NULL_TREE;
5017 if (TYPE_BINFO (type))
5019 free_lang_data_in_binfo (TYPE_BINFO (type));
5020 if ((!BINFO_VTABLE (TYPE_BINFO (type))
5021 || !flag_devirtualize)
5022 && (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type))
5023 || debug_info_level != DINFO_LEVEL_NONE))
5024 TYPE_BINFO (type) = NULL;
5027 else
5029 /* For non-aggregate types, clear out the language slot (which
5030 overloads TYPE_BINFO). */
5031 TYPE_LANG_SLOT_1 (type) = NULL_TREE;
5033 if (INTEGRAL_TYPE_P (type)
5034 || SCALAR_FLOAT_TYPE_P (type)
5035 || FIXED_POINT_TYPE_P (type))
5037 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
5038 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
5042 free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
5043 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
5045 if (TYPE_CONTEXT (type)
5046 && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
5048 tree ctx = TYPE_CONTEXT (type);
5051 ctx = BLOCK_SUPERCONTEXT (ctx);
5053 while (ctx && TREE_CODE (ctx) == BLOCK);
5054 TYPE_CONTEXT (type) = ctx;
5059 /* Return true if DECL may need an assembler name to be set. */
5061 static inline bool
5062 need_assembler_name_p (tree decl)
5064 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition Rule
5065 merging. */
5066 if (flag_lto_odr_type_mering
5067 && TREE_CODE (decl) == TYPE_DECL
5068 && DECL_NAME (decl)
5069 && decl == TYPE_NAME (TREE_TYPE (decl))
5070 && !is_lang_specific (TREE_TYPE (decl))
5071 && AGGREGATE_TYPE_P (TREE_TYPE (decl))
5072 && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE)
5073 && !type_in_anonymous_namespace_p (TREE_TYPE (decl)))
5074 return !DECL_ASSEMBLER_NAME_SET_P (decl);
5075 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5076 if (TREE_CODE (decl) != FUNCTION_DECL
5077 && TREE_CODE (decl) != VAR_DECL)
5078 return false;
5080 /* If DECL already has its assembler name set, it does not need a
5081 new one. */
5082 if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
5083 || DECL_ASSEMBLER_NAME_SET_P (decl))
5084 return false;
5086 /* Abstract decls do not need an assembler name. */
5087 if (DECL_ABSTRACT_P (decl))
5088 return false;
5090 /* For VAR_DECLs, only static, public and external symbols need an
5091 assembler name. */
5092 if (TREE_CODE (decl) == VAR_DECL
5093 && !TREE_STATIC (decl)
5094 && !TREE_PUBLIC (decl)
5095 && !DECL_EXTERNAL (decl))
5096 return false;
5098 if (TREE_CODE (decl) == FUNCTION_DECL)
5100 /* Do not set assembler name on builtins. Allow RTL expansion to
5101 decide whether to expand inline or via a regular call. */
5102 if (DECL_BUILT_IN (decl)
5103 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
5104 return false;
5106 /* Functions represented in the callgraph need an assembler name. */
5107 if (cgraph_node::get (decl) != NULL)
5108 return true;
5110 /* Unused and not public functions don't need an assembler name. */
5111 if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
5112 return false;
5115 return true;
5119 /* Reset all language specific information still present in symbol
5120 DECL. */
5122 static void
5123 free_lang_data_in_decl (tree decl)
5125 gcc_assert (DECL_P (decl));
5127 /* Give the FE a chance to remove its own data first. */
5128 lang_hooks.free_lang_data (decl);
5130 TREE_LANG_FLAG_0 (decl) = 0;
5131 TREE_LANG_FLAG_1 (decl) = 0;
5132 TREE_LANG_FLAG_2 (decl) = 0;
5133 TREE_LANG_FLAG_3 (decl) = 0;
5134 TREE_LANG_FLAG_4 (decl) = 0;
5135 TREE_LANG_FLAG_5 (decl) = 0;
5136 TREE_LANG_FLAG_6 (decl) = 0;
5138 free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
5139 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
5140 if (TREE_CODE (decl) == FIELD_DECL)
5142 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
5143 if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
5144 DECL_QUALIFIER (decl) = NULL_TREE;
5147 if (TREE_CODE (decl) == FUNCTION_DECL)
5149 struct cgraph_node *node;
5150 if (!(node = cgraph_node::get (decl))
5151 || (!node->definition && !node->clones))
5153 if (node)
5154 node->release_body ();
5155 else
5157 release_function_body (decl);
5158 DECL_ARGUMENTS (decl) = NULL;
5159 DECL_RESULT (decl) = NULL;
5160 DECL_INITIAL (decl) = error_mark_node;
5163 if (gimple_has_body_p (decl))
5165 tree t;
5167 /* If DECL has a gimple body, then the context for its
5168 arguments must be DECL. Otherwise, it doesn't really
5169 matter, as we will not be emitting any code for DECL. In
5170 general, there may be other instances of DECL created by
5171 the front end and since PARM_DECLs are generally shared,
5172 their DECL_CONTEXT changes as the replicas of DECL are
5173 created. The only time where DECL_CONTEXT is important
5174 is for the FUNCTION_DECLs that have a gimple body (since
5175 the PARM_DECL will be used in the function's body). */
5176 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
5177 DECL_CONTEXT (t) = decl;
5178 if (!DECL_FUNCTION_SPECIFIC_TARGET (decl))
5179 DECL_FUNCTION_SPECIFIC_TARGET (decl)
5180 = target_option_default_node;
5181 if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl))
5182 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl)
5183 = optimization_default_node;
5186 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5187 At this point, it is not needed anymore. */
5188 DECL_SAVED_TREE (decl) = NULL_TREE;
5190 /* Clear the abstract origin if it refers to a method. Otherwise
5191 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5192 origin will not be output correctly. */
5193 if (DECL_ABSTRACT_ORIGIN (decl)
5194 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
5195 && RECORD_OR_UNION_TYPE_P
5196 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
5197 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
5199 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5200 DECL_VINDEX referring to itself into a vtable slot number as it
5201 should. Happens with functions that are copied and then forgotten
5202 about. Just clear it, it won't matter anymore. */
5203 if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl)))
5204 DECL_VINDEX (decl) = NULL_TREE;
5206 else if (TREE_CODE (decl) == VAR_DECL)
5208 if ((DECL_EXTERNAL (decl)
5209 && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
5210 || (decl_function_context (decl) && !TREE_STATIC (decl)))
5211 DECL_INITIAL (decl) = NULL_TREE;
5213 else if (TREE_CODE (decl) == TYPE_DECL
5214 || TREE_CODE (decl) == FIELD_DECL)
5215 DECL_INITIAL (decl) = NULL_TREE;
5216 else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
5217 && DECL_INITIAL (decl)
5218 && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
5220 /* Strip builtins from the translation-unit BLOCK. We still have targets
5221 without builtin_decl_explicit support and also builtins are shared
5222 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5223 tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
5224 while (*nextp)
5226 tree var = *nextp;
5227 if (TREE_CODE (var) == FUNCTION_DECL
5228 && DECL_BUILT_IN (var))
5229 *nextp = TREE_CHAIN (var);
5230 else
5231 nextp = &TREE_CHAIN (var);
5237 /* Data used when collecting DECLs and TYPEs for language data removal. */
5239 struct free_lang_data_d
5241 /* Worklist to avoid excessive recursion. */
5242 vec<tree> worklist;
5244 /* Set of traversed objects. Used to avoid duplicate visits. */
5245 hash_set<tree> *pset;
5247 /* Array of symbols to process with free_lang_data_in_decl. */
5248 vec<tree> decls;
5250 /* Array of types to process with free_lang_data_in_type. */
5251 vec<tree> types;
5255 /* Save all language fields needed to generate proper debug information
5256 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5258 static void
5259 save_debug_info_for_decl (tree t)
5261 /*struct saved_debug_info_d *sdi;*/
5263 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
5265 /* FIXME. Partial implementation for saving debug info removed. */
5269 /* Save all language fields needed to generate proper debug information
5270 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5272 static void
5273 save_debug_info_for_type (tree t)
5275 /*struct saved_debug_info_d *sdi;*/
5277 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
5279 /* FIXME. Partial implementation for saving debug info removed. */
5283 /* Add type or decl T to one of the list of tree nodes that need their
5284 language data removed. The lists are held inside FLD. */
5286 static void
5287 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
5289 if (DECL_P (t))
5291 fld->decls.safe_push (t);
5292 if (debug_info_level > DINFO_LEVEL_TERSE)
5293 save_debug_info_for_decl (t);
5295 else if (TYPE_P (t))
5297 fld->types.safe_push (t);
5298 if (debug_info_level > DINFO_LEVEL_TERSE)
5299 save_debug_info_for_type (t);
5301 else
5302 gcc_unreachable ();
5305 /* Push tree node T into FLD->WORKLIST. */
5307 static inline void
5308 fld_worklist_push (tree t, struct free_lang_data_d *fld)
5310 if (t && !is_lang_specific (t) && !fld->pset->contains (t))
5311 fld->worklist.safe_push ((t));
5315 /* Operand callback helper for free_lang_data_in_node. *TP is the
5316 subtree operand being considered. */
5318 static tree
5319 find_decls_types_r (tree *tp, int *ws, void *data)
5321 tree t = *tp;
5322 struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
5324 if (TREE_CODE (t) == TREE_LIST)
5325 return NULL_TREE;
5327 /* Language specific nodes will be removed, so there is no need
5328 to gather anything under them. */
5329 if (is_lang_specific (t))
5331 *ws = 0;
5332 return NULL_TREE;
5335 if (DECL_P (t))
5337 /* Note that walk_tree does not traverse every possible field in
5338 decls, so we have to do our own traversals here. */
5339 add_tree_to_fld_list (t, fld);
5341 fld_worklist_push (DECL_NAME (t), fld);
5342 fld_worklist_push (DECL_CONTEXT (t), fld);
5343 fld_worklist_push (DECL_SIZE (t), fld);
5344 fld_worklist_push (DECL_SIZE_UNIT (t), fld);
5346 /* We are going to remove everything under DECL_INITIAL for
5347 TYPE_DECLs. No point walking them. */
5348 if (TREE_CODE (t) != TYPE_DECL)
5349 fld_worklist_push (DECL_INITIAL (t), fld);
5351 fld_worklist_push (DECL_ATTRIBUTES (t), fld);
5352 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
5354 if (TREE_CODE (t) == FUNCTION_DECL)
5356 fld_worklist_push (DECL_ARGUMENTS (t), fld);
5357 fld_worklist_push (DECL_RESULT (t), fld);
5359 else if (TREE_CODE (t) == TYPE_DECL)
5361 fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
5363 else if (TREE_CODE (t) == FIELD_DECL)
5365 fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
5366 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
5367 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
5368 fld_worklist_push (DECL_FCONTEXT (t), fld);
5371 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
5372 && DECL_HAS_VALUE_EXPR_P (t))
5373 fld_worklist_push (DECL_VALUE_EXPR (t), fld);
5375 if (TREE_CODE (t) != FIELD_DECL
5376 && TREE_CODE (t) != TYPE_DECL)
5377 fld_worklist_push (TREE_CHAIN (t), fld);
5378 *ws = 0;
5380 else if (TYPE_P (t))
5382 /* Note that walk_tree does not traverse every possible field in
5383 types, so we have to do our own traversals here. */
5384 add_tree_to_fld_list (t, fld);
5386 if (!RECORD_OR_UNION_TYPE_P (t))
5387 fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
5388 fld_worklist_push (TYPE_SIZE (t), fld);
5389 fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
5390 fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
5391 fld_worklist_push (TYPE_POINTER_TO (t), fld);
5392 fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
5393 fld_worklist_push (TYPE_NAME (t), fld);
5394 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5395 them and thus do not and want not to reach unused pointer types
5396 this way. */
5397 if (!POINTER_TYPE_P (t))
5398 fld_worklist_push (TYPE_MINVAL (t), fld);
5399 if (!RECORD_OR_UNION_TYPE_P (t))
5400 fld_worklist_push (TYPE_MAXVAL (t), fld);
5401 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
5402 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5403 do not and want not to reach unused variants this way. */
5404 if (TYPE_CONTEXT (t))
5406 tree ctx = TYPE_CONTEXT (t);
5407 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5408 So push that instead. */
5409 while (ctx && TREE_CODE (ctx) == BLOCK)
5410 ctx = BLOCK_SUPERCONTEXT (ctx);
5411 fld_worklist_push (ctx, fld);
5413 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5414 and want not to reach unused types this way. */
5416 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
5418 unsigned i;
5419 tree tem;
5420 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
5421 fld_worklist_push (TREE_TYPE (tem), fld);
5422 tem = BINFO_VIRTUALS (TYPE_BINFO (t));
5423 if (tem
5424 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5425 && TREE_CODE (tem) == TREE_LIST)
5428 fld_worklist_push (TREE_VALUE (tem), fld);
5429 tem = TREE_CHAIN (tem);
5431 while (tem);
5433 if (RECORD_OR_UNION_TYPE_P (t))
5435 tree tem;
5436 /* Push all TYPE_FIELDS - there can be interleaving interesting
5437 and non-interesting things. */
5438 tem = TYPE_FIELDS (t);
5439 while (tem)
5441 if (TREE_CODE (tem) == FIELD_DECL
5442 || TREE_CODE (tem) == TYPE_DECL)
5443 fld_worklist_push (tem, fld);
5444 tem = TREE_CHAIN (tem);
5448 fld_worklist_push (TYPE_STUB_DECL (t), fld);
5449 *ws = 0;
5451 else if (TREE_CODE (t) == BLOCK)
5453 tree tem;
5454 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
5455 fld_worklist_push (tem, fld);
5456 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
5457 fld_worklist_push (tem, fld);
5458 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
5461 if (TREE_CODE (t) != IDENTIFIER_NODE
5462 && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
5463 fld_worklist_push (TREE_TYPE (t), fld);
5465 return NULL_TREE;
5469 /* Find decls and types in T. */
5471 static void
5472 find_decls_types (tree t, struct free_lang_data_d *fld)
5474 while (1)
5476 if (!fld->pset->contains (t))
5477 walk_tree (&t, find_decls_types_r, fld, fld->pset);
5478 if (fld->worklist.is_empty ())
5479 break;
5480 t = fld->worklist.pop ();
5484 /* Translate all the types in LIST with the corresponding runtime
5485 types. */
5487 static tree
5488 get_eh_types_for_runtime (tree list)
5490 tree head, prev;
5492 if (list == NULL_TREE)
5493 return NULL_TREE;
5495 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5496 prev = head;
5497 list = TREE_CHAIN (list);
5498 while (list)
5500 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5501 TREE_CHAIN (prev) = n;
5502 prev = TREE_CHAIN (prev);
5503 list = TREE_CHAIN (list);
5506 return head;
5510 /* Find decls and types referenced in EH region R and store them in
5511 FLD->DECLS and FLD->TYPES. */
5513 static void
5514 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
5516 switch (r->type)
5518 case ERT_CLEANUP:
5519 break;
5521 case ERT_TRY:
5523 eh_catch c;
5525 /* The types referenced in each catch must first be changed to the
5526 EH types used at runtime. This removes references to FE types
5527 in the region. */
5528 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
5530 c->type_list = get_eh_types_for_runtime (c->type_list);
5531 walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
5534 break;
5536 case ERT_ALLOWED_EXCEPTIONS:
5537 r->u.allowed.type_list
5538 = get_eh_types_for_runtime (r->u.allowed.type_list);
5539 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
5540 break;
5542 case ERT_MUST_NOT_THROW:
5543 walk_tree (&r->u.must_not_throw.failure_decl,
5544 find_decls_types_r, fld, fld->pset);
5545 break;
5550 /* Find decls and types referenced in cgraph node N and store them in
5551 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5552 look for *every* kind of DECL and TYPE node reachable from N,
5553 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5554 NAMESPACE_DECLs, etc). */
5556 static void
5557 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
5559 basic_block bb;
5560 struct function *fn;
5561 unsigned ix;
5562 tree t;
5564 find_decls_types (n->decl, fld);
5566 if (!gimple_has_body_p (n->decl))
5567 return;
5569 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
5571 fn = DECL_STRUCT_FUNCTION (n->decl);
5573 /* Traverse locals. */
5574 FOR_EACH_LOCAL_DECL (fn, ix, t)
5575 find_decls_types (t, fld);
5577 /* Traverse EH regions in FN. */
5579 eh_region r;
5580 FOR_ALL_EH_REGION_FN (r, fn)
5581 find_decls_types_in_eh_region (r, fld);
5584 /* Traverse every statement in FN. */
5585 FOR_EACH_BB_FN (bb, fn)
5587 gphi_iterator psi;
5588 gimple_stmt_iterator si;
5589 unsigned i;
5591 for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
5593 gphi *phi = psi.phi ();
5595 for (i = 0; i < gimple_phi_num_args (phi); i++)
5597 tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
5598 find_decls_types (*arg_p, fld);
5602 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
5604 gimple stmt = gsi_stmt (si);
5606 if (is_gimple_call (stmt))
5607 find_decls_types (gimple_call_fntype (stmt), fld);
5609 for (i = 0; i < gimple_num_ops (stmt); i++)
5611 tree arg = gimple_op (stmt, i);
5612 find_decls_types (arg, fld);
5619 /* Find decls and types referenced in varpool node N and store them in
5620 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5621 look for *every* kind of DECL and TYPE node reachable from N,
5622 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5623 NAMESPACE_DECLs, etc). */
5625 static void
5626 find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
5628 find_decls_types (v->decl, fld);
5631 /* If T needs an assembler name, have one created for it. */
5633 void
5634 assign_assembler_name_if_neeeded (tree t)
5636 if (need_assembler_name_p (t))
5638 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5639 diagnostics that use input_location to show locus
5640 information. The problem here is that, at this point,
5641 input_location is generally anchored to the end of the file
5642 (since the parser is long gone), so we don't have a good
5643 position to pin it to.
5645 To alleviate this problem, this uses the location of T's
5646 declaration. Examples of this are
5647 testsuite/g++.dg/template/cond2.C and
5648 testsuite/g++.dg/template/pr35240.C. */
5649 location_t saved_location = input_location;
5650 input_location = DECL_SOURCE_LOCATION (t);
5652 decl_assembler_name (t);
5654 input_location = saved_location;
5659 /* Free language specific information for every operand and expression
5660 in every node of the call graph. This process operates in three stages:
5662 1- Every callgraph node and varpool node is traversed looking for
5663 decls and types embedded in them. This is a more exhaustive
5664 search than that done by find_referenced_vars, because it will
5665 also collect individual fields, decls embedded in types, etc.
5667 2- All the decls found are sent to free_lang_data_in_decl.
5669 3- All the types found are sent to free_lang_data_in_type.
5671 The ordering between decls and types is important because
5672 free_lang_data_in_decl sets assembler names, which includes
5673 mangling. So types cannot be freed up until assembler names have
5674 been set up. */
5676 static void
5677 free_lang_data_in_cgraph (void)
5679 struct cgraph_node *n;
5680 varpool_node *v;
5681 struct free_lang_data_d fld;
5682 tree t;
5683 unsigned i;
5684 alias_pair *p;
5686 /* Initialize sets and arrays to store referenced decls and types. */
5687 fld.pset = new hash_set<tree>;
5688 fld.worklist.create (0);
5689 fld.decls.create (100);
5690 fld.types.create (100);
5692 /* Find decls and types in the body of every function in the callgraph. */
5693 FOR_EACH_FUNCTION (n)
5694 find_decls_types_in_node (n, &fld);
5696 FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
5697 find_decls_types (p->decl, &fld);
5699 /* Find decls and types in every varpool symbol. */
5700 FOR_EACH_VARIABLE (v)
5701 find_decls_types_in_var (v, &fld);
5703 /* Set the assembler name on every decl found. We need to do this
5704 now because free_lang_data_in_decl will invalidate data needed
5705 for mangling. This breaks mangling on interdependent decls. */
5706 FOR_EACH_VEC_ELT (fld.decls, i, t)
5707 assign_assembler_name_if_neeeded (t);
5709 /* Traverse every decl found freeing its language data. */
5710 FOR_EACH_VEC_ELT (fld.decls, i, t)
5711 free_lang_data_in_decl (t);
5713 /* Traverse every type found freeing its language data. */
5714 FOR_EACH_VEC_ELT (fld.types, i, t)
5715 free_lang_data_in_type (t);
5717 delete fld.pset;
5718 fld.worklist.release ();
5719 fld.decls.release ();
5720 fld.types.release ();
5724 /* Free resources that are used by FE but are not needed once they are done. */
5726 static unsigned
5727 free_lang_data (void)
5729 unsigned i;
5731 /* If we are the LTO frontend we have freed lang-specific data already. */
5732 if (in_lto_p
5733 || !flag_generate_lto)
5734 return 0;
5736 /* Allocate and assign alias sets to the standard integer types
5737 while the slots are still in the way the frontends generated them. */
5738 for (i = 0; i < itk_none; ++i)
5739 if (integer_types[i])
5740 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5742 /* Traverse the IL resetting language specific information for
5743 operands, expressions, etc. */
5744 free_lang_data_in_cgraph ();
5746 /* Create gimple variants for common types. */
5747 ptrdiff_type_node = integer_type_node;
5748 fileptr_type_node = ptr_type_node;
5750 /* Reset some langhooks. Do not reset types_compatible_p, it may
5751 still be used indirectly via the get_alias_set langhook. */
5752 lang_hooks.dwarf_name = lhd_dwarf_name;
5753 lang_hooks.decl_printable_name = gimple_decl_printable_name;
5754 /* We do not want the default decl_assembler_name implementation,
5755 rather if we have fixed everything we want a wrapper around it
5756 asserting that all non-local symbols already got their assembler
5757 name and only produce assembler names for local symbols. Or rather
5758 make sure we never call decl_assembler_name on local symbols and
5759 devise a separate, middle-end private scheme for it. */
5761 /* Reset diagnostic machinery. */
5762 tree_diagnostics_defaults (global_dc);
5764 return 0;
5768 namespace {
5770 const pass_data pass_data_ipa_free_lang_data =
5772 SIMPLE_IPA_PASS, /* type */
5773 "*free_lang_data", /* name */
5774 OPTGROUP_NONE, /* optinfo_flags */
5775 TV_IPA_FREE_LANG_DATA, /* tv_id */
5776 0, /* properties_required */
5777 0, /* properties_provided */
5778 0, /* properties_destroyed */
5779 0, /* todo_flags_start */
5780 0, /* todo_flags_finish */
5783 class pass_ipa_free_lang_data : public simple_ipa_opt_pass
5785 public:
5786 pass_ipa_free_lang_data (gcc::context *ctxt)
5787 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
5790 /* opt_pass methods: */
5791 virtual unsigned int execute (function *) { return free_lang_data (); }
5793 }; // class pass_ipa_free_lang_data
5795 } // anon namespace
5797 simple_ipa_opt_pass *
5798 make_pass_ipa_free_lang_data (gcc::context *ctxt)
5800 return new pass_ipa_free_lang_data (ctxt);
5803 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5804 ATTR_NAME. Also used internally by remove_attribute(). */
5805 bool
5806 private_is_attribute_p (const char *attr_name, size_t attr_len, const_tree ident)
5808 size_t ident_len = IDENTIFIER_LENGTH (ident);
5810 if (ident_len == attr_len)
5812 if (strcmp (attr_name, IDENTIFIER_POINTER (ident)) == 0)
5813 return true;
5815 else if (ident_len == attr_len + 4)
5817 /* There is the possibility that ATTR is 'text' and IDENT is
5818 '__text__'. */
5819 const char *p = IDENTIFIER_POINTER (ident);
5820 if (p[0] == '_' && p[1] == '_'
5821 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5822 && strncmp (attr_name, p + 2, attr_len) == 0)
5823 return true;
5826 return false;
5829 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5830 of ATTR_NAME, and LIST is not NULL_TREE. */
5831 tree
5832 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
5834 while (list)
5836 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5838 if (ident_len == attr_len)
5840 if (!strcmp (attr_name,
5841 IDENTIFIER_POINTER (get_attribute_name (list))))
5842 break;
5844 /* TODO: If we made sure that attributes were stored in the
5845 canonical form without '__...__' (ie, as in 'text' as opposed
5846 to '__text__') then we could avoid the following case. */
5847 else if (ident_len == attr_len + 4)
5849 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5850 if (p[0] == '_' && p[1] == '_'
5851 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5852 && strncmp (attr_name, p + 2, attr_len) == 0)
5853 break;
5855 list = TREE_CHAIN (list);
5858 return list;
5861 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
5862 return a pointer to the attribute's list first element if the attribute
5863 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
5864 '__text__'). */
5866 tree
5867 private_lookup_attribute_by_prefix (const char *attr_name, size_t attr_len,
5868 tree list)
5870 while (list)
5872 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5874 if (attr_len > ident_len)
5876 list = TREE_CHAIN (list);
5877 continue;
5880 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5882 if (strncmp (attr_name, p, attr_len) == 0)
5883 break;
5885 /* TODO: If we made sure that attributes were stored in the
5886 canonical form without '__...__' (ie, as in 'text' as opposed
5887 to '__text__') then we could avoid the following case. */
5888 if (p[0] == '_' && p[1] == '_' &&
5889 strncmp (attr_name, p + 2, attr_len) == 0)
5890 break;
5892 list = TREE_CHAIN (list);
5895 return list;
5899 /* A variant of lookup_attribute() that can be used with an identifier
5900 as the first argument, and where the identifier can be either
5901 'text' or '__text__'.
5903 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5904 return a pointer to the attribute's list element if the attribute
5905 is part of the list, or NULL_TREE if not found. If the attribute
5906 appears more than once, this only returns the first occurrence; the
5907 TREE_CHAIN of the return value should be passed back in if further
5908 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5909 can be in the form 'text' or '__text__'. */
5910 static tree
5911 lookup_ident_attribute (tree attr_identifier, tree list)
5913 gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
5915 while (list)
5917 gcc_checking_assert (TREE_CODE (get_attribute_name (list))
5918 == IDENTIFIER_NODE);
5920 /* Identifiers can be compared directly for equality. */
5921 if (attr_identifier == get_attribute_name (list))
5922 break;
5924 /* If they are not equal, they may still be one in the form
5925 'text' while the other one is in the form '__text__'. TODO:
5926 If we were storing attributes in normalized 'text' form, then
5927 this could all go away and we could take full advantage of
5928 the fact that we're comparing identifiers. :-) */
5930 size_t attr_len = IDENTIFIER_LENGTH (attr_identifier);
5931 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5933 if (ident_len == attr_len + 4)
5935 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5936 const char *q = IDENTIFIER_POINTER (attr_identifier);
5937 if (p[0] == '_' && p[1] == '_'
5938 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5939 && strncmp (q, p + 2, attr_len) == 0)
5940 break;
5942 else if (ident_len + 4 == attr_len)
5944 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5945 const char *q = IDENTIFIER_POINTER (attr_identifier);
5946 if (q[0] == '_' && q[1] == '_'
5947 && q[attr_len - 2] == '_' && q[attr_len - 1] == '_'
5948 && strncmp (q + 2, p, ident_len) == 0)
5949 break;
5952 list = TREE_CHAIN (list);
5955 return list;
5958 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5959 modified list. */
5961 tree
5962 remove_attribute (const char *attr_name, tree list)
5964 tree *p;
5965 size_t attr_len = strlen (attr_name);
5967 gcc_checking_assert (attr_name[0] != '_');
5969 for (p = &list; *p; )
5971 tree l = *p;
5972 /* TODO: If we were storing attributes in normalized form, here
5973 we could use a simple strcmp(). */
5974 if (private_is_attribute_p (attr_name, attr_len, get_attribute_name (l)))
5975 *p = TREE_CHAIN (l);
5976 else
5977 p = &TREE_CHAIN (l);
5980 return list;
5983 /* Return an attribute list that is the union of a1 and a2. */
5985 tree
5986 merge_attributes (tree a1, tree a2)
5988 tree attributes;
5990 /* Either one unset? Take the set one. */
5992 if ((attributes = a1) == 0)
5993 attributes = a2;
5995 /* One that completely contains the other? Take it. */
5997 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5999 if (attribute_list_contained (a2, a1))
6000 attributes = a2;
6001 else
6003 /* Pick the longest list, and hang on the other list. */
6005 if (list_length (a1) < list_length (a2))
6006 attributes = a2, a2 = a1;
6008 for (; a2 != 0; a2 = TREE_CHAIN (a2))
6010 tree a;
6011 for (a = lookup_ident_attribute (get_attribute_name (a2),
6012 attributes);
6013 a != NULL_TREE && !attribute_value_equal (a, a2);
6014 a = lookup_ident_attribute (get_attribute_name (a2),
6015 TREE_CHAIN (a)))
6017 if (a == NULL_TREE)
6019 a1 = copy_node (a2);
6020 TREE_CHAIN (a1) = attributes;
6021 attributes = a1;
6026 return attributes;
6029 /* Given types T1 and T2, merge their attributes and return
6030 the result. */
6032 tree
6033 merge_type_attributes (tree t1, tree t2)
6035 return merge_attributes (TYPE_ATTRIBUTES (t1),
6036 TYPE_ATTRIBUTES (t2));
6039 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
6040 the result. */
6042 tree
6043 merge_decl_attributes (tree olddecl, tree newdecl)
6045 return merge_attributes (DECL_ATTRIBUTES (olddecl),
6046 DECL_ATTRIBUTES (newdecl));
6049 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
6051 /* Specialization of merge_decl_attributes for various Windows targets.
6053 This handles the following situation:
6055 __declspec (dllimport) int foo;
6056 int foo;
6058 The second instance of `foo' nullifies the dllimport. */
6060 tree
6061 merge_dllimport_decl_attributes (tree old, tree new_tree)
6063 tree a;
6064 int delete_dllimport_p = 1;
6066 /* What we need to do here is remove from `old' dllimport if it doesn't
6067 appear in `new'. dllimport behaves like extern: if a declaration is
6068 marked dllimport and a definition appears later, then the object
6069 is not dllimport'd. We also remove a `new' dllimport if the old list
6070 contains dllexport: dllexport always overrides dllimport, regardless
6071 of the order of declaration. */
6072 if (!VAR_OR_FUNCTION_DECL_P (new_tree))
6073 delete_dllimport_p = 0;
6074 else if (DECL_DLLIMPORT_P (new_tree)
6075 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
6077 DECL_DLLIMPORT_P (new_tree) = 0;
6078 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
6079 "dllimport ignored", new_tree);
6081 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
6083 /* Warn about overriding a symbol that has already been used, e.g.:
6084 extern int __attribute__ ((dllimport)) foo;
6085 int* bar () {return &foo;}
6086 int foo;
6088 if (TREE_USED (old))
6090 warning (0, "%q+D redeclared without dllimport attribute "
6091 "after being referenced with dll linkage", new_tree);
6092 /* If we have used a variable's address with dllimport linkage,
6093 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
6094 decl may already have had TREE_CONSTANT computed.
6095 We still remove the attribute so that assembler code refers
6096 to '&foo rather than '_imp__foo'. */
6097 if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
6098 DECL_DLLIMPORT_P (new_tree) = 1;
6101 /* Let an inline definition silently override the external reference,
6102 but otherwise warn about attribute inconsistency. */
6103 else if (TREE_CODE (new_tree) == VAR_DECL
6104 || !DECL_DECLARED_INLINE_P (new_tree))
6105 warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
6106 "previous dllimport ignored", new_tree);
6108 else
6109 delete_dllimport_p = 0;
6111 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
6113 if (delete_dllimport_p)
6114 a = remove_attribute ("dllimport", a);
6116 return a;
6119 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
6120 struct attribute_spec.handler. */
6122 tree
6123 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
6124 bool *no_add_attrs)
6126 tree node = *pnode;
6127 bool is_dllimport;
6129 /* These attributes may apply to structure and union types being created,
6130 but otherwise should pass to the declaration involved. */
6131 if (!DECL_P (node))
6133 if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
6134 | (int) ATTR_FLAG_ARRAY_NEXT))
6136 *no_add_attrs = true;
6137 return tree_cons (name, args, NULL_TREE);
6139 if (TREE_CODE (node) == RECORD_TYPE
6140 || TREE_CODE (node) == UNION_TYPE)
6142 node = TYPE_NAME (node);
6143 if (!node)
6144 return NULL_TREE;
6146 else
6148 warning (OPT_Wattributes, "%qE attribute ignored",
6149 name);
6150 *no_add_attrs = true;
6151 return NULL_TREE;
6155 if (TREE_CODE (node) != FUNCTION_DECL
6156 && TREE_CODE (node) != VAR_DECL
6157 && TREE_CODE (node) != TYPE_DECL)
6159 *no_add_attrs = true;
6160 warning (OPT_Wattributes, "%qE attribute ignored",
6161 name);
6162 return NULL_TREE;
6165 if (TREE_CODE (node) == TYPE_DECL
6166 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
6167 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
6169 *no_add_attrs = true;
6170 warning (OPT_Wattributes, "%qE attribute ignored",
6171 name);
6172 return NULL_TREE;
6175 is_dllimport = is_attribute_p ("dllimport", name);
6177 /* Report error on dllimport ambiguities seen now before they cause
6178 any damage. */
6179 if (is_dllimport)
6181 /* Honor any target-specific overrides. */
6182 if (!targetm.valid_dllimport_attribute_p (node))
6183 *no_add_attrs = true;
6185 else if (TREE_CODE (node) == FUNCTION_DECL
6186 && DECL_DECLARED_INLINE_P (node))
6188 warning (OPT_Wattributes, "inline function %q+D declared as "
6189 " dllimport: attribute ignored", node);
6190 *no_add_attrs = true;
6192 /* Like MS, treat definition of dllimported variables and
6193 non-inlined functions on declaration as syntax errors. */
6194 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
6196 error ("function %q+D definition is marked dllimport", node);
6197 *no_add_attrs = true;
6200 else if (TREE_CODE (node) == VAR_DECL)
6202 if (DECL_INITIAL (node))
6204 error ("variable %q+D definition is marked dllimport",
6205 node);
6206 *no_add_attrs = true;
6209 /* `extern' needn't be specified with dllimport.
6210 Specify `extern' now and hope for the best. Sigh. */
6211 DECL_EXTERNAL (node) = 1;
6212 /* Also, implicitly give dllimport'd variables declared within
6213 a function global scope, unless declared static. */
6214 if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
6215 TREE_PUBLIC (node) = 1;
6218 if (*no_add_attrs == false)
6219 DECL_DLLIMPORT_P (node) = 1;
6221 else if (TREE_CODE (node) == FUNCTION_DECL
6222 && DECL_DECLARED_INLINE_P (node)
6223 && flag_keep_inline_dllexport)
6224 /* An exported function, even if inline, must be emitted. */
6225 DECL_EXTERNAL (node) = 0;
6227 /* Report error if symbol is not accessible at global scope. */
6228 if (!TREE_PUBLIC (node)
6229 && (TREE_CODE (node) == VAR_DECL
6230 || TREE_CODE (node) == FUNCTION_DECL))
6232 error ("external linkage required for symbol %q+D because of "
6233 "%qE attribute", node, name);
6234 *no_add_attrs = true;
6237 /* A dllexport'd entity must have default visibility so that other
6238 program units (shared libraries or the main executable) can see
6239 it. A dllimport'd entity must have default visibility so that
6240 the linker knows that undefined references within this program
6241 unit can be resolved by the dynamic linker. */
6242 if (!*no_add_attrs)
6244 if (DECL_VISIBILITY_SPECIFIED (node)
6245 && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
6246 error ("%qE implies default visibility, but %qD has already "
6247 "been declared with a different visibility",
6248 name, node);
6249 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
6250 DECL_VISIBILITY_SPECIFIED (node) = 1;
6253 return NULL_TREE;
6256 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
6258 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6259 of the various TYPE_QUAL values. */
6261 static void
6262 set_type_quals (tree type, int type_quals)
6264 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
6265 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
6266 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
6267 TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
6268 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
6271 /* Returns true iff unqualified CAND and BASE are equivalent. */
6273 bool
6274 check_base_type (const_tree cand, const_tree base)
6276 return (TYPE_NAME (cand) == TYPE_NAME (base)
6277 /* Apparently this is needed for Objective-C. */
6278 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6279 /* Check alignment. */
6280 && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
6281 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6282 TYPE_ATTRIBUTES (base)));
6285 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
6287 bool
6288 check_qualified_type (const_tree cand, const_tree base, int type_quals)
6290 return (TYPE_QUALS (cand) == type_quals
6291 && check_base_type (cand, base));
6294 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6296 static bool
6297 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
6299 return (TYPE_QUALS (cand) == TYPE_QUALS (base)
6300 && TYPE_NAME (cand) == TYPE_NAME (base)
6301 /* Apparently this is needed for Objective-C. */
6302 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6303 /* Check alignment. */
6304 && TYPE_ALIGN (cand) == align
6305 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6306 TYPE_ATTRIBUTES (base)));
6309 /* This function checks to see if TYPE matches the size one of the built-in
6310 atomic types, and returns that core atomic type. */
6312 static tree
6313 find_atomic_core_type (tree type)
6315 tree base_atomic_type;
6317 /* Only handle complete types. */
6318 if (TYPE_SIZE (type) == NULL_TREE)
6319 return NULL_TREE;
6321 HOST_WIDE_INT type_size = tree_to_uhwi (TYPE_SIZE (type));
6322 switch (type_size)
6324 case 8:
6325 base_atomic_type = atomicQI_type_node;
6326 break;
6328 case 16:
6329 base_atomic_type = atomicHI_type_node;
6330 break;
6332 case 32:
6333 base_atomic_type = atomicSI_type_node;
6334 break;
6336 case 64:
6337 base_atomic_type = atomicDI_type_node;
6338 break;
6340 case 128:
6341 base_atomic_type = atomicTI_type_node;
6342 break;
6344 default:
6345 base_atomic_type = NULL_TREE;
6348 return base_atomic_type;
6351 /* Return a version of the TYPE, qualified as indicated by the
6352 TYPE_QUALS, if one exists. If no qualified version exists yet,
6353 return NULL_TREE. */
6355 tree
6356 get_qualified_type (tree type, int type_quals)
6358 tree t;
6360 if (TYPE_QUALS (type) == type_quals)
6361 return type;
6363 /* Search the chain of variants to see if there is already one there just
6364 like the one we need to have. If so, use that existing one. We must
6365 preserve the TYPE_NAME, since there is code that depends on this. */
6366 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6367 if (check_qualified_type (t, type, type_quals))
6368 return t;
6370 return NULL_TREE;
6373 /* Like get_qualified_type, but creates the type if it does not
6374 exist. This function never returns NULL_TREE. */
6376 tree
6377 build_qualified_type (tree type, int type_quals)
6379 tree t;
6381 /* See if we already have the appropriate qualified variant. */
6382 t = get_qualified_type (type, type_quals);
6384 /* If not, build it. */
6385 if (!t)
6387 t = build_variant_type_copy (type);
6388 set_type_quals (t, type_quals);
6390 if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
6392 /* See if this object can map to a basic atomic type. */
6393 tree atomic_type = find_atomic_core_type (type);
6394 if (atomic_type)
6396 /* Ensure the alignment of this type is compatible with
6397 the required alignment of the atomic type. */
6398 if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
6399 TYPE_ALIGN (t) = TYPE_ALIGN (atomic_type);
6403 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6404 /* Propagate structural equality. */
6405 SET_TYPE_STRUCTURAL_EQUALITY (t);
6406 else if (TYPE_CANONICAL (type) != type)
6407 /* Build the underlying canonical type, since it is different
6408 from TYPE. */
6410 tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals);
6411 TYPE_CANONICAL (t) = TYPE_CANONICAL (c);
6413 else
6414 /* T is its own canonical type. */
6415 TYPE_CANONICAL (t) = t;
6419 return t;
6422 /* Create a variant of type T with alignment ALIGN. */
6424 tree
6425 build_aligned_type (tree type, unsigned int align)
6427 tree t;
6429 if (TYPE_PACKED (type)
6430 || TYPE_ALIGN (type) == align)
6431 return type;
6433 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6434 if (check_aligned_type (t, type, align))
6435 return t;
6437 t = build_variant_type_copy (type);
6438 TYPE_ALIGN (t) = align;
6440 return t;
6443 /* Create a new distinct copy of TYPE. The new type is made its own
6444 MAIN_VARIANT. If TYPE requires structural equality checks, the
6445 resulting type requires structural equality checks; otherwise, its
6446 TYPE_CANONICAL points to itself. */
6448 tree
6449 build_distinct_type_copy (tree type)
6451 tree t = copy_node (type);
6453 TYPE_POINTER_TO (t) = 0;
6454 TYPE_REFERENCE_TO (t) = 0;
6456 /* Set the canonical type either to a new equivalence class, or
6457 propagate the need for structural equality checks. */
6458 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6459 SET_TYPE_STRUCTURAL_EQUALITY (t);
6460 else
6461 TYPE_CANONICAL (t) = t;
6463 /* Make it its own variant. */
6464 TYPE_MAIN_VARIANT (t) = t;
6465 TYPE_NEXT_VARIANT (t) = 0;
6467 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6468 whose TREE_TYPE is not t. This can also happen in the Ada
6469 frontend when using subtypes. */
6471 return t;
6474 /* Create a new variant of TYPE, equivalent but distinct. This is so
6475 the caller can modify it. TYPE_CANONICAL for the return type will
6476 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6477 are considered equal by the language itself (or that both types
6478 require structural equality checks). */
6480 tree
6481 build_variant_type_copy (tree type)
6483 tree t, m = TYPE_MAIN_VARIANT (type);
6485 t = build_distinct_type_copy (type);
6487 /* Since we're building a variant, assume that it is a non-semantic
6488 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6489 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6491 /* Add the new type to the chain of variants of TYPE. */
6492 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6493 TYPE_NEXT_VARIANT (m) = t;
6494 TYPE_MAIN_VARIANT (t) = m;
6496 return t;
6499 /* Return true if the from tree in both tree maps are equal. */
6502 tree_map_base_eq (const void *va, const void *vb)
6504 const struct tree_map_base *const a = (const struct tree_map_base *) va,
6505 *const b = (const struct tree_map_base *) vb;
6506 return (a->from == b->from);
6509 /* Hash a from tree in a tree_base_map. */
6511 unsigned int
6512 tree_map_base_hash (const void *item)
6514 return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6517 /* Return true if this tree map structure is marked for garbage collection
6518 purposes. We simply return true if the from tree is marked, so that this
6519 structure goes away when the from tree goes away. */
6522 tree_map_base_marked_p (const void *p)
6524 return ggc_marked_p (((const struct tree_map_base *) p)->from);
6527 /* Hash a from tree in a tree_map. */
6529 unsigned int
6530 tree_map_hash (const void *item)
6532 return (((const struct tree_map *) item)->hash);
6535 /* Hash a from tree in a tree_decl_map. */
6537 unsigned int
6538 tree_decl_map_hash (const void *item)
6540 return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6543 /* Return the initialization priority for DECL. */
6545 priority_type
6546 decl_init_priority_lookup (tree decl)
6548 symtab_node *snode = symtab_node::get (decl);
6550 if (!snode)
6551 return DEFAULT_INIT_PRIORITY;
6552 return
6553 snode->get_init_priority ();
6556 /* Return the finalization priority for DECL. */
6558 priority_type
6559 decl_fini_priority_lookup (tree decl)
6561 cgraph_node *node = cgraph_node::get (decl);
6563 if (!node)
6564 return DEFAULT_INIT_PRIORITY;
6565 return
6566 node->get_fini_priority ();
6569 /* Set the initialization priority for DECL to PRIORITY. */
6571 void
6572 decl_init_priority_insert (tree decl, priority_type priority)
6574 struct symtab_node *snode;
6576 if (priority == DEFAULT_INIT_PRIORITY)
6578 snode = symtab_node::get (decl);
6579 if (!snode)
6580 return;
6582 else if (TREE_CODE (decl) == VAR_DECL)
6583 snode = varpool_node::get_create (decl);
6584 else
6585 snode = cgraph_node::get_create (decl);
6586 snode->set_init_priority (priority);
6589 /* Set the finalization priority for DECL to PRIORITY. */
6591 void
6592 decl_fini_priority_insert (tree decl, priority_type priority)
6594 struct cgraph_node *node;
6596 if (priority == DEFAULT_INIT_PRIORITY)
6598 node = cgraph_node::get (decl);
6599 if (!node)
6600 return;
6602 else
6603 node = cgraph_node::get_create (decl);
6604 node->set_fini_priority (priority);
6607 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6609 static void
6610 print_debug_expr_statistics (void)
6612 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6613 (long) debug_expr_for_decl->size (),
6614 (long) debug_expr_for_decl->elements (),
6615 debug_expr_for_decl->collisions ());
6618 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6620 static void
6621 print_value_expr_statistics (void)
6623 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6624 (long) value_expr_for_decl->size (),
6625 (long) value_expr_for_decl->elements (),
6626 value_expr_for_decl->collisions ());
6629 /* Lookup a debug expression for FROM, and return it if we find one. */
6631 tree
6632 decl_debug_expr_lookup (tree from)
6634 struct tree_decl_map *h, in;
6635 in.base.from = from;
6637 h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6638 if (h)
6639 return h->to;
6640 return NULL_TREE;
6643 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6645 void
6646 decl_debug_expr_insert (tree from, tree to)
6648 struct tree_decl_map *h;
6650 h = ggc_alloc<tree_decl_map> ();
6651 h->base.from = from;
6652 h->to = to;
6653 *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6656 /* Lookup a value expression for FROM, and return it if we find one. */
6658 tree
6659 decl_value_expr_lookup (tree from)
6661 struct tree_decl_map *h, in;
6662 in.base.from = from;
6664 h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6665 if (h)
6666 return h->to;
6667 return NULL_TREE;
6670 /* Insert a mapping FROM->TO in the value expression hashtable. */
6672 void
6673 decl_value_expr_insert (tree from, tree to)
6675 struct tree_decl_map *h;
6677 h = ggc_alloc<tree_decl_map> ();
6678 h->base.from = from;
6679 h->to = to;
6680 *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6683 /* Lookup a vector of debug arguments for FROM, and return it if we
6684 find one. */
6686 vec<tree, va_gc> **
6687 decl_debug_args_lookup (tree from)
6689 struct tree_vec_map *h, in;
6691 if (!DECL_HAS_DEBUG_ARGS_P (from))
6692 return NULL;
6693 gcc_checking_assert (debug_args_for_decl != NULL);
6694 in.base.from = from;
6695 h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
6696 if (h)
6697 return &h->to;
6698 return NULL;
6701 /* Insert a mapping FROM->empty vector of debug arguments in the value
6702 expression hashtable. */
6704 vec<tree, va_gc> **
6705 decl_debug_args_insert (tree from)
6707 struct tree_vec_map *h;
6708 tree_vec_map **loc;
6710 if (DECL_HAS_DEBUG_ARGS_P (from))
6711 return decl_debug_args_lookup (from);
6712 if (debug_args_for_decl == NULL)
6713 debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
6714 h = ggc_alloc<tree_vec_map> ();
6715 h->base.from = from;
6716 h->to = NULL;
6717 loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
6718 *loc = h;
6719 DECL_HAS_DEBUG_ARGS_P (from) = 1;
6720 return &h->to;
6723 /* Hashing of types so that we don't make duplicates.
6724 The entry point is `type_hash_canon'. */
6726 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6727 with types in the TREE_VALUE slots), by adding the hash codes
6728 of the individual types. */
6730 static void
6731 type_hash_list (const_tree list, inchash::hash &hstate)
6733 const_tree tail;
6735 for (tail = list; tail; tail = TREE_CHAIN (tail))
6736 if (TREE_VALUE (tail) != error_mark_node)
6737 hstate.add_object (TYPE_HASH (TREE_VALUE (tail)));
6740 /* These are the Hashtable callback functions. */
6742 /* Returns true iff the types are equivalent. */
6744 bool
6745 type_cache_hasher::equal (type_hash *a, type_hash *b)
6747 /* First test the things that are the same for all types. */
6748 if (a->hash != b->hash
6749 || TREE_CODE (a->type) != TREE_CODE (b->type)
6750 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
6751 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
6752 TYPE_ATTRIBUTES (b->type))
6753 || (TREE_CODE (a->type) != COMPLEX_TYPE
6754 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
6755 return 0;
6757 /* Be careful about comparing arrays before and after the element type
6758 has been completed; don't compare TYPE_ALIGN unless both types are
6759 complete. */
6760 if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
6761 && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
6762 || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
6763 return 0;
6765 switch (TREE_CODE (a->type))
6767 case VOID_TYPE:
6768 case COMPLEX_TYPE:
6769 case POINTER_TYPE:
6770 case REFERENCE_TYPE:
6771 case NULLPTR_TYPE:
6772 return 1;
6774 case VECTOR_TYPE:
6775 return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
6777 case ENUMERAL_TYPE:
6778 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
6779 && !(TYPE_VALUES (a->type)
6780 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
6781 && TYPE_VALUES (b->type)
6782 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
6783 && type_list_equal (TYPE_VALUES (a->type),
6784 TYPE_VALUES (b->type))))
6785 return 0;
6787 /* ... fall through ... */
6789 case INTEGER_TYPE:
6790 case REAL_TYPE:
6791 case BOOLEAN_TYPE:
6792 if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
6793 return false;
6794 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
6795 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
6796 TYPE_MAX_VALUE (b->type)))
6797 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
6798 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
6799 TYPE_MIN_VALUE (b->type))));
6801 case FIXED_POINT_TYPE:
6802 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
6804 case OFFSET_TYPE:
6805 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
6807 case METHOD_TYPE:
6808 if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
6809 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6810 || (TYPE_ARG_TYPES (a->type)
6811 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6812 && TYPE_ARG_TYPES (b->type)
6813 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6814 && type_list_equal (TYPE_ARG_TYPES (a->type),
6815 TYPE_ARG_TYPES (b->type)))))
6816 break;
6817 return 0;
6818 case ARRAY_TYPE:
6819 return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
6821 case RECORD_TYPE:
6822 case UNION_TYPE:
6823 case QUAL_UNION_TYPE:
6824 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
6825 || (TYPE_FIELDS (a->type)
6826 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
6827 && TYPE_FIELDS (b->type)
6828 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
6829 && type_list_equal (TYPE_FIELDS (a->type),
6830 TYPE_FIELDS (b->type))));
6832 case FUNCTION_TYPE:
6833 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6834 || (TYPE_ARG_TYPES (a->type)
6835 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6836 && TYPE_ARG_TYPES (b->type)
6837 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6838 && type_list_equal (TYPE_ARG_TYPES (a->type),
6839 TYPE_ARG_TYPES (b->type))))
6840 break;
6841 return 0;
6843 default:
6844 return 0;
6847 if (lang_hooks.types.type_hash_eq != NULL)
6848 return lang_hooks.types.type_hash_eq (a->type, b->type);
6850 return 1;
6853 /* Given TYPE, and HASHCODE its hash code, return the canonical
6854 object for an identical type if one already exists.
6855 Otherwise, return TYPE, and record it as the canonical object.
6857 To use this function, first create a type of the sort you want.
6858 Then compute its hash code from the fields of the type that
6859 make it different from other similar types.
6860 Then call this function and use the value. */
6862 tree
6863 type_hash_canon (unsigned int hashcode, tree type)
6865 type_hash in;
6866 type_hash **loc;
6868 /* The hash table only contains main variants, so ensure that's what we're
6869 being passed. */
6870 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6872 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6873 must call that routine before comparing TYPE_ALIGNs. */
6874 layout_type (type);
6876 in.hash = hashcode;
6877 in.type = type;
6879 loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
6880 if (*loc)
6882 tree t1 = ((type_hash *) *loc)->type;
6883 gcc_assert (TYPE_MAIN_VARIANT (t1) == t1);
6884 if (GATHER_STATISTICS)
6886 tree_code_counts[(int) TREE_CODE (type)]--;
6887 tree_node_counts[(int) t_kind]--;
6888 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common);
6890 return t1;
6892 else
6894 struct type_hash *h;
6896 h = ggc_alloc<type_hash> ();
6897 h->hash = hashcode;
6898 h->type = type;
6899 *loc = h;
6901 return type;
6905 static void
6906 print_type_hash_statistics (void)
6908 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6909 (long) type_hash_table->size (),
6910 (long) type_hash_table->elements (),
6911 type_hash_table->collisions ());
6914 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6915 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6916 by adding the hash codes of the individual attributes. */
6918 static void
6919 attribute_hash_list (const_tree list, inchash::hash &hstate)
6921 const_tree tail;
6923 for (tail = list; tail; tail = TREE_CHAIN (tail))
6924 /* ??? Do we want to add in TREE_VALUE too? */
6925 hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (tail)));
6928 /* Given two lists of attributes, return true if list l2 is
6929 equivalent to l1. */
6932 attribute_list_equal (const_tree l1, const_tree l2)
6934 if (l1 == l2)
6935 return 1;
6937 return attribute_list_contained (l1, l2)
6938 && attribute_list_contained (l2, l1);
6941 /* Given two lists of attributes, return true if list L2 is
6942 completely contained within L1. */
6943 /* ??? This would be faster if attribute names were stored in a canonicalized
6944 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6945 must be used to show these elements are equivalent (which they are). */
6946 /* ??? It's not clear that attributes with arguments will always be handled
6947 correctly. */
6950 attribute_list_contained (const_tree l1, const_tree l2)
6952 const_tree t1, t2;
6954 /* First check the obvious, maybe the lists are identical. */
6955 if (l1 == l2)
6956 return 1;
6958 /* Maybe the lists are similar. */
6959 for (t1 = l1, t2 = l2;
6960 t1 != 0 && t2 != 0
6961 && get_attribute_name (t1) == get_attribute_name (t2)
6962 && TREE_VALUE (t1) == TREE_VALUE (t2);
6963 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6966 /* Maybe the lists are equal. */
6967 if (t1 == 0 && t2 == 0)
6968 return 1;
6970 for (; t2 != 0; t2 = TREE_CHAIN (t2))
6972 const_tree attr;
6973 /* This CONST_CAST is okay because lookup_attribute does not
6974 modify its argument and the return value is assigned to a
6975 const_tree. */
6976 for (attr = lookup_ident_attribute (get_attribute_name (t2),
6977 CONST_CAST_TREE (l1));
6978 attr != NULL_TREE && !attribute_value_equal (t2, attr);
6979 attr = lookup_ident_attribute (get_attribute_name (t2),
6980 TREE_CHAIN (attr)))
6983 if (attr == NULL_TREE)
6984 return 0;
6987 return 1;
6990 /* Given two lists of types
6991 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6992 return 1 if the lists contain the same types in the same order.
6993 Also, the TREE_PURPOSEs must match. */
6996 type_list_equal (const_tree l1, const_tree l2)
6998 const_tree t1, t2;
7000 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7001 if (TREE_VALUE (t1) != TREE_VALUE (t2)
7002 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
7003 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
7004 && (TREE_TYPE (TREE_PURPOSE (t1))
7005 == TREE_TYPE (TREE_PURPOSE (t2))))))
7006 return 0;
7008 return t1 == t2;
7011 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7012 given by TYPE. If the argument list accepts variable arguments,
7013 then this function counts only the ordinary arguments. */
7016 type_num_arguments (const_tree type)
7018 int i = 0;
7019 tree t;
7021 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7022 /* If the function does not take a variable number of arguments,
7023 the last element in the list will have type `void'. */
7024 if (VOID_TYPE_P (TREE_VALUE (t)))
7025 break;
7026 else
7027 ++i;
7029 return i;
7032 /* Nonzero if integer constants T1 and T2
7033 represent the same constant value. */
7036 tree_int_cst_equal (const_tree t1, const_tree t2)
7038 if (t1 == t2)
7039 return 1;
7041 if (t1 == 0 || t2 == 0)
7042 return 0;
7044 if (TREE_CODE (t1) == INTEGER_CST
7045 && TREE_CODE (t2) == INTEGER_CST
7046 && wi::to_widest (t1) == wi::to_widest (t2))
7047 return 1;
7049 return 0;
7052 /* Return true if T is an INTEGER_CST whose numerical value (extended
7053 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
7055 bool
7056 tree_fits_shwi_p (const_tree t)
7058 return (t != NULL_TREE
7059 && TREE_CODE (t) == INTEGER_CST
7060 && wi::fits_shwi_p (wi::to_widest (t)));
7063 /* Return true if T is an INTEGER_CST whose numerical value (extended
7064 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
7066 bool
7067 tree_fits_uhwi_p (const_tree t)
7069 return (t != NULL_TREE
7070 && TREE_CODE (t) == INTEGER_CST
7071 && wi::fits_uhwi_p (wi::to_widest (t)));
7074 /* T is an INTEGER_CST whose numerical value (extended according to
7075 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7076 HOST_WIDE_INT. */
7078 HOST_WIDE_INT
7079 tree_to_shwi (const_tree t)
7081 gcc_assert (tree_fits_shwi_p (t));
7082 return TREE_INT_CST_LOW (t);
7085 /* T is an INTEGER_CST whose numerical value (extended according to
7086 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7087 HOST_WIDE_INT. */
7089 unsigned HOST_WIDE_INT
7090 tree_to_uhwi (const_tree t)
7092 gcc_assert (tree_fits_uhwi_p (t));
7093 return TREE_INT_CST_LOW (t);
7096 /* Return the most significant (sign) bit of T. */
7099 tree_int_cst_sign_bit (const_tree t)
7101 unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
7103 return wi::extract_uhwi (t, bitno, 1);
7106 /* Return an indication of the sign of the integer constant T.
7107 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7108 Note that -1 will never be returned if T's type is unsigned. */
7111 tree_int_cst_sgn (const_tree t)
7113 if (wi::eq_p (t, 0))
7114 return 0;
7115 else if (TYPE_UNSIGNED (TREE_TYPE (t)))
7116 return 1;
7117 else if (wi::neg_p (t))
7118 return -1;
7119 else
7120 return 1;
7123 /* Return the minimum number of bits needed to represent VALUE in a
7124 signed or unsigned type, UNSIGNEDP says which. */
7126 unsigned int
7127 tree_int_cst_min_precision (tree value, signop sgn)
7129 /* If the value is negative, compute its negative minus 1. The latter
7130 adjustment is because the absolute value of the largest negative value
7131 is one larger than the largest positive value. This is equivalent to
7132 a bit-wise negation, so use that operation instead. */
7134 if (tree_int_cst_sgn (value) < 0)
7135 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
7137 /* Return the number of bits needed, taking into account the fact
7138 that we need one more bit for a signed than unsigned type.
7139 If value is 0 or -1, the minimum precision is 1 no matter
7140 whether unsignedp is true or false. */
7142 if (integer_zerop (value))
7143 return 1;
7144 else
7145 return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
7148 /* Return truthvalue of whether T1 is the same tree structure as T2.
7149 Return 1 if they are the same.
7150 Return 0 if they are understandably different.
7151 Return -1 if either contains tree structure not understood by
7152 this function. */
7155 simple_cst_equal (const_tree t1, const_tree t2)
7157 enum tree_code code1, code2;
7158 int cmp;
7159 int i;
7161 if (t1 == t2)
7162 return 1;
7163 if (t1 == 0 || t2 == 0)
7164 return 0;
7166 code1 = TREE_CODE (t1);
7167 code2 = TREE_CODE (t2);
7169 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
7171 if (CONVERT_EXPR_CODE_P (code2)
7172 || code2 == NON_LVALUE_EXPR)
7173 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7174 else
7175 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
7178 else if (CONVERT_EXPR_CODE_P (code2)
7179 || code2 == NON_LVALUE_EXPR)
7180 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
7182 if (code1 != code2)
7183 return 0;
7185 switch (code1)
7187 case INTEGER_CST:
7188 return wi::to_widest (t1) == wi::to_widest (t2);
7190 case REAL_CST:
7191 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
7193 case FIXED_CST:
7194 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
7196 case STRING_CST:
7197 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
7198 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
7199 TREE_STRING_LENGTH (t1)));
7201 case CONSTRUCTOR:
7203 unsigned HOST_WIDE_INT idx;
7204 vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
7205 vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
7207 if (vec_safe_length (v1) != vec_safe_length (v2))
7208 return false;
7210 for (idx = 0; idx < vec_safe_length (v1); ++idx)
7211 /* ??? Should we handle also fields here? */
7212 if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
7213 return false;
7214 return true;
7217 case SAVE_EXPR:
7218 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7220 case CALL_EXPR:
7221 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
7222 if (cmp <= 0)
7223 return cmp;
7224 if (call_expr_nargs (t1) != call_expr_nargs (t2))
7225 return 0;
7227 const_tree arg1, arg2;
7228 const_call_expr_arg_iterator iter1, iter2;
7229 for (arg1 = first_const_call_expr_arg (t1, &iter1),
7230 arg2 = first_const_call_expr_arg (t2, &iter2);
7231 arg1 && arg2;
7232 arg1 = next_const_call_expr_arg (&iter1),
7233 arg2 = next_const_call_expr_arg (&iter2))
7235 cmp = simple_cst_equal (arg1, arg2);
7236 if (cmp <= 0)
7237 return cmp;
7239 return arg1 == arg2;
7242 case TARGET_EXPR:
7243 /* Special case: if either target is an unallocated VAR_DECL,
7244 it means that it's going to be unified with whatever the
7245 TARGET_EXPR is really supposed to initialize, so treat it
7246 as being equivalent to anything. */
7247 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
7248 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
7249 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
7250 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
7251 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
7252 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
7253 cmp = 1;
7254 else
7255 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7257 if (cmp <= 0)
7258 return cmp;
7260 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
7262 case WITH_CLEANUP_EXPR:
7263 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7264 if (cmp <= 0)
7265 return cmp;
7267 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
7269 case COMPONENT_REF:
7270 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
7271 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7273 return 0;
7275 case VAR_DECL:
7276 case PARM_DECL:
7277 case CONST_DECL:
7278 case FUNCTION_DECL:
7279 return 0;
7281 default:
7282 break;
7285 /* This general rule works for most tree codes. All exceptions should be
7286 handled above. If this is a language-specific tree code, we can't
7287 trust what might be in the operand, so say we don't know
7288 the situation. */
7289 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7290 return -1;
7292 switch (TREE_CODE_CLASS (code1))
7294 case tcc_unary:
7295 case tcc_binary:
7296 case tcc_comparison:
7297 case tcc_expression:
7298 case tcc_reference:
7299 case tcc_statement:
7300 cmp = 1;
7301 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7303 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7304 if (cmp <= 0)
7305 return cmp;
7308 return cmp;
7310 default:
7311 return -1;
7315 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7316 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7317 than U, respectively. */
7320 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7322 if (tree_int_cst_sgn (t) < 0)
7323 return -1;
7324 else if (!tree_fits_uhwi_p (t))
7325 return 1;
7326 else if (TREE_INT_CST_LOW (t) == u)
7327 return 0;
7328 else if (TREE_INT_CST_LOW (t) < u)
7329 return -1;
7330 else
7331 return 1;
7334 /* Return true if SIZE represents a constant size that is in bounds of
7335 what the middle-end and the backend accepts (covering not more than
7336 half of the address-space). */
7338 bool
7339 valid_constant_size_p (const_tree size)
7341 if (! tree_fits_uhwi_p (size)
7342 || TREE_OVERFLOW (size)
7343 || tree_int_cst_sign_bit (size) != 0)
7344 return false;
7345 return true;
7348 /* Return the precision of the type, or for a complex or vector type the
7349 precision of the type of its elements. */
7351 unsigned int
7352 element_precision (const_tree type)
7354 enum tree_code code = TREE_CODE (type);
7355 if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7356 type = TREE_TYPE (type);
7358 return TYPE_PRECISION (type);
7361 /* Return true if CODE represents an associative tree code. Otherwise
7362 return false. */
7363 bool
7364 associative_tree_code (enum tree_code code)
7366 switch (code)
7368 case BIT_IOR_EXPR:
7369 case BIT_AND_EXPR:
7370 case BIT_XOR_EXPR:
7371 case PLUS_EXPR:
7372 case MULT_EXPR:
7373 case MIN_EXPR:
7374 case MAX_EXPR:
7375 return true;
7377 default:
7378 break;
7380 return false;
7383 /* Return true if CODE represents a commutative tree code. Otherwise
7384 return false. */
7385 bool
7386 commutative_tree_code (enum tree_code code)
7388 switch (code)
7390 case PLUS_EXPR:
7391 case MULT_EXPR:
7392 case MULT_HIGHPART_EXPR:
7393 case MIN_EXPR:
7394 case MAX_EXPR:
7395 case BIT_IOR_EXPR:
7396 case BIT_XOR_EXPR:
7397 case BIT_AND_EXPR:
7398 case NE_EXPR:
7399 case EQ_EXPR:
7400 case UNORDERED_EXPR:
7401 case ORDERED_EXPR:
7402 case UNEQ_EXPR:
7403 case LTGT_EXPR:
7404 case TRUTH_AND_EXPR:
7405 case TRUTH_XOR_EXPR:
7406 case TRUTH_OR_EXPR:
7407 case WIDEN_MULT_EXPR:
7408 case VEC_WIDEN_MULT_HI_EXPR:
7409 case VEC_WIDEN_MULT_LO_EXPR:
7410 case VEC_WIDEN_MULT_EVEN_EXPR:
7411 case VEC_WIDEN_MULT_ODD_EXPR:
7412 return true;
7414 default:
7415 break;
7417 return false;
7420 /* Return true if CODE represents a ternary tree code for which the
7421 first two operands are commutative. Otherwise return false. */
7422 bool
7423 commutative_ternary_tree_code (enum tree_code code)
7425 switch (code)
7427 case WIDEN_MULT_PLUS_EXPR:
7428 case WIDEN_MULT_MINUS_EXPR:
7429 case DOT_PROD_EXPR:
7430 case FMA_EXPR:
7431 return true;
7433 default:
7434 break;
7436 return false;
7439 namespace inchash
7442 /* Generate a hash value for an expression. This can be used iteratively
7443 by passing a previous result as the HSTATE argument.
7445 This function is intended to produce the same hash for expressions which
7446 would compare equal using operand_equal_p. */
7447 void
7448 add_expr (const_tree t, inchash::hash &hstate)
7450 int i;
7451 enum tree_code code;
7452 enum tree_code_class tclass;
7454 if (t == NULL_TREE)
7456 hstate.merge_hash (0);
7457 return;
7460 code = TREE_CODE (t);
7462 switch (code)
7464 /* Alas, constants aren't shared, so we can't rely on pointer
7465 identity. */
7466 case VOID_CST:
7467 hstate.merge_hash (0);
7468 return;
7469 case INTEGER_CST:
7470 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
7471 hstate.add_wide_int (TREE_INT_CST_ELT (t, i));
7472 return;
7473 case REAL_CST:
7475 unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
7476 hstate.merge_hash (val2);
7477 return;
7479 case FIXED_CST:
7481 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7482 hstate.merge_hash (val2);
7483 return;
7485 case STRING_CST:
7486 hstate.add ((const void *) TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
7487 return;
7488 case COMPLEX_CST:
7489 inchash::add_expr (TREE_REALPART (t), hstate);
7490 inchash::add_expr (TREE_IMAGPART (t), hstate);
7491 return;
7492 case VECTOR_CST:
7494 unsigned i;
7495 for (i = 0; i < VECTOR_CST_NELTS (t); ++i)
7496 inchash::add_expr (VECTOR_CST_ELT (t, i), hstate);
7497 return;
7499 case SSA_NAME:
7500 /* We can just compare by pointer. */
7501 hstate.add_wide_int (SSA_NAME_VERSION (t));
7502 return;
7503 case PLACEHOLDER_EXPR:
7504 /* The node itself doesn't matter. */
7505 return;
7506 case TREE_LIST:
7507 /* A list of expressions, for a CALL_EXPR or as the elements of a
7508 VECTOR_CST. */
7509 for (; t; t = TREE_CHAIN (t))
7510 inchash::add_expr (TREE_VALUE (t), hstate);
7511 return;
7512 case CONSTRUCTOR:
7514 unsigned HOST_WIDE_INT idx;
7515 tree field, value;
7516 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7518 inchash::add_expr (field, hstate);
7519 inchash::add_expr (value, hstate);
7521 return;
7523 case FUNCTION_DECL:
7524 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7525 Otherwise nodes that compare equal according to operand_equal_p might
7526 get different hash codes. However, don't do this for machine specific
7527 or front end builtins, since the function code is overloaded in those
7528 cases. */
7529 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7530 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7532 t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7533 code = TREE_CODE (t);
7535 /* FALL THROUGH */
7536 default:
7537 tclass = TREE_CODE_CLASS (code);
7539 if (tclass == tcc_declaration)
7541 /* DECL's have a unique ID */
7542 hstate.add_wide_int (DECL_UID (t));
7544 else
7546 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
7548 hstate.add_object (code);
7550 /* Don't hash the type, that can lead to having nodes which
7551 compare equal according to operand_equal_p, but which
7552 have different hash codes. */
7553 if (CONVERT_EXPR_CODE_P (code)
7554 || code == NON_LVALUE_EXPR)
7556 /* Make sure to include signness in the hash computation. */
7557 hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7558 inchash::add_expr (TREE_OPERAND (t, 0), hstate);
7561 else if (commutative_tree_code (code))
7563 /* It's a commutative expression. We want to hash it the same
7564 however it appears. We do this by first hashing both operands
7565 and then rehashing based on the order of their independent
7566 hashes. */
7567 inchash::hash one, two;
7568 inchash::add_expr (TREE_OPERAND (t, 0), one);
7569 inchash::add_expr (TREE_OPERAND (t, 1), two);
7570 hstate.add_commutative (one, two);
7572 else
7573 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
7574 inchash::add_expr (TREE_OPERAND (t, i), hstate);
7576 return;
7582 /* Constructors for pointer, array and function types.
7583 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7584 constructed by language-dependent code, not here.) */
7586 /* Construct, lay out and return the type of pointers to TO_TYPE with
7587 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7588 reference all of memory. If such a type has already been
7589 constructed, reuse it. */
7591 tree
7592 build_pointer_type_for_mode (tree to_type, machine_mode mode,
7593 bool can_alias_all)
7595 tree t;
7597 if (to_type == error_mark_node)
7598 return error_mark_node;
7600 /* If the pointed-to type has the may_alias attribute set, force
7601 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7602 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7603 can_alias_all = true;
7605 /* In some cases, languages will have things that aren't a POINTER_TYPE
7606 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7607 In that case, return that type without regard to the rest of our
7608 operands.
7610 ??? This is a kludge, but consistent with the way this function has
7611 always operated and there doesn't seem to be a good way to avoid this
7612 at the moment. */
7613 if (TYPE_POINTER_TO (to_type) != 0
7614 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
7615 return TYPE_POINTER_TO (to_type);
7617 /* First, if we already have a type for pointers to TO_TYPE and it's
7618 the proper mode, use it. */
7619 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
7620 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7621 return t;
7623 t = make_node (POINTER_TYPE);
7625 TREE_TYPE (t) = to_type;
7626 SET_TYPE_MODE (t, mode);
7627 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7628 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
7629 TYPE_POINTER_TO (to_type) = t;
7631 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
7632 SET_TYPE_STRUCTURAL_EQUALITY (t);
7633 else if (TYPE_CANONICAL (to_type) != to_type)
7634 TYPE_CANONICAL (t)
7635 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
7636 mode, can_alias_all);
7638 /* Lay out the type. This function has many callers that are concerned
7639 with expression-construction, and this simplifies them all. */
7640 layout_type (t);
7642 return t;
7645 /* By default build pointers in ptr_mode. */
7647 tree
7648 build_pointer_type (tree to_type)
7650 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7651 : TYPE_ADDR_SPACE (to_type);
7652 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7653 return build_pointer_type_for_mode (to_type, pointer_mode, false);
7656 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7658 tree
7659 build_reference_type_for_mode (tree to_type, machine_mode mode,
7660 bool can_alias_all)
7662 tree t;
7664 if (to_type == error_mark_node)
7665 return error_mark_node;
7667 /* If the pointed-to type has the may_alias attribute set, force
7668 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7669 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7670 can_alias_all = true;
7672 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7673 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7674 In that case, return that type without regard to the rest of our
7675 operands.
7677 ??? This is a kludge, but consistent with the way this function has
7678 always operated and there doesn't seem to be a good way to avoid this
7679 at the moment. */
7680 if (TYPE_REFERENCE_TO (to_type) != 0
7681 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
7682 return TYPE_REFERENCE_TO (to_type);
7684 /* First, if we already have a type for pointers to TO_TYPE and it's
7685 the proper mode, use it. */
7686 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
7687 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7688 return t;
7690 t = make_node (REFERENCE_TYPE);
7692 TREE_TYPE (t) = to_type;
7693 SET_TYPE_MODE (t, mode);
7694 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7695 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
7696 TYPE_REFERENCE_TO (to_type) = t;
7698 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
7699 SET_TYPE_STRUCTURAL_EQUALITY (t);
7700 else if (TYPE_CANONICAL (to_type) != to_type)
7701 TYPE_CANONICAL (t)
7702 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
7703 mode, can_alias_all);
7705 layout_type (t);
7707 return t;
7711 /* Build the node for the type of references-to-TO_TYPE by default
7712 in ptr_mode. */
7714 tree
7715 build_reference_type (tree to_type)
7717 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7718 : TYPE_ADDR_SPACE (to_type);
7719 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7720 return build_reference_type_for_mode (to_type, pointer_mode, false);
7723 #define MAX_INT_CACHED_PREC \
7724 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7725 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7727 /* Builds a signed or unsigned integer type of precision PRECISION.
7728 Used for C bitfields whose precision does not match that of
7729 built-in target types. */
7730 tree
7731 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7732 int unsignedp)
7734 tree itype, ret;
7736 if (unsignedp)
7737 unsignedp = MAX_INT_CACHED_PREC + 1;
7739 if (precision <= MAX_INT_CACHED_PREC)
7741 itype = nonstandard_integer_type_cache[precision + unsignedp];
7742 if (itype)
7743 return itype;
7746 itype = make_node (INTEGER_TYPE);
7747 TYPE_PRECISION (itype) = precision;
7749 if (unsignedp)
7750 fixup_unsigned_type (itype);
7751 else
7752 fixup_signed_type (itype);
7754 ret = itype;
7755 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype)))
7756 ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype);
7757 if (precision <= MAX_INT_CACHED_PREC)
7758 nonstandard_integer_type_cache[precision + unsignedp] = ret;
7760 return ret;
7763 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7764 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7765 is true, reuse such a type that has already been constructed. */
7767 static tree
7768 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
7770 tree itype = make_node (INTEGER_TYPE);
7771 inchash::hash hstate;
7773 TREE_TYPE (itype) = type;
7775 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7776 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7778 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7779 SET_TYPE_MODE (itype, TYPE_MODE (type));
7780 TYPE_SIZE (itype) = TYPE_SIZE (type);
7781 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7782 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
7783 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7785 if (!shared)
7786 return itype;
7788 if ((TYPE_MIN_VALUE (itype)
7789 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
7790 || (TYPE_MAX_VALUE (itype)
7791 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
7793 /* Since we cannot reliably merge this type, we need to compare it using
7794 structural equality checks. */
7795 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7796 return itype;
7799 inchash::add_expr (TYPE_MIN_VALUE (itype), hstate);
7800 inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);
7801 hstate.merge_hash (TYPE_HASH (type));
7802 itype = type_hash_canon (hstate.end (), itype);
7804 return itype;
7807 /* Wrapper around build_range_type_1 with SHARED set to true. */
7809 tree
7810 build_range_type (tree type, tree lowval, tree highval)
7812 return build_range_type_1 (type, lowval, highval, true);
7815 /* Wrapper around build_range_type_1 with SHARED set to false. */
7817 tree
7818 build_nonshared_range_type (tree type, tree lowval, tree highval)
7820 return build_range_type_1 (type, lowval, highval, false);
7823 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7824 MAXVAL should be the maximum value in the domain
7825 (one less than the length of the array).
7827 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7828 We don't enforce this limit, that is up to caller (e.g. language front end).
7829 The limit exists because the result is a signed type and we don't handle
7830 sizes that use more than one HOST_WIDE_INT. */
7832 tree
7833 build_index_type (tree maxval)
7835 return build_range_type (sizetype, size_zero_node, maxval);
7838 /* Return true if the debug information for TYPE, a subtype, should be emitted
7839 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7840 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7841 debug info and doesn't reflect the source code. */
7843 bool
7844 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7846 tree base_type = TREE_TYPE (type), low, high;
7848 /* Subrange types have a base type which is an integral type. */
7849 if (!INTEGRAL_TYPE_P (base_type))
7850 return false;
7852 /* Get the real bounds of the subtype. */
7853 if (lang_hooks.types.get_subrange_bounds)
7854 lang_hooks.types.get_subrange_bounds (type, &low, &high);
7855 else
7857 low = TYPE_MIN_VALUE (type);
7858 high = TYPE_MAX_VALUE (type);
7861 /* If the type and its base type have the same representation and the same
7862 name, then the type is not a subrange but a copy of the base type. */
7863 if ((TREE_CODE (base_type) == INTEGER_TYPE
7864 || TREE_CODE (base_type) == BOOLEAN_TYPE)
7865 && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7866 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7867 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))
7868 && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
7869 return false;
7871 if (lowval)
7872 *lowval = low;
7873 if (highval)
7874 *highval = high;
7875 return true;
7878 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7879 and number of elements specified by the range of values of INDEX_TYPE.
7880 If SHARED is true, reuse such a type that has already been constructed. */
7882 static tree
7883 build_array_type_1 (tree elt_type, tree index_type, bool shared)
7885 tree t;
7887 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7889 error ("arrays of functions are not meaningful");
7890 elt_type = integer_type_node;
7893 t = make_node (ARRAY_TYPE);
7894 TREE_TYPE (t) = elt_type;
7895 TYPE_DOMAIN (t) = index_type;
7896 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7897 layout_type (t);
7899 /* If the element type is incomplete at this point we get marked for
7900 structural equality. Do not record these types in the canonical
7901 type hashtable. */
7902 if (TYPE_STRUCTURAL_EQUALITY_P (t))
7903 return t;
7905 if (shared)
7907 inchash::hash hstate;
7908 hstate.add_object (TYPE_HASH (elt_type));
7909 if (index_type)
7910 hstate.add_object (TYPE_HASH (index_type));
7911 t = type_hash_canon (hstate.end (), t);
7914 if (TYPE_CANONICAL (t) == t)
7916 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7917 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7918 SET_TYPE_STRUCTURAL_EQUALITY (t);
7919 else if (TYPE_CANONICAL (elt_type) != elt_type
7920 || (index_type && TYPE_CANONICAL (index_type) != index_type))
7921 TYPE_CANONICAL (t)
7922 = build_array_type_1 (TYPE_CANONICAL (elt_type),
7923 index_type
7924 ? TYPE_CANONICAL (index_type) : NULL_TREE,
7925 shared);
7928 return t;
7931 /* Wrapper around build_array_type_1 with SHARED set to true. */
7933 tree
7934 build_array_type (tree elt_type, tree index_type)
7936 return build_array_type_1 (elt_type, index_type, true);
7939 /* Wrapper around build_array_type_1 with SHARED set to false. */
7941 tree
7942 build_nonshared_array_type (tree elt_type, tree index_type)
7944 return build_array_type_1 (elt_type, index_type, false);
7947 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7948 sizetype. */
7950 tree
7951 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts)
7953 return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
7956 /* Recursively examines the array elements of TYPE, until a non-array
7957 element type is found. */
7959 tree
7960 strip_array_types (tree type)
7962 while (TREE_CODE (type) == ARRAY_TYPE)
7963 type = TREE_TYPE (type);
7965 return type;
7968 /* Computes the canonical argument types from the argument type list
7969 ARGTYPES.
7971 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7972 on entry to this function, or if any of the ARGTYPES are
7973 structural.
7975 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7976 true on entry to this function, or if any of the ARGTYPES are
7977 non-canonical.
7979 Returns a canonical argument list, which may be ARGTYPES when the
7980 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7981 true) or would not differ from ARGTYPES. */
7983 static tree
7984 maybe_canonicalize_argtypes (tree argtypes,
7985 bool *any_structural_p,
7986 bool *any_noncanonical_p)
7988 tree arg;
7989 bool any_noncanonical_argtypes_p = false;
7991 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7993 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7994 /* Fail gracefully by stating that the type is structural. */
7995 *any_structural_p = true;
7996 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7997 *any_structural_p = true;
7998 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7999 || TREE_PURPOSE (arg))
8000 /* If the argument has a default argument, we consider it
8001 non-canonical even though the type itself is canonical.
8002 That way, different variants of function and method types
8003 with default arguments will all point to the variant with
8004 no defaults as their canonical type. */
8005 any_noncanonical_argtypes_p = true;
8008 if (*any_structural_p)
8009 return argtypes;
8011 if (any_noncanonical_argtypes_p)
8013 /* Build the canonical list of argument types. */
8014 tree canon_argtypes = NULL_TREE;
8015 bool is_void = false;
8017 for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
8019 if (arg == void_list_node)
8020 is_void = true;
8021 else
8022 canon_argtypes = tree_cons (NULL_TREE,
8023 TYPE_CANONICAL (TREE_VALUE (arg)),
8024 canon_argtypes);
8027 canon_argtypes = nreverse (canon_argtypes);
8028 if (is_void)
8029 canon_argtypes = chainon (canon_argtypes, void_list_node);
8031 /* There is a non-canonical type. */
8032 *any_noncanonical_p = true;
8033 return canon_argtypes;
8036 /* The canonical argument types are the same as ARGTYPES. */
8037 return argtypes;
8040 /* Construct, lay out and return
8041 the type of functions returning type VALUE_TYPE
8042 given arguments of types ARG_TYPES.
8043 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8044 are data type nodes for the arguments of the function.
8045 If such a type has already been constructed, reuse it. */
8047 tree
8048 build_function_type (tree value_type, tree arg_types)
8050 tree t;
8051 inchash::hash hstate;
8052 bool any_structural_p, any_noncanonical_p;
8053 tree canon_argtypes;
8055 if (TREE_CODE (value_type) == FUNCTION_TYPE)
8057 error ("function return type cannot be function");
8058 value_type = integer_type_node;
8061 /* Make a node of the sort we want. */
8062 t = make_node (FUNCTION_TYPE);
8063 TREE_TYPE (t) = value_type;
8064 TYPE_ARG_TYPES (t) = arg_types;
8066 /* If we already have such a type, use the old one. */
8067 hstate.add_object (TYPE_HASH (value_type));
8068 type_hash_list (arg_types, hstate);
8069 t = type_hash_canon (hstate.end (), t);
8071 /* Set up the canonical type. */
8072 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8073 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8074 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8075 &any_structural_p,
8076 &any_noncanonical_p);
8077 if (any_structural_p)
8078 SET_TYPE_STRUCTURAL_EQUALITY (t);
8079 else if (any_noncanonical_p)
8080 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8081 canon_argtypes);
8083 if (!COMPLETE_TYPE_P (t))
8084 layout_type (t);
8085 return t;
8088 /* Build a function type. The RETURN_TYPE is the type returned by the
8089 function. If VAARGS is set, no void_type_node is appended to the
8090 the list. ARGP must be always be terminated be a NULL_TREE. */
8092 static tree
8093 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8095 tree t, args, last;
8097 t = va_arg (argp, tree);
8098 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8099 args = tree_cons (NULL_TREE, t, args);
8101 if (vaargs)
8103 last = args;
8104 if (args != NULL_TREE)
8105 args = nreverse (args);
8106 gcc_assert (last != void_list_node);
8108 else if (args == NULL_TREE)
8109 args = void_list_node;
8110 else
8112 last = args;
8113 args = nreverse (args);
8114 TREE_CHAIN (last) = void_list_node;
8116 args = build_function_type (return_type, args);
8118 return args;
8121 /* Build a function type. The RETURN_TYPE is the type returned by the
8122 function. If additional arguments are provided, they are
8123 additional argument types. The list of argument types must always
8124 be terminated by NULL_TREE. */
8126 tree
8127 build_function_type_list (tree return_type, ...)
8129 tree args;
8130 va_list p;
8132 va_start (p, return_type);
8133 args = build_function_type_list_1 (false, return_type, p);
8134 va_end (p);
8135 return args;
8138 /* Build a variable argument function type. The RETURN_TYPE is the
8139 type returned by the function. If additional arguments are provided,
8140 they are additional argument types. The list of argument types must
8141 always be terminated by NULL_TREE. */
8143 tree
8144 build_varargs_function_type_list (tree return_type, ...)
8146 tree args;
8147 va_list p;
8149 va_start (p, return_type);
8150 args = build_function_type_list_1 (true, return_type, p);
8151 va_end (p);
8153 return args;
8156 /* Build a function type. RETURN_TYPE is the type returned by the
8157 function; VAARGS indicates whether the function takes varargs. The
8158 function takes N named arguments, the types of which are provided in
8159 ARG_TYPES. */
8161 static tree
8162 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8163 tree *arg_types)
8165 int i;
8166 tree t = vaargs ? NULL_TREE : void_list_node;
8168 for (i = n - 1; i >= 0; i--)
8169 t = tree_cons (NULL_TREE, arg_types[i], t);
8171 return build_function_type (return_type, t);
8174 /* Build a function type. RETURN_TYPE is the type returned by the
8175 function. The function takes N named arguments, the types of which
8176 are provided in ARG_TYPES. */
8178 tree
8179 build_function_type_array (tree return_type, int n, tree *arg_types)
8181 return build_function_type_array_1 (false, return_type, n, arg_types);
8184 /* Build a variable argument function type. RETURN_TYPE is the type
8185 returned by the function. The function takes N named arguments, the
8186 types of which are provided in ARG_TYPES. */
8188 tree
8189 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8191 return build_function_type_array_1 (true, return_type, n, arg_types);
8194 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8195 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8196 for the method. An implicit additional parameter (of type
8197 pointer-to-BASETYPE) is added to the ARGTYPES. */
8199 tree
8200 build_method_type_directly (tree basetype,
8201 tree rettype,
8202 tree argtypes)
8204 tree t;
8205 tree ptype;
8206 inchash::hash hstate;
8207 bool any_structural_p, any_noncanonical_p;
8208 tree canon_argtypes;
8210 /* Make a node of the sort we want. */
8211 t = make_node (METHOD_TYPE);
8213 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8214 TREE_TYPE (t) = rettype;
8215 ptype = build_pointer_type (basetype);
8217 /* The actual arglist for this function includes a "hidden" argument
8218 which is "this". Put it into the list of argument types. */
8219 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8220 TYPE_ARG_TYPES (t) = argtypes;
8222 /* If we already have such a type, use the old one. */
8223 hstate.add_object (TYPE_HASH (basetype));
8224 hstate.add_object (TYPE_HASH (rettype));
8225 type_hash_list (argtypes, hstate);
8226 t = type_hash_canon (hstate.end (), t);
8228 /* Set up the canonical type. */
8229 any_structural_p
8230 = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8231 || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8232 any_noncanonical_p
8233 = (TYPE_CANONICAL (basetype) != basetype
8234 || TYPE_CANONICAL (rettype) != rettype);
8235 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8236 &any_structural_p,
8237 &any_noncanonical_p);
8238 if (any_structural_p)
8239 SET_TYPE_STRUCTURAL_EQUALITY (t);
8240 else if (any_noncanonical_p)
8241 TYPE_CANONICAL (t)
8242 = build_method_type_directly (TYPE_CANONICAL (basetype),
8243 TYPE_CANONICAL (rettype),
8244 canon_argtypes);
8245 if (!COMPLETE_TYPE_P (t))
8246 layout_type (t);
8248 return t;
8251 /* Construct, lay out and return the type of methods belonging to class
8252 BASETYPE and whose arguments and values are described by TYPE.
8253 If that type exists already, reuse it.
8254 TYPE must be a FUNCTION_TYPE node. */
8256 tree
8257 build_method_type (tree basetype, tree type)
8259 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8261 return build_method_type_directly (basetype,
8262 TREE_TYPE (type),
8263 TYPE_ARG_TYPES (type));
8266 /* Construct, lay out and return the type of offsets to a value
8267 of type TYPE, within an object of type BASETYPE.
8268 If a suitable offset type exists already, reuse it. */
8270 tree
8271 build_offset_type (tree basetype, tree type)
8273 tree t;
8274 inchash::hash hstate;
8276 /* Make a node of the sort we want. */
8277 t = make_node (OFFSET_TYPE);
8279 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8280 TREE_TYPE (t) = type;
8282 /* If we already have such a type, use the old one. */
8283 hstate.add_object (TYPE_HASH (basetype));
8284 hstate.add_object (TYPE_HASH (type));
8285 t = type_hash_canon (hstate.end (), t);
8287 if (!COMPLETE_TYPE_P (t))
8288 layout_type (t);
8290 if (TYPE_CANONICAL (t) == t)
8292 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8293 || TYPE_STRUCTURAL_EQUALITY_P (type))
8294 SET_TYPE_STRUCTURAL_EQUALITY (t);
8295 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8296 || TYPE_CANONICAL (type) != type)
8297 TYPE_CANONICAL (t)
8298 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8299 TYPE_CANONICAL (type));
8302 return t;
8305 /* Create a complex type whose components are COMPONENT_TYPE. */
8307 tree
8308 build_complex_type (tree component_type)
8310 tree t;
8311 inchash::hash hstate;
8313 gcc_assert (INTEGRAL_TYPE_P (component_type)
8314 || SCALAR_FLOAT_TYPE_P (component_type)
8315 || FIXED_POINT_TYPE_P (component_type));
8317 /* Make a node of the sort we want. */
8318 t = make_node (COMPLEX_TYPE);
8320 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
8322 /* If we already have such a type, use the old one. */
8323 hstate.add_object (TYPE_HASH (component_type));
8324 t = type_hash_canon (hstate.end (), t);
8326 if (!COMPLETE_TYPE_P (t))
8327 layout_type (t);
8329 if (TYPE_CANONICAL (t) == t)
8331 if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
8332 SET_TYPE_STRUCTURAL_EQUALITY (t);
8333 else if (TYPE_CANONICAL (component_type) != component_type)
8334 TYPE_CANONICAL (t)
8335 = build_complex_type (TYPE_CANONICAL (component_type));
8338 /* We need to create a name, since complex is a fundamental type. */
8339 if (! TYPE_NAME (t))
8341 const char *name;
8342 if (component_type == char_type_node)
8343 name = "complex char";
8344 else if (component_type == signed_char_type_node)
8345 name = "complex signed char";
8346 else if (component_type == unsigned_char_type_node)
8347 name = "complex unsigned char";
8348 else if (component_type == short_integer_type_node)
8349 name = "complex short int";
8350 else if (component_type == short_unsigned_type_node)
8351 name = "complex short unsigned int";
8352 else if (component_type == integer_type_node)
8353 name = "complex int";
8354 else if (component_type == unsigned_type_node)
8355 name = "complex unsigned int";
8356 else if (component_type == long_integer_type_node)
8357 name = "complex long int";
8358 else if (component_type == long_unsigned_type_node)
8359 name = "complex long unsigned int";
8360 else if (component_type == long_long_integer_type_node)
8361 name = "complex long long int";
8362 else if (component_type == long_long_unsigned_type_node)
8363 name = "complex long long unsigned int";
8364 else
8365 name = 0;
8367 if (name != 0)
8368 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8369 get_identifier (name), t);
8372 return build_qualified_type (t, TYPE_QUALS (component_type));
8375 /* If TYPE is a real or complex floating-point type and the target
8376 does not directly support arithmetic on TYPE then return the wider
8377 type to be used for arithmetic on TYPE. Otherwise, return
8378 NULL_TREE. */
8380 tree
8381 excess_precision_type (tree type)
8383 if (flag_excess_precision != EXCESS_PRECISION_FAST)
8385 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
8386 switch (TREE_CODE (type))
8388 case REAL_TYPE:
8389 switch (flt_eval_method)
8391 case 1:
8392 if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
8393 return double_type_node;
8394 break;
8395 case 2:
8396 if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
8397 || TYPE_MODE (type) == TYPE_MODE (double_type_node))
8398 return long_double_type_node;
8399 break;
8400 default:
8401 gcc_unreachable ();
8403 break;
8404 case COMPLEX_TYPE:
8405 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8406 return NULL_TREE;
8407 switch (flt_eval_method)
8409 case 1:
8410 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
8411 return complex_double_type_node;
8412 break;
8413 case 2:
8414 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
8415 || (TYPE_MODE (TREE_TYPE (type))
8416 == TYPE_MODE (double_type_node)))
8417 return complex_long_double_type_node;
8418 break;
8419 default:
8420 gcc_unreachable ();
8422 break;
8423 default:
8424 break;
8427 return NULL_TREE;
8430 /* Return OP, stripped of any conversions to wider types as much as is safe.
8431 Converting the value back to OP's type makes a value equivalent to OP.
8433 If FOR_TYPE is nonzero, we return a value which, if converted to
8434 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8436 OP must have integer, real or enumeral type. Pointers are not allowed!
8438 There are some cases where the obvious value we could return
8439 would regenerate to OP if converted to OP's type,
8440 but would not extend like OP to wider types.
8441 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8442 For example, if OP is (unsigned short)(signed char)-1,
8443 we avoid returning (signed char)-1 if FOR_TYPE is int,
8444 even though extending that to an unsigned short would regenerate OP,
8445 since the result of extending (signed char)-1 to (int)
8446 is different from (int) OP. */
8448 tree
8449 get_unwidened (tree op, tree for_type)
8451 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8452 tree type = TREE_TYPE (op);
8453 unsigned final_prec
8454 = TYPE_PRECISION (for_type != 0 ? for_type : type);
8455 int uns
8456 = (for_type != 0 && for_type != type
8457 && final_prec > TYPE_PRECISION (type)
8458 && TYPE_UNSIGNED (type));
8459 tree win = op;
8461 while (CONVERT_EXPR_P (op))
8463 int bitschange;
8465 /* TYPE_PRECISION on vector types has different meaning
8466 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8467 so avoid them here. */
8468 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
8469 break;
8471 bitschange = TYPE_PRECISION (TREE_TYPE (op))
8472 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
8474 /* Truncations are many-one so cannot be removed.
8475 Unless we are later going to truncate down even farther. */
8476 if (bitschange < 0
8477 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
8478 break;
8480 /* See what's inside this conversion. If we decide to strip it,
8481 we will set WIN. */
8482 op = TREE_OPERAND (op, 0);
8484 /* If we have not stripped any zero-extensions (uns is 0),
8485 we can strip any kind of extension.
8486 If we have previously stripped a zero-extension,
8487 only zero-extensions can safely be stripped.
8488 Any extension can be stripped if the bits it would produce
8489 are all going to be discarded later by truncating to FOR_TYPE. */
8491 if (bitschange > 0)
8493 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
8494 win = op;
8495 /* TYPE_UNSIGNED says whether this is a zero-extension.
8496 Let's avoid computing it if it does not affect WIN
8497 and if UNS will not be needed again. */
8498 if ((uns
8499 || CONVERT_EXPR_P (op))
8500 && TYPE_UNSIGNED (TREE_TYPE (op)))
8502 uns = 1;
8503 win = op;
8508 /* If we finally reach a constant see if it fits in for_type and
8509 in that case convert it. */
8510 if (for_type
8511 && TREE_CODE (win) == INTEGER_CST
8512 && TREE_TYPE (win) != for_type
8513 && int_fits_type_p (win, for_type))
8514 win = fold_convert (for_type, win);
8516 return win;
8519 /* Return OP or a simpler expression for a narrower value
8520 which can be sign-extended or zero-extended to give back OP.
8521 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8522 or 0 if the value should be sign-extended. */
8524 tree
8525 get_narrower (tree op, int *unsignedp_ptr)
8527 int uns = 0;
8528 int first = 1;
8529 tree win = op;
8530 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
8532 while (TREE_CODE (op) == NOP_EXPR)
8534 int bitschange
8535 = (TYPE_PRECISION (TREE_TYPE (op))
8536 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
8538 /* Truncations are many-one so cannot be removed. */
8539 if (bitschange < 0)
8540 break;
8542 /* See what's inside this conversion. If we decide to strip it,
8543 we will set WIN. */
8545 if (bitschange > 0)
8547 op = TREE_OPERAND (op, 0);
8548 /* An extension: the outermost one can be stripped,
8549 but remember whether it is zero or sign extension. */
8550 if (first)
8551 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8552 /* Otherwise, if a sign extension has been stripped,
8553 only sign extensions can now be stripped;
8554 if a zero extension has been stripped, only zero-extensions. */
8555 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
8556 break;
8557 first = 0;
8559 else /* bitschange == 0 */
8561 /* A change in nominal type can always be stripped, but we must
8562 preserve the unsignedness. */
8563 if (first)
8564 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8565 first = 0;
8566 op = TREE_OPERAND (op, 0);
8567 /* Keep trying to narrow, but don't assign op to win if it
8568 would turn an integral type into something else. */
8569 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
8570 continue;
8573 win = op;
8576 if (TREE_CODE (op) == COMPONENT_REF
8577 /* Since type_for_size always gives an integer type. */
8578 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
8579 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
8580 /* Ensure field is laid out already. */
8581 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
8582 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
8584 unsigned HOST_WIDE_INT innerprec
8585 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
8586 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
8587 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
8588 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
8590 /* We can get this structure field in a narrower type that fits it,
8591 but the resulting extension to its nominal type (a fullword type)
8592 must satisfy the same conditions as for other extensions.
8594 Do this only for fields that are aligned (not bit-fields),
8595 because when bit-field insns will be used there is no
8596 advantage in doing this. */
8598 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
8599 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
8600 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
8601 && type != 0)
8603 if (first)
8604 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
8605 win = fold_convert (type, op);
8609 *unsignedp_ptr = uns;
8610 return win;
8613 /* Returns true if integer constant C has a value that is permissible
8614 for type TYPE (an INTEGER_TYPE). */
8616 bool
8617 int_fits_type_p (const_tree c, const_tree type)
8619 tree type_low_bound, type_high_bound;
8620 bool ok_for_low_bound, ok_for_high_bound;
8621 signop sgn_c = TYPE_SIGN (TREE_TYPE (c));
8623 retry:
8624 type_low_bound = TYPE_MIN_VALUE (type);
8625 type_high_bound = TYPE_MAX_VALUE (type);
8627 /* If at least one bound of the type is a constant integer, we can check
8628 ourselves and maybe make a decision. If no such decision is possible, but
8629 this type is a subtype, try checking against that. Otherwise, use
8630 fits_to_tree_p, which checks against the precision.
8632 Compute the status for each possibly constant bound, and return if we see
8633 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8634 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8635 for "constant known to fit". */
8637 /* Check if c >= type_low_bound. */
8638 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
8640 if (tree_int_cst_lt (c, type_low_bound))
8641 return false;
8642 ok_for_low_bound = true;
8644 else
8645 ok_for_low_bound = false;
8647 /* Check if c <= type_high_bound. */
8648 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
8650 if (tree_int_cst_lt (type_high_bound, c))
8651 return false;
8652 ok_for_high_bound = true;
8654 else
8655 ok_for_high_bound = false;
8657 /* If the constant fits both bounds, the result is known. */
8658 if (ok_for_low_bound && ok_for_high_bound)
8659 return true;
8661 /* Perform some generic filtering which may allow making a decision
8662 even if the bounds are not constant. First, negative integers
8663 never fit in unsigned types, */
8664 if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (c))
8665 return false;
8667 /* Second, narrower types always fit in wider ones. */
8668 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8669 return true;
8671 /* Third, unsigned integers with top bit set never fit signed types. */
8672 if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED)
8674 int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1;
8675 if (prec < TYPE_PRECISION (TREE_TYPE (c)))
8677 /* When a tree_cst is converted to a wide-int, the precision
8678 is taken from the type. However, if the precision of the
8679 mode underneath the type is smaller than that, it is
8680 possible that the value will not fit. The test below
8681 fails if any bit is set between the sign bit of the
8682 underlying mode and the top bit of the type. */
8683 if (wi::ne_p (wi::zext (c, prec - 1), c))
8684 return false;
8686 else if (wi::neg_p (c))
8687 return false;
8690 /* If we haven't been able to decide at this point, there nothing more we
8691 can check ourselves here. Look at the base type if we have one and it
8692 has the same precision. */
8693 if (TREE_CODE (type) == INTEGER_TYPE
8694 && TREE_TYPE (type) != 0
8695 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8697 type = TREE_TYPE (type);
8698 goto retry;
8701 /* Or to fits_to_tree_p, if nothing else. */
8702 return wi::fits_to_tree_p (c, type);
8705 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8706 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8707 represented (assuming two's-complement arithmetic) within the bit
8708 precision of the type are returned instead. */
8710 void
8711 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8713 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8714 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8715 wi::to_mpz (TYPE_MIN_VALUE (type), min, TYPE_SIGN (type));
8716 else
8718 if (TYPE_UNSIGNED (type))
8719 mpz_set_ui (min, 0);
8720 else
8722 wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED);
8723 wi::to_mpz (mn, min, SIGNED);
8727 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8728 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8729 wi::to_mpz (TYPE_MAX_VALUE (type), max, TYPE_SIGN (type));
8730 else
8732 wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
8733 wi::to_mpz (mn, max, TYPE_SIGN (type));
8737 /* Return true if VAR is an automatic variable defined in function FN. */
8739 bool
8740 auto_var_in_fn_p (const_tree var, const_tree fn)
8742 return (DECL_P (var) && DECL_CONTEXT (var) == fn
8743 && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
8744 || TREE_CODE (var) == PARM_DECL)
8745 && ! TREE_STATIC (var))
8746 || TREE_CODE (var) == LABEL_DECL
8747 || TREE_CODE (var) == RESULT_DECL));
8750 /* Subprogram of following function. Called by walk_tree.
8752 Return *TP if it is an automatic variable or parameter of the
8753 function passed in as DATA. */
8755 static tree
8756 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8758 tree fn = (tree) data;
8760 if (TYPE_P (*tp))
8761 *walk_subtrees = 0;
8763 else if (DECL_P (*tp)
8764 && auto_var_in_fn_p (*tp, fn))
8765 return *tp;
8767 return NULL_TREE;
8770 /* Returns true if T is, contains, or refers to a type with variable
8771 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8772 arguments, but not the return type. If FN is nonzero, only return
8773 true if a modifier of the type or position of FN is a variable or
8774 parameter inside FN.
8776 This concept is more general than that of C99 'variably modified types':
8777 in C99, a struct type is never variably modified because a VLA may not
8778 appear as a structure member. However, in GNU C code like:
8780 struct S { int i[f()]; };
8782 is valid, and other languages may define similar constructs. */
8784 bool
8785 variably_modified_type_p (tree type, tree fn)
8787 tree t;
8789 /* Test if T is either variable (if FN is zero) or an expression containing
8790 a variable in FN. If TYPE isn't gimplified, return true also if
8791 gimplify_one_sizepos would gimplify the expression into a local
8792 variable. */
8793 #define RETURN_TRUE_IF_VAR(T) \
8794 do { tree _t = (T); \
8795 if (_t != NULL_TREE \
8796 && _t != error_mark_node \
8797 && TREE_CODE (_t) != INTEGER_CST \
8798 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8799 && (!fn \
8800 || (!TYPE_SIZES_GIMPLIFIED (type) \
8801 && !is_gimple_sizepos (_t)) \
8802 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8803 return true; } while (0)
8805 if (type == error_mark_node)
8806 return false;
8808 /* If TYPE itself has variable size, it is variably modified. */
8809 RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8810 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8812 switch (TREE_CODE (type))
8814 case POINTER_TYPE:
8815 case REFERENCE_TYPE:
8816 case VECTOR_TYPE:
8817 if (variably_modified_type_p (TREE_TYPE (type), fn))
8818 return true;
8819 break;
8821 case FUNCTION_TYPE:
8822 case METHOD_TYPE:
8823 /* If TYPE is a function type, it is variably modified if the
8824 return type is variably modified. */
8825 if (variably_modified_type_p (TREE_TYPE (type), fn))
8826 return true;
8827 break;
8829 case INTEGER_TYPE:
8830 case REAL_TYPE:
8831 case FIXED_POINT_TYPE:
8832 case ENUMERAL_TYPE:
8833 case BOOLEAN_TYPE:
8834 /* Scalar types are variably modified if their end points
8835 aren't constant. */
8836 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8837 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8838 break;
8840 case RECORD_TYPE:
8841 case UNION_TYPE:
8842 case QUAL_UNION_TYPE:
8843 /* We can't see if any of the fields are variably-modified by the
8844 definition we normally use, since that would produce infinite
8845 recursion via pointers. */
8846 /* This is variably modified if some field's type is. */
8847 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
8848 if (TREE_CODE (t) == FIELD_DECL)
8850 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8851 RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8852 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8854 if (TREE_CODE (type) == QUAL_UNION_TYPE)
8855 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8857 break;
8859 case ARRAY_TYPE:
8860 /* Do not call ourselves to avoid infinite recursion. This is
8861 variably modified if the element type is. */
8862 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8863 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8864 break;
8866 default:
8867 break;
8870 /* The current language may have other cases to check, but in general,
8871 all other types are not variably modified. */
8872 return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8874 #undef RETURN_TRUE_IF_VAR
8877 /* Given a DECL or TYPE, return the scope in which it was declared, or
8878 NULL_TREE if there is no containing scope. */
8880 tree
8881 get_containing_scope (const_tree t)
8883 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8886 /* Return the innermost context enclosing DECL that is
8887 a FUNCTION_DECL, or zero if none. */
8889 tree
8890 decl_function_context (const_tree decl)
8892 tree context;
8894 if (TREE_CODE (decl) == ERROR_MARK)
8895 return 0;
8897 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8898 where we look up the function at runtime. Such functions always take
8899 a first argument of type 'pointer to real context'.
8901 C++ should really be fixed to use DECL_CONTEXT for the real context,
8902 and use something else for the "virtual context". */
8903 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8904 context
8905 = TYPE_MAIN_VARIANT
8906 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8907 else
8908 context = DECL_CONTEXT (decl);
8910 while (context && TREE_CODE (context) != FUNCTION_DECL)
8912 if (TREE_CODE (context) == BLOCK)
8913 context = BLOCK_SUPERCONTEXT (context);
8914 else
8915 context = get_containing_scope (context);
8918 return context;
8921 /* Return the innermost context enclosing DECL that is
8922 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8923 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8925 tree
8926 decl_type_context (const_tree decl)
8928 tree context = DECL_CONTEXT (decl);
8930 while (context)
8931 switch (TREE_CODE (context))
8933 case NAMESPACE_DECL:
8934 case TRANSLATION_UNIT_DECL:
8935 return NULL_TREE;
8937 case RECORD_TYPE:
8938 case UNION_TYPE:
8939 case QUAL_UNION_TYPE:
8940 return context;
8942 case TYPE_DECL:
8943 case FUNCTION_DECL:
8944 context = DECL_CONTEXT (context);
8945 break;
8947 case BLOCK:
8948 context = BLOCK_SUPERCONTEXT (context);
8949 break;
8951 default:
8952 gcc_unreachable ();
8955 return NULL_TREE;
8958 /* CALL is a CALL_EXPR. Return the declaration for the function
8959 called, or NULL_TREE if the called function cannot be
8960 determined. */
8962 tree
8963 get_callee_fndecl (const_tree call)
8965 tree addr;
8967 if (call == error_mark_node)
8968 return error_mark_node;
8970 /* It's invalid to call this function with anything but a
8971 CALL_EXPR. */
8972 gcc_assert (TREE_CODE (call) == CALL_EXPR);
8974 /* The first operand to the CALL is the address of the function
8975 called. */
8976 addr = CALL_EXPR_FN (call);
8978 /* If there is no function, return early. */
8979 if (addr == NULL_TREE)
8980 return NULL_TREE;
8982 STRIP_NOPS (addr);
8984 /* If this is a readonly function pointer, extract its initial value. */
8985 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8986 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8987 && DECL_INITIAL (addr))
8988 addr = DECL_INITIAL (addr);
8990 /* If the address is just `&f' for some function `f', then we know
8991 that `f' is being called. */
8992 if (TREE_CODE (addr) == ADDR_EXPR
8993 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8994 return TREE_OPERAND (addr, 0);
8996 /* We couldn't figure out what was being called. */
8997 return NULL_TREE;
9000 /* Print debugging information about tree nodes generated during the compile,
9001 and any language-specific information. */
9003 void
9004 dump_tree_statistics (void)
9006 if (GATHER_STATISTICS)
9008 int i;
9009 int total_nodes, total_bytes;
9010 fprintf (stderr, "Kind Nodes Bytes\n");
9011 fprintf (stderr, "---------------------------------------\n");
9012 total_nodes = total_bytes = 0;
9013 for (i = 0; i < (int) all_kinds; i++)
9015 fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
9016 tree_node_counts[i], tree_node_sizes[i]);
9017 total_nodes += tree_node_counts[i];
9018 total_bytes += tree_node_sizes[i];
9020 fprintf (stderr, "---------------------------------------\n");
9021 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
9022 fprintf (stderr, "---------------------------------------\n");
9023 fprintf (stderr, "Code Nodes\n");
9024 fprintf (stderr, "----------------------------\n");
9025 for (i = 0; i < (int) MAX_TREE_CODES; i++)
9026 fprintf (stderr, "%-20s %7d\n", get_tree_code_name ((enum tree_code) i),
9027 tree_code_counts[i]);
9028 fprintf (stderr, "----------------------------\n");
9029 ssanames_print_statistics ();
9030 phinodes_print_statistics ();
9032 else
9033 fprintf (stderr, "(No per-node statistics)\n");
9035 print_type_hash_statistics ();
9036 print_debug_expr_statistics ();
9037 print_value_expr_statistics ();
9038 lang_hooks.print_statistics ();
9041 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9043 /* Generate a crc32 of a byte. */
9045 static unsigned
9046 crc32_unsigned_bits (unsigned chksum, unsigned value, unsigned bits)
9048 unsigned ix;
9050 for (ix = bits; ix--; value <<= 1)
9052 unsigned feedback;
9054 feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
9055 chksum <<= 1;
9056 chksum ^= feedback;
9058 return chksum;
9061 /* Generate a crc32 of a 32-bit unsigned. */
9063 unsigned
9064 crc32_unsigned (unsigned chksum, unsigned value)
9066 return crc32_unsigned_bits (chksum, value, 32);
9069 /* Generate a crc32 of a byte. */
9071 unsigned
9072 crc32_byte (unsigned chksum, char byte)
9074 return crc32_unsigned_bits (chksum, (unsigned) byte << 24, 8);
9077 /* Generate a crc32 of a string. */
9079 unsigned
9080 crc32_string (unsigned chksum, const char *string)
9084 chksum = crc32_byte (chksum, *string);
9086 while (*string++);
9087 return chksum;
9090 /* P is a string that will be used in a symbol. Mask out any characters
9091 that are not valid in that context. */
9093 void
9094 clean_symbol_name (char *p)
9096 for (; *p; p++)
9097 if (! (ISALNUM (*p)
9098 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9099 || *p == '$'
9100 #endif
9101 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9102 || *p == '.'
9103 #endif
9105 *p = '_';
9108 /* Generate a name for a special-purpose function.
9109 The generated name may need to be unique across the whole link.
9110 Changes to this function may also require corresponding changes to
9111 xstrdup_mask_random.
9112 TYPE is some string to identify the purpose of this function to the
9113 linker or collect2; it must start with an uppercase letter,
9114 one of:
9115 I - for constructors
9116 D - for destructors
9117 N - for C++ anonymous namespaces
9118 F - for DWARF unwind frame information. */
9120 tree
9121 get_file_function_name (const char *type)
9123 char *buf;
9124 const char *p;
9125 char *q;
9127 /* If we already have a name we know to be unique, just use that. */
9128 if (first_global_object_name)
9129 p = q = ASTRDUP (first_global_object_name);
9130 /* If the target is handling the constructors/destructors, they
9131 will be local to this file and the name is only necessary for
9132 debugging purposes.
9133 We also assign sub_I and sub_D sufixes to constructors called from
9134 the global static constructors. These are always local. */
9135 else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9136 || (strncmp (type, "sub_", 4) == 0
9137 && (type[4] == 'I' || type[4] == 'D')))
9139 const char *file = main_input_filename;
9140 if (! file)
9141 file = LOCATION_FILE (input_location);
9142 /* Just use the file's basename, because the full pathname
9143 might be quite long. */
9144 p = q = ASTRDUP (lbasename (file));
9146 else
9148 /* Otherwise, the name must be unique across the entire link.
9149 We don't have anything that we know to be unique to this translation
9150 unit, so use what we do have and throw in some randomness. */
9151 unsigned len;
9152 const char *name = weak_global_object_name;
9153 const char *file = main_input_filename;
9155 if (! name)
9156 name = "";
9157 if (! file)
9158 file = LOCATION_FILE (input_location);
9160 len = strlen (file);
9161 q = (char *) alloca (9 + 17 + len + 1);
9162 memcpy (q, file, len + 1);
9164 snprintf (q + len, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9165 crc32_string (0, name), get_random_seed (false));
9167 p = q;
9170 clean_symbol_name (q);
9171 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9172 + strlen (type));
9174 /* Set up the name of the file-level functions we may need.
9175 Use a global object (which is already required to be unique over
9176 the program) rather than the file name (which imposes extra
9177 constraints). */
9178 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9180 return get_identifier (buf);
9183 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9185 /* Complain that the tree code of NODE does not match the expected 0
9186 terminated list of trailing codes. The trailing code list can be
9187 empty, for a more vague error message. FILE, LINE, and FUNCTION
9188 are of the caller. */
9190 void
9191 tree_check_failed (const_tree node, const char *file,
9192 int line, const char *function, ...)
9194 va_list args;
9195 const char *buffer;
9196 unsigned length = 0;
9197 enum tree_code code;
9199 va_start (args, function);
9200 while ((code = (enum tree_code) va_arg (args, int)))
9201 length += 4 + strlen (get_tree_code_name (code));
9202 va_end (args);
9203 if (length)
9205 char *tmp;
9206 va_start (args, function);
9207 length += strlen ("expected ");
9208 buffer = tmp = (char *) alloca (length);
9209 length = 0;
9210 while ((code = (enum tree_code) va_arg (args, int)))
9212 const char *prefix = length ? " or " : "expected ";
9214 strcpy (tmp + length, prefix);
9215 length += strlen (prefix);
9216 strcpy (tmp + length, get_tree_code_name (code));
9217 length += strlen (get_tree_code_name (code));
9219 va_end (args);
9221 else
9222 buffer = "unexpected node";
9224 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9225 buffer, get_tree_code_name (TREE_CODE (node)),
9226 function, trim_filename (file), line);
9229 /* Complain that the tree code of NODE does match the expected 0
9230 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9231 the caller. */
9233 void
9234 tree_not_check_failed (const_tree node, const char *file,
9235 int line, const char *function, ...)
9237 va_list args;
9238 char *buffer;
9239 unsigned length = 0;
9240 enum tree_code code;
9242 va_start (args, function);
9243 while ((code = (enum tree_code) va_arg (args, int)))
9244 length += 4 + strlen (get_tree_code_name (code));
9245 va_end (args);
9246 va_start (args, function);
9247 buffer = (char *) alloca (length);
9248 length = 0;
9249 while ((code = (enum tree_code) va_arg (args, int)))
9251 if (length)
9253 strcpy (buffer + length, " or ");
9254 length += 4;
9256 strcpy (buffer + length, get_tree_code_name (code));
9257 length += strlen (get_tree_code_name (code));
9259 va_end (args);
9261 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9262 buffer, get_tree_code_name (TREE_CODE (node)),
9263 function, trim_filename (file), line);
9266 /* Similar to tree_check_failed, except that we check for a class of tree
9267 code, given in CL. */
9269 void
9270 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9271 const char *file, int line, const char *function)
9273 internal_error
9274 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9275 TREE_CODE_CLASS_STRING (cl),
9276 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9277 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9280 /* Similar to tree_check_failed, except that instead of specifying a
9281 dozen codes, use the knowledge that they're all sequential. */
9283 void
9284 tree_range_check_failed (const_tree node, const char *file, int line,
9285 const char *function, enum tree_code c1,
9286 enum tree_code c2)
9288 char *buffer;
9289 unsigned length = 0;
9290 unsigned int c;
9292 for (c = c1; c <= c2; ++c)
9293 length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9295 length += strlen ("expected ");
9296 buffer = (char *) alloca (length);
9297 length = 0;
9299 for (c = c1; c <= c2; ++c)
9301 const char *prefix = length ? " or " : "expected ";
9303 strcpy (buffer + length, prefix);
9304 length += strlen (prefix);
9305 strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9306 length += strlen (get_tree_code_name ((enum tree_code) c));
9309 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9310 buffer, get_tree_code_name (TREE_CODE (node)),
9311 function, trim_filename (file), line);
9315 /* Similar to tree_check_failed, except that we check that a tree does
9316 not have the specified code, given in CL. */
9318 void
9319 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9320 const char *file, int line, const char *function)
9322 internal_error
9323 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9324 TREE_CODE_CLASS_STRING (cl),
9325 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9326 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9330 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9332 void
9333 omp_clause_check_failed (const_tree node, const char *file, int line,
9334 const char *function, enum omp_clause_code code)
9336 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9337 omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9338 function, trim_filename (file), line);
9342 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9344 void
9345 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9346 const char *function, enum omp_clause_code c1,
9347 enum omp_clause_code c2)
9349 char *buffer;
9350 unsigned length = 0;
9351 unsigned int c;
9353 for (c = c1; c <= c2; ++c)
9354 length += 4 + strlen (omp_clause_code_name[c]);
9356 length += strlen ("expected ");
9357 buffer = (char *) alloca (length);
9358 length = 0;
9360 for (c = c1; c <= c2; ++c)
9362 const char *prefix = length ? " or " : "expected ";
9364 strcpy (buffer + length, prefix);
9365 length += strlen (prefix);
9366 strcpy (buffer + length, omp_clause_code_name[c]);
9367 length += strlen (omp_clause_code_name[c]);
9370 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9371 buffer, omp_clause_code_name[TREE_CODE (node)],
9372 function, trim_filename (file), line);
9376 #undef DEFTREESTRUCT
9377 #define DEFTREESTRUCT(VAL, NAME) NAME,
9379 static const char *ts_enum_names[] = {
9380 #include "treestruct.def"
9382 #undef DEFTREESTRUCT
9384 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9386 /* Similar to tree_class_check_failed, except that we check for
9387 whether CODE contains the tree structure identified by EN. */
9389 void
9390 tree_contains_struct_check_failed (const_tree node,
9391 const enum tree_node_structure_enum en,
9392 const char *file, int line,
9393 const char *function)
9395 internal_error
9396 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9397 TS_ENUM_NAME (en),
9398 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9402 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9403 (dynamically sized) vector. */
9405 void
9406 tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line,
9407 const char *function)
9409 internal_error
9410 ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
9411 idx + 1, len, function, trim_filename (file), line);
9414 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9415 (dynamically sized) vector. */
9417 void
9418 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
9419 const char *function)
9421 internal_error
9422 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9423 idx + 1, len, function, trim_filename (file), line);
9426 /* Similar to above, except that the check is for the bounds of the operand
9427 vector of an expression node EXP. */
9429 void
9430 tree_operand_check_failed (int idx, const_tree exp, const char *file,
9431 int line, const char *function)
9433 enum tree_code code = TREE_CODE (exp);
9434 internal_error
9435 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9436 idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
9437 function, trim_filename (file), line);
9440 /* Similar to above, except that the check is for the number of
9441 operands of an OMP_CLAUSE node. */
9443 void
9444 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
9445 int line, const char *function)
9447 internal_error
9448 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9449 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
9450 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
9451 trim_filename (file), line);
9453 #endif /* ENABLE_TREE_CHECKING */
9455 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9456 and mapped to the machine mode MODE. Initialize its fields and build
9457 the information necessary for debugging output. */
9459 static tree
9460 make_vector_type (tree innertype, int nunits, machine_mode mode)
9462 tree t;
9463 inchash::hash hstate;
9465 t = make_node (VECTOR_TYPE);
9466 TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
9467 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
9468 SET_TYPE_MODE (t, mode);
9470 if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
9471 SET_TYPE_STRUCTURAL_EQUALITY (t);
9472 else if (TYPE_CANONICAL (innertype) != innertype
9473 || mode != VOIDmode)
9474 TYPE_CANONICAL (t)
9475 = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
9477 layout_type (t);
9479 hstate.add_wide_int (VECTOR_TYPE);
9480 hstate.add_wide_int (nunits);
9481 hstate.add_wide_int (mode);
9482 hstate.add_object (TYPE_HASH (TREE_TYPE (t)));
9483 t = type_hash_canon (hstate.end (), t);
9485 /* We have built a main variant, based on the main variant of the
9486 inner type. Use it to build the variant we return. */
9487 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
9488 && TREE_TYPE (t) != innertype)
9489 return build_type_attribute_qual_variant (t,
9490 TYPE_ATTRIBUTES (innertype),
9491 TYPE_QUALS (innertype));
9493 return t;
9496 static tree
9497 make_or_reuse_type (unsigned size, int unsignedp)
9499 int i;
9501 if (size == INT_TYPE_SIZE)
9502 return unsignedp ? unsigned_type_node : integer_type_node;
9503 if (size == CHAR_TYPE_SIZE)
9504 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
9505 if (size == SHORT_TYPE_SIZE)
9506 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
9507 if (size == LONG_TYPE_SIZE)
9508 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
9509 if (size == LONG_LONG_TYPE_SIZE)
9510 return (unsignedp ? long_long_unsigned_type_node
9511 : long_long_integer_type_node);
9513 for (i = 0; i < NUM_INT_N_ENTS; i ++)
9514 if (size == int_n_data[i].bitsize
9515 && int_n_enabled_p[i])
9516 return (unsignedp ? int_n_trees[i].unsigned_type
9517 : int_n_trees[i].signed_type);
9519 if (unsignedp)
9520 return make_unsigned_type (size);
9521 else
9522 return make_signed_type (size);
9525 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9527 static tree
9528 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
9530 if (satp)
9532 if (size == SHORT_FRACT_TYPE_SIZE)
9533 return unsignedp ? sat_unsigned_short_fract_type_node
9534 : sat_short_fract_type_node;
9535 if (size == FRACT_TYPE_SIZE)
9536 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
9537 if (size == LONG_FRACT_TYPE_SIZE)
9538 return unsignedp ? sat_unsigned_long_fract_type_node
9539 : sat_long_fract_type_node;
9540 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9541 return unsignedp ? sat_unsigned_long_long_fract_type_node
9542 : sat_long_long_fract_type_node;
9544 else
9546 if (size == SHORT_FRACT_TYPE_SIZE)
9547 return unsignedp ? unsigned_short_fract_type_node
9548 : short_fract_type_node;
9549 if (size == FRACT_TYPE_SIZE)
9550 return unsignedp ? unsigned_fract_type_node : fract_type_node;
9551 if (size == LONG_FRACT_TYPE_SIZE)
9552 return unsignedp ? unsigned_long_fract_type_node
9553 : long_fract_type_node;
9554 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9555 return unsignedp ? unsigned_long_long_fract_type_node
9556 : long_long_fract_type_node;
9559 return make_fract_type (size, unsignedp, satp);
9562 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9564 static tree
9565 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
9567 if (satp)
9569 if (size == SHORT_ACCUM_TYPE_SIZE)
9570 return unsignedp ? sat_unsigned_short_accum_type_node
9571 : sat_short_accum_type_node;
9572 if (size == ACCUM_TYPE_SIZE)
9573 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
9574 if (size == LONG_ACCUM_TYPE_SIZE)
9575 return unsignedp ? sat_unsigned_long_accum_type_node
9576 : sat_long_accum_type_node;
9577 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9578 return unsignedp ? sat_unsigned_long_long_accum_type_node
9579 : sat_long_long_accum_type_node;
9581 else
9583 if (size == SHORT_ACCUM_TYPE_SIZE)
9584 return unsignedp ? unsigned_short_accum_type_node
9585 : short_accum_type_node;
9586 if (size == ACCUM_TYPE_SIZE)
9587 return unsignedp ? unsigned_accum_type_node : accum_type_node;
9588 if (size == LONG_ACCUM_TYPE_SIZE)
9589 return unsignedp ? unsigned_long_accum_type_node
9590 : long_accum_type_node;
9591 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9592 return unsignedp ? unsigned_long_long_accum_type_node
9593 : long_long_accum_type_node;
9596 return make_accum_type (size, unsignedp, satp);
9600 /* Create an atomic variant node for TYPE. This routine is called
9601 during initialization of data types to create the 5 basic atomic
9602 types. The generic build_variant_type function requires these to
9603 already be set up in order to function properly, so cannot be
9604 called from there. If ALIGN is non-zero, then ensure alignment is
9605 overridden to this value. */
9607 static tree
9608 build_atomic_base (tree type, unsigned int align)
9610 tree t;
9612 /* Make sure its not already registered. */
9613 if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
9614 return t;
9616 t = build_variant_type_copy (type);
9617 set_type_quals (t, TYPE_QUAL_ATOMIC);
9619 if (align)
9620 TYPE_ALIGN (t) = align;
9622 return t;
9625 /* Create nodes for all integer types (and error_mark_node) using the sizes
9626 of C datatypes. SIGNED_CHAR specifies whether char is signed,
9627 SHORT_DOUBLE specifies whether double should be of the same precision
9628 as float. */
9630 void
9631 build_common_tree_nodes (bool signed_char, bool short_double)
9633 int i;
9635 error_mark_node = make_node (ERROR_MARK);
9636 TREE_TYPE (error_mark_node) = error_mark_node;
9638 initialize_sizetypes ();
9640 /* Define both `signed char' and `unsigned char'. */
9641 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
9642 TYPE_STRING_FLAG (signed_char_type_node) = 1;
9643 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
9644 TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
9646 /* Define `char', which is like either `signed char' or `unsigned char'
9647 but not the same as either. */
9648 char_type_node
9649 = (signed_char
9650 ? make_signed_type (CHAR_TYPE_SIZE)
9651 : make_unsigned_type (CHAR_TYPE_SIZE));
9652 TYPE_STRING_FLAG (char_type_node) = 1;
9654 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
9655 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
9656 integer_type_node = make_signed_type (INT_TYPE_SIZE);
9657 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
9658 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
9659 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
9660 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
9661 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
9663 for (i = 0; i < NUM_INT_N_ENTS; i ++)
9665 int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize);
9666 int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize);
9667 TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize);
9668 TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize);
9670 if (int_n_data[i].bitsize > LONG_LONG_TYPE_SIZE
9671 && int_n_enabled_p[i])
9673 integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type;
9674 integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type;
9678 /* Define a boolean type. This type only represents boolean values but
9679 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
9680 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
9681 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
9682 TYPE_PRECISION (boolean_type_node) = 1;
9683 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
9685 /* Define what type to use for size_t. */
9686 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
9687 size_type_node = unsigned_type_node;
9688 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
9689 size_type_node = long_unsigned_type_node;
9690 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
9691 size_type_node = long_long_unsigned_type_node;
9692 else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
9693 size_type_node = short_unsigned_type_node;
9694 else
9696 int i;
9698 size_type_node = NULL_TREE;
9699 for (i = 0; i < NUM_INT_N_ENTS; i++)
9700 if (int_n_enabled_p[i])
9702 char name[50];
9703 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
9705 if (strcmp (name, SIZE_TYPE) == 0)
9707 size_type_node = int_n_trees[i].unsigned_type;
9710 if (size_type_node == NULL_TREE)
9711 gcc_unreachable ();
9714 /* Fill in the rest of the sized types. Reuse existing type nodes
9715 when possible. */
9716 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
9717 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
9718 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
9719 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
9720 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
9722 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
9723 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
9724 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
9725 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
9726 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
9728 /* Don't call build_qualified type for atomics. That routine does
9729 special processing for atomics, and until they are initialized
9730 it's better not to make that call.
9732 Check to see if there is a target override for atomic types. */
9734 atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
9735 targetm.atomic_align_for_mode (QImode));
9736 atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
9737 targetm.atomic_align_for_mode (HImode));
9738 atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
9739 targetm.atomic_align_for_mode (SImode));
9740 atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
9741 targetm.atomic_align_for_mode (DImode));
9742 atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
9743 targetm.atomic_align_for_mode (TImode));
9745 access_public_node = get_identifier ("public");
9746 access_protected_node = get_identifier ("protected");
9747 access_private_node = get_identifier ("private");
9749 /* Define these next since types below may used them. */
9750 integer_zero_node = build_int_cst (integer_type_node, 0);
9751 integer_one_node = build_int_cst (integer_type_node, 1);
9752 integer_three_node = build_int_cst (integer_type_node, 3);
9753 integer_minus_one_node = build_int_cst (integer_type_node, -1);
9755 size_zero_node = size_int (0);
9756 size_one_node = size_int (1);
9757 bitsize_zero_node = bitsize_int (0);
9758 bitsize_one_node = bitsize_int (1);
9759 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
9761 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
9762 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
9764 void_type_node = make_node (VOID_TYPE);
9765 layout_type (void_type_node);
9767 pointer_bounds_type_node = targetm.chkp_bound_type ();
9769 /* We are not going to have real types in C with less than byte alignment,
9770 so we might as well not have any types that claim to have it. */
9771 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
9772 TYPE_USER_ALIGN (void_type_node) = 0;
9774 void_node = make_node (VOID_CST);
9775 TREE_TYPE (void_node) = void_type_node;
9777 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9778 layout_type (TREE_TYPE (null_pointer_node));
9780 ptr_type_node = build_pointer_type (void_type_node);
9781 const_ptr_type_node
9782 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9783 fileptr_type_node = ptr_type_node;
9785 pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
9787 float_type_node = make_node (REAL_TYPE);
9788 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9789 layout_type (float_type_node);
9791 double_type_node = make_node (REAL_TYPE);
9792 if (short_double)
9793 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
9794 else
9795 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9796 layout_type (double_type_node);
9798 long_double_type_node = make_node (REAL_TYPE);
9799 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9800 layout_type (long_double_type_node);
9802 float_ptr_type_node = build_pointer_type (float_type_node);
9803 double_ptr_type_node = build_pointer_type (double_type_node);
9804 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9805 integer_ptr_type_node = build_pointer_type (integer_type_node);
9807 /* Fixed size integer types. */
9808 uint16_type_node = make_or_reuse_type (16, 1);
9809 uint32_type_node = make_or_reuse_type (32, 1);
9810 uint64_type_node = make_or_reuse_type (64, 1);
9812 /* Decimal float types. */
9813 dfloat32_type_node = make_node (REAL_TYPE);
9814 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9815 layout_type (dfloat32_type_node);
9816 SET_TYPE_MODE (dfloat32_type_node, SDmode);
9817 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9819 dfloat64_type_node = make_node (REAL_TYPE);
9820 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9821 layout_type (dfloat64_type_node);
9822 SET_TYPE_MODE (dfloat64_type_node, DDmode);
9823 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9825 dfloat128_type_node = make_node (REAL_TYPE);
9826 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9827 layout_type (dfloat128_type_node);
9828 SET_TYPE_MODE (dfloat128_type_node, TDmode);
9829 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
9831 complex_integer_type_node = build_complex_type (integer_type_node);
9832 complex_float_type_node = build_complex_type (float_type_node);
9833 complex_double_type_node = build_complex_type (double_type_node);
9834 complex_long_double_type_node = build_complex_type (long_double_type_node);
9836 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9837 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9838 sat_ ## KIND ## _type_node = \
9839 make_sat_signed_ ## KIND ## _type (SIZE); \
9840 sat_unsigned_ ## KIND ## _type_node = \
9841 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9842 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9843 unsigned_ ## KIND ## _type_node = \
9844 make_unsigned_ ## KIND ## _type (SIZE);
9846 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9847 sat_ ## WIDTH ## KIND ## _type_node = \
9848 make_sat_signed_ ## KIND ## _type (SIZE); \
9849 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9850 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9851 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9852 unsigned_ ## WIDTH ## KIND ## _type_node = \
9853 make_unsigned_ ## KIND ## _type (SIZE);
9855 /* Make fixed-point type nodes based on four different widths. */
9856 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9857 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9858 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9859 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9860 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9862 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9863 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9864 NAME ## _type_node = \
9865 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9866 u ## NAME ## _type_node = \
9867 make_or_reuse_unsigned_ ## KIND ## _type \
9868 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9869 sat_ ## NAME ## _type_node = \
9870 make_or_reuse_sat_signed_ ## KIND ## _type \
9871 (GET_MODE_BITSIZE (MODE ## mode)); \
9872 sat_u ## NAME ## _type_node = \
9873 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9874 (GET_MODE_BITSIZE (U ## MODE ## mode));
9876 /* Fixed-point type and mode nodes. */
9877 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
9878 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
9879 MAKE_FIXED_MODE_NODE (fract, qq, QQ)
9880 MAKE_FIXED_MODE_NODE (fract, hq, HQ)
9881 MAKE_FIXED_MODE_NODE (fract, sq, SQ)
9882 MAKE_FIXED_MODE_NODE (fract, dq, DQ)
9883 MAKE_FIXED_MODE_NODE (fract, tq, TQ)
9884 MAKE_FIXED_MODE_NODE (accum, ha, HA)
9885 MAKE_FIXED_MODE_NODE (accum, sa, SA)
9886 MAKE_FIXED_MODE_NODE (accum, da, DA)
9887 MAKE_FIXED_MODE_NODE (accum, ta, TA)
9890 tree t = targetm.build_builtin_va_list ();
9892 /* Many back-ends define record types without setting TYPE_NAME.
9893 If we copied the record type here, we'd keep the original
9894 record type without a name. This breaks name mangling. So,
9895 don't copy record types and let c_common_nodes_and_builtins()
9896 declare the type to be __builtin_va_list. */
9897 if (TREE_CODE (t) != RECORD_TYPE)
9898 t = build_variant_type_copy (t);
9900 va_list_type_node = t;
9904 /* Modify DECL for given flags.
9905 TM_PURE attribute is set only on types, so the function will modify
9906 DECL's type when ECF_TM_PURE is used. */
9908 void
9909 set_call_expr_flags (tree decl, int flags)
9911 if (flags & ECF_NOTHROW)
9912 TREE_NOTHROW (decl) = 1;
9913 if (flags & ECF_CONST)
9914 TREE_READONLY (decl) = 1;
9915 if (flags & ECF_PURE)
9916 DECL_PURE_P (decl) = 1;
9917 if (flags & ECF_LOOPING_CONST_OR_PURE)
9918 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9919 if (flags & ECF_NOVOPS)
9920 DECL_IS_NOVOPS (decl) = 1;
9921 if (flags & ECF_NORETURN)
9922 TREE_THIS_VOLATILE (decl) = 1;
9923 if (flags & ECF_MALLOC)
9924 DECL_IS_MALLOC (decl) = 1;
9925 if (flags & ECF_RETURNS_TWICE)
9926 DECL_IS_RETURNS_TWICE (decl) = 1;
9927 if (flags & ECF_LEAF)
9928 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
9929 NULL, DECL_ATTRIBUTES (decl));
9930 if ((flags & ECF_TM_PURE) && flag_tm)
9931 apply_tm_attr (decl, get_identifier ("transaction_pure"));
9932 /* Looping const or pure is implied by noreturn.
9933 There is currently no way to declare looping const or looping pure alone. */
9934 gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
9935 || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
9939 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9941 static void
9942 local_define_builtin (const char *name, tree type, enum built_in_function code,
9943 const char *library_name, int ecf_flags)
9945 tree decl;
9947 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9948 library_name, NULL_TREE);
9949 set_call_expr_flags (decl, ecf_flags);
9951 set_builtin_decl (code, decl, true);
9954 /* Call this function after instantiating all builtins that the language
9955 front end cares about. This will build the rest of the builtins
9956 and internal functions that are relied upon by the tree optimizers and
9957 the middle-end. */
9959 void
9960 build_common_builtin_nodes (void)
9962 tree tmp, ftype;
9963 int ecf_flags;
9965 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
9967 ftype = build_function_type (void_type_node, void_list_node);
9968 local_define_builtin ("__builtin_unreachable", ftype, BUILT_IN_UNREACHABLE,
9969 "__builtin_unreachable",
9970 ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
9971 | ECF_CONST);
9974 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
9975 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
9977 ftype = build_function_type_list (ptr_type_node,
9978 ptr_type_node, const_ptr_type_node,
9979 size_type_node, NULL_TREE);
9981 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
9982 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9983 "memcpy", ECF_NOTHROW | ECF_LEAF);
9984 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
9985 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9986 "memmove", ECF_NOTHROW | ECF_LEAF);
9989 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
9991 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
9992 const_ptr_type_node, size_type_node,
9993 NULL_TREE);
9994 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9995 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
9998 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
10000 ftype = build_function_type_list (ptr_type_node,
10001 ptr_type_node, integer_type_node,
10002 size_type_node, NULL_TREE);
10003 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
10004 "memset", ECF_NOTHROW | ECF_LEAF);
10007 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
10009 ftype = build_function_type_list (ptr_type_node,
10010 size_type_node, NULL_TREE);
10011 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
10012 "alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
10015 ftype = build_function_type_list (ptr_type_node, size_type_node,
10016 size_type_node, NULL_TREE);
10017 local_define_builtin ("__builtin_alloca_with_align", ftype,
10018 BUILT_IN_ALLOCA_WITH_ALIGN, "alloca",
10019 ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
10021 /* If we're checking the stack, `alloca' can throw. */
10022 if (flag_stack_check)
10024 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA)) = 0;
10025 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN)) = 0;
10028 ftype = build_function_type_list (void_type_node,
10029 ptr_type_node, ptr_type_node,
10030 ptr_type_node, NULL_TREE);
10031 local_define_builtin ("__builtin_init_trampoline", ftype,
10032 BUILT_IN_INIT_TRAMPOLINE,
10033 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
10034 local_define_builtin ("__builtin_init_heap_trampoline", ftype,
10035 BUILT_IN_INIT_HEAP_TRAMPOLINE,
10036 "__builtin_init_heap_trampoline",
10037 ECF_NOTHROW | ECF_LEAF);
10039 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
10040 local_define_builtin ("__builtin_adjust_trampoline", ftype,
10041 BUILT_IN_ADJUST_TRAMPOLINE,
10042 "__builtin_adjust_trampoline",
10043 ECF_CONST | ECF_NOTHROW);
10045 ftype = build_function_type_list (void_type_node,
10046 ptr_type_node, ptr_type_node, NULL_TREE);
10047 local_define_builtin ("__builtin_nonlocal_goto", ftype,
10048 BUILT_IN_NONLOCAL_GOTO,
10049 "__builtin_nonlocal_goto",
10050 ECF_NORETURN | ECF_NOTHROW);
10052 ftype = build_function_type_list (void_type_node,
10053 ptr_type_node, ptr_type_node, NULL_TREE);
10054 local_define_builtin ("__builtin_setjmp_setup", ftype,
10055 BUILT_IN_SETJMP_SETUP,
10056 "__builtin_setjmp_setup", ECF_NOTHROW);
10058 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10059 local_define_builtin ("__builtin_setjmp_receiver", ftype,
10060 BUILT_IN_SETJMP_RECEIVER,
10061 "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
10063 ftype = build_function_type_list (ptr_type_node, NULL_TREE);
10064 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
10065 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
10067 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10068 local_define_builtin ("__builtin_stack_restore", ftype,
10069 BUILT_IN_STACK_RESTORE,
10070 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
10072 /* If there's a possibility that we might use the ARM EABI, build the
10073 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
10074 if (targetm.arm_eabi_unwinder)
10076 ftype = build_function_type_list (void_type_node, NULL_TREE);
10077 local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10078 BUILT_IN_CXA_END_CLEANUP,
10079 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10082 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10083 local_define_builtin ("__builtin_unwind_resume", ftype,
10084 BUILT_IN_UNWIND_RESUME,
10085 ((targetm_common.except_unwind_info (&global_options)
10086 == UI_SJLJ)
10087 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10088 ECF_NORETURN);
10090 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10092 ftype = build_function_type_list (ptr_type_node, integer_type_node,
10093 NULL_TREE);
10094 local_define_builtin ("__builtin_return_address", ftype,
10095 BUILT_IN_RETURN_ADDRESS,
10096 "__builtin_return_address",
10097 ECF_NOTHROW);
10100 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10101 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10103 ftype = build_function_type_list (void_type_node, ptr_type_node,
10104 ptr_type_node, NULL_TREE);
10105 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10106 local_define_builtin ("__cyg_profile_func_enter", ftype,
10107 BUILT_IN_PROFILE_FUNC_ENTER,
10108 "__cyg_profile_func_enter", 0);
10109 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10110 local_define_builtin ("__cyg_profile_func_exit", ftype,
10111 BUILT_IN_PROFILE_FUNC_EXIT,
10112 "__cyg_profile_func_exit", 0);
10115 /* The exception object and filter values from the runtime. The argument
10116 must be zero before exception lowering, i.e. from the front end. After
10117 exception lowering, it will be the region number for the exception
10118 landing pad. These functions are PURE instead of CONST to prevent
10119 them from being hoisted past the exception edge that will initialize
10120 its value in the landing pad. */
10121 ftype = build_function_type_list (ptr_type_node,
10122 integer_type_node, NULL_TREE);
10123 ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10124 /* Only use TM_PURE if we we have TM language support. */
10125 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10126 ecf_flags |= ECF_TM_PURE;
10127 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10128 "__builtin_eh_pointer", ecf_flags);
10130 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10131 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10132 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10133 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10135 ftype = build_function_type_list (void_type_node,
10136 integer_type_node, integer_type_node,
10137 NULL_TREE);
10138 local_define_builtin ("__builtin_eh_copy_values", ftype,
10139 BUILT_IN_EH_COPY_VALUES,
10140 "__builtin_eh_copy_values", ECF_NOTHROW);
10142 /* Complex multiplication and division. These are handled as builtins
10143 rather than optabs because emit_library_call_value doesn't support
10144 complex. Further, we can do slightly better with folding these
10145 beasties if the real and complex parts of the arguments are separate. */
10147 int mode;
10149 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10151 char mode_name_buf[4], *q;
10152 const char *p;
10153 enum built_in_function mcode, dcode;
10154 tree type, inner_type;
10155 const char *prefix = "__";
10157 if (targetm.libfunc_gnu_prefix)
10158 prefix = "__gnu_";
10160 type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0);
10161 if (type == NULL)
10162 continue;
10163 inner_type = TREE_TYPE (type);
10165 ftype = build_function_type_list (type, inner_type, inner_type,
10166 inner_type, inner_type, NULL_TREE);
10168 mcode = ((enum built_in_function)
10169 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10170 dcode = ((enum built_in_function)
10171 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10173 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10174 *q = TOLOWER (*p);
10175 *q = '\0';
10177 built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10178 NULL);
10179 local_define_builtin (built_in_names[mcode], ftype, mcode,
10180 built_in_names[mcode],
10181 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10183 built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10184 NULL);
10185 local_define_builtin (built_in_names[dcode], ftype, dcode,
10186 built_in_names[dcode],
10187 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10191 init_internal_fns ();
10194 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10195 better way.
10197 If we requested a pointer to a vector, build up the pointers that
10198 we stripped off while looking for the inner type. Similarly for
10199 return values from functions.
10201 The argument TYPE is the top of the chain, and BOTTOM is the
10202 new type which we will point to. */
10204 tree
10205 reconstruct_complex_type (tree type, tree bottom)
10207 tree inner, outer;
10209 if (TREE_CODE (type) == POINTER_TYPE)
10211 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10212 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10213 TYPE_REF_CAN_ALIAS_ALL (type));
10215 else if (TREE_CODE (type) == REFERENCE_TYPE)
10217 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10218 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10219 TYPE_REF_CAN_ALIAS_ALL (type));
10221 else if (TREE_CODE (type) == ARRAY_TYPE)
10223 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10224 outer = build_array_type (inner, TYPE_DOMAIN (type));
10226 else if (TREE_CODE (type) == FUNCTION_TYPE)
10228 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10229 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10231 else if (TREE_CODE (type) == METHOD_TYPE)
10233 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10234 /* The build_method_type_directly() routine prepends 'this' to argument list,
10235 so we must compensate by getting rid of it. */
10236 outer
10237 = build_method_type_directly
10238 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10239 inner,
10240 TREE_CHAIN (TYPE_ARG_TYPES (type)));
10242 else if (TREE_CODE (type) == OFFSET_TYPE)
10244 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10245 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10247 else
10248 return bottom;
10250 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10251 TYPE_QUALS (type));
10254 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10255 the inner type. */
10256 tree
10257 build_vector_type_for_mode (tree innertype, machine_mode mode)
10259 int nunits;
10261 switch (GET_MODE_CLASS (mode))
10263 case MODE_VECTOR_INT:
10264 case MODE_VECTOR_FLOAT:
10265 case MODE_VECTOR_FRACT:
10266 case MODE_VECTOR_UFRACT:
10267 case MODE_VECTOR_ACCUM:
10268 case MODE_VECTOR_UACCUM:
10269 nunits = GET_MODE_NUNITS (mode);
10270 break;
10272 case MODE_INT:
10273 /* Check that there are no leftover bits. */
10274 gcc_assert (GET_MODE_BITSIZE (mode)
10275 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10277 nunits = GET_MODE_BITSIZE (mode)
10278 / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
10279 break;
10281 default:
10282 gcc_unreachable ();
10285 return make_vector_type (innertype, nunits, mode);
10288 /* Similarly, but takes the inner type and number of units, which must be
10289 a power of two. */
10291 tree
10292 build_vector_type (tree innertype, int nunits)
10294 return make_vector_type (innertype, nunits, VOIDmode);
10297 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10299 tree
10300 build_opaque_vector_type (tree innertype, int nunits)
10302 tree t = make_vector_type (innertype, nunits, VOIDmode);
10303 tree cand;
10304 /* We always build the non-opaque variant before the opaque one,
10305 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10306 cand = TYPE_NEXT_VARIANT (t);
10307 if (cand
10308 && TYPE_VECTOR_OPAQUE (cand)
10309 && check_qualified_type (cand, t, TYPE_QUALS (t)))
10310 return cand;
10311 /* Othewise build a variant type and make sure to queue it after
10312 the non-opaque type. */
10313 cand = build_distinct_type_copy (t);
10314 TYPE_VECTOR_OPAQUE (cand) = true;
10315 TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
10316 TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
10317 TYPE_NEXT_VARIANT (t) = cand;
10318 TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
10319 return cand;
10323 /* Given an initializer INIT, return TRUE if INIT is zero or some
10324 aggregate of zeros. Otherwise return FALSE. */
10325 bool
10326 initializer_zerop (const_tree init)
10328 tree elt;
10330 STRIP_NOPS (init);
10332 switch (TREE_CODE (init))
10334 case INTEGER_CST:
10335 return integer_zerop (init);
10337 case REAL_CST:
10338 /* ??? Note that this is not correct for C4X float formats. There,
10339 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10340 negative exponent. */
10341 return real_zerop (init)
10342 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
10344 case FIXED_CST:
10345 return fixed_zerop (init);
10347 case COMPLEX_CST:
10348 return integer_zerop (init)
10349 || (real_zerop (init)
10350 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
10351 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
10353 case VECTOR_CST:
10355 unsigned i;
10356 for (i = 0; i < VECTOR_CST_NELTS (init); ++i)
10357 if (!initializer_zerop (VECTOR_CST_ELT (init, i)))
10358 return false;
10359 return true;
10362 case CONSTRUCTOR:
10364 unsigned HOST_WIDE_INT idx;
10366 if (TREE_CLOBBER_P (init))
10367 return false;
10368 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
10369 if (!initializer_zerop (elt))
10370 return false;
10371 return true;
10374 case STRING_CST:
10376 int i;
10378 /* We need to loop through all elements to handle cases like
10379 "\0" and "\0foobar". */
10380 for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
10381 if (TREE_STRING_POINTER (init)[i] != '\0')
10382 return false;
10384 return true;
10387 default:
10388 return false;
10392 /* Check if vector VEC consists of all the equal elements and
10393 that the number of elements corresponds to the type of VEC.
10394 The function returns first element of the vector
10395 or NULL_TREE if the vector is not uniform. */
10396 tree
10397 uniform_vector_p (const_tree vec)
10399 tree first, t;
10400 unsigned i;
10402 if (vec == NULL_TREE)
10403 return NULL_TREE;
10405 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
10407 if (TREE_CODE (vec) == VECTOR_CST)
10409 first = VECTOR_CST_ELT (vec, 0);
10410 for (i = 1; i < VECTOR_CST_NELTS (vec); ++i)
10411 if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0))
10412 return NULL_TREE;
10414 return first;
10417 else if (TREE_CODE (vec) == CONSTRUCTOR)
10419 first = error_mark_node;
10421 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
10423 if (i == 0)
10425 first = t;
10426 continue;
10428 if (!operand_equal_p (first, t, 0))
10429 return NULL_TREE;
10431 if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)))
10432 return NULL_TREE;
10434 return first;
10437 return NULL_TREE;
10440 /* Build an empty statement at location LOC. */
10442 tree
10443 build_empty_stmt (location_t loc)
10445 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
10446 SET_EXPR_LOCATION (t, loc);
10447 return t;
10451 /* Build an OpenMP clause with code CODE. LOC is the location of the
10452 clause. */
10454 tree
10455 build_omp_clause (location_t loc, enum omp_clause_code code)
10457 tree t;
10458 int size, length;
10460 length = omp_clause_num_ops[code];
10461 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
10463 record_node_allocation_statistics (OMP_CLAUSE, size);
10465 t = (tree) ggc_internal_alloc (size);
10466 memset (t, 0, size);
10467 TREE_SET_CODE (t, OMP_CLAUSE);
10468 OMP_CLAUSE_SET_CODE (t, code);
10469 OMP_CLAUSE_LOCATION (t) = loc;
10471 return t;
10474 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10475 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10476 Except for the CODE and operand count field, other storage for the
10477 object is initialized to zeros. */
10479 tree
10480 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
10482 tree t;
10483 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
10485 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
10486 gcc_assert (len >= 1);
10488 record_node_allocation_statistics (code, length);
10490 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
10492 TREE_SET_CODE (t, code);
10494 /* Can't use TREE_OPERAND to store the length because if checking is
10495 enabled, it will try to check the length before we store it. :-P */
10496 t->exp.operands[0] = build_int_cst (sizetype, len);
10498 return t;
10501 /* Helper function for build_call_* functions; build a CALL_EXPR with
10502 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10503 the argument slots. */
10505 static tree
10506 build_call_1 (tree return_type, tree fn, int nargs)
10508 tree t;
10510 t = build_vl_exp (CALL_EXPR, nargs + 3);
10511 TREE_TYPE (t) = return_type;
10512 CALL_EXPR_FN (t) = fn;
10513 CALL_EXPR_STATIC_CHAIN (t) = NULL;
10515 return t;
10518 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10519 FN and a null static chain slot. NARGS is the number of call arguments
10520 which are specified as "..." arguments. */
10522 tree
10523 build_call_nary (tree return_type, tree fn, int nargs, ...)
10525 tree ret;
10526 va_list args;
10527 va_start (args, nargs);
10528 ret = build_call_valist (return_type, fn, nargs, args);
10529 va_end (args);
10530 return ret;
10533 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10534 FN and a null static chain slot. NARGS is the number of call arguments
10535 which are specified as a va_list ARGS. */
10537 tree
10538 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
10540 tree t;
10541 int i;
10543 t = build_call_1 (return_type, fn, nargs);
10544 for (i = 0; i < nargs; i++)
10545 CALL_EXPR_ARG (t, i) = va_arg (args, tree);
10546 process_call_operands (t);
10547 return t;
10550 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10551 FN and a null static chain slot. NARGS is the number of call arguments
10552 which are specified as a tree array ARGS. */
10554 tree
10555 build_call_array_loc (location_t loc, tree return_type, tree fn,
10556 int nargs, const tree *args)
10558 tree t;
10559 int i;
10561 t = build_call_1 (return_type, fn, nargs);
10562 for (i = 0; i < nargs; i++)
10563 CALL_EXPR_ARG (t, i) = args[i];
10564 process_call_operands (t);
10565 SET_EXPR_LOCATION (t, loc);
10566 return t;
10569 /* Like build_call_array, but takes a vec. */
10571 tree
10572 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
10574 tree ret, t;
10575 unsigned int ix;
10577 ret = build_call_1 (return_type, fn, vec_safe_length (args));
10578 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
10579 CALL_EXPR_ARG (ret, ix) = t;
10580 process_call_operands (ret);
10581 return ret;
10584 /* Conveniently construct a function call expression. FNDECL names the
10585 function to be called and N arguments are passed in the array
10586 ARGARRAY. */
10588 tree
10589 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10591 tree fntype = TREE_TYPE (fndecl);
10592 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10594 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10597 /* Conveniently construct a function call expression. FNDECL names the
10598 function to be called and the arguments are passed in the vector
10599 VEC. */
10601 tree
10602 build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec)
10604 return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec),
10605 vec_safe_address (vec));
10609 /* Conveniently construct a function call expression. FNDECL names the
10610 function to be called, N is the number of arguments, and the "..."
10611 parameters are the argument expressions. */
10613 tree
10614 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10616 va_list ap;
10617 tree *argarray = XALLOCAVEC (tree, n);
10618 int i;
10620 va_start (ap, n);
10621 for (i = 0; i < n; i++)
10622 argarray[i] = va_arg (ap, tree);
10623 va_end (ap);
10624 return build_call_expr_loc_array (loc, fndecl, n, argarray);
10627 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10628 varargs macros aren't supported by all bootstrap compilers. */
10630 tree
10631 build_call_expr (tree fndecl, int n, ...)
10633 va_list ap;
10634 tree *argarray = XALLOCAVEC (tree, n);
10635 int i;
10637 va_start (ap, n);
10638 for (i = 0; i < n; i++)
10639 argarray[i] = va_arg (ap, tree);
10640 va_end (ap);
10641 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10644 /* Build internal call expression. This is just like CALL_EXPR, except
10645 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
10646 internal function. */
10648 tree
10649 build_call_expr_internal_loc (location_t loc, enum internal_fn ifn,
10650 tree type, int n, ...)
10652 va_list ap;
10653 int i;
10655 tree fn = build_call_1 (type, NULL_TREE, n);
10656 va_start (ap, n);
10657 for (i = 0; i < n; i++)
10658 CALL_EXPR_ARG (fn, i) = va_arg (ap, tree);
10659 va_end (ap);
10660 SET_EXPR_LOCATION (fn, loc);
10661 CALL_EXPR_IFN (fn) = ifn;
10662 return fn;
10665 /* Create a new constant string literal and return a char* pointer to it.
10666 The STRING_CST value is the LEN characters at STR. */
10667 tree
10668 build_string_literal (int len, const char *str)
10670 tree t, elem, index, type;
10672 t = build_string (len, str);
10673 elem = build_type_variant (char_type_node, 1, 0);
10674 index = build_index_type (size_int (len - 1));
10675 type = build_array_type (elem, index);
10676 TREE_TYPE (t) = type;
10677 TREE_CONSTANT (t) = 1;
10678 TREE_READONLY (t) = 1;
10679 TREE_STATIC (t) = 1;
10681 type = build_pointer_type (elem);
10682 t = build1 (ADDR_EXPR, type,
10683 build4 (ARRAY_REF, elem,
10684 t, integer_zero_node, NULL_TREE, NULL_TREE));
10685 return t;
10690 /* Return true if T (assumed to be a DECL) must be assigned a memory
10691 location. */
10693 bool
10694 needs_to_live_in_memory (const_tree t)
10696 return (TREE_ADDRESSABLE (t)
10697 || is_global_var (t)
10698 || (TREE_CODE (t) == RESULT_DECL
10699 && !DECL_BY_REFERENCE (t)
10700 && aggregate_value_p (t, current_function_decl)));
10703 /* Return value of a constant X and sign-extend it. */
10705 HOST_WIDE_INT
10706 int_cst_value (const_tree x)
10708 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
10709 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
10711 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10712 gcc_assert (cst_and_fits_in_hwi (x));
10714 if (bits < HOST_BITS_PER_WIDE_INT)
10716 bool negative = ((val >> (bits - 1)) & 1) != 0;
10717 if (negative)
10718 val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
10719 else
10720 val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
10723 return val;
10726 /* If TYPE is an integral or pointer type, return an integer type with
10727 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10728 if TYPE is already an integer type of signedness UNSIGNEDP. */
10730 tree
10731 signed_or_unsigned_type_for (int unsignedp, tree type)
10733 if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
10734 return type;
10736 if (TREE_CODE (type) == VECTOR_TYPE)
10738 tree inner = TREE_TYPE (type);
10739 tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
10740 if (!inner2)
10741 return NULL_TREE;
10742 if (inner == inner2)
10743 return type;
10744 return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
10747 if (!INTEGRAL_TYPE_P (type)
10748 && !POINTER_TYPE_P (type)
10749 && TREE_CODE (type) != OFFSET_TYPE)
10750 return NULL_TREE;
10752 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
10755 /* If TYPE is an integral or pointer type, return an integer type with
10756 the same precision which is unsigned, or itself if TYPE is already an
10757 unsigned integer type. */
10759 tree
10760 unsigned_type_for (tree type)
10762 return signed_or_unsigned_type_for (1, type);
10765 /* If TYPE is an integral or pointer type, return an integer type with
10766 the same precision which is signed, or itself if TYPE is already a
10767 signed integer type. */
10769 tree
10770 signed_type_for (tree type)
10772 return signed_or_unsigned_type_for (0, type);
10775 /* If TYPE is a vector type, return a signed integer vector type with the
10776 same width and number of subparts. Otherwise return boolean_type_node. */
10778 tree
10779 truth_type_for (tree type)
10781 if (TREE_CODE (type) == VECTOR_TYPE)
10783 tree elem = lang_hooks.types.type_for_size
10784 (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))), 0);
10785 return build_opaque_vector_type (elem, TYPE_VECTOR_SUBPARTS (type));
10787 else
10788 return boolean_type_node;
10791 /* Returns the largest value obtainable by casting something in INNER type to
10792 OUTER type. */
10794 tree
10795 upper_bound_in_type (tree outer, tree inner)
10797 unsigned int det = 0;
10798 unsigned oprec = TYPE_PRECISION (outer);
10799 unsigned iprec = TYPE_PRECISION (inner);
10800 unsigned prec;
10802 /* Compute a unique number for every combination. */
10803 det |= (oprec > iprec) ? 4 : 0;
10804 det |= TYPE_UNSIGNED (outer) ? 2 : 0;
10805 det |= TYPE_UNSIGNED (inner) ? 1 : 0;
10807 /* Determine the exponent to use. */
10808 switch (det)
10810 case 0:
10811 case 1:
10812 /* oprec <= iprec, outer: signed, inner: don't care. */
10813 prec = oprec - 1;
10814 break;
10815 case 2:
10816 case 3:
10817 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10818 prec = oprec;
10819 break;
10820 case 4:
10821 /* oprec > iprec, outer: signed, inner: signed. */
10822 prec = iprec - 1;
10823 break;
10824 case 5:
10825 /* oprec > iprec, outer: signed, inner: unsigned. */
10826 prec = iprec;
10827 break;
10828 case 6:
10829 /* oprec > iprec, outer: unsigned, inner: signed. */
10830 prec = oprec;
10831 break;
10832 case 7:
10833 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10834 prec = iprec;
10835 break;
10836 default:
10837 gcc_unreachable ();
10840 return wide_int_to_tree (outer,
10841 wi::mask (prec, false, TYPE_PRECISION (outer)));
10844 /* Returns the smallest value obtainable by casting something in INNER type to
10845 OUTER type. */
10847 tree
10848 lower_bound_in_type (tree outer, tree inner)
10850 unsigned oprec = TYPE_PRECISION (outer);
10851 unsigned iprec = TYPE_PRECISION (inner);
10853 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10854 and obtain 0. */
10855 if (TYPE_UNSIGNED (outer)
10856 /* If we are widening something of an unsigned type, OUTER type
10857 contains all values of INNER type. In particular, both INNER
10858 and OUTER types have zero in common. */
10859 || (oprec > iprec && TYPE_UNSIGNED (inner)))
10860 return build_int_cst (outer, 0);
10861 else
10863 /* If we are widening a signed type to another signed type, we
10864 want to obtain -2^^(iprec-1). If we are keeping the
10865 precision or narrowing to a signed type, we want to obtain
10866 -2^(oprec-1). */
10867 unsigned prec = oprec > iprec ? iprec : oprec;
10868 return wide_int_to_tree (outer,
10869 wi::mask (prec - 1, true,
10870 TYPE_PRECISION (outer)));
10874 /* Return nonzero if two operands that are suitable for PHI nodes are
10875 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10876 SSA_NAME or invariant. Note that this is strictly an optimization.
10877 That is, callers of this function can directly call operand_equal_p
10878 and get the same result, only slower. */
10881 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
10883 if (arg0 == arg1)
10884 return 1;
10885 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
10886 return 0;
10887 return operand_equal_p (arg0, arg1, 0);
10890 /* Returns number of zeros at the end of binary representation of X. */
10892 tree
10893 num_ending_zeros (const_tree x)
10895 return build_int_cst (TREE_TYPE (x), wi::ctz (x));
10899 #define WALK_SUBTREE(NODE) \
10900 do \
10902 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10903 if (result) \
10904 return result; \
10906 while (0)
10908 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10909 be walked whenever a type is seen in the tree. Rest of operands and return
10910 value are as for walk_tree. */
10912 static tree
10913 walk_type_fields (tree type, walk_tree_fn func, void *data,
10914 hash_set<tree> *pset, walk_tree_lh lh)
10916 tree result = NULL_TREE;
10918 switch (TREE_CODE (type))
10920 case POINTER_TYPE:
10921 case REFERENCE_TYPE:
10922 case VECTOR_TYPE:
10923 /* We have to worry about mutually recursive pointers. These can't
10924 be written in C. They can in Ada. It's pathological, but
10925 there's an ACATS test (c38102a) that checks it. Deal with this
10926 by checking if we're pointing to another pointer, that one
10927 points to another pointer, that one does too, and we have no htab.
10928 If so, get a hash table. We check three levels deep to avoid
10929 the cost of the hash table if we don't need one. */
10930 if (POINTER_TYPE_P (TREE_TYPE (type))
10931 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10932 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10933 && !pset)
10935 result = walk_tree_without_duplicates (&TREE_TYPE (type),
10936 func, data);
10937 if (result)
10938 return result;
10940 break;
10943 /* ... fall through ... */
10945 case COMPLEX_TYPE:
10946 WALK_SUBTREE (TREE_TYPE (type));
10947 break;
10949 case METHOD_TYPE:
10950 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10952 /* Fall through. */
10954 case FUNCTION_TYPE:
10955 WALK_SUBTREE (TREE_TYPE (type));
10957 tree arg;
10959 /* We never want to walk into default arguments. */
10960 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10961 WALK_SUBTREE (TREE_VALUE (arg));
10963 break;
10965 case ARRAY_TYPE:
10966 /* Don't follow this nodes's type if a pointer for fear that
10967 we'll have infinite recursion. If we have a PSET, then we
10968 need not fear. */
10969 if (pset
10970 || (!POINTER_TYPE_P (TREE_TYPE (type))
10971 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10972 WALK_SUBTREE (TREE_TYPE (type));
10973 WALK_SUBTREE (TYPE_DOMAIN (type));
10974 break;
10976 case OFFSET_TYPE:
10977 WALK_SUBTREE (TREE_TYPE (type));
10978 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10979 break;
10981 default:
10982 break;
10985 return NULL_TREE;
10988 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10989 called with the DATA and the address of each sub-tree. If FUNC returns a
10990 non-NULL value, the traversal is stopped, and the value returned by FUNC
10991 is returned. If PSET is non-NULL it is used to record the nodes visited,
10992 and to avoid visiting a node more than once. */
10994 tree
10995 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10996 hash_set<tree> *pset, walk_tree_lh lh)
10998 enum tree_code code;
10999 int walk_subtrees;
11000 tree result;
11002 #define WALK_SUBTREE_TAIL(NODE) \
11003 do \
11005 tp = & (NODE); \
11006 goto tail_recurse; \
11008 while (0)
11010 tail_recurse:
11011 /* Skip empty subtrees. */
11012 if (!*tp)
11013 return NULL_TREE;
11015 /* Don't walk the same tree twice, if the user has requested
11016 that we avoid doing so. */
11017 if (pset && pset->add (*tp))
11018 return NULL_TREE;
11020 /* Call the function. */
11021 walk_subtrees = 1;
11022 result = (*func) (tp, &walk_subtrees, data);
11024 /* If we found something, return it. */
11025 if (result)
11026 return result;
11028 code = TREE_CODE (*tp);
11030 /* Even if we didn't, FUNC may have decided that there was nothing
11031 interesting below this point in the tree. */
11032 if (!walk_subtrees)
11034 /* But we still need to check our siblings. */
11035 if (code == TREE_LIST)
11036 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11037 else if (code == OMP_CLAUSE)
11038 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11039 else
11040 return NULL_TREE;
11043 if (lh)
11045 result = (*lh) (tp, &walk_subtrees, func, data, pset);
11046 if (result || !walk_subtrees)
11047 return result;
11050 switch (code)
11052 case ERROR_MARK:
11053 case IDENTIFIER_NODE:
11054 case INTEGER_CST:
11055 case REAL_CST:
11056 case FIXED_CST:
11057 case VECTOR_CST:
11058 case STRING_CST:
11059 case BLOCK:
11060 case PLACEHOLDER_EXPR:
11061 case SSA_NAME:
11062 case FIELD_DECL:
11063 case RESULT_DECL:
11064 /* None of these have subtrees other than those already walked
11065 above. */
11066 break;
11068 case TREE_LIST:
11069 WALK_SUBTREE (TREE_VALUE (*tp));
11070 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11071 break;
11073 case TREE_VEC:
11075 int len = TREE_VEC_LENGTH (*tp);
11077 if (len == 0)
11078 break;
11080 /* Walk all elements but the first. */
11081 while (--len)
11082 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
11084 /* Now walk the first one as a tail call. */
11085 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
11088 case COMPLEX_CST:
11089 WALK_SUBTREE (TREE_REALPART (*tp));
11090 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
11092 case CONSTRUCTOR:
11094 unsigned HOST_WIDE_INT idx;
11095 constructor_elt *ce;
11097 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11098 idx++)
11099 WALK_SUBTREE (ce->value);
11101 break;
11103 case SAVE_EXPR:
11104 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11106 case BIND_EXPR:
11108 tree decl;
11109 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11111 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11112 into declarations that are just mentioned, rather than
11113 declared; they don't really belong to this part of the tree.
11114 And, we can see cycles: the initializer for a declaration
11115 can refer to the declaration itself. */
11116 WALK_SUBTREE (DECL_INITIAL (decl));
11117 WALK_SUBTREE (DECL_SIZE (decl));
11118 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11120 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11123 case STATEMENT_LIST:
11125 tree_stmt_iterator i;
11126 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11127 WALK_SUBTREE (*tsi_stmt_ptr (i));
11129 break;
11131 case OMP_CLAUSE:
11132 switch (OMP_CLAUSE_CODE (*tp))
11134 case OMP_CLAUSE_PRIVATE:
11135 case OMP_CLAUSE_SHARED:
11136 case OMP_CLAUSE_FIRSTPRIVATE:
11137 case OMP_CLAUSE_COPYIN:
11138 case OMP_CLAUSE_COPYPRIVATE:
11139 case OMP_CLAUSE_FINAL:
11140 case OMP_CLAUSE_IF:
11141 case OMP_CLAUSE_NUM_THREADS:
11142 case OMP_CLAUSE_SCHEDULE:
11143 case OMP_CLAUSE_UNIFORM:
11144 case OMP_CLAUSE_DEPEND:
11145 case OMP_CLAUSE_NUM_TEAMS:
11146 case OMP_CLAUSE_THREAD_LIMIT:
11147 case OMP_CLAUSE_DEVICE:
11148 case OMP_CLAUSE_DIST_SCHEDULE:
11149 case OMP_CLAUSE_SAFELEN:
11150 case OMP_CLAUSE_SIMDLEN:
11151 case OMP_CLAUSE__LOOPTEMP_:
11152 case OMP_CLAUSE__SIMDUID_:
11153 case OMP_CLAUSE__CILK_FOR_COUNT_:
11154 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11155 /* FALLTHRU */
11157 case OMP_CLAUSE_NOWAIT:
11158 case OMP_CLAUSE_ORDERED:
11159 case OMP_CLAUSE_DEFAULT:
11160 case OMP_CLAUSE_UNTIED:
11161 case OMP_CLAUSE_MERGEABLE:
11162 case OMP_CLAUSE_PROC_BIND:
11163 case OMP_CLAUSE_INBRANCH:
11164 case OMP_CLAUSE_NOTINBRANCH:
11165 case OMP_CLAUSE_FOR:
11166 case OMP_CLAUSE_PARALLEL:
11167 case OMP_CLAUSE_SECTIONS:
11168 case OMP_CLAUSE_TASKGROUP:
11169 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11171 case OMP_CLAUSE_LASTPRIVATE:
11172 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11173 WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
11174 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11176 case OMP_CLAUSE_COLLAPSE:
11178 int i;
11179 for (i = 0; i < 3; i++)
11180 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11181 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11184 case OMP_CLAUSE_LINEAR:
11185 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11186 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp));
11187 WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp));
11188 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11190 case OMP_CLAUSE_ALIGNED:
11191 case OMP_CLAUSE_FROM:
11192 case OMP_CLAUSE_TO:
11193 case OMP_CLAUSE_MAP:
11194 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11195 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11196 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11198 case OMP_CLAUSE_REDUCTION:
11200 int i;
11201 for (i = 0; i < 4; i++)
11202 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11203 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11206 default:
11207 gcc_unreachable ();
11209 break;
11211 case TARGET_EXPR:
11213 int i, len;
11215 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11216 But, we only want to walk once. */
11217 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
11218 for (i = 0; i < len; ++i)
11219 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11220 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
11223 case DECL_EXPR:
11224 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11225 defining. We only want to walk into these fields of a type in this
11226 case and not in the general case of a mere reference to the type.
11228 The criterion is as follows: if the field can be an expression, it
11229 must be walked only here. This should be in keeping with the fields
11230 that are directly gimplified in gimplify_type_sizes in order for the
11231 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11232 variable-sized types.
11234 Note that DECLs get walked as part of processing the BIND_EXPR. */
11235 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
11237 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
11238 if (TREE_CODE (*type_p) == ERROR_MARK)
11239 return NULL_TREE;
11241 /* Call the function for the type. See if it returns anything or
11242 doesn't want us to continue. If we are to continue, walk both
11243 the normal fields and those for the declaration case. */
11244 result = (*func) (type_p, &walk_subtrees, data);
11245 if (result || !walk_subtrees)
11246 return result;
11248 /* But do not walk a pointed-to type since it may itself need to
11249 be walked in the declaration case if it isn't anonymous. */
11250 if (!POINTER_TYPE_P (*type_p))
11252 result = walk_type_fields (*type_p, func, data, pset, lh);
11253 if (result)
11254 return result;
11257 /* If this is a record type, also walk the fields. */
11258 if (RECORD_OR_UNION_TYPE_P (*type_p))
11260 tree field;
11262 for (field = TYPE_FIELDS (*type_p); field;
11263 field = DECL_CHAIN (field))
11265 /* We'd like to look at the type of the field, but we can
11266 easily get infinite recursion. So assume it's pointed
11267 to elsewhere in the tree. Also, ignore things that
11268 aren't fields. */
11269 if (TREE_CODE (field) != FIELD_DECL)
11270 continue;
11272 WALK_SUBTREE (DECL_FIELD_OFFSET (field));
11273 WALK_SUBTREE (DECL_SIZE (field));
11274 WALK_SUBTREE (DECL_SIZE_UNIT (field));
11275 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
11276 WALK_SUBTREE (DECL_QUALIFIER (field));
11280 /* Same for scalar types. */
11281 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
11282 || TREE_CODE (*type_p) == ENUMERAL_TYPE
11283 || TREE_CODE (*type_p) == INTEGER_TYPE
11284 || TREE_CODE (*type_p) == FIXED_POINT_TYPE
11285 || TREE_CODE (*type_p) == REAL_TYPE)
11287 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
11288 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
11291 WALK_SUBTREE (TYPE_SIZE (*type_p));
11292 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
11294 /* FALLTHRU */
11296 default:
11297 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
11299 int i, len;
11301 /* Walk over all the sub-trees of this operand. */
11302 len = TREE_OPERAND_LENGTH (*tp);
11304 /* Go through the subtrees. We need to do this in forward order so
11305 that the scope of a FOR_EXPR is handled properly. */
11306 if (len)
11308 for (i = 0; i < len - 1; ++i)
11309 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11310 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
11313 /* If this is a type, walk the needed fields in the type. */
11314 else if (TYPE_P (*tp))
11315 return walk_type_fields (*tp, func, data, pset, lh);
11316 break;
11319 /* We didn't find what we were looking for. */
11320 return NULL_TREE;
11322 #undef WALK_SUBTREE_TAIL
11324 #undef WALK_SUBTREE
11326 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11328 tree
11329 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
11330 walk_tree_lh lh)
11332 tree result;
11334 hash_set<tree> pset;
11335 result = walk_tree_1 (tp, func, data, &pset, lh);
11336 return result;
11340 tree
11341 tree_block (tree t)
11343 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
11345 if (IS_EXPR_CODE_CLASS (c))
11346 return LOCATION_BLOCK (t->exp.locus);
11347 gcc_unreachable ();
11348 return NULL;
11351 void
11352 tree_set_block (tree t, tree b)
11354 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
11356 if (IS_EXPR_CODE_CLASS (c))
11358 if (b)
11359 t->exp.locus = COMBINE_LOCATION_DATA (line_table, t->exp.locus, b);
11360 else
11361 t->exp.locus = LOCATION_LOCUS (t->exp.locus);
11363 else
11364 gcc_unreachable ();
11367 /* Create a nameless artificial label and put it in the current
11368 function context. The label has a location of LOC. Returns the
11369 newly created label. */
11371 tree
11372 create_artificial_label (location_t loc)
11374 tree lab = build_decl (loc,
11375 LABEL_DECL, NULL_TREE, void_type_node);
11377 DECL_ARTIFICIAL (lab) = 1;
11378 DECL_IGNORED_P (lab) = 1;
11379 DECL_CONTEXT (lab) = current_function_decl;
11380 return lab;
11383 /* Given a tree, try to return a useful variable name that we can use
11384 to prefix a temporary that is being assigned the value of the tree.
11385 I.E. given <temp> = &A, return A. */
11387 const char *
11388 get_name (tree t)
11390 tree stripped_decl;
11392 stripped_decl = t;
11393 STRIP_NOPS (stripped_decl);
11394 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
11395 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
11396 else if (TREE_CODE (stripped_decl) == SSA_NAME)
11398 tree name = SSA_NAME_IDENTIFIER (stripped_decl);
11399 if (!name)
11400 return NULL;
11401 return IDENTIFIER_POINTER (name);
11403 else
11405 switch (TREE_CODE (stripped_decl))
11407 case ADDR_EXPR:
11408 return get_name (TREE_OPERAND (stripped_decl, 0));
11409 default:
11410 return NULL;
11415 /* Return true if TYPE has a variable argument list. */
11417 bool
11418 stdarg_p (const_tree fntype)
11420 function_args_iterator args_iter;
11421 tree n = NULL_TREE, t;
11423 if (!fntype)
11424 return false;
11426 FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
11428 n = t;
11431 return n != NULL_TREE && n != void_type_node;
11434 /* Return true if TYPE has a prototype. */
11436 bool
11437 prototype_p (tree fntype)
11439 tree t;
11441 gcc_assert (fntype != NULL_TREE);
11443 t = TYPE_ARG_TYPES (fntype);
11444 return (t != NULL_TREE);
11447 /* If BLOCK is inlined from an __attribute__((__artificial__))
11448 routine, return pointer to location from where it has been
11449 called. */
11450 location_t *
11451 block_nonartificial_location (tree block)
11453 location_t *ret = NULL;
11455 while (block && TREE_CODE (block) == BLOCK
11456 && BLOCK_ABSTRACT_ORIGIN (block))
11458 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
11460 while (TREE_CODE (ao) == BLOCK
11461 && BLOCK_ABSTRACT_ORIGIN (ao)
11462 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
11463 ao = BLOCK_ABSTRACT_ORIGIN (ao);
11465 if (TREE_CODE (ao) == FUNCTION_DECL)
11467 /* If AO is an artificial inline, point RET to the
11468 call site locus at which it has been inlined and continue
11469 the loop, in case AO's caller is also an artificial
11470 inline. */
11471 if (DECL_DECLARED_INLINE_P (ao)
11472 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
11473 ret = &BLOCK_SOURCE_LOCATION (block);
11474 else
11475 break;
11477 else if (TREE_CODE (ao) != BLOCK)
11478 break;
11480 block = BLOCK_SUPERCONTEXT (block);
11482 return ret;
11486 /* If EXP is inlined from an __attribute__((__artificial__))
11487 function, return the location of the original call expression. */
11489 location_t
11490 tree_nonartificial_location (tree exp)
11492 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
11494 if (loc)
11495 return *loc;
11496 else
11497 return EXPR_LOCATION (exp);
11501 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11502 nodes. */
11504 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11506 hashval_t
11507 cl_option_hasher::hash (tree x)
11509 const_tree const t = x;
11510 const char *p;
11511 size_t i;
11512 size_t len = 0;
11513 hashval_t hash = 0;
11515 if (TREE_CODE (t) == OPTIMIZATION_NODE)
11517 p = (const char *)TREE_OPTIMIZATION (t);
11518 len = sizeof (struct cl_optimization);
11521 else if (TREE_CODE (t) == TARGET_OPTION_NODE)
11522 return cl_target_option_hash (TREE_TARGET_OPTION (t));
11524 else
11525 gcc_unreachable ();
11527 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11528 something else. */
11529 for (i = 0; i < len; i++)
11530 if (p[i])
11531 hash = (hash << 4) ^ ((i << 2) | p[i]);
11533 return hash;
11536 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11537 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11538 same. */
11540 bool
11541 cl_option_hasher::equal (tree x, tree y)
11543 const_tree const xt = x;
11544 const_tree const yt = y;
11545 const char *xp;
11546 const char *yp;
11547 size_t len;
11549 if (TREE_CODE (xt) != TREE_CODE (yt))
11550 return 0;
11552 if (TREE_CODE (xt) == OPTIMIZATION_NODE)
11554 xp = (const char *)TREE_OPTIMIZATION (xt);
11555 yp = (const char *)TREE_OPTIMIZATION (yt);
11556 len = sizeof (struct cl_optimization);
11559 else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
11561 return cl_target_option_eq (TREE_TARGET_OPTION (xt),
11562 TREE_TARGET_OPTION (yt));
11565 else
11566 gcc_unreachable ();
11568 return (memcmp (xp, yp, len) == 0);
11571 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11573 tree
11574 build_optimization_node (struct gcc_options *opts)
11576 tree t;
11578 /* Use the cache of optimization nodes. */
11580 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
11581 opts);
11583 tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT);
11584 t = *slot;
11585 if (!t)
11587 /* Insert this one into the hash table. */
11588 t = cl_optimization_node;
11589 *slot = t;
11591 /* Make a new node for next time round. */
11592 cl_optimization_node = make_node (OPTIMIZATION_NODE);
11595 return t;
11598 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
11600 tree
11601 build_target_option_node (struct gcc_options *opts)
11603 tree t;
11605 /* Use the cache of optimization nodes. */
11607 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
11608 opts);
11610 tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT);
11611 t = *slot;
11612 if (!t)
11614 /* Insert this one into the hash table. */
11615 t = cl_target_option_node;
11616 *slot = t;
11618 /* Make a new node for next time round. */
11619 cl_target_option_node = make_node (TARGET_OPTION_NODE);
11622 return t;
11625 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
11626 so that they aren't saved during PCH writing. */
11628 void
11629 prepare_target_option_nodes_for_pch (void)
11631 hash_table<cl_option_hasher>::iterator iter = cl_option_hash_table->begin ();
11632 for (; iter != cl_option_hash_table->end (); ++iter)
11633 if (TREE_CODE (*iter) == TARGET_OPTION_NODE)
11634 TREE_TARGET_GLOBALS (*iter) = NULL;
11637 /* Determine the "ultimate origin" of a block. The block may be an inlined
11638 instance of an inlined instance of a block which is local to an inline
11639 function, so we have to trace all of the way back through the origin chain
11640 to find out what sort of node actually served as the original seed for the
11641 given block. */
11643 tree
11644 block_ultimate_origin (const_tree block)
11646 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
11648 /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
11649 we're trying to output the abstract instance of this function. */
11650 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
11651 return NULL_TREE;
11653 if (immediate_origin == NULL_TREE)
11654 return NULL_TREE;
11655 else
11657 tree ret_val;
11658 tree lookahead = immediate_origin;
11662 ret_val = lookahead;
11663 lookahead = (TREE_CODE (ret_val) == BLOCK
11664 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
11666 while (lookahead != NULL && lookahead != ret_val);
11668 /* The block's abstract origin chain may not be the *ultimate* origin of
11669 the block. It could lead to a DECL that has an abstract origin set.
11670 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11671 will give us if it has one). Note that DECL's abstract origins are
11672 supposed to be the most distant ancestor (or so decl_ultimate_origin
11673 claims), so we don't need to loop following the DECL origins. */
11674 if (DECL_P (ret_val))
11675 return DECL_ORIGIN (ret_val);
11677 return ret_val;
11681 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
11682 no instruction. */
11684 bool
11685 tree_nop_conversion_p (const_tree outer_type, const_tree inner_type)
11687 /* Use precision rather then machine mode when we can, which gives
11688 the correct answer even for submode (bit-field) types. */
11689 if ((INTEGRAL_TYPE_P (outer_type)
11690 || POINTER_TYPE_P (outer_type)
11691 || TREE_CODE (outer_type) == OFFSET_TYPE)
11692 && (INTEGRAL_TYPE_P (inner_type)
11693 || POINTER_TYPE_P (inner_type)
11694 || TREE_CODE (inner_type) == OFFSET_TYPE))
11695 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
11697 /* Otherwise fall back on comparing machine modes (e.g. for
11698 aggregate types, floats). */
11699 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
11702 /* Return true iff conversion in EXP generates no instruction. Mark
11703 it inline so that we fully inline into the stripping functions even
11704 though we have two uses of this function. */
11706 static inline bool
11707 tree_nop_conversion (const_tree exp)
11709 tree outer_type, inner_type;
11711 if (!CONVERT_EXPR_P (exp)
11712 && TREE_CODE (exp) != NON_LVALUE_EXPR)
11713 return false;
11714 if (TREE_OPERAND (exp, 0) == error_mark_node)
11715 return false;
11717 outer_type = TREE_TYPE (exp);
11718 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
11720 if (!inner_type)
11721 return false;
11723 return tree_nop_conversion_p (outer_type, inner_type);
11726 /* Return true iff conversion in EXP generates no instruction. Don't
11727 consider conversions changing the signedness. */
11729 static bool
11730 tree_sign_nop_conversion (const_tree exp)
11732 tree outer_type, inner_type;
11734 if (!tree_nop_conversion (exp))
11735 return false;
11737 outer_type = TREE_TYPE (exp);
11738 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
11740 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
11741 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
11744 /* Strip conversions from EXP according to tree_nop_conversion and
11745 return the resulting expression. */
11747 tree
11748 tree_strip_nop_conversions (tree exp)
11750 while (tree_nop_conversion (exp))
11751 exp = TREE_OPERAND (exp, 0);
11752 return exp;
11755 /* Strip conversions from EXP according to tree_sign_nop_conversion
11756 and return the resulting expression. */
11758 tree
11759 tree_strip_sign_nop_conversions (tree exp)
11761 while (tree_sign_nop_conversion (exp))
11762 exp = TREE_OPERAND (exp, 0);
11763 return exp;
11766 /* Avoid any floating point extensions from EXP. */
11767 tree
11768 strip_float_extensions (tree exp)
11770 tree sub, expt, subt;
11772 /* For floating point constant look up the narrowest type that can hold
11773 it properly and handle it like (type)(narrowest_type)constant.
11774 This way we can optimize for instance a=a*2.0 where "a" is float
11775 but 2.0 is double constant. */
11776 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
11778 REAL_VALUE_TYPE orig;
11779 tree type = NULL;
11781 orig = TREE_REAL_CST (exp);
11782 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
11783 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
11784 type = float_type_node;
11785 else if (TYPE_PRECISION (TREE_TYPE (exp))
11786 > TYPE_PRECISION (double_type_node)
11787 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
11788 type = double_type_node;
11789 if (type)
11790 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
11793 if (!CONVERT_EXPR_P (exp))
11794 return exp;
11796 sub = TREE_OPERAND (exp, 0);
11797 subt = TREE_TYPE (sub);
11798 expt = TREE_TYPE (exp);
11800 if (!FLOAT_TYPE_P (subt))
11801 return exp;
11803 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
11804 return exp;
11806 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
11807 return exp;
11809 return strip_float_extensions (sub);
11812 /* Strip out all handled components that produce invariant
11813 offsets. */
11815 const_tree
11816 strip_invariant_refs (const_tree op)
11818 while (handled_component_p (op))
11820 switch (TREE_CODE (op))
11822 case ARRAY_REF:
11823 case ARRAY_RANGE_REF:
11824 if (!is_gimple_constant (TREE_OPERAND (op, 1))
11825 || TREE_OPERAND (op, 2) != NULL_TREE
11826 || TREE_OPERAND (op, 3) != NULL_TREE)
11827 return NULL;
11828 break;
11830 case COMPONENT_REF:
11831 if (TREE_OPERAND (op, 2) != NULL_TREE)
11832 return NULL;
11833 break;
11835 default:;
11837 op = TREE_OPERAND (op, 0);
11840 return op;
11843 static GTY(()) tree gcc_eh_personality_decl;
11845 /* Return the GCC personality function decl. */
11847 tree
11848 lhd_gcc_personality (void)
11850 if (!gcc_eh_personality_decl)
11851 gcc_eh_personality_decl = build_personality_function ("gcc");
11852 return gcc_eh_personality_decl;
11855 /* TARGET is a call target of GIMPLE call statement
11856 (obtained by gimple_call_fn). Return true if it is
11857 OBJ_TYPE_REF representing an virtual call of C++ method.
11858 (As opposed to OBJ_TYPE_REF representing objc calls
11859 through a cast where middle-end devirtualization machinery
11860 can't apply.) */
11862 bool
11863 virtual_method_call_p (tree target)
11865 if (TREE_CODE (target) != OBJ_TYPE_REF)
11866 return false;
11867 target = TREE_TYPE (target);
11868 gcc_checking_assert (TREE_CODE (target) == POINTER_TYPE);
11869 target = TREE_TYPE (target);
11870 if (TREE_CODE (target) == FUNCTION_TYPE)
11871 return false;
11872 gcc_checking_assert (TREE_CODE (target) == METHOD_TYPE);
11873 return true;
11876 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
11878 tree
11879 obj_type_ref_class (tree ref)
11881 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
11882 ref = TREE_TYPE (ref);
11883 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
11884 ref = TREE_TYPE (ref);
11885 /* We look for type THIS points to. ObjC also builds
11886 OBJ_TYPE_REF with non-method calls, Their first parameter
11887 ID however also corresponds to class type. */
11888 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
11889 || TREE_CODE (ref) == FUNCTION_TYPE);
11890 ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
11891 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
11892 return TREE_TYPE (ref);
11895 /* Return true if T is in anonymous namespace. */
11897 bool
11898 type_in_anonymous_namespace_p (const_tree t)
11900 /* TREE_PUBLIC of TYPE_STUB_DECL may not be properly set for
11901 bulitin types; those have CONTEXT NULL. */
11902 if (!TYPE_CONTEXT (t))
11903 return false;
11904 return (TYPE_STUB_DECL (t) && !TREE_PUBLIC (TYPE_STUB_DECL (t)));
11907 /* Try to find a base info of BINFO that would have its field decl at offset
11908 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11909 found, return, otherwise return NULL_TREE. */
11911 tree
11912 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
11914 tree type = BINFO_TYPE (binfo);
11916 while (true)
11918 HOST_WIDE_INT pos, size;
11919 tree fld;
11920 int i;
11922 if (types_same_for_odr (type, expected_type))
11923 return binfo;
11924 if (offset < 0)
11925 return NULL_TREE;
11927 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
11929 if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld))
11930 continue;
11932 pos = int_bit_position (fld);
11933 size = tree_to_uhwi (DECL_SIZE (fld));
11934 if (pos <= offset && (pos + size) > offset)
11935 break;
11937 if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
11938 return NULL_TREE;
11940 /* Offset 0 indicates the primary base, whose vtable contents are
11941 represented in the binfo for the derived class. */
11942 else if (offset != 0)
11944 tree base_binfo, binfo2 = binfo;
11946 /* Find BINFO corresponding to FLD. This is bit harder
11947 by a fact that in virtual inheritance we may need to walk down
11948 the non-virtual inheritance chain. */
11949 while (true)
11951 tree containing_binfo = NULL, found_binfo = NULL;
11952 for (i = 0; BINFO_BASE_ITERATE (binfo2, i, base_binfo); i++)
11953 if (types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
11955 found_binfo = base_binfo;
11956 break;
11958 else
11959 if ((tree_to_shwi (BINFO_OFFSET (base_binfo))
11960 - tree_to_shwi (BINFO_OFFSET (binfo)))
11961 * BITS_PER_UNIT < pos
11962 /* Rule out types with no virtual methods or we can get confused
11963 here by zero sized bases. */
11964 && TYPE_BINFO (BINFO_TYPE (base_binfo))
11965 && BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (base_binfo)))
11966 && (!containing_binfo
11967 || (tree_to_shwi (BINFO_OFFSET (containing_binfo))
11968 < tree_to_shwi (BINFO_OFFSET (base_binfo)))))
11969 containing_binfo = base_binfo;
11970 if (found_binfo)
11972 binfo = found_binfo;
11973 break;
11975 if (!containing_binfo)
11976 return NULL_TREE;
11977 binfo2 = containing_binfo;
11981 type = TREE_TYPE (fld);
11982 offset -= pos;
11986 /* Returns true if X is a typedef decl. */
11988 bool
11989 is_typedef_decl (tree x)
11991 return (x && TREE_CODE (x) == TYPE_DECL
11992 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
11995 /* Returns true iff TYPE is a type variant created for a typedef. */
11997 bool
11998 typedef_variant_p (tree type)
12000 return is_typedef_decl (TYPE_NAME (type));
12003 /* Warn about a use of an identifier which was marked deprecated. */
12004 void
12005 warn_deprecated_use (tree node, tree attr)
12007 const char *msg;
12009 if (node == 0 || !warn_deprecated_decl)
12010 return;
12012 if (!attr)
12014 if (DECL_P (node))
12015 attr = DECL_ATTRIBUTES (node);
12016 else if (TYPE_P (node))
12018 tree decl = TYPE_STUB_DECL (node);
12019 if (decl)
12020 attr = lookup_attribute ("deprecated",
12021 TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12025 if (attr)
12026 attr = lookup_attribute ("deprecated", attr);
12028 if (attr)
12029 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12030 else
12031 msg = NULL;
12033 bool w;
12034 if (DECL_P (node))
12036 if (msg)
12037 w = warning (OPT_Wdeprecated_declarations,
12038 "%qD is deprecated: %s", node, msg);
12039 else
12040 w = warning (OPT_Wdeprecated_declarations,
12041 "%qD is deprecated", node);
12042 if (w)
12043 inform (DECL_SOURCE_LOCATION (node), "declared here");
12045 else if (TYPE_P (node))
12047 tree what = NULL_TREE;
12048 tree decl = TYPE_STUB_DECL (node);
12050 if (TYPE_NAME (node))
12052 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12053 what = TYPE_NAME (node);
12054 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12055 && DECL_NAME (TYPE_NAME (node)))
12056 what = DECL_NAME (TYPE_NAME (node));
12059 if (decl)
12061 if (what)
12063 if (msg)
12064 w = warning (OPT_Wdeprecated_declarations,
12065 "%qE is deprecated: %s", what, msg);
12066 else
12067 w = warning (OPT_Wdeprecated_declarations,
12068 "%qE is deprecated", what);
12070 else
12072 if (msg)
12073 w = warning (OPT_Wdeprecated_declarations,
12074 "type is deprecated: %s", msg);
12075 else
12076 w = warning (OPT_Wdeprecated_declarations,
12077 "type is deprecated");
12079 if (w)
12080 inform (DECL_SOURCE_LOCATION (decl), "declared here");
12082 else
12084 if (what)
12086 if (msg)
12087 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12088 what, msg);
12089 else
12090 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12092 else
12094 if (msg)
12095 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12096 msg);
12097 else
12098 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12104 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12105 somewhere in it. */
12107 bool
12108 contains_bitfld_component_ref_p (const_tree ref)
12110 while (handled_component_p (ref))
12112 if (TREE_CODE (ref) == COMPONENT_REF
12113 && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12114 return true;
12115 ref = TREE_OPERAND (ref, 0);
12118 return false;
12121 /* Try to determine whether a TRY_CATCH expression can fall through.
12122 This is a subroutine of block_may_fallthru. */
12124 static bool
12125 try_catch_may_fallthru (const_tree stmt)
12127 tree_stmt_iterator i;
12129 /* If the TRY block can fall through, the whole TRY_CATCH can
12130 fall through. */
12131 if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12132 return true;
12134 i = tsi_start (TREE_OPERAND (stmt, 1));
12135 switch (TREE_CODE (tsi_stmt (i)))
12137 case CATCH_EXPR:
12138 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12139 catch expression and a body. The whole TRY_CATCH may fall
12140 through iff any of the catch bodies falls through. */
12141 for (; !tsi_end_p (i); tsi_next (&i))
12143 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12144 return true;
12146 return false;
12148 case EH_FILTER_EXPR:
12149 /* The exception filter expression only matters if there is an
12150 exception. If the exception does not match EH_FILTER_TYPES,
12151 we will execute EH_FILTER_FAILURE, and we will fall through
12152 if that falls through. If the exception does match
12153 EH_FILTER_TYPES, the stack unwinder will continue up the
12154 stack, so we will not fall through. We don't know whether we
12155 will throw an exception which matches EH_FILTER_TYPES or not,
12156 so we just ignore EH_FILTER_TYPES and assume that we might
12157 throw an exception which doesn't match. */
12158 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
12160 default:
12161 /* This case represents statements to be executed when an
12162 exception occurs. Those statements are implicitly followed
12163 by a RESX statement to resume execution after the exception.
12164 So in this case the TRY_CATCH never falls through. */
12165 return false;
12169 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12170 need not be 100% accurate; simply be conservative and return true if we
12171 don't know. This is used only to avoid stupidly generating extra code.
12172 If we're wrong, we'll just delete the extra code later. */
12174 bool
12175 block_may_fallthru (const_tree block)
12177 /* This CONST_CAST is okay because expr_last returns its argument
12178 unmodified and we assign it to a const_tree. */
12179 const_tree stmt = expr_last (CONST_CAST_TREE (block));
12181 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
12183 case GOTO_EXPR:
12184 case RETURN_EXPR:
12185 /* Easy cases. If the last statement of the block implies
12186 control transfer, then we can't fall through. */
12187 return false;
12189 case SWITCH_EXPR:
12190 /* If SWITCH_LABELS is set, this is lowered, and represents a
12191 branch to a selected label and hence can not fall through.
12192 Otherwise SWITCH_BODY is set, and the switch can fall
12193 through. */
12194 return SWITCH_LABELS (stmt) == NULL_TREE;
12196 case COND_EXPR:
12197 if (block_may_fallthru (COND_EXPR_THEN (stmt)))
12198 return true;
12199 return block_may_fallthru (COND_EXPR_ELSE (stmt));
12201 case BIND_EXPR:
12202 return block_may_fallthru (BIND_EXPR_BODY (stmt));
12204 case TRY_CATCH_EXPR:
12205 return try_catch_may_fallthru (stmt);
12207 case TRY_FINALLY_EXPR:
12208 /* The finally clause is always executed after the try clause,
12209 so if it does not fall through, then the try-finally will not
12210 fall through. Otherwise, if the try clause does not fall
12211 through, then when the finally clause falls through it will
12212 resume execution wherever the try clause was going. So the
12213 whole try-finally will only fall through if both the try
12214 clause and the finally clause fall through. */
12215 return (block_may_fallthru (TREE_OPERAND (stmt, 0))
12216 && block_may_fallthru (TREE_OPERAND (stmt, 1)));
12218 case MODIFY_EXPR:
12219 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
12220 stmt = TREE_OPERAND (stmt, 1);
12221 else
12222 return true;
12223 /* FALLTHRU */
12225 case CALL_EXPR:
12226 /* Functions that do not return do not fall through. */
12227 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
12229 case CLEANUP_POINT_EXPR:
12230 return block_may_fallthru (TREE_OPERAND (stmt, 0));
12232 case TARGET_EXPR:
12233 return block_may_fallthru (TREE_OPERAND (stmt, 1));
12235 case ERROR_MARK:
12236 return true;
12238 default:
12239 return lang_hooks.block_may_fallthru (stmt);
12243 /* True if we are using EH to handle cleanups. */
12244 static bool using_eh_for_cleanups_flag = false;
12246 /* This routine is called from front ends to indicate eh should be used for
12247 cleanups. */
12248 void
12249 using_eh_for_cleanups (void)
12251 using_eh_for_cleanups_flag = true;
12254 /* Query whether EH is used for cleanups. */
12255 bool
12256 using_eh_for_cleanups_p (void)
12258 return using_eh_for_cleanups_flag;
12261 /* Wrapper for tree_code_name to ensure that tree code is valid */
12262 const char *
12263 get_tree_code_name (enum tree_code code)
12265 const char *invalid = "<invalid tree code>";
12267 if (code >= MAX_TREE_CODES)
12268 return invalid;
12270 return tree_code_name[code];
12273 /* Drops the TREE_OVERFLOW flag from T. */
12275 tree
12276 drop_tree_overflow (tree t)
12278 gcc_checking_assert (TREE_OVERFLOW (t));
12280 /* For tree codes with a sharing machinery re-build the result. */
12281 if (TREE_CODE (t) == INTEGER_CST)
12282 return wide_int_to_tree (TREE_TYPE (t), t);
12284 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12285 and drop the flag. */
12286 t = copy_node (t);
12287 TREE_OVERFLOW (t) = 0;
12288 return t;
12291 /* Given a memory reference expression T, return its base address.
12292 The base address of a memory reference expression is the main
12293 object being referenced. For instance, the base address for
12294 'array[i].fld[j]' is 'array'. You can think of this as stripping
12295 away the offset part from a memory address.
12297 This function calls handled_component_p to strip away all the inner
12298 parts of the memory reference until it reaches the base object. */
12300 tree
12301 get_base_address (tree t)
12303 while (handled_component_p (t))
12304 t = TREE_OPERAND (t, 0);
12306 if ((TREE_CODE (t) == MEM_REF
12307 || TREE_CODE (t) == TARGET_MEM_REF)
12308 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
12309 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
12311 /* ??? Either the alias oracle or all callers need to properly deal
12312 with WITH_SIZE_EXPRs before we can look through those. */
12313 if (TREE_CODE (t) == WITH_SIZE_EXPR)
12314 return NULL_TREE;
12316 return t;
12319 /* Return the machine mode of T. For vectors, returns the mode of the
12320 inner type. The main use case is to feed the result to HONOR_NANS,
12321 avoiding the BLKmode that a direct TYPE_MODE (T) might return. */
12323 machine_mode
12324 element_mode (const_tree t)
12326 if (!TYPE_P (t))
12327 t = TREE_TYPE (t);
12328 if (VECTOR_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)
12329 t = TREE_TYPE (t);
12330 return TYPE_MODE (t);
12333 #include "gt-tree.h"