svn merge -r 216846:217483 svn+ssh://gcc.gnu.org/svn/gcc/trunk
[official-gcc.git] / gcc / tree.c
blob29301cbe1547564cfe0c8466cf299c03c78d95ea
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(()) 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 /* Now here is the hash table. When recording a type, it is added to
197 the slot whose index is the hash code. Note that the hash table is
198 used for several kinds of types (function types, array types and
199 array index range types, for now). While all these live in the
200 same table, they are completely independent, and the hash code is
201 computed differently for each of these. */
203 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
204 htab_t type_hash_table;
206 /* Hash table and temporary node for larger integer const values. */
207 static GTY (()) tree int_cst_node;
208 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
209 htab_t int_cst_hash_table;
211 /* Hash table for optimization flags and target option flags. Use the same
212 hash table for both sets of options. Nodes for building the current
213 optimization and target option nodes. The assumption is most of the time
214 the options created will already be in the hash table, so we avoid
215 allocating and freeing up a node repeatably. */
216 static GTY (()) tree cl_optimization_node;
217 static GTY (()) tree cl_target_option_node;
218 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
219 htab_t cl_option_hash_table;
221 /* General tree->tree mapping structure for use in hash tables. */
224 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
225 htab_t debug_expr_for_decl;
227 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
228 htab_t value_expr_for_decl;
230 static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map)))
231 htab_t debug_args_for_decl;
233 static void set_type_quals (tree, int);
234 static int type_hash_eq (const void *, const void *);
235 static hashval_t type_hash_hash (const void *);
236 static hashval_t int_cst_hash_hash (const void *);
237 static int int_cst_hash_eq (const void *, const void *);
238 static hashval_t cl_option_hash_hash (const void *);
239 static int cl_option_hash_eq (const void *, const void *);
240 static void print_type_hash_statistics (void);
241 static void print_debug_expr_statistics (void);
242 static void print_value_expr_statistics (void);
243 static int type_hash_marked_p (const void *);
244 static void type_hash_list (const_tree, inchash::hash &);
245 static void attribute_hash_list (const_tree, inchash::hash &);
247 tree global_trees[TI_MAX];
248 tree integer_types[itk_none];
250 bool int_n_enabled_p[NUM_INT_N_ENTS];
251 struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS];
253 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
255 /* Number of operands for each OpenMP clause. */
256 unsigned const char omp_clause_num_ops[] =
258 0, /* OMP_CLAUSE_ERROR */
259 1, /* OMP_CLAUSE_PRIVATE */
260 1, /* OMP_CLAUSE_SHARED */
261 1, /* OMP_CLAUSE_FIRSTPRIVATE */
262 2, /* OMP_CLAUSE_LASTPRIVATE */
263 4, /* OMP_CLAUSE_REDUCTION */
264 1, /* OMP_CLAUSE_COPYIN */
265 1, /* OMP_CLAUSE_COPYPRIVATE */
266 3, /* OMP_CLAUSE_LINEAR */
267 2, /* OMP_CLAUSE_ALIGNED */
268 1, /* OMP_CLAUSE_DEPEND */
269 1, /* OMP_CLAUSE_UNIFORM */
270 2, /* OMP_CLAUSE_FROM */
271 2, /* OMP_CLAUSE_TO */
272 2, /* OMP_CLAUSE_MAP */
273 2, /* OMP_CLAUSE__CACHE_ */
274 1, /* OMP_CLAUSE_DEVICE_RESIDENT */
275 1, /* OMP_CLAUSE_USE_DEVICE */
276 1, /* OMP_CLAUSE_GANG */
277 1, /* OMP_CLAUSE_ASYNC */
278 1, /* OMP_CLAUSE_WAIT */
279 1, /* OMP_CLAUSE__LOOPTEMP_ */
280 1, /* OMP_CLAUSE_IF */
281 1, /* OMP_CLAUSE_NUM_THREADS */
282 1, /* OMP_CLAUSE_SCHEDULE */
283 0, /* OMP_CLAUSE_NOWAIT */
284 0, /* OMP_CLAUSE_ORDERED */
285 0, /* OMP_CLAUSE_DEFAULT */
286 3, /* OMP_CLAUSE_COLLAPSE */
287 0, /* OMP_CLAUSE_UNTIED */
288 1, /* OMP_CLAUSE_FINAL */
289 0, /* OMP_CLAUSE_MERGEABLE */
290 1, /* OMP_CLAUSE_DEVICE */
291 1, /* OMP_CLAUSE_DIST_SCHEDULE */
292 0, /* OMP_CLAUSE_INBRANCH */
293 0, /* OMP_CLAUSE_NOTINBRANCH */
294 1, /* OMP_CLAUSE_NUM_TEAMS */
295 1, /* OMP_CLAUSE_THREAD_LIMIT */
296 0, /* OMP_CLAUSE_PROC_BIND */
297 1, /* OMP_CLAUSE_SAFELEN */
298 1, /* OMP_CLAUSE_SIMDLEN */
299 0, /* OMP_CLAUSE_FOR */
300 0, /* OMP_CLAUSE_PARALLEL */
301 0, /* OMP_CLAUSE_SECTIONS */
302 0, /* OMP_CLAUSE_TASKGROUP */
303 1, /* OMP_CLAUSE__SIMDUID_ */
304 1, /* OMP_CLAUSE__CILK_FOR_COUNT_ */
305 0, /* OMP_CLAUSE_INDEPENDENT */
306 1, /* OMP_CLAUSE_WORKER */
307 1, /* OMP_CLAUSE_VECTOR */
308 1, /* OMP_CLAUSE_NUM_GANGS */
309 1, /* OMP_CLAUSE_NUM_WORKERS */
310 1, /* OMP_CLAUSE_VECTOR_LENGTH */
313 const char * const omp_clause_code_name[] =
315 "error_clause",
316 "private",
317 "shared",
318 "firstprivate",
319 "lastprivate",
320 "reduction",
321 "copyin",
322 "copyprivate",
323 "linear",
324 "aligned",
325 "depend",
326 "uniform",
327 "from",
328 "to",
329 "map",
330 "_cache_",
331 "device_resident",
332 "use_device",
333 "gang",
334 "async",
335 "wait",
336 "_looptemp_",
337 "if",
338 "num_threads",
339 "schedule",
340 "nowait",
341 "ordered",
342 "default",
343 "collapse",
344 "untied",
345 "final",
346 "mergeable",
347 "device",
348 "dist_schedule",
349 "inbranch",
350 "notinbranch",
351 "num_teams",
352 "thread_limit",
353 "proc_bind",
354 "safelen",
355 "simdlen",
356 "for",
357 "parallel",
358 "sections",
359 "taskgroup",
360 "_simduid_",
361 "_Cilk_for_count_",
362 "independent",
363 "worker",
364 "vector",
365 "num_gangs",
366 "num_workers",
367 "vector_length"
371 /* Return the tree node structure used by tree code CODE. */
373 static inline enum tree_node_structure_enum
374 tree_node_structure_for_code (enum tree_code code)
376 switch (TREE_CODE_CLASS (code))
378 case tcc_declaration:
380 switch (code)
382 case FIELD_DECL:
383 return TS_FIELD_DECL;
384 case PARM_DECL:
385 return TS_PARM_DECL;
386 case VAR_DECL:
387 return TS_VAR_DECL;
388 case LABEL_DECL:
389 return TS_LABEL_DECL;
390 case RESULT_DECL:
391 return TS_RESULT_DECL;
392 case DEBUG_EXPR_DECL:
393 return TS_DECL_WRTL;
394 case CONST_DECL:
395 return TS_CONST_DECL;
396 case TYPE_DECL:
397 return TS_TYPE_DECL;
398 case FUNCTION_DECL:
399 return TS_FUNCTION_DECL;
400 case TRANSLATION_UNIT_DECL:
401 return TS_TRANSLATION_UNIT_DECL;
402 default:
403 return TS_DECL_NON_COMMON;
406 case tcc_type:
407 return TS_TYPE_NON_COMMON;
408 case tcc_reference:
409 case tcc_comparison:
410 case tcc_unary:
411 case tcc_binary:
412 case tcc_expression:
413 case tcc_statement:
414 case tcc_vl_exp:
415 return TS_EXP;
416 default: /* tcc_constant and tcc_exceptional */
417 break;
419 switch (code)
421 /* tcc_constant cases. */
422 case VOID_CST: return TS_TYPED;
423 case INTEGER_CST: return TS_INT_CST;
424 case REAL_CST: return TS_REAL_CST;
425 case FIXED_CST: return TS_FIXED_CST;
426 case COMPLEX_CST: return TS_COMPLEX;
427 case VECTOR_CST: return TS_VECTOR;
428 case STRING_CST: return TS_STRING;
429 /* tcc_exceptional cases. */
430 case ERROR_MARK: return TS_COMMON;
431 case IDENTIFIER_NODE: return TS_IDENTIFIER;
432 case TREE_LIST: return TS_LIST;
433 case TREE_VEC: return TS_VEC;
434 case SSA_NAME: return TS_SSA_NAME;
435 case PLACEHOLDER_EXPR: return TS_COMMON;
436 case STATEMENT_LIST: return TS_STATEMENT_LIST;
437 case BLOCK: return TS_BLOCK;
438 case CONSTRUCTOR: return TS_CONSTRUCTOR;
439 case TREE_BINFO: return TS_BINFO;
440 case OMP_CLAUSE: return TS_OMP_CLAUSE;
441 case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
442 case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
444 default:
445 gcc_unreachable ();
450 /* Initialize tree_contains_struct to describe the hierarchy of tree
451 nodes. */
453 static void
454 initialize_tree_contains_struct (void)
456 unsigned i;
458 for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
460 enum tree_code code;
461 enum tree_node_structure_enum ts_code;
463 code = (enum tree_code) i;
464 ts_code = tree_node_structure_for_code (code);
466 /* Mark the TS structure itself. */
467 tree_contains_struct[code][ts_code] = 1;
469 /* Mark all the structures that TS is derived from. */
470 switch (ts_code)
472 case TS_TYPED:
473 case TS_BLOCK:
474 MARK_TS_BASE (code);
475 break;
477 case TS_COMMON:
478 case TS_INT_CST:
479 case TS_REAL_CST:
480 case TS_FIXED_CST:
481 case TS_VECTOR:
482 case TS_STRING:
483 case TS_COMPLEX:
484 case TS_SSA_NAME:
485 case TS_CONSTRUCTOR:
486 case TS_EXP:
487 case TS_STATEMENT_LIST:
488 MARK_TS_TYPED (code);
489 break;
491 case TS_IDENTIFIER:
492 case TS_DECL_MINIMAL:
493 case TS_TYPE_COMMON:
494 case TS_LIST:
495 case TS_VEC:
496 case TS_BINFO:
497 case TS_OMP_CLAUSE:
498 case TS_OPTIMIZATION:
499 case TS_TARGET_OPTION:
500 MARK_TS_COMMON (code);
501 break;
503 case TS_TYPE_WITH_LANG_SPECIFIC:
504 MARK_TS_TYPE_COMMON (code);
505 break;
507 case TS_TYPE_NON_COMMON:
508 MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
509 break;
511 case TS_DECL_COMMON:
512 MARK_TS_DECL_MINIMAL (code);
513 break;
515 case TS_DECL_WRTL:
516 case TS_CONST_DECL:
517 MARK_TS_DECL_COMMON (code);
518 break;
520 case TS_DECL_NON_COMMON:
521 MARK_TS_DECL_WITH_VIS (code);
522 break;
524 case TS_DECL_WITH_VIS:
525 case TS_PARM_DECL:
526 case TS_LABEL_DECL:
527 case TS_RESULT_DECL:
528 MARK_TS_DECL_WRTL (code);
529 break;
531 case TS_FIELD_DECL:
532 MARK_TS_DECL_COMMON (code);
533 break;
535 case TS_VAR_DECL:
536 MARK_TS_DECL_WITH_VIS (code);
537 break;
539 case TS_TYPE_DECL:
540 case TS_FUNCTION_DECL:
541 MARK_TS_DECL_NON_COMMON (code);
542 break;
544 case TS_TRANSLATION_UNIT_DECL:
545 MARK_TS_DECL_COMMON (code);
546 break;
548 default:
549 gcc_unreachable ();
553 /* Basic consistency checks for attributes used in fold. */
554 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
555 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
556 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
557 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
558 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
559 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
560 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
561 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
562 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
563 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
564 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
565 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
566 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
567 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
568 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
569 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
570 gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
571 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
572 gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
573 gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
574 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
575 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
576 gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
577 gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
578 gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
579 gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
580 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
581 gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
582 gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
583 gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
584 gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
585 gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
586 gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
587 gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
588 gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
589 gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
590 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
591 gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
592 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
593 gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
597 /* Init tree.c. */
599 void
600 init_ttree (void)
602 /* Initialize the hash table of types. */
603 type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
604 type_hash_eq, 0);
606 debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
607 tree_decl_map_eq, 0);
609 value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
610 tree_decl_map_eq, 0);
612 int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
613 int_cst_hash_eq, NULL);
615 int_cst_node = make_int_cst (1, 1);
617 cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
618 cl_option_hash_eq, NULL);
620 cl_optimization_node = make_node (OPTIMIZATION_NODE);
621 cl_target_option_node = make_node (TARGET_OPTION_NODE);
623 /* Initialize the tree_contains_struct array. */
624 initialize_tree_contains_struct ();
625 lang_hooks.init_ts ();
629 /* The name of the object as the assembler will see it (but before any
630 translations made by ASM_OUTPUT_LABELREF). Often this is the same
631 as DECL_NAME. It is an IDENTIFIER_NODE. */
632 tree
633 decl_assembler_name (tree decl)
635 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
636 lang_hooks.set_decl_assembler_name (decl);
637 return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
640 /* When the target supports COMDAT groups, this indicates which group the
641 DECL is associated with. This can be either an IDENTIFIER_NODE or a
642 decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */
643 tree
644 decl_comdat_group (const_tree node)
646 struct symtab_node *snode = symtab_node::get (node);
647 if (!snode)
648 return NULL;
649 return snode->get_comdat_group ();
652 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */
653 tree
654 decl_comdat_group_id (const_tree node)
656 struct symtab_node *snode = symtab_node::get (node);
657 if (!snode)
658 return NULL;
659 return snode->get_comdat_group_id ();
662 /* When the target supports named section, return its name as IDENTIFIER_NODE
663 or NULL if it is in no section. */
664 const char *
665 decl_section_name (const_tree node)
667 struct symtab_node *snode = symtab_node::get (node);
668 if (!snode)
669 return NULL;
670 return snode->get_section ();
673 /* Set section section name of NODE to VALUE (that is expected to
674 be identifier node) */
675 void
676 set_decl_section_name (tree node, const char *value)
678 struct symtab_node *snode;
680 if (value == NULL)
682 snode = symtab_node::get (node);
683 if (!snode)
684 return;
686 else if (TREE_CODE (node) == VAR_DECL)
687 snode = varpool_node::get_create (node);
688 else
689 snode = cgraph_node::get_create (node);
690 snode->set_section (value);
693 /* Return TLS model of a variable NODE. */
694 enum tls_model
695 decl_tls_model (const_tree node)
697 struct varpool_node *snode = varpool_node::get (node);
698 if (!snode)
699 return TLS_MODEL_NONE;
700 return snode->tls_model;
703 /* Set TLS model of variable NODE to MODEL. */
704 void
705 set_decl_tls_model (tree node, enum tls_model model)
707 struct varpool_node *vnode;
709 if (model == TLS_MODEL_NONE)
711 vnode = varpool_node::get (node);
712 if (!vnode)
713 return;
715 else
716 vnode = varpool_node::get_create (node);
717 vnode->tls_model = model;
720 /* Compute the number of bytes occupied by a tree with code CODE.
721 This function cannot be used for nodes that have variable sizes,
722 including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */
723 size_t
724 tree_code_size (enum tree_code code)
726 switch (TREE_CODE_CLASS (code))
728 case tcc_declaration: /* A decl node */
730 switch (code)
732 case FIELD_DECL:
733 return sizeof (struct tree_field_decl);
734 case PARM_DECL:
735 return sizeof (struct tree_parm_decl);
736 case VAR_DECL:
737 return sizeof (struct tree_var_decl);
738 case LABEL_DECL:
739 return sizeof (struct tree_label_decl);
740 case RESULT_DECL:
741 return sizeof (struct tree_result_decl);
742 case CONST_DECL:
743 return sizeof (struct tree_const_decl);
744 case TYPE_DECL:
745 return sizeof (struct tree_type_decl);
746 case FUNCTION_DECL:
747 return sizeof (struct tree_function_decl);
748 case DEBUG_EXPR_DECL:
749 return sizeof (struct tree_decl_with_rtl);
750 case TRANSLATION_UNIT_DECL:
751 return sizeof (struct tree_translation_unit_decl);
752 case NAMESPACE_DECL:
753 case IMPORTED_DECL:
754 case NAMELIST_DECL:
755 return sizeof (struct tree_decl_non_common);
756 default:
757 return lang_hooks.tree_size (code);
761 case tcc_type: /* a type node */
762 return sizeof (struct tree_type_non_common);
764 case tcc_reference: /* a reference */
765 case tcc_expression: /* an expression */
766 case tcc_statement: /* an expression with side effects */
767 case tcc_comparison: /* a comparison expression */
768 case tcc_unary: /* a unary arithmetic expression */
769 case tcc_binary: /* a binary arithmetic expression */
770 return (sizeof (struct tree_exp)
771 + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
773 case tcc_constant: /* a constant */
774 switch (code)
776 case VOID_CST: return sizeof (struct tree_typed);
777 case INTEGER_CST: gcc_unreachable ();
778 case REAL_CST: return sizeof (struct tree_real_cst);
779 case FIXED_CST: return sizeof (struct tree_fixed_cst);
780 case COMPLEX_CST: return sizeof (struct tree_complex);
781 case VECTOR_CST: return sizeof (struct tree_vector);
782 case STRING_CST: gcc_unreachable ();
783 default:
784 return lang_hooks.tree_size (code);
787 case tcc_exceptional: /* something random, like an identifier. */
788 switch (code)
790 case IDENTIFIER_NODE: return lang_hooks.identifier_size;
791 case TREE_LIST: return sizeof (struct tree_list);
793 case ERROR_MARK:
794 case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
796 case TREE_VEC:
797 case OMP_CLAUSE: gcc_unreachable ();
799 case SSA_NAME: return sizeof (struct tree_ssa_name);
801 case STATEMENT_LIST: return sizeof (struct tree_statement_list);
802 case BLOCK: return sizeof (struct tree_block);
803 case CONSTRUCTOR: return sizeof (struct tree_constructor);
804 case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
805 case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
807 default:
808 return lang_hooks.tree_size (code);
811 default:
812 gcc_unreachable ();
816 /* Compute the number of bytes occupied by NODE. This routine only
817 looks at TREE_CODE, except for those nodes that have variable sizes. */
818 size_t
819 tree_size (const_tree node)
821 const enum tree_code code = TREE_CODE (node);
822 switch (code)
824 case INTEGER_CST:
825 return (sizeof (struct tree_int_cst)
826 + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT));
828 case TREE_BINFO:
829 return (offsetof (struct tree_binfo, base_binfos)
830 + vec<tree, va_gc>
831 ::embedded_size (BINFO_N_BASE_BINFOS (node)));
833 case TREE_VEC:
834 return (sizeof (struct tree_vec)
835 + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
837 case VECTOR_CST:
838 return (sizeof (struct tree_vector)
839 + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node)) - 1) * sizeof (tree));
841 case STRING_CST:
842 return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
844 case OMP_CLAUSE:
845 return (sizeof (struct tree_omp_clause)
846 + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
847 * sizeof (tree));
849 default:
850 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
851 return (sizeof (struct tree_exp)
852 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
853 else
854 return tree_code_size (code);
858 /* Record interesting allocation statistics for a tree node with CODE
859 and LENGTH. */
861 static void
862 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
863 size_t length ATTRIBUTE_UNUSED)
865 enum tree_code_class type = TREE_CODE_CLASS (code);
866 tree_node_kind kind;
868 if (!GATHER_STATISTICS)
869 return;
871 switch (type)
873 case tcc_declaration: /* A decl node */
874 kind = d_kind;
875 break;
877 case tcc_type: /* a type node */
878 kind = t_kind;
879 break;
881 case tcc_statement: /* an expression with side effects */
882 kind = s_kind;
883 break;
885 case tcc_reference: /* a reference */
886 kind = r_kind;
887 break;
889 case tcc_expression: /* an expression */
890 case tcc_comparison: /* a comparison expression */
891 case tcc_unary: /* a unary arithmetic expression */
892 case tcc_binary: /* a binary arithmetic expression */
893 kind = e_kind;
894 break;
896 case tcc_constant: /* a constant */
897 kind = c_kind;
898 break;
900 case tcc_exceptional: /* something random, like an identifier. */
901 switch (code)
903 case IDENTIFIER_NODE:
904 kind = id_kind;
905 break;
907 case TREE_VEC:
908 kind = vec_kind;
909 break;
911 case TREE_BINFO:
912 kind = binfo_kind;
913 break;
915 case SSA_NAME:
916 kind = ssa_name_kind;
917 break;
919 case BLOCK:
920 kind = b_kind;
921 break;
923 case CONSTRUCTOR:
924 kind = constr_kind;
925 break;
927 case OMP_CLAUSE:
928 kind = omp_clause_kind;
929 break;
931 default:
932 kind = x_kind;
933 break;
935 break;
937 case tcc_vl_exp:
938 kind = e_kind;
939 break;
941 default:
942 gcc_unreachable ();
945 tree_code_counts[(int) code]++;
946 tree_node_counts[(int) kind]++;
947 tree_node_sizes[(int) kind] += length;
950 /* Allocate and return a new UID from the DECL_UID namespace. */
953 allocate_decl_uid (void)
955 return next_decl_uid++;
958 /* Return a newly allocated node of code CODE. For decl and type
959 nodes, some other fields are initialized. The rest of the node is
960 initialized to zero. This function cannot be used for TREE_VEC,
961 INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
962 tree_code_size.
964 Achoo! I got a code in the node. */
966 tree
967 make_node_stat (enum tree_code code MEM_STAT_DECL)
969 tree t;
970 enum tree_code_class type = TREE_CODE_CLASS (code);
971 size_t length = tree_code_size (code);
973 record_node_allocation_statistics (code, length);
975 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
976 TREE_SET_CODE (t, code);
978 switch (type)
980 case tcc_statement:
981 TREE_SIDE_EFFECTS (t) = 1;
982 break;
984 case tcc_declaration:
985 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
987 if (code == FUNCTION_DECL)
989 DECL_ALIGN (t) = FUNCTION_BOUNDARY;
990 DECL_MODE (t) = FUNCTION_MODE;
992 else
993 DECL_ALIGN (t) = 1;
995 DECL_SOURCE_LOCATION (t) = input_location;
996 if (TREE_CODE (t) == DEBUG_EXPR_DECL)
997 DECL_UID (t) = --next_debug_decl_uid;
998 else
1000 DECL_UID (t) = allocate_decl_uid ();
1001 SET_DECL_PT_UID (t, -1);
1003 if (TREE_CODE (t) == LABEL_DECL)
1004 LABEL_DECL_UID (t) = -1;
1006 break;
1008 case tcc_type:
1009 TYPE_UID (t) = next_type_uid++;
1010 TYPE_ALIGN (t) = BITS_PER_UNIT;
1011 TYPE_USER_ALIGN (t) = 0;
1012 TYPE_MAIN_VARIANT (t) = t;
1013 TYPE_CANONICAL (t) = t;
1015 /* Default to no attributes for type, but let target change that. */
1016 TYPE_ATTRIBUTES (t) = NULL_TREE;
1017 targetm.set_default_type_attributes (t);
1019 /* We have not yet computed the alias set for this type. */
1020 TYPE_ALIAS_SET (t) = -1;
1021 break;
1023 case tcc_constant:
1024 TREE_CONSTANT (t) = 1;
1025 break;
1027 case tcc_expression:
1028 switch (code)
1030 case INIT_EXPR:
1031 case MODIFY_EXPR:
1032 case VA_ARG_EXPR:
1033 case PREDECREMENT_EXPR:
1034 case PREINCREMENT_EXPR:
1035 case POSTDECREMENT_EXPR:
1036 case POSTINCREMENT_EXPR:
1037 /* All of these have side-effects, no matter what their
1038 operands are. */
1039 TREE_SIDE_EFFECTS (t) = 1;
1040 break;
1042 default:
1043 break;
1045 break;
1047 default:
1048 /* Other classes need no special treatment. */
1049 break;
1052 return t;
1055 /* Return a new node with the same contents as NODE except that its
1056 TREE_CHAIN, if it has one, is zero and it has a fresh uid. */
1058 tree
1059 copy_node_stat (tree node MEM_STAT_DECL)
1061 tree t;
1062 enum tree_code code = TREE_CODE (node);
1063 size_t length;
1065 gcc_assert (code != STATEMENT_LIST);
1067 length = tree_size (node);
1068 record_node_allocation_statistics (code, length);
1069 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
1070 memcpy (t, node, length);
1072 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1073 TREE_CHAIN (t) = 0;
1074 TREE_ASM_WRITTEN (t) = 0;
1075 TREE_VISITED (t) = 0;
1077 if (TREE_CODE_CLASS (code) == tcc_declaration)
1079 if (code == DEBUG_EXPR_DECL)
1080 DECL_UID (t) = --next_debug_decl_uid;
1081 else
1083 DECL_UID (t) = allocate_decl_uid ();
1084 if (DECL_PT_UID_SET_P (node))
1085 SET_DECL_PT_UID (t, DECL_PT_UID (node));
1087 if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
1088 && DECL_HAS_VALUE_EXPR_P (node))
1090 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
1091 DECL_HAS_VALUE_EXPR_P (t) = 1;
1093 /* DECL_DEBUG_EXPR is copied explicitely by callers. */
1094 if (TREE_CODE (node) == VAR_DECL)
1096 DECL_HAS_DEBUG_EXPR_P (t) = 0;
1097 t->decl_with_vis.symtab_node = NULL;
1099 if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
1101 SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
1102 DECL_HAS_INIT_PRIORITY_P (t) = 1;
1104 if (TREE_CODE (node) == FUNCTION_DECL)
1106 DECL_STRUCT_FUNCTION (t) = NULL;
1107 t->decl_with_vis.symtab_node = NULL;
1110 else if (TREE_CODE_CLASS (code) == tcc_type)
1112 TYPE_UID (t) = next_type_uid++;
1113 /* The following is so that the debug code for
1114 the copy is different from the original type.
1115 The two statements usually duplicate each other
1116 (because they clear fields of the same union),
1117 but the optimizer should catch that. */
1118 TYPE_SYMTAB_POINTER (t) = 0;
1119 TYPE_SYMTAB_ADDRESS (t) = 0;
1121 /* Do not copy the values cache. */
1122 if (TYPE_CACHED_VALUES_P (t))
1124 TYPE_CACHED_VALUES_P (t) = 0;
1125 TYPE_CACHED_VALUES (t) = NULL_TREE;
1129 return t;
1132 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1133 For example, this can copy a list made of TREE_LIST nodes. */
1135 tree
1136 copy_list (tree list)
1138 tree head;
1139 tree prev, next;
1141 if (list == 0)
1142 return 0;
1144 head = prev = copy_node (list);
1145 next = TREE_CHAIN (list);
1146 while (next)
1148 TREE_CHAIN (prev) = copy_node (next);
1149 prev = TREE_CHAIN (prev);
1150 next = TREE_CHAIN (next);
1152 return head;
1156 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1157 INTEGER_CST with value CST and type TYPE. */
1159 static unsigned int
1160 get_int_cst_ext_nunits (tree type, const wide_int &cst)
1162 gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
1163 /* We need an extra zero HWI if CST is an unsigned integer with its
1164 upper bit set, and if CST occupies a whole number of HWIs. */
1165 if (TYPE_UNSIGNED (type)
1166 && wi::neg_p (cst)
1167 && (cst.get_precision () % HOST_BITS_PER_WIDE_INT) == 0)
1168 return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
1169 return cst.get_len ();
1172 /* Return a new INTEGER_CST with value CST and type TYPE. */
1174 static tree
1175 build_new_int_cst (tree type, const wide_int &cst)
1177 unsigned int len = cst.get_len ();
1178 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1179 tree nt = make_int_cst (len, ext_len);
1181 if (len < ext_len)
1183 --ext_len;
1184 TREE_INT_CST_ELT (nt, ext_len) = 0;
1185 for (unsigned int i = len; i < ext_len; ++i)
1186 TREE_INT_CST_ELT (nt, i) = -1;
1188 else if (TYPE_UNSIGNED (type)
1189 && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT)
1191 len--;
1192 TREE_INT_CST_ELT (nt, len)
1193 = zext_hwi (cst.elt (len),
1194 cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1197 for (unsigned int i = 0; i < len; i++)
1198 TREE_INT_CST_ELT (nt, i) = cst.elt (i);
1199 TREE_TYPE (nt) = type;
1200 return nt;
1203 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1205 tree
1206 build_int_cst (tree type, HOST_WIDE_INT low)
1208 /* Support legacy code. */
1209 if (!type)
1210 type = integer_type_node;
1212 return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1215 tree
1216 build_int_cstu (tree type, unsigned HOST_WIDE_INT cst)
1218 return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
1221 /* Create an INT_CST node with a LOW value sign extended to TYPE. */
1223 tree
1224 build_int_cst_type (tree type, HOST_WIDE_INT low)
1226 gcc_assert (type);
1227 return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1230 /* Constructs tree in type TYPE from with value given by CST. Signedness
1231 of CST is assumed to be the same as the signedness of TYPE. */
1233 tree
1234 double_int_to_tree (tree type, double_int cst)
1236 return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type)));
1239 /* We force the wide_int CST to the range of the type TYPE by sign or
1240 zero extending it. OVERFLOWABLE indicates if we are interested in
1241 overflow of the value, when >0 we are only interested in signed
1242 overflow, for <0 we are interested in any overflow. OVERFLOWED
1243 indicates whether overflow has already occurred. CONST_OVERFLOWED
1244 indicates whether constant overflow has already occurred. We force
1245 T's value to be within range of T's type (by setting to 0 or 1 all
1246 the bits outside the type's range). We set TREE_OVERFLOWED if,
1247 OVERFLOWED is nonzero,
1248 or OVERFLOWABLE is >0 and signed overflow occurs
1249 or OVERFLOWABLE is <0 and any overflow occurs
1250 We return a new tree node for the extended wide_int. The node
1251 is shared if no overflow flags are set. */
1254 tree
1255 force_fit_type (tree type, const wide_int_ref &cst,
1256 int overflowable, bool overflowed)
1258 signop sign = TYPE_SIGN (type);
1260 /* If we need to set overflow flags, return a new unshared node. */
1261 if (overflowed || !wi::fits_to_tree_p (cst, type))
1263 if (overflowed
1264 || overflowable < 0
1265 || (overflowable > 0 && sign == SIGNED))
1267 wide_int tmp = wide_int::from (cst, TYPE_PRECISION (type), sign);
1268 tree t = build_new_int_cst (type, tmp);
1269 TREE_OVERFLOW (t) = 1;
1270 return t;
1274 /* Else build a shared node. */
1275 return wide_int_to_tree (type, cst);
1278 /* These are the hash table functions for the hash table of INTEGER_CST
1279 nodes of a sizetype. */
1281 /* Return the hash code code X, an INTEGER_CST. */
1283 static hashval_t
1284 int_cst_hash_hash (const void *x)
1286 const_tree const t = (const_tree) x;
1287 hashval_t code = htab_hash_pointer (TREE_TYPE (t));
1288 int i;
1290 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
1291 code ^= TREE_INT_CST_ELT (t, i);
1293 return code;
1296 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1297 is the same as that given by *Y, which is the same. */
1299 static int
1300 int_cst_hash_eq (const void *x, const void *y)
1302 const_tree const xt = (const_tree) x;
1303 const_tree const yt = (const_tree) y;
1305 if (TREE_TYPE (xt) != TREE_TYPE (yt)
1306 || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt)
1307 || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt))
1308 return false;
1310 for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++)
1311 if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i))
1312 return false;
1314 return true;
1317 /* Create an INT_CST node of TYPE and value CST.
1318 The returned node is always shared. For small integers we use a
1319 per-type vector cache, for larger ones we use a single hash table.
1320 The value is extended from its precision according to the sign of
1321 the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines
1322 the upper bits and ensures that hashing and value equality based
1323 upon the underlying HOST_WIDE_INTs works without masking. */
1325 tree
1326 wide_int_to_tree (tree type, const wide_int_ref &pcst)
1328 tree t;
1329 int ix = -1;
1330 int limit = 0;
1332 gcc_assert (type);
1333 unsigned int prec = TYPE_PRECISION (type);
1334 signop sgn = TYPE_SIGN (type);
1336 /* Verify that everything is canonical. */
1337 int l = pcst.get_len ();
1338 if (l > 1)
1340 if (pcst.elt (l - 1) == 0)
1341 gcc_checking_assert (pcst.elt (l - 2) < 0);
1342 if (pcst.elt (l - 1) == (HOST_WIDE_INT) -1)
1343 gcc_checking_assert (pcst.elt (l - 2) >= 0);
1346 wide_int cst = wide_int::from (pcst, prec, sgn);
1347 unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1349 if (ext_len == 1)
1351 /* We just need to store a single HOST_WIDE_INT. */
1352 HOST_WIDE_INT hwi;
1353 if (TYPE_UNSIGNED (type))
1354 hwi = cst.to_uhwi ();
1355 else
1356 hwi = cst.to_shwi ();
1358 switch (TREE_CODE (type))
1360 case NULLPTR_TYPE:
1361 gcc_assert (hwi == 0);
1362 /* Fallthru. */
1364 case POINTER_TYPE:
1365 case REFERENCE_TYPE:
1366 case POINTER_BOUNDS_TYPE:
1367 /* Cache NULL pointer and zero bounds. */
1368 if (hwi == 0)
1370 limit = 1;
1371 ix = 0;
1373 break;
1375 case BOOLEAN_TYPE:
1376 /* Cache false or true. */
1377 limit = 2;
1378 if (hwi < 2)
1379 ix = hwi;
1380 break;
1382 case INTEGER_TYPE:
1383 case OFFSET_TYPE:
1384 if (TYPE_SIGN (type) == UNSIGNED)
1386 /* Cache [0, N). */
1387 limit = INTEGER_SHARE_LIMIT;
1388 if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1))
1389 ix = hwi;
1391 else
1393 /* Cache [-1, N). */
1394 limit = INTEGER_SHARE_LIMIT + 1;
1395 if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1))
1396 ix = hwi + 1;
1398 break;
1400 case ENUMERAL_TYPE:
1401 break;
1403 default:
1404 gcc_unreachable ();
1407 if (ix >= 0)
1409 /* Look for it in the type's vector of small shared ints. */
1410 if (!TYPE_CACHED_VALUES_P (type))
1412 TYPE_CACHED_VALUES_P (type) = 1;
1413 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1416 t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1417 if (t)
1418 /* Make sure no one is clobbering the shared constant. */
1419 gcc_checking_assert (TREE_TYPE (t) == type
1420 && TREE_INT_CST_NUNITS (t) == 1
1421 && TREE_INT_CST_OFFSET_NUNITS (t) == 1
1422 && TREE_INT_CST_EXT_NUNITS (t) == 1
1423 && TREE_INT_CST_ELT (t, 0) == hwi);
1424 else
1426 /* Create a new shared int. */
1427 t = build_new_int_cst (type, cst);
1428 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1431 else
1433 /* Use the cache of larger shared ints, using int_cst_node as
1434 a temporary. */
1435 void **slot;
1437 TREE_INT_CST_ELT (int_cst_node, 0) = hwi;
1438 TREE_TYPE (int_cst_node) = type;
1440 slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1441 t = (tree) *slot;
1442 if (!t)
1444 /* Insert this one into the hash table. */
1445 t = int_cst_node;
1446 *slot = t;
1447 /* Make a new node for next time round. */
1448 int_cst_node = make_int_cst (1, 1);
1452 else
1454 /* The value either hashes properly or we drop it on the floor
1455 for the gc to take care of. There will not be enough of them
1456 to worry about. */
1457 void **slot;
1459 tree nt = build_new_int_cst (type, cst);
1460 slot = htab_find_slot (int_cst_hash_table, nt, INSERT);
1461 t = (tree) *slot;
1462 if (!t)
1464 /* Insert this one into the hash table. */
1465 t = nt;
1466 *slot = t;
1470 return t;
1473 void
1474 cache_integer_cst (tree t)
1476 tree type = TREE_TYPE (t);
1477 int ix = -1;
1478 int limit = 0;
1479 int prec = TYPE_PRECISION (type);
1481 gcc_assert (!TREE_OVERFLOW (t));
1483 switch (TREE_CODE (type))
1485 case NULLPTR_TYPE:
1486 gcc_assert (integer_zerop (t));
1487 /* Fallthru. */
1489 case POINTER_TYPE:
1490 case REFERENCE_TYPE:
1491 /* Cache NULL pointer. */
1492 if (integer_zerop (t))
1494 limit = 1;
1495 ix = 0;
1497 break;
1499 case BOOLEAN_TYPE:
1500 /* Cache false or true. */
1501 limit = 2;
1502 if (wi::ltu_p (t, 2))
1503 ix = TREE_INT_CST_ELT (t, 0);
1504 break;
1506 case INTEGER_TYPE:
1507 case OFFSET_TYPE:
1508 if (TYPE_UNSIGNED (type))
1510 /* Cache 0..N */
1511 limit = INTEGER_SHARE_LIMIT;
1513 /* This is a little hokie, but if the prec is smaller than
1514 what is necessary to hold INTEGER_SHARE_LIMIT, then the
1515 obvious test will not get the correct answer. */
1516 if (prec < HOST_BITS_PER_WIDE_INT)
1518 if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
1519 ix = tree_to_uhwi (t);
1521 else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1522 ix = tree_to_uhwi (t);
1524 else
1526 /* Cache -1..N */
1527 limit = INTEGER_SHARE_LIMIT + 1;
1529 if (integer_minus_onep (t))
1530 ix = 0;
1531 else if (!wi::neg_p (t))
1533 if (prec < HOST_BITS_PER_WIDE_INT)
1535 if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
1536 ix = tree_to_shwi (t) + 1;
1538 else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1539 ix = tree_to_shwi (t) + 1;
1542 break;
1544 case ENUMERAL_TYPE:
1545 break;
1547 default:
1548 gcc_unreachable ();
1551 if (ix >= 0)
1553 /* Look for it in the type's vector of small shared ints. */
1554 if (!TYPE_CACHED_VALUES_P (type))
1556 TYPE_CACHED_VALUES_P (type) = 1;
1557 TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1560 gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
1561 TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1563 else
1565 /* Use the cache of larger shared ints. */
1566 void **slot;
1568 slot = htab_find_slot (int_cst_hash_table, t, INSERT);
1569 /* If there is already an entry for the number verify it's the
1570 same. */
1571 if (*slot)
1572 gcc_assert (wi::eq_p (tree (*slot), t));
1573 else
1574 /* Otherwise insert this one into the hash table. */
1575 *slot = t;
1580 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1581 and the rest are zeros. */
1583 tree
1584 build_low_bits_mask (tree type, unsigned bits)
1586 gcc_assert (bits <= TYPE_PRECISION (type));
1588 return wide_int_to_tree (type, wi::mask (bits, false,
1589 TYPE_PRECISION (type)));
1592 /* Checks that X is integer constant that can be expressed in (unsigned)
1593 HOST_WIDE_INT without loss of precision. */
1595 bool
1596 cst_and_fits_in_hwi (const_tree x)
1598 if (TREE_CODE (x) != INTEGER_CST)
1599 return false;
1601 if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1602 return false;
1604 return TREE_INT_CST_NUNITS (x) == 1;
1607 /* Build a newly constructed TREE_VEC node of length LEN. */
1609 tree
1610 make_vector_stat (unsigned len MEM_STAT_DECL)
1612 tree t;
1613 unsigned length = (len - 1) * sizeof (tree) + sizeof (struct tree_vector);
1615 record_node_allocation_statistics (VECTOR_CST, length);
1617 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1619 TREE_SET_CODE (t, VECTOR_CST);
1620 TREE_CONSTANT (t) = 1;
1622 return t;
1625 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1626 are in a list pointed to by VALS. */
1628 tree
1629 build_vector_stat (tree type, tree *vals MEM_STAT_DECL)
1631 int over = 0;
1632 unsigned cnt = 0;
1633 tree v = make_vector (TYPE_VECTOR_SUBPARTS (type));
1634 TREE_TYPE (v) = type;
1636 /* Iterate through elements and check for overflow. */
1637 for (cnt = 0; cnt < TYPE_VECTOR_SUBPARTS (type); ++cnt)
1639 tree value = vals[cnt];
1641 VECTOR_CST_ELT (v, cnt) = value;
1643 /* Don't crash if we get an address constant. */
1644 if (!CONSTANT_CLASS_P (value))
1645 continue;
1647 over |= TREE_OVERFLOW (value);
1650 TREE_OVERFLOW (v) = over;
1651 return v;
1654 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1655 are extracted from V, a vector of CONSTRUCTOR_ELT. */
1657 tree
1658 build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
1660 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
1661 unsigned HOST_WIDE_INT idx;
1662 tree value;
1664 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1665 vec[idx] = value;
1666 for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx)
1667 vec[idx] = build_zero_cst (TREE_TYPE (type));
1669 return build_vector (type, vec);
1672 /* Build a vector of type VECTYPE where all the elements are SCs. */
1673 tree
1674 build_vector_from_val (tree vectype, tree sc)
1676 int i, nunits = TYPE_VECTOR_SUBPARTS (vectype);
1678 if (sc == error_mark_node)
1679 return sc;
1681 /* Verify that the vector type is suitable for SC. Note that there
1682 is some inconsistency in the type-system with respect to restrict
1683 qualifications of pointers. Vector types always have a main-variant
1684 element type and the qualification is applied to the vector-type.
1685 So TREE_TYPE (vector-type) does not return a properly qualified
1686 vector element-type. */
1687 gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
1688 TREE_TYPE (vectype)));
1690 if (CONSTANT_CLASS_P (sc))
1692 tree *v = XALLOCAVEC (tree, nunits);
1693 for (i = 0; i < nunits; ++i)
1694 v[i] = sc;
1695 return build_vector (vectype, v);
1697 else
1699 vec<constructor_elt, va_gc> *v;
1700 vec_alloc (v, nunits);
1701 for (i = 0; i < nunits; ++i)
1702 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1703 return build_constructor (vectype, v);
1707 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1708 are in the vec pointed to by VALS. */
1709 tree
1710 build_constructor (tree type, vec<constructor_elt, va_gc> *vals)
1712 tree c = make_node (CONSTRUCTOR);
1713 unsigned int i;
1714 constructor_elt *elt;
1715 bool constant_p = true;
1716 bool side_effects_p = false;
1718 TREE_TYPE (c) = type;
1719 CONSTRUCTOR_ELTS (c) = vals;
1721 FOR_EACH_VEC_SAFE_ELT (vals, i, elt)
1723 /* Mostly ctors will have elts that don't have side-effects, so
1724 the usual case is to scan all the elements. Hence a single
1725 loop for both const and side effects, rather than one loop
1726 each (with early outs). */
1727 if (!TREE_CONSTANT (elt->value))
1728 constant_p = false;
1729 if (TREE_SIDE_EFFECTS (elt->value))
1730 side_effects_p = true;
1733 TREE_SIDE_EFFECTS (c) = side_effects_p;
1734 TREE_CONSTANT (c) = constant_p;
1736 return c;
1739 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1740 INDEX and VALUE. */
1741 tree
1742 build_constructor_single (tree type, tree index, tree value)
1744 vec<constructor_elt, va_gc> *v;
1745 constructor_elt elt = {index, value};
1747 vec_alloc (v, 1);
1748 v->quick_push (elt);
1750 return build_constructor (type, v);
1754 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1755 are in a list pointed to by VALS. */
1756 tree
1757 build_constructor_from_list (tree type, tree vals)
1759 tree t;
1760 vec<constructor_elt, va_gc> *v = NULL;
1762 if (vals)
1764 vec_alloc (v, list_length (vals));
1765 for (t = vals; t; t = TREE_CHAIN (t))
1766 CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1769 return build_constructor (type, v);
1772 /* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number
1773 of elements, provided as index/value pairs. */
1775 tree
1776 build_constructor_va (tree type, int nelts, ...)
1778 vec<constructor_elt, va_gc> *v = NULL;
1779 va_list p;
1781 va_start (p, nelts);
1782 vec_alloc (v, nelts);
1783 while (nelts--)
1785 tree index = va_arg (p, tree);
1786 tree value = va_arg (p, tree);
1787 CONSTRUCTOR_APPEND_ELT (v, index, value);
1789 va_end (p);
1790 return build_constructor (type, v);
1793 /* Return a new FIXED_CST node whose type is TYPE and value is F. */
1795 tree
1796 build_fixed (tree type, FIXED_VALUE_TYPE f)
1798 tree v;
1799 FIXED_VALUE_TYPE *fp;
1801 v = make_node (FIXED_CST);
1802 fp = ggc_alloc<fixed_value> ();
1803 memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1805 TREE_TYPE (v) = type;
1806 TREE_FIXED_CST_PTR (v) = fp;
1807 return v;
1810 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1812 tree
1813 build_real (tree type, REAL_VALUE_TYPE d)
1815 tree v;
1816 REAL_VALUE_TYPE *dp;
1817 int overflow = 0;
1819 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1820 Consider doing it via real_convert now. */
1822 v = make_node (REAL_CST);
1823 dp = ggc_alloc<real_value> ();
1824 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1826 TREE_TYPE (v) = type;
1827 TREE_REAL_CST_PTR (v) = dp;
1828 TREE_OVERFLOW (v) = overflow;
1829 return v;
1832 /* Return a new REAL_CST node whose type is TYPE
1833 and whose value is the integer value of the INTEGER_CST node I. */
1835 REAL_VALUE_TYPE
1836 real_value_from_int_cst (const_tree type, const_tree i)
1838 REAL_VALUE_TYPE d;
1840 /* Clear all bits of the real value type so that we can later do
1841 bitwise comparisons to see if two values are the same. */
1842 memset (&d, 0, sizeof d);
1844 real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, i,
1845 TYPE_SIGN (TREE_TYPE (i)));
1846 return d;
1849 /* Given a tree representing an integer constant I, return a tree
1850 representing the same value as a floating-point constant of type TYPE. */
1852 tree
1853 build_real_from_int_cst (tree type, const_tree i)
1855 tree v;
1856 int overflow = TREE_OVERFLOW (i);
1858 v = build_real (type, real_value_from_int_cst (type, i));
1860 TREE_OVERFLOW (v) |= overflow;
1861 return v;
1864 /* Return a newly constructed STRING_CST node whose value is
1865 the LEN characters at STR.
1866 Note that for a C string literal, LEN should include the trailing NUL.
1867 The TREE_TYPE is not initialized. */
1869 tree
1870 build_string (int len, const char *str)
1872 tree s;
1873 size_t length;
1875 /* Do not waste bytes provided by padding of struct tree_string. */
1876 length = len + offsetof (struct tree_string, str) + 1;
1878 record_node_allocation_statistics (STRING_CST, length);
1880 s = (tree) ggc_internal_alloc (length);
1882 memset (s, 0, sizeof (struct tree_typed));
1883 TREE_SET_CODE (s, STRING_CST);
1884 TREE_CONSTANT (s) = 1;
1885 TREE_STRING_LENGTH (s) = len;
1886 memcpy (s->string.str, str, len);
1887 s->string.str[len] = '\0';
1889 return s;
1892 /* Return a newly constructed COMPLEX_CST node whose value is
1893 specified by the real and imaginary parts REAL and IMAG.
1894 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1895 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1897 tree
1898 build_complex (tree type, tree real, tree imag)
1900 tree t = make_node (COMPLEX_CST);
1902 TREE_REALPART (t) = real;
1903 TREE_IMAGPART (t) = imag;
1904 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1905 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1906 return t;
1909 /* Return a constant of arithmetic type TYPE which is the
1910 multiplicative identity of the set TYPE. */
1912 tree
1913 build_one_cst (tree type)
1915 switch (TREE_CODE (type))
1917 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1918 case POINTER_TYPE: case REFERENCE_TYPE:
1919 case OFFSET_TYPE:
1920 return build_int_cst (type, 1);
1922 case REAL_TYPE:
1923 return build_real (type, dconst1);
1925 case FIXED_POINT_TYPE:
1926 /* We can only generate 1 for accum types. */
1927 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1928 return build_fixed (type, FCONST1 (TYPE_MODE (type)));
1930 case VECTOR_TYPE:
1932 tree scalar = build_one_cst (TREE_TYPE (type));
1934 return build_vector_from_val (type, scalar);
1937 case COMPLEX_TYPE:
1938 return build_complex (type,
1939 build_one_cst (TREE_TYPE (type)),
1940 build_zero_cst (TREE_TYPE (type)));
1942 default:
1943 gcc_unreachable ();
1947 /* Return an integer of type TYPE containing all 1's in as much precision as
1948 it contains, or a complex or vector whose subparts are such integers. */
1950 tree
1951 build_all_ones_cst (tree type)
1953 if (TREE_CODE (type) == COMPLEX_TYPE)
1955 tree scalar = build_all_ones_cst (TREE_TYPE (type));
1956 return build_complex (type, scalar, scalar);
1958 else
1959 return build_minus_one_cst (type);
1962 /* Return a constant of arithmetic type TYPE which is the
1963 opposite of the multiplicative identity of the set TYPE. */
1965 tree
1966 build_minus_one_cst (tree type)
1968 switch (TREE_CODE (type))
1970 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1971 case POINTER_TYPE: case REFERENCE_TYPE:
1972 case OFFSET_TYPE:
1973 return build_int_cst (type, -1);
1975 case REAL_TYPE:
1976 return build_real (type, dconstm1);
1978 case FIXED_POINT_TYPE:
1979 /* We can only generate 1 for accum types. */
1980 gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1981 return build_fixed (type, fixed_from_double_int (double_int_minus_one,
1982 TYPE_MODE (type)));
1984 case VECTOR_TYPE:
1986 tree scalar = build_minus_one_cst (TREE_TYPE (type));
1988 return build_vector_from_val (type, scalar);
1991 case COMPLEX_TYPE:
1992 return build_complex (type,
1993 build_minus_one_cst (TREE_TYPE (type)),
1994 build_zero_cst (TREE_TYPE (type)));
1996 default:
1997 gcc_unreachable ();
2001 /* Build 0 constant of type TYPE. This is used by constructor folding
2002 and thus the constant should be represented in memory by
2003 zero(es). */
2005 tree
2006 build_zero_cst (tree type)
2008 switch (TREE_CODE (type))
2010 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2011 case POINTER_TYPE: case REFERENCE_TYPE:
2012 case OFFSET_TYPE: case NULLPTR_TYPE:
2013 return build_int_cst (type, 0);
2015 case REAL_TYPE:
2016 return build_real (type, dconst0);
2018 case FIXED_POINT_TYPE:
2019 return build_fixed (type, FCONST0 (TYPE_MODE (type)));
2021 case VECTOR_TYPE:
2023 tree scalar = build_zero_cst (TREE_TYPE (type));
2025 return build_vector_from_val (type, scalar);
2028 case COMPLEX_TYPE:
2030 tree zero = build_zero_cst (TREE_TYPE (type));
2032 return build_complex (type, zero, zero);
2035 default:
2036 if (!AGGREGATE_TYPE_P (type))
2037 return fold_convert (type, integer_zero_node);
2038 return build_constructor (type, NULL);
2043 /* Build a BINFO with LEN language slots. */
2045 tree
2046 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
2048 tree t;
2049 size_t length = (offsetof (struct tree_binfo, base_binfos)
2050 + vec<tree, va_gc>::embedded_size (base_binfos));
2052 record_node_allocation_statistics (TREE_BINFO, length);
2054 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
2056 memset (t, 0, offsetof (struct tree_binfo, base_binfos));
2058 TREE_SET_CODE (t, TREE_BINFO);
2060 BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
2062 return t;
2065 /* Create a CASE_LABEL_EXPR tree node and return it. */
2067 tree
2068 build_case_label (tree low_value, tree high_value, tree label_decl)
2070 tree t = make_node (CASE_LABEL_EXPR);
2072 TREE_TYPE (t) = void_type_node;
2073 SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
2075 CASE_LOW (t) = low_value;
2076 CASE_HIGH (t) = high_value;
2077 CASE_LABEL (t) = label_decl;
2078 CASE_CHAIN (t) = NULL_TREE;
2080 return t;
2083 /* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the
2084 values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2085 The latter determines the length of the HOST_WIDE_INT vector. */
2087 tree
2088 make_int_cst_stat (int len, int ext_len MEM_STAT_DECL)
2090 tree t;
2091 int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT)
2092 + sizeof (struct tree_int_cst));
2094 gcc_assert (len);
2095 record_node_allocation_statistics (INTEGER_CST, length);
2097 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2099 TREE_SET_CODE (t, INTEGER_CST);
2100 TREE_INT_CST_NUNITS (t) = len;
2101 TREE_INT_CST_EXT_NUNITS (t) = ext_len;
2102 /* to_offset can only be applied to trees that are offset_int-sized
2103 or smaller. EXT_LEN is correct if it fits, otherwise the constant
2104 must be exactly the precision of offset_int and so LEN is correct. */
2105 if (ext_len <= OFFSET_INT_ELTS)
2106 TREE_INT_CST_OFFSET_NUNITS (t) = ext_len;
2107 else
2108 TREE_INT_CST_OFFSET_NUNITS (t) = len;
2110 TREE_CONSTANT (t) = 1;
2112 return t;
2115 /* Build a newly constructed TREE_VEC node of length LEN. */
2117 tree
2118 make_tree_vec_stat (int len MEM_STAT_DECL)
2120 tree t;
2121 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2123 record_node_allocation_statistics (TREE_VEC, length);
2125 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2127 TREE_SET_CODE (t, TREE_VEC);
2128 TREE_VEC_LENGTH (t) = len;
2130 return t;
2133 /* Grow a TREE_VEC node to new length LEN. */
2135 tree
2136 grow_tree_vec_stat (tree v, int len MEM_STAT_DECL)
2138 gcc_assert (TREE_CODE (v) == TREE_VEC);
2140 int oldlen = TREE_VEC_LENGTH (v);
2141 gcc_assert (len > oldlen);
2143 int oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
2144 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2146 record_node_allocation_statistics (TREE_VEC, length - oldlength);
2148 v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
2150 TREE_VEC_LENGTH (v) = len;
2152 return v;
2155 /* Return 1 if EXPR is the integer constant zero or a complex constant
2156 of zero. */
2159 integer_zerop (const_tree expr)
2161 STRIP_NOPS (expr);
2163 switch (TREE_CODE (expr))
2165 case INTEGER_CST:
2166 return wi::eq_p (expr, 0);
2167 case COMPLEX_CST:
2168 return (integer_zerop (TREE_REALPART (expr))
2169 && integer_zerop (TREE_IMAGPART (expr)));
2170 case VECTOR_CST:
2172 unsigned i;
2173 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2174 if (!integer_zerop (VECTOR_CST_ELT (expr, i)))
2175 return false;
2176 return true;
2178 default:
2179 return false;
2183 /* Return 1 if EXPR is the integer constant one or the corresponding
2184 complex constant. */
2187 integer_onep (const_tree expr)
2189 STRIP_NOPS (expr);
2191 switch (TREE_CODE (expr))
2193 case INTEGER_CST:
2194 return wi::eq_p (wi::to_widest (expr), 1);
2195 case COMPLEX_CST:
2196 return (integer_onep (TREE_REALPART (expr))
2197 && integer_zerop (TREE_IMAGPART (expr)));
2198 case VECTOR_CST:
2200 unsigned i;
2201 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2202 if (!integer_onep (VECTOR_CST_ELT (expr, i)))
2203 return false;
2204 return true;
2206 default:
2207 return false;
2211 /* Return 1 if EXPR is the integer constant one. For complex and vector,
2212 return 1 if every piece is the integer constant one. */
2215 integer_each_onep (const_tree expr)
2217 STRIP_NOPS (expr);
2219 if (TREE_CODE (expr) == COMPLEX_CST)
2220 return (integer_onep (TREE_REALPART (expr))
2221 && integer_onep (TREE_IMAGPART (expr)));
2222 else
2223 return integer_onep (expr);
2226 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2227 it contains, or a complex or vector whose subparts are such integers. */
2230 integer_all_onesp (const_tree expr)
2232 STRIP_NOPS (expr);
2234 if (TREE_CODE (expr) == COMPLEX_CST
2235 && integer_all_onesp (TREE_REALPART (expr))
2236 && integer_all_onesp (TREE_IMAGPART (expr)))
2237 return 1;
2239 else if (TREE_CODE (expr) == VECTOR_CST)
2241 unsigned i;
2242 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2243 if (!integer_all_onesp (VECTOR_CST_ELT (expr, i)))
2244 return 0;
2245 return 1;
2248 else if (TREE_CODE (expr) != INTEGER_CST)
2249 return 0;
2251 return wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED) == expr;
2254 /* Return 1 if EXPR is the integer constant minus one. */
2257 integer_minus_onep (const_tree expr)
2259 STRIP_NOPS (expr);
2261 if (TREE_CODE (expr) == COMPLEX_CST)
2262 return (integer_all_onesp (TREE_REALPART (expr))
2263 && integer_zerop (TREE_IMAGPART (expr)));
2264 else
2265 return integer_all_onesp (expr);
2268 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2269 one bit on). */
2272 integer_pow2p (const_tree expr)
2274 STRIP_NOPS (expr);
2276 if (TREE_CODE (expr) == COMPLEX_CST
2277 && integer_pow2p (TREE_REALPART (expr))
2278 && integer_zerop (TREE_IMAGPART (expr)))
2279 return 1;
2281 if (TREE_CODE (expr) != INTEGER_CST)
2282 return 0;
2284 return wi::popcount (expr) == 1;
2287 /* Return 1 if EXPR is an integer constant other than zero or a
2288 complex constant other than zero. */
2291 integer_nonzerop (const_tree expr)
2293 STRIP_NOPS (expr);
2295 return ((TREE_CODE (expr) == INTEGER_CST
2296 && !wi::eq_p (expr, 0))
2297 || (TREE_CODE (expr) == COMPLEX_CST
2298 && (integer_nonzerop (TREE_REALPART (expr))
2299 || integer_nonzerop (TREE_IMAGPART (expr)))));
2302 /* Return 1 if EXPR is the fixed-point constant zero. */
2305 fixed_zerop (const_tree expr)
2307 return (TREE_CODE (expr) == FIXED_CST
2308 && TREE_FIXED_CST (expr).data.is_zero ());
2311 /* Return the power of two represented by a tree node known to be a
2312 power of two. */
2315 tree_log2 (const_tree expr)
2317 STRIP_NOPS (expr);
2319 if (TREE_CODE (expr) == COMPLEX_CST)
2320 return tree_log2 (TREE_REALPART (expr));
2322 return wi::exact_log2 (expr);
2325 /* Similar, but return the largest integer Y such that 2 ** Y is less
2326 than or equal to EXPR. */
2329 tree_floor_log2 (const_tree expr)
2331 STRIP_NOPS (expr);
2333 if (TREE_CODE (expr) == COMPLEX_CST)
2334 return tree_log2 (TREE_REALPART (expr));
2336 return wi::floor_log2 (expr);
2339 /* Return number of known trailing zero bits in EXPR, or, if the value of
2340 EXPR is known to be zero, the precision of it's type. */
2342 unsigned int
2343 tree_ctz (const_tree expr)
2345 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
2346 && !POINTER_TYPE_P (TREE_TYPE (expr)))
2347 return 0;
2349 unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
2350 switch (TREE_CODE (expr))
2352 case INTEGER_CST:
2353 ret1 = wi::ctz (expr);
2354 return MIN (ret1, prec);
2355 case SSA_NAME:
2356 ret1 = wi::ctz (get_nonzero_bits (expr));
2357 return MIN (ret1, prec);
2358 case PLUS_EXPR:
2359 case MINUS_EXPR:
2360 case BIT_IOR_EXPR:
2361 case BIT_XOR_EXPR:
2362 case MIN_EXPR:
2363 case MAX_EXPR:
2364 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2365 if (ret1 == 0)
2366 return ret1;
2367 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2368 return MIN (ret1, ret2);
2369 case POINTER_PLUS_EXPR:
2370 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2371 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2372 /* Second operand is sizetype, which could be in theory
2373 wider than pointer's precision. Make sure we never
2374 return more than prec. */
2375 ret2 = MIN (ret2, prec);
2376 return MIN (ret1, ret2);
2377 case BIT_AND_EXPR:
2378 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2379 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2380 return MAX (ret1, ret2);
2381 case MULT_EXPR:
2382 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2383 ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2384 return MIN (ret1 + ret2, prec);
2385 case LSHIFT_EXPR:
2386 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2387 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2388 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2390 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2391 return MIN (ret1 + ret2, prec);
2393 return ret1;
2394 case RSHIFT_EXPR:
2395 if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2396 && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2398 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2399 ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2400 if (ret1 > ret2)
2401 return ret1 - ret2;
2403 return 0;
2404 case TRUNC_DIV_EXPR:
2405 case CEIL_DIV_EXPR:
2406 case FLOOR_DIV_EXPR:
2407 case ROUND_DIV_EXPR:
2408 case EXACT_DIV_EXPR:
2409 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
2410 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
2412 int l = tree_log2 (TREE_OPERAND (expr, 1));
2413 if (l >= 0)
2415 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2416 ret2 = l;
2417 if (ret1 > ret2)
2418 return ret1 - ret2;
2421 return 0;
2422 CASE_CONVERT:
2423 ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2424 if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2425 ret1 = prec;
2426 return MIN (ret1, prec);
2427 case SAVE_EXPR:
2428 return tree_ctz (TREE_OPERAND (expr, 0));
2429 case COND_EXPR:
2430 ret1 = tree_ctz (TREE_OPERAND (expr, 1));
2431 if (ret1 == 0)
2432 return 0;
2433 ret2 = tree_ctz (TREE_OPERAND (expr, 2));
2434 return MIN (ret1, ret2);
2435 case COMPOUND_EXPR:
2436 return tree_ctz (TREE_OPERAND (expr, 1));
2437 case ADDR_EXPR:
2438 ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
2439 if (ret1 > BITS_PER_UNIT)
2441 ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
2442 return MIN (ret1, prec);
2444 return 0;
2445 default:
2446 return 0;
2450 /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for
2451 decimal float constants, so don't return 1 for them. */
2454 real_zerop (const_tree expr)
2456 STRIP_NOPS (expr);
2458 switch (TREE_CODE (expr))
2460 case REAL_CST:
2461 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
2462 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2463 case COMPLEX_CST:
2464 return real_zerop (TREE_REALPART (expr))
2465 && real_zerop (TREE_IMAGPART (expr));
2466 case VECTOR_CST:
2468 unsigned i;
2469 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2470 if (!real_zerop (VECTOR_CST_ELT (expr, i)))
2471 return false;
2472 return true;
2474 default:
2475 return false;
2479 /* Return 1 if EXPR is the real constant one in real or complex form.
2480 Trailing zeroes matter for decimal float constants, so don't return
2481 1 for them. */
2484 real_onep (const_tree expr)
2486 STRIP_NOPS (expr);
2488 switch (TREE_CODE (expr))
2490 case REAL_CST:
2491 return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
2492 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2493 case COMPLEX_CST:
2494 return real_onep (TREE_REALPART (expr))
2495 && real_zerop (TREE_IMAGPART (expr));
2496 case VECTOR_CST:
2498 unsigned i;
2499 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2500 if (!real_onep (VECTOR_CST_ELT (expr, i)))
2501 return false;
2502 return true;
2504 default:
2505 return false;
2509 /* Return 1 if EXPR is the real constant minus one. Trailing zeroes
2510 matter for decimal float constants, so don't return 1 for them. */
2513 real_minus_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), dconstm1)
2521 && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2522 case COMPLEX_CST:
2523 return real_minus_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_minus_onep (VECTOR_CST_ELT (expr, i)))
2530 return false;
2531 return true;
2533 default:
2534 return false;
2538 /* Nonzero if EXP is a constant or a cast of a constant. */
2541 really_constant_p (const_tree exp)
2543 /* This is not quite the same as STRIP_NOPS. It does more. */
2544 while (CONVERT_EXPR_P (exp)
2545 || TREE_CODE (exp) == NON_LVALUE_EXPR)
2546 exp = TREE_OPERAND (exp, 0);
2547 return TREE_CONSTANT (exp);
2550 /* Return first list element whose TREE_VALUE is ELEM.
2551 Return 0 if ELEM is not in LIST. */
2553 tree
2554 value_member (tree elem, tree list)
2556 while (list)
2558 if (elem == TREE_VALUE (list))
2559 return list;
2560 list = TREE_CHAIN (list);
2562 return NULL_TREE;
2565 /* Return first list element whose TREE_PURPOSE is ELEM.
2566 Return 0 if ELEM is not in LIST. */
2568 tree
2569 purpose_member (const_tree elem, tree list)
2571 while (list)
2573 if (elem == TREE_PURPOSE (list))
2574 return list;
2575 list = TREE_CHAIN (list);
2577 return NULL_TREE;
2580 /* Return true if ELEM is in V. */
2582 bool
2583 vec_member (const_tree elem, vec<tree, va_gc> *v)
2585 unsigned ix;
2586 tree t;
2587 FOR_EACH_VEC_SAFE_ELT (v, ix, t)
2588 if (elem == t)
2589 return true;
2590 return false;
2593 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2594 NULL_TREE. */
2596 tree
2597 chain_index (int idx, tree chain)
2599 for (; chain && idx > 0; --idx)
2600 chain = TREE_CHAIN (chain);
2601 return chain;
2604 /* Return nonzero if ELEM is part of the chain CHAIN. */
2607 chain_member (const_tree elem, const_tree chain)
2609 while (chain)
2611 if (elem == chain)
2612 return 1;
2613 chain = DECL_CHAIN (chain);
2616 return 0;
2619 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2620 We expect a null pointer to mark the end of the chain.
2621 This is the Lisp primitive `length'. */
2624 list_length (const_tree t)
2626 const_tree p = t;
2627 #ifdef ENABLE_TREE_CHECKING
2628 const_tree q = t;
2629 #endif
2630 int len = 0;
2632 while (p)
2634 p = TREE_CHAIN (p);
2635 #ifdef ENABLE_TREE_CHECKING
2636 if (len % 2)
2637 q = TREE_CHAIN (q);
2638 gcc_assert (p != q);
2639 #endif
2640 len++;
2643 return len;
2646 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2647 UNION_TYPE TYPE, or NULL_TREE if none. */
2649 tree
2650 first_field (const_tree type)
2652 tree t = TYPE_FIELDS (type);
2653 while (t && TREE_CODE (t) != FIELD_DECL)
2654 t = TREE_CHAIN (t);
2655 return t;
2658 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2659 by modifying the last node in chain 1 to point to chain 2.
2660 This is the Lisp primitive `nconc'. */
2662 tree
2663 chainon (tree op1, tree op2)
2665 tree t1;
2667 if (!op1)
2668 return op2;
2669 if (!op2)
2670 return op1;
2672 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2673 continue;
2674 TREE_CHAIN (t1) = op2;
2676 #ifdef ENABLE_TREE_CHECKING
2678 tree t2;
2679 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2680 gcc_assert (t2 != t1);
2682 #endif
2684 return op1;
2687 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
2689 tree
2690 tree_last (tree chain)
2692 tree next;
2693 if (chain)
2694 while ((next = TREE_CHAIN (chain)))
2695 chain = next;
2696 return chain;
2699 /* Reverse the order of elements in the chain T,
2700 and return the new head of the chain (old last element). */
2702 tree
2703 nreverse (tree t)
2705 tree prev = 0, decl, next;
2706 for (decl = t; decl; decl = next)
2708 /* We shouldn't be using this function to reverse BLOCK chains; we
2709 have blocks_nreverse for that. */
2710 gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2711 next = TREE_CHAIN (decl);
2712 TREE_CHAIN (decl) = prev;
2713 prev = decl;
2715 return prev;
2718 /* Return a newly created TREE_LIST node whose
2719 purpose and value fields are PARM and VALUE. */
2721 tree
2722 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2724 tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2725 TREE_PURPOSE (t) = parm;
2726 TREE_VALUE (t) = value;
2727 return t;
2730 /* Build a chain of TREE_LIST nodes from a vector. */
2732 tree
2733 build_tree_list_vec_stat (const vec<tree, va_gc> *vec MEM_STAT_DECL)
2735 tree ret = NULL_TREE;
2736 tree *pp = &ret;
2737 unsigned int i;
2738 tree t;
2739 FOR_EACH_VEC_SAFE_ELT (vec, i, t)
2741 *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2742 pp = &TREE_CHAIN (*pp);
2744 return ret;
2747 /* Return a newly created TREE_LIST node whose
2748 purpose and value fields are PURPOSE and VALUE
2749 and whose TREE_CHAIN is CHAIN. */
2751 tree
2752 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2754 tree node;
2756 node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
2757 memset (node, 0, sizeof (struct tree_common));
2759 record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
2761 TREE_SET_CODE (node, TREE_LIST);
2762 TREE_CHAIN (node) = chain;
2763 TREE_PURPOSE (node) = purpose;
2764 TREE_VALUE (node) = value;
2765 return node;
2768 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2769 trees. */
2771 vec<tree, va_gc> *
2772 ctor_to_vec (tree ctor)
2774 vec<tree, va_gc> *vec;
2775 vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
2776 unsigned int ix;
2777 tree val;
2779 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2780 vec->quick_push (val);
2782 return vec;
2785 /* Return the size nominally occupied by an object of type TYPE
2786 when it resides in memory. The value is measured in units of bytes,
2787 and its data type is that normally used for type sizes
2788 (which is the first type created by make_signed_type or
2789 make_unsigned_type). */
2791 tree
2792 size_in_bytes (const_tree type)
2794 tree t;
2796 if (type == error_mark_node)
2797 return integer_zero_node;
2799 type = TYPE_MAIN_VARIANT (type);
2800 t = TYPE_SIZE_UNIT (type);
2802 if (t == 0)
2804 lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2805 return size_zero_node;
2808 return t;
2811 /* Return the size of TYPE (in bytes) as a wide integer
2812 or return -1 if the size can vary or is larger than an integer. */
2814 HOST_WIDE_INT
2815 int_size_in_bytes (const_tree type)
2817 tree t;
2819 if (type == error_mark_node)
2820 return 0;
2822 type = TYPE_MAIN_VARIANT (type);
2823 t = TYPE_SIZE_UNIT (type);
2825 if (t && tree_fits_uhwi_p (t))
2826 return TREE_INT_CST_LOW (t);
2827 else
2828 return -1;
2831 /* Return the maximum size of TYPE (in bytes) as a wide integer
2832 or return -1 if the size can vary or is larger than an integer. */
2834 HOST_WIDE_INT
2835 max_int_size_in_bytes (const_tree type)
2837 HOST_WIDE_INT size = -1;
2838 tree size_tree;
2840 /* If this is an array type, check for a possible MAX_SIZE attached. */
2842 if (TREE_CODE (type) == ARRAY_TYPE)
2844 size_tree = TYPE_ARRAY_MAX_SIZE (type);
2846 if (size_tree && tree_fits_uhwi_p (size_tree))
2847 size = tree_to_uhwi (size_tree);
2850 /* If we still haven't been able to get a size, see if the language
2851 can compute a maximum size. */
2853 if (size == -1)
2855 size_tree = lang_hooks.types.max_size (type);
2857 if (size_tree && tree_fits_uhwi_p (size_tree))
2858 size = tree_to_uhwi (size_tree);
2861 return size;
2864 /* Return the bit position of FIELD, in bits from the start of the record.
2865 This is a tree of type bitsizetype. */
2867 tree
2868 bit_position (const_tree field)
2870 return bit_from_pos (DECL_FIELD_OFFSET (field),
2871 DECL_FIELD_BIT_OFFSET (field));
2874 /* Return the byte position of FIELD, in bytes from the start of the record.
2875 This is a tree of type sizetype. */
2877 tree
2878 byte_position (const_tree field)
2880 return byte_from_pos (DECL_FIELD_OFFSET (field),
2881 DECL_FIELD_BIT_OFFSET (field));
2884 /* Likewise, but return as an integer. It must be representable in
2885 that way (since it could be a signed value, we don't have the
2886 option of returning -1 like int_size_in_byte can. */
2888 HOST_WIDE_INT
2889 int_byte_position (const_tree field)
2891 return tree_to_shwi (byte_position (field));
2894 /* Return the strictest alignment, in bits, that T is known to have. */
2896 unsigned int
2897 expr_align (const_tree t)
2899 unsigned int align0, align1;
2901 switch (TREE_CODE (t))
2903 CASE_CONVERT: case NON_LVALUE_EXPR:
2904 /* If we have conversions, we know that the alignment of the
2905 object must meet each of the alignments of the types. */
2906 align0 = expr_align (TREE_OPERAND (t, 0));
2907 align1 = TYPE_ALIGN (TREE_TYPE (t));
2908 return MAX (align0, align1);
2910 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
2911 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
2912 case CLEANUP_POINT_EXPR:
2913 /* These don't change the alignment of an object. */
2914 return expr_align (TREE_OPERAND (t, 0));
2916 case COND_EXPR:
2917 /* The best we can do is say that the alignment is the least aligned
2918 of the two arms. */
2919 align0 = expr_align (TREE_OPERAND (t, 1));
2920 align1 = expr_align (TREE_OPERAND (t, 2));
2921 return MIN (align0, align1);
2923 /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2924 meaningfully, it's always 1. */
2925 case LABEL_DECL: case CONST_DECL:
2926 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
2927 case FUNCTION_DECL:
2928 gcc_assert (DECL_ALIGN (t) != 0);
2929 return DECL_ALIGN (t);
2931 default:
2932 break;
2935 /* Otherwise take the alignment from that of the type. */
2936 return TYPE_ALIGN (TREE_TYPE (t));
2939 /* Return, as a tree node, the number of elements for TYPE (which is an
2940 ARRAY_TYPE) minus one. This counts only elements of the top array. */
2942 tree
2943 array_type_nelts (const_tree type)
2945 tree index_type, min, max;
2947 /* If they did it with unspecified bounds, then we should have already
2948 given an error about it before we got here. */
2949 if (! TYPE_DOMAIN (type))
2950 return error_mark_node;
2952 index_type = TYPE_DOMAIN (type);
2953 min = TYPE_MIN_VALUE (index_type);
2954 max = TYPE_MAX_VALUE (index_type);
2956 /* TYPE_MAX_VALUE may not be set if the array has unknown length. */
2957 if (!max)
2958 return error_mark_node;
2960 return (integer_zerop (min)
2961 ? max
2962 : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2965 /* If arg is static -- a reference to an object in static storage -- then
2966 return the object. This is not the same as the C meaning of `static'.
2967 If arg isn't static, return NULL. */
2969 tree
2970 staticp (tree arg)
2972 switch (TREE_CODE (arg))
2974 case FUNCTION_DECL:
2975 /* Nested functions are static, even though taking their address will
2976 involve a trampoline as we unnest the nested function and create
2977 the trampoline on the tree level. */
2978 return arg;
2980 case VAR_DECL:
2981 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2982 && ! DECL_THREAD_LOCAL_P (arg)
2983 && ! DECL_DLLIMPORT_P (arg)
2984 ? arg : NULL);
2986 case CONST_DECL:
2987 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2988 ? arg : NULL);
2990 case CONSTRUCTOR:
2991 return TREE_STATIC (arg) ? arg : NULL;
2993 case LABEL_DECL:
2994 case STRING_CST:
2995 return arg;
2997 case COMPONENT_REF:
2998 /* If the thing being referenced is not a field, then it is
2999 something language specific. */
3000 gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
3002 /* If we are referencing a bitfield, we can't evaluate an
3003 ADDR_EXPR at compile time and so it isn't a constant. */
3004 if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
3005 return NULL;
3007 return staticp (TREE_OPERAND (arg, 0));
3009 case BIT_FIELD_REF:
3010 return NULL;
3012 case INDIRECT_REF:
3013 return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
3015 case ARRAY_REF:
3016 case ARRAY_RANGE_REF:
3017 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
3018 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
3019 return staticp (TREE_OPERAND (arg, 0));
3020 else
3021 return NULL;
3023 case COMPOUND_LITERAL_EXPR:
3024 return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
3026 default:
3027 return NULL;
3034 /* Return whether OP is a DECL whose address is function-invariant. */
3036 bool
3037 decl_address_invariant_p (const_tree op)
3039 /* The conditions below are slightly less strict than the one in
3040 staticp. */
3042 switch (TREE_CODE (op))
3044 case PARM_DECL:
3045 case RESULT_DECL:
3046 case LABEL_DECL:
3047 case FUNCTION_DECL:
3048 return true;
3050 case VAR_DECL:
3051 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3052 || DECL_THREAD_LOCAL_P (op)
3053 || DECL_CONTEXT (op) == current_function_decl
3054 || decl_function_context (op) == current_function_decl)
3055 return true;
3056 break;
3058 case CONST_DECL:
3059 if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3060 || decl_function_context (op) == current_function_decl)
3061 return true;
3062 break;
3064 default:
3065 break;
3068 return false;
3071 /* Return whether OP is a DECL whose address is interprocedural-invariant. */
3073 bool
3074 decl_address_ip_invariant_p (const_tree op)
3076 /* The conditions below are slightly less strict than the one in
3077 staticp. */
3079 switch (TREE_CODE (op))
3081 case LABEL_DECL:
3082 case FUNCTION_DECL:
3083 case STRING_CST:
3084 return true;
3086 case VAR_DECL:
3087 if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
3088 && !DECL_DLLIMPORT_P (op))
3089 || DECL_THREAD_LOCAL_P (op))
3090 return true;
3091 break;
3093 case CONST_DECL:
3094 if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
3095 return true;
3096 break;
3098 default:
3099 break;
3102 return false;
3106 /* Return true if T is function-invariant (internal function, does
3107 not handle arithmetic; that's handled in skip_simple_arithmetic and
3108 tree_invariant_p). */
3110 static bool tree_invariant_p (tree t);
3112 static bool
3113 tree_invariant_p_1 (tree t)
3115 tree op;
3117 if (TREE_CONSTANT (t)
3118 || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
3119 return true;
3121 switch (TREE_CODE (t))
3123 case SAVE_EXPR:
3124 return true;
3126 case ADDR_EXPR:
3127 op = TREE_OPERAND (t, 0);
3128 while (handled_component_p (op))
3130 switch (TREE_CODE (op))
3132 case ARRAY_REF:
3133 case ARRAY_RANGE_REF:
3134 if (!tree_invariant_p (TREE_OPERAND (op, 1))
3135 || TREE_OPERAND (op, 2) != NULL_TREE
3136 || TREE_OPERAND (op, 3) != NULL_TREE)
3137 return false;
3138 break;
3140 case COMPONENT_REF:
3141 if (TREE_OPERAND (op, 2) != NULL_TREE)
3142 return false;
3143 break;
3145 default:;
3147 op = TREE_OPERAND (op, 0);
3150 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
3152 default:
3153 break;
3156 return false;
3159 /* Return true if T is function-invariant. */
3161 static bool
3162 tree_invariant_p (tree t)
3164 tree inner = skip_simple_arithmetic (t);
3165 return tree_invariant_p_1 (inner);
3168 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3169 Do this to any expression which may be used in more than one place,
3170 but must be evaluated only once.
3172 Normally, expand_expr would reevaluate the expression each time.
3173 Calling save_expr produces something that is evaluated and recorded
3174 the first time expand_expr is called on it. Subsequent calls to
3175 expand_expr just reuse the recorded value.
3177 The call to expand_expr that generates code that actually computes
3178 the value is the first call *at compile time*. Subsequent calls
3179 *at compile time* generate code to use the saved value.
3180 This produces correct result provided that *at run time* control
3181 always flows through the insns made by the first expand_expr
3182 before reaching the other places where the save_expr was evaluated.
3183 You, the caller of save_expr, must make sure this is so.
3185 Constants, and certain read-only nodes, are returned with no
3186 SAVE_EXPR because that is safe. Expressions containing placeholders
3187 are not touched; see tree.def for an explanation of what these
3188 are used for. */
3190 tree
3191 save_expr (tree expr)
3193 tree t = fold (expr);
3194 tree inner;
3196 /* If the tree evaluates to a constant, then we don't want to hide that
3197 fact (i.e. this allows further folding, and direct checks for constants).
3198 However, a read-only object that has side effects cannot be bypassed.
3199 Since it is no problem to reevaluate literals, we just return the
3200 literal node. */
3201 inner = skip_simple_arithmetic (t);
3202 if (TREE_CODE (inner) == ERROR_MARK)
3203 return inner;
3205 if (tree_invariant_p_1 (inner))
3206 return t;
3208 /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3209 it means that the size or offset of some field of an object depends on
3210 the value within another field.
3212 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3213 and some variable since it would then need to be both evaluated once and
3214 evaluated more than once. Front-ends must assure this case cannot
3215 happen by surrounding any such subexpressions in their own SAVE_EXPR
3216 and forcing evaluation at the proper time. */
3217 if (contains_placeholder_p (inner))
3218 return t;
3220 t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
3221 SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
3223 /* This expression might be placed ahead of a jump to ensure that the
3224 value was computed on both sides of the jump. So make sure it isn't
3225 eliminated as dead. */
3226 TREE_SIDE_EFFECTS (t) = 1;
3227 return t;
3230 /* Look inside EXPR into any simple arithmetic operations. Return the
3231 outermost non-arithmetic or non-invariant node. */
3233 tree
3234 skip_simple_arithmetic (tree expr)
3236 /* We don't care about whether this can be used as an lvalue in this
3237 context. */
3238 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3239 expr = TREE_OPERAND (expr, 0);
3241 /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3242 a constant, it will be more efficient to not make another SAVE_EXPR since
3243 it will allow better simplification and GCSE will be able to merge the
3244 computations if they actually occur. */
3245 while (true)
3247 if (UNARY_CLASS_P (expr))
3248 expr = TREE_OPERAND (expr, 0);
3249 else if (BINARY_CLASS_P (expr))
3251 if (tree_invariant_p (TREE_OPERAND (expr, 1)))
3252 expr = TREE_OPERAND (expr, 0);
3253 else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
3254 expr = TREE_OPERAND (expr, 1);
3255 else
3256 break;
3258 else
3259 break;
3262 return expr;
3265 /* Look inside EXPR into simple arithmetic operations involving constants.
3266 Return the outermost non-arithmetic or non-constant node. */
3268 tree
3269 skip_simple_constant_arithmetic (tree expr)
3271 while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3272 expr = TREE_OPERAND (expr, 0);
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_CONSTANT (TREE_OPERAND (expr, 1)))
3281 expr = TREE_OPERAND (expr, 0);
3282 else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
3283 expr = TREE_OPERAND (expr, 1);
3284 else
3285 break;
3287 else
3288 break;
3291 return expr;
3294 /* Return which tree structure is used by T. */
3296 enum tree_node_structure_enum
3297 tree_node_structure (const_tree t)
3299 const enum tree_code code = TREE_CODE (t);
3300 return tree_node_structure_for_code (code);
3303 /* Set various status flags when building a CALL_EXPR object T. */
3305 static void
3306 process_call_operands (tree t)
3308 bool side_effects = TREE_SIDE_EFFECTS (t);
3309 bool read_only = false;
3310 int i = call_expr_flags (t);
3312 /* Calls have side-effects, except those to const or pure functions. */
3313 if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
3314 side_effects = true;
3315 /* Propagate TREE_READONLY of arguments for const functions. */
3316 if (i & ECF_CONST)
3317 read_only = true;
3319 if (!side_effects || read_only)
3320 for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
3322 tree op = TREE_OPERAND (t, i);
3323 if (op && TREE_SIDE_EFFECTS (op))
3324 side_effects = true;
3325 if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
3326 read_only = false;
3329 TREE_SIDE_EFFECTS (t) = side_effects;
3330 TREE_READONLY (t) = read_only;
3333 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3334 size or offset that depends on a field within a record. */
3336 bool
3337 contains_placeholder_p (const_tree exp)
3339 enum tree_code code;
3341 if (!exp)
3342 return 0;
3344 code = TREE_CODE (exp);
3345 if (code == PLACEHOLDER_EXPR)
3346 return 1;
3348 switch (TREE_CODE_CLASS (code))
3350 case tcc_reference:
3351 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3352 position computations since they will be converted into a
3353 WITH_RECORD_EXPR involving the reference, which will assume
3354 here will be valid. */
3355 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3357 case tcc_exceptional:
3358 if (code == TREE_LIST)
3359 return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
3360 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
3361 break;
3363 case tcc_unary:
3364 case tcc_binary:
3365 case tcc_comparison:
3366 case tcc_expression:
3367 switch (code)
3369 case COMPOUND_EXPR:
3370 /* Ignoring the first operand isn't quite right, but works best. */
3371 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
3373 case COND_EXPR:
3374 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3375 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
3376 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
3378 case SAVE_EXPR:
3379 /* The save_expr function never wraps anything containing
3380 a PLACEHOLDER_EXPR. */
3381 return 0;
3383 default:
3384 break;
3387 switch (TREE_CODE_LENGTH (code))
3389 case 1:
3390 return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3391 case 2:
3392 return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3393 || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
3394 default:
3395 return 0;
3398 case tcc_vl_exp:
3399 switch (code)
3401 case CALL_EXPR:
3403 const_tree arg;
3404 const_call_expr_arg_iterator iter;
3405 FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
3406 if (CONTAINS_PLACEHOLDER_P (arg))
3407 return 1;
3408 return 0;
3410 default:
3411 return 0;
3414 default:
3415 return 0;
3417 return 0;
3420 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3421 directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3422 field positions. */
3424 static bool
3425 type_contains_placeholder_1 (const_tree type)
3427 /* If the size contains a placeholder or the parent type (component type in
3428 the case of arrays) type involves a placeholder, this type does. */
3429 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
3430 || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
3431 || (!POINTER_TYPE_P (type)
3432 && TREE_TYPE (type)
3433 && type_contains_placeholder_p (TREE_TYPE (type))))
3434 return true;
3436 /* Now do type-specific checks. Note that the last part of the check above
3437 greatly limits what we have to do below. */
3438 switch (TREE_CODE (type))
3440 case VOID_TYPE:
3441 case POINTER_BOUNDS_TYPE:
3442 case COMPLEX_TYPE:
3443 case ENUMERAL_TYPE:
3444 case BOOLEAN_TYPE:
3445 case POINTER_TYPE:
3446 case OFFSET_TYPE:
3447 case REFERENCE_TYPE:
3448 case METHOD_TYPE:
3449 case FUNCTION_TYPE:
3450 case VECTOR_TYPE:
3451 case NULLPTR_TYPE:
3452 return false;
3454 case INTEGER_TYPE:
3455 case REAL_TYPE:
3456 case FIXED_POINT_TYPE:
3457 /* Here we just check the bounds. */
3458 return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
3459 || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
3461 case ARRAY_TYPE:
3462 /* We have already checked the component type above, so just check the
3463 domain type. */
3464 return type_contains_placeholder_p (TYPE_DOMAIN (type));
3466 case RECORD_TYPE:
3467 case UNION_TYPE:
3468 case QUAL_UNION_TYPE:
3470 tree field;
3472 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3473 if (TREE_CODE (field) == FIELD_DECL
3474 && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
3475 || (TREE_CODE (type) == QUAL_UNION_TYPE
3476 && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
3477 || type_contains_placeholder_p (TREE_TYPE (field))))
3478 return true;
3480 return false;
3483 default:
3484 gcc_unreachable ();
3488 /* Wrapper around above function used to cache its result. */
3490 bool
3491 type_contains_placeholder_p (tree type)
3493 bool result;
3495 /* If the contains_placeholder_bits field has been initialized,
3496 then we know the answer. */
3497 if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
3498 return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
3500 /* Indicate that we've seen this type node, and the answer is false.
3501 This is what we want to return if we run into recursion via fields. */
3502 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
3504 /* Compute the real value. */
3505 result = type_contains_placeholder_1 (type);
3507 /* Store the real value. */
3508 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
3510 return result;
3513 /* Push tree EXP onto vector QUEUE if it is not already present. */
3515 static void
3516 push_without_duplicates (tree exp, vec<tree> *queue)
3518 unsigned int i;
3519 tree iter;
3521 FOR_EACH_VEC_ELT (*queue, i, iter)
3522 if (simple_cst_equal (iter, exp) == 1)
3523 break;
3525 if (!iter)
3526 queue->safe_push (exp);
3529 /* Given a tree EXP, find all occurrences of references to fields
3530 in a PLACEHOLDER_EXPR and place them in vector REFS without
3531 duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
3532 we assume here that EXP contains only arithmetic expressions
3533 or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3534 argument list. */
3536 void
3537 find_placeholder_in_expr (tree exp, vec<tree> *refs)
3539 enum tree_code code = TREE_CODE (exp);
3540 tree inner;
3541 int i;
3543 /* We handle TREE_LIST and COMPONENT_REF separately. */
3544 if (code == TREE_LIST)
3546 FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
3547 FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
3549 else if (code == COMPONENT_REF)
3551 for (inner = TREE_OPERAND (exp, 0);
3552 REFERENCE_CLASS_P (inner);
3553 inner = TREE_OPERAND (inner, 0))
3556 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
3557 push_without_duplicates (exp, refs);
3558 else
3559 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
3561 else
3562 switch (TREE_CODE_CLASS (code))
3564 case tcc_constant:
3565 break;
3567 case tcc_declaration:
3568 /* Variables allocated to static storage can stay. */
3569 if (!TREE_STATIC (exp))
3570 push_without_duplicates (exp, refs);
3571 break;
3573 case tcc_expression:
3574 /* This is the pattern built in ada/make_aligning_type. */
3575 if (code == ADDR_EXPR
3576 && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3578 push_without_duplicates (exp, refs);
3579 break;
3582 /* Fall through... */
3584 case tcc_exceptional:
3585 case tcc_unary:
3586 case tcc_binary:
3587 case tcc_comparison:
3588 case tcc_reference:
3589 for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3590 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3591 break;
3593 case tcc_vl_exp:
3594 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3595 FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3596 break;
3598 default:
3599 gcc_unreachable ();
3603 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3604 return a tree with all occurrences of references to F in a
3605 PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
3606 CONST_DECLs. Note that we assume here that EXP contains only
3607 arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3608 occurring only in their argument list. */
3610 tree
3611 substitute_in_expr (tree exp, tree f, tree r)
3613 enum tree_code code = TREE_CODE (exp);
3614 tree op0, op1, op2, op3;
3615 tree new_tree;
3617 /* We handle TREE_LIST and COMPONENT_REF separately. */
3618 if (code == TREE_LIST)
3620 op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3621 op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3622 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3623 return exp;
3625 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3627 else if (code == COMPONENT_REF)
3629 tree inner;
3631 /* If this expression is getting a value from a PLACEHOLDER_EXPR
3632 and it is the right field, replace it with R. */
3633 for (inner = TREE_OPERAND (exp, 0);
3634 REFERENCE_CLASS_P (inner);
3635 inner = TREE_OPERAND (inner, 0))
3638 /* The field. */
3639 op1 = TREE_OPERAND (exp, 1);
3641 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3642 return r;
3644 /* If this expression hasn't been completed let, leave it alone. */
3645 if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3646 return exp;
3648 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3649 if (op0 == TREE_OPERAND (exp, 0))
3650 return exp;
3652 new_tree
3653 = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3655 else
3656 switch (TREE_CODE_CLASS (code))
3658 case tcc_constant:
3659 return exp;
3661 case tcc_declaration:
3662 if (exp == f)
3663 return r;
3664 else
3665 return exp;
3667 case tcc_expression:
3668 if (exp == f)
3669 return r;
3671 /* Fall through... */
3673 case tcc_exceptional:
3674 case tcc_unary:
3675 case tcc_binary:
3676 case tcc_comparison:
3677 case tcc_reference:
3678 switch (TREE_CODE_LENGTH (code))
3680 case 0:
3681 return exp;
3683 case 1:
3684 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3685 if (op0 == TREE_OPERAND (exp, 0))
3686 return exp;
3688 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3689 break;
3691 case 2:
3692 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3693 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3695 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3696 return exp;
3698 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3699 break;
3701 case 3:
3702 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3703 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3704 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3706 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3707 && op2 == TREE_OPERAND (exp, 2))
3708 return exp;
3710 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3711 break;
3713 case 4:
3714 op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3715 op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3716 op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3717 op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3719 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3720 && op2 == TREE_OPERAND (exp, 2)
3721 && op3 == TREE_OPERAND (exp, 3))
3722 return exp;
3724 new_tree
3725 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3726 break;
3728 default:
3729 gcc_unreachable ();
3731 break;
3733 case tcc_vl_exp:
3735 int i;
3737 new_tree = NULL_TREE;
3739 /* If we are trying to replace F with a constant, inline back
3740 functions which do nothing else than computing a value from
3741 the arguments they are passed. This makes it possible to
3742 fold partially or entirely the replacement expression. */
3743 if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3745 tree t = maybe_inline_call_in_expr (exp);
3746 if (t)
3747 return SUBSTITUTE_IN_EXPR (t, f, r);
3750 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3752 tree op = TREE_OPERAND (exp, i);
3753 tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3754 if (new_op != op)
3756 if (!new_tree)
3757 new_tree = copy_node (exp);
3758 TREE_OPERAND (new_tree, i) = new_op;
3762 if (new_tree)
3764 new_tree = fold (new_tree);
3765 if (TREE_CODE (new_tree) == CALL_EXPR)
3766 process_call_operands (new_tree);
3768 else
3769 return exp;
3771 break;
3773 default:
3774 gcc_unreachable ();
3777 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3779 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3780 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3782 return new_tree;
3785 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3786 for it within OBJ, a tree that is an object or a chain of references. */
3788 tree
3789 substitute_placeholder_in_expr (tree exp, tree obj)
3791 enum tree_code code = TREE_CODE (exp);
3792 tree op0, op1, op2, op3;
3793 tree new_tree;
3795 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3796 in the chain of OBJ. */
3797 if (code == PLACEHOLDER_EXPR)
3799 tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3800 tree elt;
3802 for (elt = obj; elt != 0;
3803 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3804 || TREE_CODE (elt) == COND_EXPR)
3805 ? TREE_OPERAND (elt, 1)
3806 : (REFERENCE_CLASS_P (elt)
3807 || UNARY_CLASS_P (elt)
3808 || BINARY_CLASS_P (elt)
3809 || VL_EXP_CLASS_P (elt)
3810 || EXPRESSION_CLASS_P (elt))
3811 ? TREE_OPERAND (elt, 0) : 0))
3812 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3813 return elt;
3815 for (elt = obj; elt != 0;
3816 elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3817 || TREE_CODE (elt) == COND_EXPR)
3818 ? TREE_OPERAND (elt, 1)
3819 : (REFERENCE_CLASS_P (elt)
3820 || UNARY_CLASS_P (elt)
3821 || BINARY_CLASS_P (elt)
3822 || VL_EXP_CLASS_P (elt)
3823 || EXPRESSION_CLASS_P (elt))
3824 ? TREE_OPERAND (elt, 0) : 0))
3825 if (POINTER_TYPE_P (TREE_TYPE (elt))
3826 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3827 == need_type))
3828 return fold_build1 (INDIRECT_REF, need_type, elt);
3830 /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
3831 survives until RTL generation, there will be an error. */
3832 return exp;
3835 /* TREE_LIST is special because we need to look at TREE_VALUE
3836 and TREE_CHAIN, not TREE_OPERANDS. */
3837 else if (code == TREE_LIST)
3839 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3840 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3841 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3842 return exp;
3844 return tree_cons (TREE_PURPOSE (exp), op1, op0);
3846 else
3847 switch (TREE_CODE_CLASS (code))
3849 case tcc_constant:
3850 case tcc_declaration:
3851 return exp;
3853 case tcc_exceptional:
3854 case tcc_unary:
3855 case tcc_binary:
3856 case tcc_comparison:
3857 case tcc_expression:
3858 case tcc_reference:
3859 case tcc_statement:
3860 switch (TREE_CODE_LENGTH (code))
3862 case 0:
3863 return exp;
3865 case 1:
3866 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3867 if (op0 == TREE_OPERAND (exp, 0))
3868 return exp;
3870 new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3871 break;
3873 case 2:
3874 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3875 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3877 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3878 return exp;
3880 new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3881 break;
3883 case 3:
3884 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3885 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3886 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3888 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3889 && op2 == TREE_OPERAND (exp, 2))
3890 return exp;
3892 new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3893 break;
3895 case 4:
3896 op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3897 op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3898 op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3899 op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3901 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3902 && op2 == TREE_OPERAND (exp, 2)
3903 && op3 == TREE_OPERAND (exp, 3))
3904 return exp;
3906 new_tree
3907 = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3908 break;
3910 default:
3911 gcc_unreachable ();
3913 break;
3915 case tcc_vl_exp:
3917 int i;
3919 new_tree = NULL_TREE;
3921 for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3923 tree op = TREE_OPERAND (exp, i);
3924 tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3925 if (new_op != op)
3927 if (!new_tree)
3928 new_tree = copy_node (exp);
3929 TREE_OPERAND (new_tree, i) = new_op;
3933 if (new_tree)
3935 new_tree = fold (new_tree);
3936 if (TREE_CODE (new_tree) == CALL_EXPR)
3937 process_call_operands (new_tree);
3939 else
3940 return exp;
3942 break;
3944 default:
3945 gcc_unreachable ();
3948 TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3950 if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3951 TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3953 return new_tree;
3957 /* Subroutine of stabilize_reference; this is called for subtrees of
3958 references. Any expression with side-effects must be put in a SAVE_EXPR
3959 to ensure that it is only evaluated once.
3961 We don't put SAVE_EXPR nodes around everything, because assigning very
3962 simple expressions to temporaries causes us to miss good opportunities
3963 for optimizations. Among other things, the opportunity to fold in the
3964 addition of a constant into an addressing mode often gets lost, e.g.
3965 "y[i+1] += x;". In general, we take the approach that we should not make
3966 an assignment unless we are forced into it - i.e., that any non-side effect
3967 operator should be allowed, and that cse should take care of coalescing
3968 multiple utterances of the same expression should that prove fruitful. */
3970 static tree
3971 stabilize_reference_1 (tree e)
3973 tree result;
3974 enum tree_code code = TREE_CODE (e);
3976 /* We cannot ignore const expressions because it might be a reference
3977 to a const array but whose index contains side-effects. But we can
3978 ignore things that are actual constant or that already have been
3979 handled by this function. */
3981 if (tree_invariant_p (e))
3982 return e;
3984 switch (TREE_CODE_CLASS (code))
3986 case tcc_exceptional:
3987 case tcc_type:
3988 case tcc_declaration:
3989 case tcc_comparison:
3990 case tcc_statement:
3991 case tcc_expression:
3992 case tcc_reference:
3993 case tcc_vl_exp:
3994 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3995 so that it will only be evaluated once. */
3996 /* The reference (r) and comparison (<) classes could be handled as
3997 below, but it is generally faster to only evaluate them once. */
3998 if (TREE_SIDE_EFFECTS (e))
3999 return save_expr (e);
4000 return e;
4002 case tcc_constant:
4003 /* Constants need no processing. In fact, we should never reach
4004 here. */
4005 return e;
4007 case tcc_binary:
4008 /* Division is slow and tends to be compiled with jumps,
4009 especially the division by powers of 2 that is often
4010 found inside of an array reference. So do it just once. */
4011 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
4012 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
4013 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
4014 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
4015 return save_expr (e);
4016 /* Recursively stabilize each operand. */
4017 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
4018 stabilize_reference_1 (TREE_OPERAND (e, 1)));
4019 break;
4021 case tcc_unary:
4022 /* Recursively stabilize each operand. */
4023 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
4024 break;
4026 default:
4027 gcc_unreachable ();
4030 TREE_TYPE (result) = TREE_TYPE (e);
4031 TREE_READONLY (result) = TREE_READONLY (e);
4032 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
4033 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
4035 return result;
4038 /* Stabilize a reference so that we can use it any number of times
4039 without causing its operands to be evaluated more than once.
4040 Returns the stabilized reference. This works by means of save_expr,
4041 so see the caveats in the comments about save_expr.
4043 Also allows conversion expressions whose operands are references.
4044 Any other kind of expression is returned unchanged. */
4046 tree
4047 stabilize_reference (tree ref)
4049 tree result;
4050 enum tree_code code = TREE_CODE (ref);
4052 switch (code)
4054 case VAR_DECL:
4055 case PARM_DECL:
4056 case RESULT_DECL:
4057 /* No action is needed in this case. */
4058 return ref;
4060 CASE_CONVERT:
4061 case FLOAT_EXPR:
4062 case FIX_TRUNC_EXPR:
4063 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
4064 break;
4066 case INDIRECT_REF:
4067 result = build_nt (INDIRECT_REF,
4068 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
4069 break;
4071 case COMPONENT_REF:
4072 result = build_nt (COMPONENT_REF,
4073 stabilize_reference (TREE_OPERAND (ref, 0)),
4074 TREE_OPERAND (ref, 1), NULL_TREE);
4075 break;
4077 case BIT_FIELD_REF:
4078 result = build_nt (BIT_FIELD_REF,
4079 stabilize_reference (TREE_OPERAND (ref, 0)),
4080 TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
4081 break;
4083 case ARRAY_REF:
4084 result = build_nt (ARRAY_REF,
4085 stabilize_reference (TREE_OPERAND (ref, 0)),
4086 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4087 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4088 break;
4090 case ARRAY_RANGE_REF:
4091 result = build_nt (ARRAY_RANGE_REF,
4092 stabilize_reference (TREE_OPERAND (ref, 0)),
4093 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4094 TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4095 break;
4097 case COMPOUND_EXPR:
4098 /* We cannot wrap the first expression in a SAVE_EXPR, as then
4099 it wouldn't be ignored. This matters when dealing with
4100 volatiles. */
4101 return stabilize_reference_1 (ref);
4103 /* If arg isn't a kind of lvalue we recognize, make no change.
4104 Caller should recognize the error for an invalid lvalue. */
4105 default:
4106 return ref;
4108 case ERROR_MARK:
4109 return error_mark_node;
4112 TREE_TYPE (result) = TREE_TYPE (ref);
4113 TREE_READONLY (result) = TREE_READONLY (ref);
4114 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
4115 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
4117 return result;
4120 /* Low-level constructors for expressions. */
4122 /* A helper function for build1 and constant folders. Set TREE_CONSTANT,
4123 and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
4125 void
4126 recompute_tree_invariant_for_addr_expr (tree t)
4128 tree node;
4129 bool tc = true, se = false;
4131 /* We started out assuming this address is both invariant and constant, but
4132 does not have side effects. Now go down any handled components and see if
4133 any of them involve offsets that are either non-constant or non-invariant.
4134 Also check for side-effects.
4136 ??? Note that this code makes no attempt to deal with the case where
4137 taking the address of something causes a copy due to misalignment. */
4139 #define UPDATE_FLAGS(NODE) \
4140 do { tree _node = (NODE); \
4141 if (_node && !TREE_CONSTANT (_node)) tc = false; \
4142 if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4144 for (node = TREE_OPERAND (t, 0); handled_component_p (node);
4145 node = TREE_OPERAND (node, 0))
4147 /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4148 array reference (probably made temporarily by the G++ front end),
4149 so ignore all the operands. */
4150 if ((TREE_CODE (node) == ARRAY_REF
4151 || TREE_CODE (node) == ARRAY_RANGE_REF)
4152 && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
4154 UPDATE_FLAGS (TREE_OPERAND (node, 1));
4155 if (TREE_OPERAND (node, 2))
4156 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4157 if (TREE_OPERAND (node, 3))
4158 UPDATE_FLAGS (TREE_OPERAND (node, 3));
4160 /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4161 FIELD_DECL, apparently. The G++ front end can put something else
4162 there, at least temporarily. */
4163 else if (TREE_CODE (node) == COMPONENT_REF
4164 && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
4166 if (TREE_OPERAND (node, 2))
4167 UPDATE_FLAGS (TREE_OPERAND (node, 2));
4171 node = lang_hooks.expr_to_decl (node, &tc, &se);
4173 /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
4174 the address, since &(*a)->b is a form of addition. If it's a constant, the
4175 address is constant too. If it's a decl, its address is constant if the
4176 decl is static. Everything else is not constant and, furthermore,
4177 taking the address of a volatile variable is not volatile. */
4178 if (TREE_CODE (node) == INDIRECT_REF
4179 || TREE_CODE (node) == MEM_REF)
4180 UPDATE_FLAGS (TREE_OPERAND (node, 0));
4181 else if (CONSTANT_CLASS_P (node))
4183 else if (DECL_P (node))
4184 tc &= (staticp (node) != NULL_TREE);
4185 else
4187 tc = false;
4188 se |= TREE_SIDE_EFFECTS (node);
4192 TREE_CONSTANT (t) = tc;
4193 TREE_SIDE_EFFECTS (t) = se;
4194 #undef UPDATE_FLAGS
4197 /* Build an expression of code CODE, data type TYPE, and operands as
4198 specified. Expressions and reference nodes can be created this way.
4199 Constants, decls, types and misc nodes cannot be.
4201 We define 5 non-variadic functions, from 0 to 4 arguments. This is
4202 enough for all extant tree codes. */
4204 tree
4205 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
4207 tree t;
4209 gcc_assert (TREE_CODE_LENGTH (code) == 0);
4211 t = make_node_stat (code PASS_MEM_STAT);
4212 TREE_TYPE (t) = tt;
4214 return t;
4217 tree
4218 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
4220 int length = sizeof (struct tree_exp);
4221 tree t;
4223 record_node_allocation_statistics (code, length);
4225 gcc_assert (TREE_CODE_LENGTH (code) == 1);
4227 t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
4229 memset (t, 0, sizeof (struct tree_common));
4231 TREE_SET_CODE (t, code);
4233 TREE_TYPE (t) = type;
4234 SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
4235 TREE_OPERAND (t, 0) = node;
4236 if (node && !TYPE_P (node))
4238 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
4239 TREE_READONLY (t) = TREE_READONLY (node);
4242 if (TREE_CODE_CLASS (code) == tcc_statement)
4243 TREE_SIDE_EFFECTS (t) = 1;
4244 else switch (code)
4246 case VA_ARG_EXPR:
4247 /* All of these have side-effects, no matter what their
4248 operands are. */
4249 TREE_SIDE_EFFECTS (t) = 1;
4250 TREE_READONLY (t) = 0;
4251 break;
4253 case INDIRECT_REF:
4254 /* Whether a dereference is readonly has nothing to do with whether
4255 its operand is readonly. */
4256 TREE_READONLY (t) = 0;
4257 break;
4259 case ADDR_EXPR:
4260 if (node)
4261 recompute_tree_invariant_for_addr_expr (t);
4262 break;
4264 default:
4265 if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
4266 && node && !TYPE_P (node)
4267 && TREE_CONSTANT (node))
4268 TREE_CONSTANT (t) = 1;
4269 if (TREE_CODE_CLASS (code) == tcc_reference
4270 && node && TREE_THIS_VOLATILE (node))
4271 TREE_THIS_VOLATILE (t) = 1;
4272 break;
4275 return t;
4278 #define PROCESS_ARG(N) \
4279 do { \
4280 TREE_OPERAND (t, N) = arg##N; \
4281 if (arg##N &&!TYPE_P (arg##N)) \
4283 if (TREE_SIDE_EFFECTS (arg##N)) \
4284 side_effects = 1; \
4285 if (!TREE_READONLY (arg##N) \
4286 && !CONSTANT_CLASS_P (arg##N)) \
4287 (void) (read_only = 0); \
4288 if (!TREE_CONSTANT (arg##N)) \
4289 (void) (constant = 0); \
4291 } while (0)
4293 tree
4294 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
4296 bool constant, read_only, side_effects;
4297 tree t;
4299 gcc_assert (TREE_CODE_LENGTH (code) == 2);
4301 if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
4302 && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
4303 /* When sizetype precision doesn't match that of pointers
4304 we need to be able to build explicit extensions or truncations
4305 of the offset argument. */
4306 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
4307 gcc_assert (TREE_CODE (arg0) == INTEGER_CST
4308 && TREE_CODE (arg1) == INTEGER_CST);
4310 if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
4311 gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
4312 && ptrofftype_p (TREE_TYPE (arg1)));
4314 t = make_node_stat (code PASS_MEM_STAT);
4315 TREE_TYPE (t) = tt;
4317 /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4318 result based on those same flags for the arguments. But if the
4319 arguments aren't really even `tree' expressions, we shouldn't be trying
4320 to do this. */
4322 /* Expressions without side effects may be constant if their
4323 arguments are as well. */
4324 constant = (TREE_CODE_CLASS (code) == tcc_comparison
4325 || TREE_CODE_CLASS (code) == tcc_binary);
4326 read_only = 1;
4327 side_effects = TREE_SIDE_EFFECTS (t);
4329 PROCESS_ARG (0);
4330 PROCESS_ARG (1);
4332 TREE_READONLY (t) = read_only;
4333 TREE_CONSTANT (t) = constant;
4334 TREE_SIDE_EFFECTS (t) = side_effects;
4335 TREE_THIS_VOLATILE (t)
4336 = (TREE_CODE_CLASS (code) == tcc_reference
4337 && arg0 && TREE_THIS_VOLATILE (arg0));
4339 return t;
4343 tree
4344 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4345 tree arg2 MEM_STAT_DECL)
4347 bool constant, read_only, side_effects;
4348 tree t;
4350 gcc_assert (TREE_CODE_LENGTH (code) == 3);
4351 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4353 t = make_node_stat (code PASS_MEM_STAT);
4354 TREE_TYPE (t) = tt;
4356 read_only = 1;
4358 /* As a special exception, if COND_EXPR has NULL branches, we
4359 assume that it is a gimple statement and always consider
4360 it to have side effects. */
4361 if (code == COND_EXPR
4362 && tt == void_type_node
4363 && arg1 == NULL_TREE
4364 && arg2 == NULL_TREE)
4365 side_effects = true;
4366 else
4367 side_effects = TREE_SIDE_EFFECTS (t);
4369 PROCESS_ARG (0);
4370 PROCESS_ARG (1);
4371 PROCESS_ARG (2);
4373 if (code == COND_EXPR)
4374 TREE_READONLY (t) = read_only;
4376 TREE_SIDE_EFFECTS (t) = side_effects;
4377 TREE_THIS_VOLATILE (t)
4378 = (TREE_CODE_CLASS (code) == tcc_reference
4379 && arg0 && TREE_THIS_VOLATILE (arg0));
4381 return t;
4384 tree
4385 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4386 tree arg2, tree arg3 MEM_STAT_DECL)
4388 bool constant, read_only, side_effects;
4389 tree t;
4391 gcc_assert (TREE_CODE_LENGTH (code) == 4);
4393 t = make_node_stat (code PASS_MEM_STAT);
4394 TREE_TYPE (t) = tt;
4396 side_effects = TREE_SIDE_EFFECTS (t);
4398 PROCESS_ARG (0);
4399 PROCESS_ARG (1);
4400 PROCESS_ARG (2);
4401 PROCESS_ARG (3);
4403 TREE_SIDE_EFFECTS (t) = side_effects;
4404 TREE_THIS_VOLATILE (t)
4405 = (TREE_CODE_CLASS (code) == tcc_reference
4406 && arg0 && TREE_THIS_VOLATILE (arg0));
4408 return t;
4411 tree
4412 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4413 tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
4415 bool constant, read_only, side_effects;
4416 tree t;
4418 gcc_assert (TREE_CODE_LENGTH (code) == 5);
4420 t = make_node_stat (code PASS_MEM_STAT);
4421 TREE_TYPE (t) = tt;
4423 side_effects = TREE_SIDE_EFFECTS (t);
4425 PROCESS_ARG (0);
4426 PROCESS_ARG (1);
4427 PROCESS_ARG (2);
4428 PROCESS_ARG (3);
4429 PROCESS_ARG (4);
4431 TREE_SIDE_EFFECTS (t) = side_effects;
4432 TREE_THIS_VOLATILE (t)
4433 = (TREE_CODE_CLASS (code) == tcc_reference
4434 && arg0 && TREE_THIS_VOLATILE (arg0));
4436 return t;
4439 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4440 on the pointer PTR. */
4442 tree
4443 build_simple_mem_ref_loc (location_t loc, tree ptr)
4445 HOST_WIDE_INT offset = 0;
4446 tree ptype = TREE_TYPE (ptr);
4447 tree tem;
4448 /* For convenience allow addresses that collapse to a simple base
4449 and offset. */
4450 if (TREE_CODE (ptr) == ADDR_EXPR
4451 && (handled_component_p (TREE_OPERAND (ptr, 0))
4452 || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
4454 ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
4455 gcc_assert (ptr);
4456 ptr = build_fold_addr_expr (ptr);
4457 gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
4459 tem = build2 (MEM_REF, TREE_TYPE (ptype),
4460 ptr, build_int_cst (ptype, offset));
4461 SET_EXPR_LOCATION (tem, loc);
4462 return tem;
4465 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
4467 offset_int
4468 mem_ref_offset (const_tree t)
4470 return offset_int::from (TREE_OPERAND (t, 1), SIGNED);
4473 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4474 offsetted by OFFSET units. */
4476 tree
4477 build_invariant_address (tree type, tree base, HOST_WIDE_INT offset)
4479 tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
4480 build_fold_addr_expr (base),
4481 build_int_cst (ptr_type_node, offset));
4482 tree addr = build1 (ADDR_EXPR, type, ref);
4483 recompute_tree_invariant_for_addr_expr (addr);
4484 return addr;
4487 /* Similar except don't specify the TREE_TYPE
4488 and leave the TREE_SIDE_EFFECTS as 0.
4489 It is permissible for arguments to be null,
4490 or even garbage if their values do not matter. */
4492 tree
4493 build_nt (enum tree_code code, ...)
4495 tree t;
4496 int length;
4497 int i;
4498 va_list p;
4500 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4502 va_start (p, code);
4504 t = make_node (code);
4505 length = TREE_CODE_LENGTH (code);
4507 for (i = 0; i < length; i++)
4508 TREE_OPERAND (t, i) = va_arg (p, tree);
4510 va_end (p);
4511 return t;
4514 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4515 tree vec. */
4517 tree
4518 build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
4520 tree ret, t;
4521 unsigned int ix;
4523 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
4524 CALL_EXPR_FN (ret) = fn;
4525 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4526 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
4527 CALL_EXPR_ARG (ret, ix) = t;
4528 return ret;
4531 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4532 We do NOT enter this node in any sort of symbol table.
4534 LOC is the location of the decl.
4536 layout_decl is used to set up the decl's storage layout.
4537 Other slots are initialized to 0 or null pointers. */
4539 tree
4540 build_decl_stat (location_t loc, enum tree_code code, tree name,
4541 tree type MEM_STAT_DECL)
4543 tree t;
4545 t = make_node_stat (code PASS_MEM_STAT);
4546 DECL_SOURCE_LOCATION (t) = loc;
4548 /* if (type == error_mark_node)
4549 type = integer_type_node; */
4550 /* That is not done, deliberately, so that having error_mark_node
4551 as the type can suppress useless errors in the use of this variable. */
4553 DECL_NAME (t) = name;
4554 TREE_TYPE (t) = type;
4556 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4557 layout_decl (t, 0);
4559 return t;
4562 /* Builds and returns function declaration with NAME and TYPE. */
4564 tree
4565 build_fn_decl (const char *name, tree type)
4567 tree id = get_identifier (name);
4568 tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4570 DECL_EXTERNAL (decl) = 1;
4571 TREE_PUBLIC (decl) = 1;
4572 DECL_ARTIFICIAL (decl) = 1;
4573 TREE_NOTHROW (decl) = 1;
4575 return decl;
4578 vec<tree, va_gc> *all_translation_units;
4580 /* Builds a new translation-unit decl with name NAME, queues it in the
4581 global list of translation-unit decls and returns it. */
4583 tree
4584 build_translation_unit_decl (tree name)
4586 tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4587 name, NULL_TREE);
4588 TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4589 vec_safe_push (all_translation_units, tu);
4590 return tu;
4594 /* BLOCK nodes are used to represent the structure of binding contours
4595 and declarations, once those contours have been exited and their contents
4596 compiled. This information is used for outputting debugging info. */
4598 tree
4599 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4601 tree block = make_node (BLOCK);
4603 BLOCK_VARS (block) = vars;
4604 BLOCK_SUBBLOCKS (block) = subblocks;
4605 BLOCK_SUPERCONTEXT (block) = supercontext;
4606 BLOCK_CHAIN (block) = chain;
4607 return block;
4611 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4613 LOC is the location to use in tree T. */
4615 void
4616 protected_set_expr_location (tree t, location_t loc)
4618 if (CAN_HAVE_LOCATION_P (t))
4619 SET_EXPR_LOCATION (t, loc);
4622 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4623 is ATTRIBUTE. */
4625 tree
4626 build_decl_attribute_variant (tree ddecl, tree attribute)
4628 DECL_ATTRIBUTES (ddecl) = attribute;
4629 return ddecl;
4632 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4633 is ATTRIBUTE and its qualifiers are QUALS.
4635 Record such modified types already made so we don't make duplicates. */
4637 tree
4638 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4640 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4642 inchash::hash hstate;
4643 tree ntype;
4644 int i;
4645 tree t;
4646 enum tree_code code = TREE_CODE (ttype);
4648 /* Building a distinct copy of a tagged type is inappropriate; it
4649 causes breakage in code that expects there to be a one-to-one
4650 relationship between a struct and its fields.
4651 build_duplicate_type is another solution (as used in
4652 handle_transparent_union_attribute), but that doesn't play well
4653 with the stronger C++ type identity model. */
4654 if (TREE_CODE (ttype) == RECORD_TYPE
4655 || TREE_CODE (ttype) == UNION_TYPE
4656 || TREE_CODE (ttype) == QUAL_UNION_TYPE
4657 || TREE_CODE (ttype) == ENUMERAL_TYPE)
4659 warning (OPT_Wattributes,
4660 "ignoring attributes applied to %qT after definition",
4661 TYPE_MAIN_VARIANT (ttype));
4662 return build_qualified_type (ttype, quals);
4665 ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4666 ntype = build_distinct_type_copy (ttype);
4668 TYPE_ATTRIBUTES (ntype) = attribute;
4670 hstate.add_int (code);
4671 if (TREE_TYPE (ntype))
4672 hstate.add_object (TYPE_HASH (TREE_TYPE (ntype)));
4673 attribute_hash_list (attribute, hstate);
4675 switch (TREE_CODE (ntype))
4677 case FUNCTION_TYPE:
4678 type_hash_list (TYPE_ARG_TYPES (ntype), hstate);
4679 break;
4680 case ARRAY_TYPE:
4681 if (TYPE_DOMAIN (ntype))
4682 hstate.add_object (TYPE_HASH (TYPE_DOMAIN (ntype)));
4683 break;
4684 case INTEGER_TYPE:
4685 t = TYPE_MAX_VALUE (ntype);
4686 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
4687 hstate.add_object (TREE_INT_CST_ELT (t, i));
4688 break;
4689 case REAL_TYPE:
4690 case FIXED_POINT_TYPE:
4692 unsigned int precision = TYPE_PRECISION (ntype);
4693 hstate.add_object (precision);
4695 break;
4696 default:
4697 break;
4700 ntype = type_hash_canon (hstate.end(), ntype);
4702 /* If the target-dependent attributes make NTYPE different from
4703 its canonical type, we will need to use structural equality
4704 checks for this type. */
4705 if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4706 || !comp_type_attributes (ntype, ttype))
4707 SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4708 else if (TYPE_CANONICAL (ntype) == ntype)
4709 TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4711 ttype = build_qualified_type (ntype, quals);
4713 else if (TYPE_QUALS (ttype) != quals)
4714 ttype = build_qualified_type (ttype, quals);
4716 return ttype;
4719 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4720 the same. */
4722 static bool
4723 omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
4725 tree cl1, cl2;
4726 for (cl1 = clauses1, cl2 = clauses2;
4727 cl1 && cl2;
4728 cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
4730 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
4731 return false;
4732 if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
4734 if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
4735 OMP_CLAUSE_DECL (cl2)) != 1)
4736 return false;
4738 switch (OMP_CLAUSE_CODE (cl1))
4740 case OMP_CLAUSE_ALIGNED:
4741 if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
4742 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
4743 return false;
4744 break;
4745 case OMP_CLAUSE_LINEAR:
4746 if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
4747 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
4748 return false;
4749 break;
4750 case OMP_CLAUSE_SIMDLEN:
4751 if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
4752 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
4753 return false;
4754 default:
4755 break;
4758 return true;
4761 /* Compare two constructor-element-type constants. Return 1 if the lists
4762 are known to be equal; otherwise return 0. */
4764 static bool
4765 simple_cst_list_equal (const_tree l1, const_tree l2)
4767 while (l1 != NULL_TREE && l2 != NULL_TREE)
4769 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
4770 return false;
4772 l1 = TREE_CHAIN (l1);
4773 l2 = TREE_CHAIN (l2);
4776 return l1 == l2;
4779 /* Compare two attributes for their value identity. Return true if the
4780 attribute values are known to be equal; otherwise return false.
4783 static bool
4784 attribute_value_equal (const_tree attr1, const_tree attr2)
4786 if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
4787 return true;
4789 if (TREE_VALUE (attr1) != NULL_TREE
4790 && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
4791 && TREE_VALUE (attr2) != NULL
4792 && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
4793 return (simple_cst_list_equal (TREE_VALUE (attr1),
4794 TREE_VALUE (attr2)) == 1);
4796 if ((flag_openmp || flag_openmp_simd)
4797 && TREE_VALUE (attr1) && TREE_VALUE (attr2)
4798 && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
4799 && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
4800 return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
4801 TREE_VALUE (attr2));
4803 return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
4806 /* Return 0 if the attributes for two types are incompatible, 1 if they
4807 are compatible, and 2 if they are nearly compatible (which causes a
4808 warning to be generated). */
4810 comp_type_attributes (const_tree type1, const_tree type2)
4812 const_tree a1 = TYPE_ATTRIBUTES (type1);
4813 const_tree a2 = TYPE_ATTRIBUTES (type2);
4814 const_tree a;
4816 if (a1 == a2)
4817 return 1;
4818 for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
4820 const struct attribute_spec *as;
4821 const_tree attr;
4823 as = lookup_attribute_spec (get_attribute_name (a));
4824 if (!as || as->affects_type_identity == false)
4825 continue;
4827 attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
4828 if (!attr || !attribute_value_equal (a, attr))
4829 break;
4831 if (!a)
4833 for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
4835 const struct attribute_spec *as;
4837 as = lookup_attribute_spec (get_attribute_name (a));
4838 if (!as || as->affects_type_identity == false)
4839 continue;
4841 if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
4842 break;
4843 /* We don't need to compare trees again, as we did this
4844 already in first loop. */
4846 /* All types - affecting identity - are equal, so
4847 there is no need to call target hook for comparison. */
4848 if (!a)
4849 return 1;
4851 /* As some type combinations - like default calling-convention - might
4852 be compatible, we have to call the target hook to get the final result. */
4853 return targetm.comp_type_attributes (type1, type2);
4856 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4857 is ATTRIBUTE.
4859 Record such modified types already made so we don't make duplicates. */
4861 tree
4862 build_type_attribute_variant (tree ttype, tree attribute)
4864 return build_type_attribute_qual_variant (ttype, attribute,
4865 TYPE_QUALS (ttype));
4869 /* Reset the expression *EXPR_P, a size or position.
4871 ??? We could reset all non-constant sizes or positions. But it's cheap
4872 enough to not do so and refrain from adding workarounds to dwarf2out.c.
4874 We need to reset self-referential sizes or positions because they cannot
4875 be gimplified and thus can contain a CALL_EXPR after the gimplification
4876 is finished, which will run afoul of LTO streaming. And they need to be
4877 reset to something essentially dummy but not constant, so as to preserve
4878 the properties of the object they are attached to. */
4880 static inline void
4881 free_lang_data_in_one_sizepos (tree *expr_p)
4883 tree expr = *expr_p;
4884 if (CONTAINS_PLACEHOLDER_P (expr))
4885 *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4889 /* Reset all the fields in a binfo node BINFO. We only keep
4890 BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */
4892 static void
4893 free_lang_data_in_binfo (tree binfo)
4895 unsigned i;
4896 tree t;
4898 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4900 BINFO_VIRTUALS (binfo) = NULL_TREE;
4901 BINFO_BASE_ACCESSES (binfo) = NULL;
4902 BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4903 BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4905 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
4906 free_lang_data_in_binfo (t);
4910 /* Reset all language specific information still present in TYPE. */
4912 static void
4913 free_lang_data_in_type (tree type)
4915 gcc_assert (TYPE_P (type));
4917 /* Give the FE a chance to remove its own data first. */
4918 lang_hooks.free_lang_data (type);
4920 TREE_LANG_FLAG_0 (type) = 0;
4921 TREE_LANG_FLAG_1 (type) = 0;
4922 TREE_LANG_FLAG_2 (type) = 0;
4923 TREE_LANG_FLAG_3 (type) = 0;
4924 TREE_LANG_FLAG_4 (type) = 0;
4925 TREE_LANG_FLAG_5 (type) = 0;
4926 TREE_LANG_FLAG_6 (type) = 0;
4928 if (TREE_CODE (type) == FUNCTION_TYPE)
4930 /* Remove the const and volatile qualifiers from arguments. The
4931 C++ front end removes them, but the C front end does not,
4932 leading to false ODR violation errors when merging two
4933 instances of the same function signature compiled by
4934 different front ends. */
4935 tree p;
4937 for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4939 tree arg_type = TREE_VALUE (p);
4941 if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4943 int quals = TYPE_QUALS (arg_type)
4944 & ~TYPE_QUAL_CONST
4945 & ~TYPE_QUAL_VOLATILE;
4946 TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4947 free_lang_data_in_type (TREE_VALUE (p));
4952 /* Remove members that are not actually FIELD_DECLs from the field
4953 list of an aggregate. These occur in C++. */
4954 if (RECORD_OR_UNION_TYPE_P (type))
4956 tree prev, member;
4958 /* Note that TYPE_FIELDS can be shared across distinct
4959 TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is
4960 to be removed, we cannot set its TREE_CHAIN to NULL.
4961 Otherwise, we would not be able to find all the other fields
4962 in the other instances of this TREE_TYPE.
4964 This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */
4965 prev = NULL_TREE;
4966 member = TYPE_FIELDS (type);
4967 while (member)
4969 if (TREE_CODE (member) == FIELD_DECL
4970 || TREE_CODE (member) == TYPE_DECL)
4972 if (prev)
4973 TREE_CHAIN (prev) = member;
4974 else
4975 TYPE_FIELDS (type) = member;
4976 prev = member;
4979 member = TREE_CHAIN (member);
4982 if (prev)
4983 TREE_CHAIN (prev) = NULL_TREE;
4984 else
4985 TYPE_FIELDS (type) = NULL_TREE;
4987 TYPE_METHODS (type) = NULL_TREE;
4988 if (TYPE_BINFO (type))
4989 free_lang_data_in_binfo (TYPE_BINFO (type));
4991 else
4993 /* For non-aggregate types, clear out the language slot (which
4994 overloads TYPE_BINFO). */
4995 TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4997 if (INTEGRAL_TYPE_P (type)
4998 || SCALAR_FLOAT_TYPE_P (type)
4999 || FIXED_POINT_TYPE_P (type))
5001 free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
5002 free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
5006 free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
5007 free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
5009 if (TYPE_CONTEXT (type)
5010 && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
5012 tree ctx = TYPE_CONTEXT (type);
5015 ctx = BLOCK_SUPERCONTEXT (ctx);
5017 while (ctx && TREE_CODE (ctx) == BLOCK);
5018 TYPE_CONTEXT (type) = ctx;
5023 /* Return true if DECL may need an assembler name to be set. */
5025 static inline bool
5026 need_assembler_name_p (tree decl)
5028 /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition Rule
5029 merging. */
5030 if (flag_lto_odr_type_mering
5031 && TREE_CODE (decl) == TYPE_DECL
5032 && DECL_NAME (decl)
5033 && decl == TYPE_NAME (TREE_TYPE (decl))
5034 && !is_lang_specific (TREE_TYPE (decl))
5035 && AGGREGATE_TYPE_P (TREE_TYPE (decl))
5036 && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE)
5037 && !type_in_anonymous_namespace_p (TREE_TYPE (decl)))
5038 return !DECL_ASSEMBLER_NAME_SET_P (decl);
5039 /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
5040 if (TREE_CODE (decl) != FUNCTION_DECL
5041 && TREE_CODE (decl) != VAR_DECL)
5042 return false;
5044 /* If DECL already has its assembler name set, it does not need a
5045 new one. */
5046 if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
5047 || DECL_ASSEMBLER_NAME_SET_P (decl))
5048 return false;
5050 /* Abstract decls do not need an assembler name. */
5051 if (DECL_ABSTRACT_P (decl))
5052 return false;
5054 /* For VAR_DECLs, only static, public and external symbols need an
5055 assembler name. */
5056 if (TREE_CODE (decl) == VAR_DECL
5057 && !TREE_STATIC (decl)
5058 && !TREE_PUBLIC (decl)
5059 && !DECL_EXTERNAL (decl))
5060 return false;
5062 if (TREE_CODE (decl) == FUNCTION_DECL)
5064 /* Do not set assembler name on builtins. Allow RTL expansion to
5065 decide whether to expand inline or via a regular call. */
5066 if (DECL_BUILT_IN (decl)
5067 && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
5068 return false;
5070 /* Functions represented in the callgraph need an assembler name. */
5071 if (cgraph_node::get (decl) != NULL)
5072 return true;
5074 /* Unused and not public functions don't need an assembler name. */
5075 if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
5076 return false;
5079 return true;
5083 /* Reset all language specific information still present in symbol
5084 DECL. */
5086 static void
5087 free_lang_data_in_decl (tree decl)
5089 gcc_assert (DECL_P (decl));
5091 /* Give the FE a chance to remove its own data first. */
5092 lang_hooks.free_lang_data (decl);
5094 TREE_LANG_FLAG_0 (decl) = 0;
5095 TREE_LANG_FLAG_1 (decl) = 0;
5096 TREE_LANG_FLAG_2 (decl) = 0;
5097 TREE_LANG_FLAG_3 (decl) = 0;
5098 TREE_LANG_FLAG_4 (decl) = 0;
5099 TREE_LANG_FLAG_5 (decl) = 0;
5100 TREE_LANG_FLAG_6 (decl) = 0;
5102 free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
5103 free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
5104 if (TREE_CODE (decl) == FIELD_DECL)
5106 free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
5107 if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
5108 DECL_QUALIFIER (decl) = NULL_TREE;
5111 if (TREE_CODE (decl) == FUNCTION_DECL)
5113 struct cgraph_node *node;
5114 if (!(node = cgraph_node::get (decl))
5115 || (!node->definition && !node->clones))
5117 if (node)
5118 node->release_body ();
5119 else
5121 release_function_body (decl);
5122 DECL_ARGUMENTS (decl) = NULL;
5123 DECL_RESULT (decl) = NULL;
5124 DECL_INITIAL (decl) = error_mark_node;
5127 if (gimple_has_body_p (decl))
5129 tree t;
5131 /* If DECL has a gimple body, then the context for its
5132 arguments must be DECL. Otherwise, it doesn't really
5133 matter, as we will not be emitting any code for DECL. In
5134 general, there may be other instances of DECL created by
5135 the front end and since PARM_DECLs are generally shared,
5136 their DECL_CONTEXT changes as the replicas of DECL are
5137 created. The only time where DECL_CONTEXT is important
5138 is for the FUNCTION_DECLs that have a gimple body (since
5139 the PARM_DECL will be used in the function's body). */
5140 for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
5141 DECL_CONTEXT (t) = decl;
5144 /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5145 At this point, it is not needed anymore. */
5146 DECL_SAVED_TREE (decl) = NULL_TREE;
5148 /* Clear the abstract origin if it refers to a method. Otherwise
5149 dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5150 origin will not be output correctly. */
5151 if (DECL_ABSTRACT_ORIGIN (decl)
5152 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
5153 && RECORD_OR_UNION_TYPE_P
5154 (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
5155 DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
5157 /* Sometimes the C++ frontend doesn't manage to transform a temporary
5158 DECL_VINDEX referring to itself into a vtable slot number as it
5159 should. Happens with functions that are copied and then forgotten
5160 about. Just clear it, it won't matter anymore. */
5161 if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl)))
5162 DECL_VINDEX (decl) = NULL_TREE;
5164 else if (TREE_CODE (decl) == VAR_DECL)
5166 if ((DECL_EXTERNAL (decl)
5167 && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
5168 || (decl_function_context (decl) && !TREE_STATIC (decl)))
5169 DECL_INITIAL (decl) = NULL_TREE;
5171 else if (TREE_CODE (decl) == TYPE_DECL
5172 || TREE_CODE (decl) == FIELD_DECL)
5173 DECL_INITIAL (decl) = NULL_TREE;
5174 else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
5175 && DECL_INITIAL (decl)
5176 && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
5178 /* Strip builtins from the translation-unit BLOCK. We still have targets
5179 without builtin_decl_explicit support and also builtins are shared
5180 nodes and thus we can't use TREE_CHAIN in multiple lists. */
5181 tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
5182 while (*nextp)
5184 tree var = *nextp;
5185 if (TREE_CODE (var) == FUNCTION_DECL
5186 && DECL_BUILT_IN (var))
5187 *nextp = TREE_CHAIN (var);
5188 else
5189 nextp = &TREE_CHAIN (var);
5195 /* Data used when collecting DECLs and TYPEs for language data removal. */
5197 struct free_lang_data_d
5199 /* Worklist to avoid excessive recursion. */
5200 vec<tree> worklist;
5202 /* Set of traversed objects. Used to avoid duplicate visits. */
5203 hash_set<tree> *pset;
5205 /* Array of symbols to process with free_lang_data_in_decl. */
5206 vec<tree> decls;
5208 /* Array of types to process with free_lang_data_in_type. */
5209 vec<tree> types;
5213 /* Save all language fields needed to generate proper debug information
5214 for DECL. This saves most fields cleared out by free_lang_data_in_decl. */
5216 static void
5217 save_debug_info_for_decl (tree t)
5219 /*struct saved_debug_info_d *sdi;*/
5221 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
5223 /* FIXME. Partial implementation for saving debug info removed. */
5227 /* Save all language fields needed to generate proper debug information
5228 for TYPE. This saves most fields cleared out by free_lang_data_in_type. */
5230 static void
5231 save_debug_info_for_type (tree t)
5233 /*struct saved_debug_info_d *sdi;*/
5235 gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
5237 /* FIXME. Partial implementation for saving debug info removed. */
5241 /* Add type or decl T to one of the list of tree nodes that need their
5242 language data removed. The lists are held inside FLD. */
5244 static void
5245 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
5247 if (DECL_P (t))
5249 fld->decls.safe_push (t);
5250 if (debug_info_level > DINFO_LEVEL_TERSE)
5251 save_debug_info_for_decl (t);
5253 else if (TYPE_P (t))
5255 fld->types.safe_push (t);
5256 if (debug_info_level > DINFO_LEVEL_TERSE)
5257 save_debug_info_for_type (t);
5259 else
5260 gcc_unreachable ();
5263 /* Push tree node T into FLD->WORKLIST. */
5265 static inline void
5266 fld_worklist_push (tree t, struct free_lang_data_d *fld)
5268 if (t && !is_lang_specific (t) && !fld->pset->contains (t))
5269 fld->worklist.safe_push ((t));
5273 /* Operand callback helper for free_lang_data_in_node. *TP is the
5274 subtree operand being considered. */
5276 static tree
5277 find_decls_types_r (tree *tp, int *ws, void *data)
5279 tree t = *tp;
5280 struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
5282 if (TREE_CODE (t) == TREE_LIST)
5283 return NULL_TREE;
5285 /* Language specific nodes will be removed, so there is no need
5286 to gather anything under them. */
5287 if (is_lang_specific (t))
5289 *ws = 0;
5290 return NULL_TREE;
5293 if (DECL_P (t))
5295 /* Note that walk_tree does not traverse every possible field in
5296 decls, so we have to do our own traversals here. */
5297 add_tree_to_fld_list (t, fld);
5299 fld_worklist_push (DECL_NAME (t), fld);
5300 fld_worklist_push (DECL_CONTEXT (t), fld);
5301 fld_worklist_push (DECL_SIZE (t), fld);
5302 fld_worklist_push (DECL_SIZE_UNIT (t), fld);
5304 /* We are going to remove everything under DECL_INITIAL for
5305 TYPE_DECLs. No point walking them. */
5306 if (TREE_CODE (t) != TYPE_DECL)
5307 fld_worklist_push (DECL_INITIAL (t), fld);
5309 fld_worklist_push (DECL_ATTRIBUTES (t), fld);
5310 fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
5312 if (TREE_CODE (t) == FUNCTION_DECL)
5314 fld_worklist_push (DECL_ARGUMENTS (t), fld);
5315 fld_worklist_push (DECL_RESULT (t), fld);
5317 else if (TREE_CODE (t) == TYPE_DECL)
5319 fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
5321 else if (TREE_CODE (t) == FIELD_DECL)
5323 fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
5324 fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
5325 fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
5326 fld_worklist_push (DECL_FCONTEXT (t), fld);
5329 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
5330 && DECL_HAS_VALUE_EXPR_P (t))
5331 fld_worklist_push (DECL_VALUE_EXPR (t), fld);
5333 if (TREE_CODE (t) != FIELD_DECL
5334 && TREE_CODE (t) != TYPE_DECL)
5335 fld_worklist_push (TREE_CHAIN (t), fld);
5336 *ws = 0;
5338 else if (TYPE_P (t))
5340 /* Note that walk_tree does not traverse every possible field in
5341 types, so we have to do our own traversals here. */
5342 add_tree_to_fld_list (t, fld);
5344 if (!RECORD_OR_UNION_TYPE_P (t))
5345 fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
5346 fld_worklist_push (TYPE_SIZE (t), fld);
5347 fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
5348 fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
5349 fld_worklist_push (TYPE_POINTER_TO (t), fld);
5350 fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
5351 fld_worklist_push (TYPE_NAME (t), fld);
5352 /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. We do not stream
5353 them and thus do not and want not to reach unused pointer types
5354 this way. */
5355 if (!POINTER_TYPE_P (t))
5356 fld_worklist_push (TYPE_MINVAL (t), fld);
5357 if (!RECORD_OR_UNION_TYPE_P (t))
5358 fld_worklist_push (TYPE_MAXVAL (t), fld);
5359 fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
5360 /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus
5361 do not and want not to reach unused variants this way. */
5362 if (TYPE_CONTEXT (t))
5364 tree ctx = TYPE_CONTEXT (t);
5365 /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5366 So push that instead. */
5367 while (ctx && TREE_CODE (ctx) == BLOCK)
5368 ctx = BLOCK_SUPERCONTEXT (ctx);
5369 fld_worklist_push (ctx, fld);
5371 /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not
5372 and want not to reach unused types this way. */
5374 if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
5376 unsigned i;
5377 tree tem;
5378 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
5379 fld_worklist_push (TREE_TYPE (tem), fld);
5380 tem = BINFO_VIRTUALS (TYPE_BINFO (t));
5381 if (tem
5382 /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */
5383 && TREE_CODE (tem) == TREE_LIST)
5386 fld_worklist_push (TREE_VALUE (tem), fld);
5387 tem = TREE_CHAIN (tem);
5389 while (tem);
5391 if (RECORD_OR_UNION_TYPE_P (t))
5393 tree tem;
5394 /* Push all TYPE_FIELDS - there can be interleaving interesting
5395 and non-interesting things. */
5396 tem = TYPE_FIELDS (t);
5397 while (tem)
5399 if (TREE_CODE (tem) == FIELD_DECL
5400 || TREE_CODE (tem) == TYPE_DECL)
5401 fld_worklist_push (tem, fld);
5402 tem = TREE_CHAIN (tem);
5406 fld_worklist_push (TYPE_STUB_DECL (t), fld);
5407 *ws = 0;
5409 else if (TREE_CODE (t) == BLOCK)
5411 tree tem;
5412 for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
5413 fld_worklist_push (tem, fld);
5414 for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
5415 fld_worklist_push (tem, fld);
5416 fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
5419 if (TREE_CODE (t) != IDENTIFIER_NODE
5420 && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
5421 fld_worklist_push (TREE_TYPE (t), fld);
5423 return NULL_TREE;
5427 /* Find decls and types in T. */
5429 static void
5430 find_decls_types (tree t, struct free_lang_data_d *fld)
5432 while (1)
5434 if (!fld->pset->contains (t))
5435 walk_tree (&t, find_decls_types_r, fld, fld->pset);
5436 if (fld->worklist.is_empty ())
5437 break;
5438 t = fld->worklist.pop ();
5442 /* Translate all the types in LIST with the corresponding runtime
5443 types. */
5445 static tree
5446 get_eh_types_for_runtime (tree list)
5448 tree head, prev;
5450 if (list == NULL_TREE)
5451 return NULL_TREE;
5453 head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5454 prev = head;
5455 list = TREE_CHAIN (list);
5456 while (list)
5458 tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5459 TREE_CHAIN (prev) = n;
5460 prev = TREE_CHAIN (prev);
5461 list = TREE_CHAIN (list);
5464 return head;
5468 /* Find decls and types referenced in EH region R and store them in
5469 FLD->DECLS and FLD->TYPES. */
5471 static void
5472 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
5474 switch (r->type)
5476 case ERT_CLEANUP:
5477 break;
5479 case ERT_TRY:
5481 eh_catch c;
5483 /* The types referenced in each catch must first be changed to the
5484 EH types used at runtime. This removes references to FE types
5485 in the region. */
5486 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
5488 c->type_list = get_eh_types_for_runtime (c->type_list);
5489 walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
5492 break;
5494 case ERT_ALLOWED_EXCEPTIONS:
5495 r->u.allowed.type_list
5496 = get_eh_types_for_runtime (r->u.allowed.type_list);
5497 walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
5498 break;
5500 case ERT_MUST_NOT_THROW:
5501 walk_tree (&r->u.must_not_throw.failure_decl,
5502 find_decls_types_r, fld, fld->pset);
5503 break;
5508 /* Find decls and types referenced in cgraph node N and store them in
5509 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5510 look for *every* kind of DECL and TYPE node reachable from N,
5511 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5512 NAMESPACE_DECLs, etc). */
5514 static void
5515 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
5517 basic_block bb;
5518 struct function *fn;
5519 unsigned ix;
5520 tree t;
5522 find_decls_types (n->decl, fld);
5524 if (!gimple_has_body_p (n->decl))
5525 return;
5527 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
5529 fn = DECL_STRUCT_FUNCTION (n->decl);
5531 /* Traverse locals. */
5532 FOR_EACH_LOCAL_DECL (fn, ix, t)
5533 find_decls_types (t, fld);
5535 /* Traverse EH regions in FN. */
5537 eh_region r;
5538 FOR_ALL_EH_REGION_FN (r, fn)
5539 find_decls_types_in_eh_region (r, fld);
5542 /* Traverse every statement in FN. */
5543 FOR_EACH_BB_FN (bb, fn)
5545 gimple_stmt_iterator si;
5546 unsigned i;
5548 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
5550 gimple phi = gsi_stmt (si);
5552 for (i = 0; i < gimple_phi_num_args (phi); i++)
5554 tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
5555 find_decls_types (*arg_p, fld);
5559 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
5561 gimple stmt = gsi_stmt (si);
5563 if (is_gimple_call (stmt))
5564 find_decls_types (gimple_call_fntype (stmt), fld);
5566 for (i = 0; i < gimple_num_ops (stmt); i++)
5568 tree arg = gimple_op (stmt, i);
5569 find_decls_types (arg, fld);
5576 /* Find decls and types referenced in varpool node N and store them in
5577 FLD->DECLS and FLD->TYPES. Unlike pass_referenced_vars, this will
5578 look for *every* kind of DECL and TYPE node reachable from N,
5579 including those embedded inside types and decls (i.e,, TYPE_DECLs,
5580 NAMESPACE_DECLs, etc). */
5582 static void
5583 find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
5585 find_decls_types (v->decl, fld);
5588 /* If T needs an assembler name, have one created for it. */
5590 void
5591 assign_assembler_name_if_neeeded (tree t)
5593 if (need_assembler_name_p (t))
5595 /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5596 diagnostics that use input_location to show locus
5597 information. The problem here is that, at this point,
5598 input_location is generally anchored to the end of the file
5599 (since the parser is long gone), so we don't have a good
5600 position to pin it to.
5602 To alleviate this problem, this uses the location of T's
5603 declaration. Examples of this are
5604 testsuite/g++.dg/template/cond2.C and
5605 testsuite/g++.dg/template/pr35240.C. */
5606 location_t saved_location = input_location;
5607 input_location = DECL_SOURCE_LOCATION (t);
5609 decl_assembler_name (t);
5611 input_location = saved_location;
5616 /* Free language specific information for every operand and expression
5617 in every node of the call graph. This process operates in three stages:
5619 1- Every callgraph node and varpool node is traversed looking for
5620 decls and types embedded in them. This is a more exhaustive
5621 search than that done by find_referenced_vars, because it will
5622 also collect individual fields, decls embedded in types, etc.
5624 2- All the decls found are sent to free_lang_data_in_decl.
5626 3- All the types found are sent to free_lang_data_in_type.
5628 The ordering between decls and types is important because
5629 free_lang_data_in_decl sets assembler names, which includes
5630 mangling. So types cannot be freed up until assembler names have
5631 been set up. */
5633 static void
5634 free_lang_data_in_cgraph (void)
5636 struct cgraph_node *n;
5637 varpool_node *v;
5638 struct free_lang_data_d fld;
5639 tree t;
5640 unsigned i;
5641 alias_pair *p;
5643 /* Initialize sets and arrays to store referenced decls and types. */
5644 fld.pset = new hash_set<tree>;
5645 fld.worklist.create (0);
5646 fld.decls.create (100);
5647 fld.types.create (100);
5649 /* Find decls and types in the body of every function in the callgraph. */
5650 FOR_EACH_FUNCTION (n)
5651 find_decls_types_in_node (n, &fld);
5653 FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
5654 find_decls_types (p->decl, &fld);
5656 /* Find decls and types in every varpool symbol. */
5657 FOR_EACH_VARIABLE (v)
5658 find_decls_types_in_var (v, &fld);
5660 /* Set the assembler name on every decl found. We need to do this
5661 now because free_lang_data_in_decl will invalidate data needed
5662 for mangling. This breaks mangling on interdependent decls. */
5663 FOR_EACH_VEC_ELT (fld.decls, i, t)
5664 assign_assembler_name_if_neeeded (t);
5666 /* Traverse every decl found freeing its language data. */
5667 FOR_EACH_VEC_ELT (fld.decls, i, t)
5668 free_lang_data_in_decl (t);
5670 /* Traverse every type found freeing its language data. */
5671 FOR_EACH_VEC_ELT (fld.types, i, t)
5672 free_lang_data_in_type (t);
5674 delete fld.pset;
5675 fld.worklist.release ();
5676 fld.decls.release ();
5677 fld.types.release ();
5681 /* Free resources that are used by FE but are not needed once they are done. */
5683 static unsigned
5684 free_lang_data (void)
5686 unsigned i;
5688 /* If we are the LTO frontend we have freed lang-specific data already. */
5689 if (in_lto_p
5690 || !flag_generate_lto)
5691 return 0;
5693 /* Allocate and assign alias sets to the standard integer types
5694 while the slots are still in the way the frontends generated them. */
5695 for (i = 0; i < itk_none; ++i)
5696 if (integer_types[i])
5697 TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5699 /* Traverse the IL resetting language specific information for
5700 operands, expressions, etc. */
5701 free_lang_data_in_cgraph ();
5703 /* Create gimple variants for common types. */
5704 ptrdiff_type_node = integer_type_node;
5705 fileptr_type_node = ptr_type_node;
5707 /* Reset some langhooks. Do not reset types_compatible_p, it may
5708 still be used indirectly via the get_alias_set langhook. */
5709 lang_hooks.dwarf_name = lhd_dwarf_name;
5710 lang_hooks.decl_printable_name = gimple_decl_printable_name;
5711 /* We do not want the default decl_assembler_name implementation,
5712 rather if we have fixed everything we want a wrapper around it
5713 asserting that all non-local symbols already got their assembler
5714 name and only produce assembler names for local symbols. Or rather
5715 make sure we never call decl_assembler_name on local symbols and
5716 devise a separate, middle-end private scheme for it. */
5718 /* Reset diagnostic machinery. */
5719 tree_diagnostics_defaults (global_dc);
5721 return 0;
5725 namespace {
5727 const pass_data pass_data_ipa_free_lang_data =
5729 SIMPLE_IPA_PASS, /* type */
5730 "*free_lang_data", /* name */
5731 OPTGROUP_NONE, /* optinfo_flags */
5732 TV_IPA_FREE_LANG_DATA, /* tv_id */
5733 0, /* properties_required */
5734 0, /* properties_provided */
5735 0, /* properties_destroyed */
5736 0, /* todo_flags_start */
5737 0, /* todo_flags_finish */
5740 class pass_ipa_free_lang_data : public simple_ipa_opt_pass
5742 public:
5743 pass_ipa_free_lang_data (gcc::context *ctxt)
5744 : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
5747 /* opt_pass methods: */
5748 virtual unsigned int execute (function *) { return free_lang_data (); }
5750 }; // class pass_ipa_free_lang_data
5752 } // anon namespace
5754 simple_ipa_opt_pass *
5755 make_pass_ipa_free_lang_data (gcc::context *ctxt)
5757 return new pass_ipa_free_lang_data (ctxt);
5760 /* The backbone of is_attribute_p(). ATTR_LEN is the string length of
5761 ATTR_NAME. Also used internally by remove_attribute(). */
5762 bool
5763 private_is_attribute_p (const char *attr_name, size_t attr_len, const_tree ident)
5765 size_t ident_len = IDENTIFIER_LENGTH (ident);
5767 if (ident_len == attr_len)
5769 if (strcmp (attr_name, IDENTIFIER_POINTER (ident)) == 0)
5770 return true;
5772 else if (ident_len == attr_len + 4)
5774 /* There is the possibility that ATTR is 'text' and IDENT is
5775 '__text__'. */
5776 const char *p = IDENTIFIER_POINTER (ident);
5777 if (p[0] == '_' && p[1] == '_'
5778 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5779 && strncmp (attr_name, p + 2, attr_len) == 0)
5780 return true;
5783 return false;
5786 /* The backbone of lookup_attribute(). ATTR_LEN is the string length
5787 of ATTR_NAME, and LIST is not NULL_TREE. */
5788 tree
5789 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
5791 while (list)
5793 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5795 if (ident_len == attr_len)
5797 if (!strcmp (attr_name,
5798 IDENTIFIER_POINTER (get_attribute_name (list))))
5799 break;
5801 /* TODO: If we made sure that attributes were stored in the
5802 canonical form without '__...__' (ie, as in 'text' as opposed
5803 to '__text__') then we could avoid the following case. */
5804 else if (ident_len == attr_len + 4)
5806 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5807 if (p[0] == '_' && p[1] == '_'
5808 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5809 && strncmp (attr_name, p + 2, attr_len) == 0)
5810 break;
5812 list = TREE_CHAIN (list);
5815 return list;
5818 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
5819 return a pointer to the attribute's list first element if the attribute
5820 starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
5821 '__text__'). */
5823 tree
5824 private_lookup_attribute_by_prefix (const char *attr_name, size_t attr_len,
5825 tree list)
5827 while (list)
5829 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5831 if (attr_len > ident_len)
5833 list = TREE_CHAIN (list);
5834 continue;
5837 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5839 if (strncmp (attr_name, p, attr_len) == 0)
5840 break;
5842 /* TODO: If we made sure that attributes were stored in the
5843 canonical form without '__...__' (ie, as in 'text' as opposed
5844 to '__text__') then we could avoid the following case. */
5845 if (p[0] == '_' && p[1] == '_' &&
5846 strncmp (attr_name, p + 2, attr_len) == 0)
5847 break;
5849 list = TREE_CHAIN (list);
5852 return list;
5856 /* A variant of lookup_attribute() that can be used with an identifier
5857 as the first argument, and where the identifier can be either
5858 'text' or '__text__'.
5860 Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
5861 return a pointer to the attribute's list element if the attribute
5862 is part of the list, or NULL_TREE if not found. If the attribute
5863 appears more than once, this only returns the first occurrence; the
5864 TREE_CHAIN of the return value should be passed back in if further
5865 occurrences are wanted. ATTR_IDENTIFIER must be an identifier but
5866 can be in the form 'text' or '__text__'. */
5867 static tree
5868 lookup_ident_attribute (tree attr_identifier, tree list)
5870 gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
5872 while (list)
5874 gcc_checking_assert (TREE_CODE (get_attribute_name (list))
5875 == IDENTIFIER_NODE);
5877 /* Identifiers can be compared directly for equality. */
5878 if (attr_identifier == get_attribute_name (list))
5879 break;
5881 /* If they are not equal, they may still be one in the form
5882 'text' while the other one is in the form '__text__'. TODO:
5883 If we were storing attributes in normalized 'text' form, then
5884 this could all go away and we could take full advantage of
5885 the fact that we're comparing identifiers. :-) */
5887 size_t attr_len = IDENTIFIER_LENGTH (attr_identifier);
5888 size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
5890 if (ident_len == attr_len + 4)
5892 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5893 const char *q = IDENTIFIER_POINTER (attr_identifier);
5894 if (p[0] == '_' && p[1] == '_'
5895 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5896 && strncmp (q, p + 2, attr_len) == 0)
5897 break;
5899 else if (ident_len + 4 == attr_len)
5901 const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
5902 const char *q = IDENTIFIER_POINTER (attr_identifier);
5903 if (q[0] == '_' && q[1] == '_'
5904 && q[attr_len - 2] == '_' && q[attr_len - 1] == '_'
5905 && strncmp (q + 2, p, ident_len) == 0)
5906 break;
5909 list = TREE_CHAIN (list);
5912 return list;
5915 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5916 modified list. */
5918 tree
5919 remove_attribute (const char *attr_name, tree list)
5921 tree *p;
5922 size_t attr_len = strlen (attr_name);
5924 gcc_checking_assert (attr_name[0] != '_');
5926 for (p = &list; *p; )
5928 tree l = *p;
5929 /* TODO: If we were storing attributes in normalized form, here
5930 we could use a simple strcmp(). */
5931 if (private_is_attribute_p (attr_name, attr_len, get_attribute_name (l)))
5932 *p = TREE_CHAIN (l);
5933 else
5934 p = &TREE_CHAIN (l);
5937 return list;
5940 /* Return an attribute list that is the union of a1 and a2. */
5942 tree
5943 merge_attributes (tree a1, tree a2)
5945 tree attributes;
5947 /* Either one unset? Take the set one. */
5949 if ((attributes = a1) == 0)
5950 attributes = a2;
5952 /* One that completely contains the other? Take it. */
5954 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5956 if (attribute_list_contained (a2, a1))
5957 attributes = a2;
5958 else
5960 /* Pick the longest list, and hang on the other list. */
5962 if (list_length (a1) < list_length (a2))
5963 attributes = a2, a2 = a1;
5965 for (; a2 != 0; a2 = TREE_CHAIN (a2))
5967 tree a;
5968 for (a = lookup_ident_attribute (get_attribute_name (a2),
5969 attributes);
5970 a != NULL_TREE && !attribute_value_equal (a, a2);
5971 a = lookup_ident_attribute (get_attribute_name (a2),
5972 TREE_CHAIN (a)))
5974 if (a == NULL_TREE)
5976 a1 = copy_node (a2);
5977 TREE_CHAIN (a1) = attributes;
5978 attributes = a1;
5983 return attributes;
5986 /* Given types T1 and T2, merge their attributes and return
5987 the result. */
5989 tree
5990 merge_type_attributes (tree t1, tree t2)
5992 return merge_attributes (TYPE_ATTRIBUTES (t1),
5993 TYPE_ATTRIBUTES (t2));
5996 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5997 the result. */
5999 tree
6000 merge_decl_attributes (tree olddecl, tree newdecl)
6002 return merge_attributes (DECL_ATTRIBUTES (olddecl),
6003 DECL_ATTRIBUTES (newdecl));
6006 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
6008 /* Specialization of merge_decl_attributes for various Windows targets.
6010 This handles the following situation:
6012 __declspec (dllimport) int foo;
6013 int foo;
6015 The second instance of `foo' nullifies the dllimport. */
6017 tree
6018 merge_dllimport_decl_attributes (tree old, tree new_tree)
6020 tree a;
6021 int delete_dllimport_p = 1;
6023 /* What we need to do here is remove from `old' dllimport if it doesn't
6024 appear in `new'. dllimport behaves like extern: if a declaration is
6025 marked dllimport and a definition appears later, then the object
6026 is not dllimport'd. We also remove a `new' dllimport if the old list
6027 contains dllexport: dllexport always overrides dllimport, regardless
6028 of the order of declaration. */
6029 if (!VAR_OR_FUNCTION_DECL_P (new_tree))
6030 delete_dllimport_p = 0;
6031 else if (DECL_DLLIMPORT_P (new_tree)
6032 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
6034 DECL_DLLIMPORT_P (new_tree) = 0;
6035 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
6036 "dllimport ignored", new_tree);
6038 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
6040 /* Warn about overriding a symbol that has already been used, e.g.:
6041 extern int __attribute__ ((dllimport)) foo;
6042 int* bar () {return &foo;}
6043 int foo;
6045 if (TREE_USED (old))
6047 warning (0, "%q+D redeclared without dllimport attribute "
6048 "after being referenced with dll linkage", new_tree);
6049 /* If we have used a variable's address with dllimport linkage,
6050 keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
6051 decl may already have had TREE_CONSTANT computed.
6052 We still remove the attribute so that assembler code refers
6053 to '&foo rather than '_imp__foo'. */
6054 if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
6055 DECL_DLLIMPORT_P (new_tree) = 1;
6058 /* Let an inline definition silently override the external reference,
6059 but otherwise warn about attribute inconsistency. */
6060 else if (TREE_CODE (new_tree) == VAR_DECL
6061 || !DECL_DECLARED_INLINE_P (new_tree))
6062 warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
6063 "previous dllimport ignored", new_tree);
6065 else
6066 delete_dllimport_p = 0;
6068 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
6070 if (delete_dllimport_p)
6071 a = remove_attribute ("dllimport", a);
6073 return a;
6076 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
6077 struct attribute_spec.handler. */
6079 tree
6080 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
6081 bool *no_add_attrs)
6083 tree node = *pnode;
6084 bool is_dllimport;
6086 /* These attributes may apply to structure and union types being created,
6087 but otherwise should pass to the declaration involved. */
6088 if (!DECL_P (node))
6090 if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
6091 | (int) ATTR_FLAG_ARRAY_NEXT))
6093 *no_add_attrs = true;
6094 return tree_cons (name, args, NULL_TREE);
6096 if (TREE_CODE (node) == RECORD_TYPE
6097 || TREE_CODE (node) == UNION_TYPE)
6099 node = TYPE_NAME (node);
6100 if (!node)
6101 return NULL_TREE;
6103 else
6105 warning (OPT_Wattributes, "%qE attribute ignored",
6106 name);
6107 *no_add_attrs = true;
6108 return NULL_TREE;
6112 if (TREE_CODE (node) != FUNCTION_DECL
6113 && TREE_CODE (node) != VAR_DECL
6114 && TREE_CODE (node) != TYPE_DECL)
6116 *no_add_attrs = true;
6117 warning (OPT_Wattributes, "%qE attribute ignored",
6118 name);
6119 return NULL_TREE;
6122 if (TREE_CODE (node) == TYPE_DECL
6123 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
6124 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
6126 *no_add_attrs = true;
6127 warning (OPT_Wattributes, "%qE attribute ignored",
6128 name);
6129 return NULL_TREE;
6132 is_dllimport = is_attribute_p ("dllimport", name);
6134 /* Report error on dllimport ambiguities seen now before they cause
6135 any damage. */
6136 if (is_dllimport)
6138 /* Honor any target-specific overrides. */
6139 if (!targetm.valid_dllimport_attribute_p (node))
6140 *no_add_attrs = true;
6142 else if (TREE_CODE (node) == FUNCTION_DECL
6143 && DECL_DECLARED_INLINE_P (node))
6145 warning (OPT_Wattributes, "inline function %q+D declared as "
6146 " dllimport: attribute ignored", node);
6147 *no_add_attrs = true;
6149 /* Like MS, treat definition of dllimported variables and
6150 non-inlined functions on declaration as syntax errors. */
6151 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
6153 error ("function %q+D definition is marked dllimport", node);
6154 *no_add_attrs = true;
6157 else if (TREE_CODE (node) == VAR_DECL)
6159 if (DECL_INITIAL (node))
6161 error ("variable %q+D definition is marked dllimport",
6162 node);
6163 *no_add_attrs = true;
6166 /* `extern' needn't be specified with dllimport.
6167 Specify `extern' now and hope for the best. Sigh. */
6168 DECL_EXTERNAL (node) = 1;
6169 /* Also, implicitly give dllimport'd variables declared within
6170 a function global scope, unless declared static. */
6171 if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
6172 TREE_PUBLIC (node) = 1;
6175 if (*no_add_attrs == false)
6176 DECL_DLLIMPORT_P (node) = 1;
6178 else if (TREE_CODE (node) == FUNCTION_DECL
6179 && DECL_DECLARED_INLINE_P (node)
6180 && flag_keep_inline_dllexport)
6181 /* An exported function, even if inline, must be emitted. */
6182 DECL_EXTERNAL (node) = 0;
6184 /* Report error if symbol is not accessible at global scope. */
6185 if (!TREE_PUBLIC (node)
6186 && (TREE_CODE (node) == VAR_DECL
6187 || TREE_CODE (node) == FUNCTION_DECL))
6189 error ("external linkage required for symbol %q+D because of "
6190 "%qE attribute", node, name);
6191 *no_add_attrs = true;
6194 /* A dllexport'd entity must have default visibility so that other
6195 program units (shared libraries or the main executable) can see
6196 it. A dllimport'd entity must have default visibility so that
6197 the linker knows that undefined references within this program
6198 unit can be resolved by the dynamic linker. */
6199 if (!*no_add_attrs)
6201 if (DECL_VISIBILITY_SPECIFIED (node)
6202 && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
6203 error ("%qE implies default visibility, but %qD has already "
6204 "been declared with a different visibility",
6205 name, node);
6206 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
6207 DECL_VISIBILITY_SPECIFIED (node) = 1;
6210 return NULL_TREE;
6213 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
6215 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6216 of the various TYPE_QUAL values. */
6218 static void
6219 set_type_quals (tree type, int type_quals)
6221 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
6222 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
6223 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
6224 TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
6225 TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
6228 /* Returns true iff unqualified CAND and BASE are equivalent. */
6230 bool
6231 check_base_type (const_tree cand, const_tree base)
6233 return (TYPE_NAME (cand) == TYPE_NAME (base)
6234 /* Apparently this is needed for Objective-C. */
6235 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6236 /* Check alignment. */
6237 && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
6238 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6239 TYPE_ATTRIBUTES (base)));
6242 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */
6244 bool
6245 check_qualified_type (const_tree cand, const_tree base, int type_quals)
6247 return (TYPE_QUALS (cand) == type_quals
6248 && check_base_type (cand, base));
6251 /* Returns true iff CAND is equivalent to BASE with ALIGN. */
6253 static bool
6254 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
6256 return (TYPE_QUALS (cand) == TYPE_QUALS (base)
6257 && TYPE_NAME (cand) == TYPE_NAME (base)
6258 /* Apparently this is needed for Objective-C. */
6259 && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6260 /* Check alignment. */
6261 && TYPE_ALIGN (cand) == align
6262 && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6263 TYPE_ATTRIBUTES (base)));
6266 /* This function checks to see if TYPE matches the size one of the built-in
6267 atomic types, and returns that core atomic type. */
6269 static tree
6270 find_atomic_core_type (tree type)
6272 tree base_atomic_type;
6274 /* Only handle complete types. */
6275 if (TYPE_SIZE (type) == NULL_TREE)
6276 return NULL_TREE;
6278 HOST_WIDE_INT type_size = tree_to_uhwi (TYPE_SIZE (type));
6279 switch (type_size)
6281 case 8:
6282 base_atomic_type = atomicQI_type_node;
6283 break;
6285 case 16:
6286 base_atomic_type = atomicHI_type_node;
6287 break;
6289 case 32:
6290 base_atomic_type = atomicSI_type_node;
6291 break;
6293 case 64:
6294 base_atomic_type = atomicDI_type_node;
6295 break;
6297 case 128:
6298 base_atomic_type = atomicTI_type_node;
6299 break;
6301 default:
6302 base_atomic_type = NULL_TREE;
6305 return base_atomic_type;
6308 /* Return a version of the TYPE, qualified as indicated by the
6309 TYPE_QUALS, if one exists. If no qualified version exists yet,
6310 return NULL_TREE. */
6312 tree
6313 get_qualified_type (tree type, int type_quals)
6315 tree t;
6317 if (TYPE_QUALS (type) == type_quals)
6318 return type;
6320 /* Search the chain of variants to see if there is already one there just
6321 like the one we need to have. If so, use that existing one. We must
6322 preserve the TYPE_NAME, since there is code that depends on this. */
6323 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6324 if (check_qualified_type (t, type, type_quals))
6325 return t;
6327 return NULL_TREE;
6330 /* Like get_qualified_type, but creates the type if it does not
6331 exist. This function never returns NULL_TREE. */
6333 tree
6334 build_qualified_type (tree type, int type_quals)
6336 tree t;
6338 /* See if we already have the appropriate qualified variant. */
6339 t = get_qualified_type (type, type_quals);
6341 /* If not, build it. */
6342 if (!t)
6344 t = build_variant_type_copy (type);
6345 set_type_quals (t, type_quals);
6347 if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
6349 /* See if this object can map to a basic atomic type. */
6350 tree atomic_type = find_atomic_core_type (type);
6351 if (atomic_type)
6353 /* Ensure the alignment of this type is compatible with
6354 the required alignment of the atomic type. */
6355 if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
6356 TYPE_ALIGN (t) = TYPE_ALIGN (atomic_type);
6360 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6361 /* Propagate structural equality. */
6362 SET_TYPE_STRUCTURAL_EQUALITY (t);
6363 else if (TYPE_CANONICAL (type) != type)
6364 /* Build the underlying canonical type, since it is different
6365 from TYPE. */
6367 tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals);
6368 TYPE_CANONICAL (t) = TYPE_CANONICAL (c);
6370 else
6371 /* T is its own canonical type. */
6372 TYPE_CANONICAL (t) = t;
6376 return t;
6379 /* Create a variant of type T with alignment ALIGN. */
6381 tree
6382 build_aligned_type (tree type, unsigned int align)
6384 tree t;
6386 if (TYPE_PACKED (type)
6387 || TYPE_ALIGN (type) == align)
6388 return type;
6390 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6391 if (check_aligned_type (t, type, align))
6392 return t;
6394 t = build_variant_type_copy (type);
6395 TYPE_ALIGN (t) = align;
6397 return t;
6400 /* Create a new distinct copy of TYPE. The new type is made its own
6401 MAIN_VARIANT. If TYPE requires structural equality checks, the
6402 resulting type requires structural equality checks; otherwise, its
6403 TYPE_CANONICAL points to itself. */
6405 tree
6406 build_distinct_type_copy (tree type)
6408 tree t = copy_node (type);
6410 TYPE_POINTER_TO (t) = 0;
6411 TYPE_REFERENCE_TO (t) = 0;
6413 /* Set the canonical type either to a new equivalence class, or
6414 propagate the need for structural equality checks. */
6415 if (TYPE_STRUCTURAL_EQUALITY_P (type))
6416 SET_TYPE_STRUCTURAL_EQUALITY (t);
6417 else
6418 TYPE_CANONICAL (t) = t;
6420 /* Make it its own variant. */
6421 TYPE_MAIN_VARIANT (t) = t;
6422 TYPE_NEXT_VARIANT (t) = 0;
6424 /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6425 whose TREE_TYPE is not t. This can also happen in the Ada
6426 frontend when using subtypes. */
6428 return t;
6431 /* Create a new variant of TYPE, equivalent but distinct. This is so
6432 the caller can modify it. TYPE_CANONICAL for the return type will
6433 be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6434 are considered equal by the language itself (or that both types
6435 require structural equality checks). */
6437 tree
6438 build_variant_type_copy (tree type)
6440 tree t, m = TYPE_MAIN_VARIANT (type);
6442 t = build_distinct_type_copy (type);
6444 /* Since we're building a variant, assume that it is a non-semantic
6445 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6446 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6448 /* Add the new type to the chain of variants of TYPE. */
6449 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6450 TYPE_NEXT_VARIANT (m) = t;
6451 TYPE_MAIN_VARIANT (t) = m;
6453 return t;
6456 /* Return true if the from tree in both tree maps are equal. */
6459 tree_map_base_eq (const void *va, const void *vb)
6461 const struct tree_map_base *const a = (const struct tree_map_base *) va,
6462 *const b = (const struct tree_map_base *) vb;
6463 return (a->from == b->from);
6466 /* Hash a from tree in a tree_base_map. */
6468 unsigned int
6469 tree_map_base_hash (const void *item)
6471 return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6474 /* Return true if this tree map structure is marked for garbage collection
6475 purposes. We simply return true if the from tree is marked, so that this
6476 structure goes away when the from tree goes away. */
6479 tree_map_base_marked_p (const void *p)
6481 return ggc_marked_p (((const struct tree_map_base *) p)->from);
6484 /* Hash a from tree in a tree_map. */
6486 unsigned int
6487 tree_map_hash (const void *item)
6489 return (((const struct tree_map *) item)->hash);
6492 /* Hash a from tree in a tree_decl_map. */
6494 unsigned int
6495 tree_decl_map_hash (const void *item)
6497 return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6500 /* Return the initialization priority for DECL. */
6502 priority_type
6503 decl_init_priority_lookup (tree decl)
6505 symtab_node *snode = symtab_node::get (decl);
6507 if (!snode)
6508 return DEFAULT_INIT_PRIORITY;
6509 return
6510 snode->get_init_priority ();
6513 /* Return the finalization priority for DECL. */
6515 priority_type
6516 decl_fini_priority_lookup (tree decl)
6518 cgraph_node *node = cgraph_node::get (decl);
6520 if (!node)
6521 return DEFAULT_INIT_PRIORITY;
6522 return
6523 node->get_fini_priority ();
6526 /* Set the initialization priority for DECL to PRIORITY. */
6528 void
6529 decl_init_priority_insert (tree decl, priority_type priority)
6531 struct symtab_node *snode;
6533 if (priority == DEFAULT_INIT_PRIORITY)
6535 snode = symtab_node::get (decl);
6536 if (!snode)
6537 return;
6539 else if (TREE_CODE (decl) == VAR_DECL)
6540 snode = varpool_node::get_create (decl);
6541 else
6542 snode = cgraph_node::get_create (decl);
6543 snode->set_init_priority (priority);
6546 /* Set the finalization priority for DECL to PRIORITY. */
6548 void
6549 decl_fini_priority_insert (tree decl, priority_type priority)
6551 struct cgraph_node *node;
6553 if (priority == DEFAULT_INIT_PRIORITY)
6555 node = cgraph_node::get (decl);
6556 if (!node)
6557 return;
6559 else
6560 node = cgraph_node::get_create (decl);
6561 node->set_fini_priority (priority);
6564 /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
6566 static void
6567 print_debug_expr_statistics (void)
6569 fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
6570 (long) htab_size (debug_expr_for_decl),
6571 (long) htab_elements (debug_expr_for_decl),
6572 htab_collisions (debug_expr_for_decl));
6575 /* Print out the statistics for the DECL_VALUE_EXPR hash table. */
6577 static void
6578 print_value_expr_statistics (void)
6580 fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
6581 (long) htab_size (value_expr_for_decl),
6582 (long) htab_elements (value_expr_for_decl),
6583 htab_collisions (value_expr_for_decl));
6586 /* Lookup a debug expression for FROM, and return it if we find one. */
6588 tree
6589 decl_debug_expr_lookup (tree from)
6591 struct tree_decl_map *h, in;
6592 in.base.from = from;
6594 h = (struct tree_decl_map *)
6595 htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from));
6596 if (h)
6597 return h->to;
6598 return NULL_TREE;
6601 /* Insert a mapping FROM->TO in the debug expression hashtable. */
6603 void
6604 decl_debug_expr_insert (tree from, tree to)
6606 struct tree_decl_map *h;
6607 void **loc;
6609 h = ggc_alloc<tree_decl_map> ();
6610 h->base.from = from;
6611 h->to = to;
6612 loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from),
6613 INSERT);
6614 *(struct tree_decl_map **) loc = h;
6617 /* Lookup a value expression for FROM, and return it if we find one. */
6619 tree
6620 decl_value_expr_lookup (tree from)
6622 struct tree_decl_map *h, in;
6623 in.base.from = from;
6625 h = (struct tree_decl_map *)
6626 htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from));
6627 if (h)
6628 return h->to;
6629 return NULL_TREE;
6632 /* Insert a mapping FROM->TO in the value expression hashtable. */
6634 void
6635 decl_value_expr_insert (tree from, tree to)
6637 struct tree_decl_map *h;
6638 void **loc;
6640 h = ggc_alloc<tree_decl_map> ();
6641 h->base.from = from;
6642 h->to = to;
6643 loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from),
6644 INSERT);
6645 *(struct tree_decl_map **) loc = h;
6648 /* Lookup a vector of debug arguments for FROM, and return it if we
6649 find one. */
6651 vec<tree, va_gc> **
6652 decl_debug_args_lookup (tree from)
6654 struct tree_vec_map *h, in;
6656 if (!DECL_HAS_DEBUG_ARGS_P (from))
6657 return NULL;
6658 gcc_checking_assert (debug_args_for_decl != NULL);
6659 in.base.from = from;
6660 h = (struct tree_vec_map *)
6661 htab_find_with_hash (debug_args_for_decl, &in, DECL_UID (from));
6662 if (h)
6663 return &h->to;
6664 return NULL;
6667 /* Insert a mapping FROM->empty vector of debug arguments in the value
6668 expression hashtable. */
6670 vec<tree, va_gc> **
6671 decl_debug_args_insert (tree from)
6673 struct tree_vec_map *h;
6674 void **loc;
6676 if (DECL_HAS_DEBUG_ARGS_P (from))
6677 return decl_debug_args_lookup (from);
6678 if (debug_args_for_decl == NULL)
6679 debug_args_for_decl = htab_create_ggc (64, tree_vec_map_hash,
6680 tree_vec_map_eq, 0);
6681 h = ggc_alloc<tree_vec_map> ();
6682 h->base.from = from;
6683 h->to = NULL;
6684 loc = htab_find_slot_with_hash (debug_args_for_decl, h, DECL_UID (from),
6685 INSERT);
6686 *(struct tree_vec_map **) loc = h;
6687 DECL_HAS_DEBUG_ARGS_P (from) = 1;
6688 return &h->to;
6691 /* Hashing of types so that we don't make duplicates.
6692 The entry point is `type_hash_canon'. */
6694 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6695 with types in the TREE_VALUE slots), by adding the hash codes
6696 of the individual types. */
6698 static void
6699 type_hash_list (const_tree list, inchash::hash &hstate)
6701 const_tree tail;
6703 for (tail = list; tail; tail = TREE_CHAIN (tail))
6704 if (TREE_VALUE (tail) != error_mark_node)
6705 hstate.add_object (TYPE_HASH (TREE_VALUE (tail)));
6708 /* These are the Hashtable callback functions. */
6710 /* Returns true iff the types are equivalent. */
6712 static int
6713 type_hash_eq (const void *va, const void *vb)
6715 const struct type_hash *const a = (const struct type_hash *) va,
6716 *const b = (const struct type_hash *) vb;
6718 /* First test the things that are the same for all types. */
6719 if (a->hash != b->hash
6720 || TREE_CODE (a->type) != TREE_CODE (b->type)
6721 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
6722 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
6723 TYPE_ATTRIBUTES (b->type))
6724 || (TREE_CODE (a->type) != COMPLEX_TYPE
6725 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
6726 return 0;
6728 /* Be careful about comparing arrays before and after the element type
6729 has been completed; don't compare TYPE_ALIGN unless both types are
6730 complete. */
6731 if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
6732 && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
6733 || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
6734 return 0;
6736 switch (TREE_CODE (a->type))
6738 case VOID_TYPE:
6739 case COMPLEX_TYPE:
6740 case POINTER_TYPE:
6741 case REFERENCE_TYPE:
6742 case NULLPTR_TYPE:
6743 return 1;
6745 case VECTOR_TYPE:
6746 return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
6748 case ENUMERAL_TYPE:
6749 if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
6750 && !(TYPE_VALUES (a->type)
6751 && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
6752 && TYPE_VALUES (b->type)
6753 && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
6754 && type_list_equal (TYPE_VALUES (a->type),
6755 TYPE_VALUES (b->type))))
6756 return 0;
6758 /* ... fall through ... */
6760 case INTEGER_TYPE:
6761 case REAL_TYPE:
6762 case BOOLEAN_TYPE:
6763 if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
6764 return false;
6765 return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
6766 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
6767 TYPE_MAX_VALUE (b->type)))
6768 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
6769 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
6770 TYPE_MIN_VALUE (b->type))));
6772 case FIXED_POINT_TYPE:
6773 return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
6775 case OFFSET_TYPE:
6776 return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
6778 case METHOD_TYPE:
6779 if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
6780 && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6781 || (TYPE_ARG_TYPES (a->type)
6782 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6783 && TYPE_ARG_TYPES (b->type)
6784 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6785 && type_list_equal (TYPE_ARG_TYPES (a->type),
6786 TYPE_ARG_TYPES (b->type)))))
6787 break;
6788 return 0;
6789 case ARRAY_TYPE:
6790 return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
6792 case RECORD_TYPE:
6793 case UNION_TYPE:
6794 case QUAL_UNION_TYPE:
6795 return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
6796 || (TYPE_FIELDS (a->type)
6797 && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
6798 && TYPE_FIELDS (b->type)
6799 && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
6800 && type_list_equal (TYPE_FIELDS (a->type),
6801 TYPE_FIELDS (b->type))));
6803 case FUNCTION_TYPE:
6804 if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
6805 || (TYPE_ARG_TYPES (a->type)
6806 && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
6807 && TYPE_ARG_TYPES (b->type)
6808 && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
6809 && type_list_equal (TYPE_ARG_TYPES (a->type),
6810 TYPE_ARG_TYPES (b->type))))
6811 break;
6812 return 0;
6814 default:
6815 return 0;
6818 if (lang_hooks.types.type_hash_eq != NULL)
6819 return lang_hooks.types.type_hash_eq (a->type, b->type);
6821 return 1;
6824 /* Return the cached hash value. */
6826 static hashval_t
6827 type_hash_hash (const void *item)
6829 return ((const struct type_hash *) item)->hash;
6832 /* Given TYPE, and HASHCODE its hash code, return the canonical
6833 object for an identical type if one already exists.
6834 Otherwise, return TYPE, and record it as the canonical object.
6836 To use this function, first create a type of the sort you want.
6837 Then compute its hash code from the fields of the type that
6838 make it different from other similar types.
6839 Then call this function and use the value. */
6841 tree
6842 type_hash_canon (unsigned int hashcode, tree type)
6844 type_hash in;
6845 void **loc;
6847 /* The hash table only contains main variants, so ensure that's what we're
6848 being passed. */
6849 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6851 /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6852 must call that routine before comparing TYPE_ALIGNs. */
6853 layout_type (type);
6855 in.hash = hashcode;
6856 in.type = type;
6858 loc = htab_find_slot_with_hash (type_hash_table, &in, hashcode, INSERT);
6859 if (*loc)
6861 tree t1 = ((type_hash *) *loc)->type;
6862 gcc_assert (TYPE_MAIN_VARIANT (t1) == t1);
6863 if (GATHER_STATISTICS)
6865 tree_code_counts[(int) TREE_CODE (type)]--;
6866 tree_node_counts[(int) t_kind]--;
6867 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type_non_common);
6869 return t1;
6871 else
6873 struct type_hash *h;
6875 h = ggc_alloc<type_hash> ();
6876 h->hash = hashcode;
6877 h->type = type;
6878 *loc = (void *)h;
6880 return type;
6884 /* See if the data pointed to by the type hash table is marked. We consider
6885 it marked if the type is marked or if a debug type number or symbol
6886 table entry has been made for the type. */
6888 static int
6889 type_hash_marked_p (const void *p)
6891 const_tree const type = ((const struct type_hash *) p)->type;
6893 return ggc_marked_p (type);
6896 static void
6897 print_type_hash_statistics (void)
6899 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6900 (long) htab_size (type_hash_table),
6901 (long) htab_elements (type_hash_table),
6902 htab_collisions (type_hash_table));
6905 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6906 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6907 by adding the hash codes of the individual attributes. */
6909 static void
6910 attribute_hash_list (const_tree list, inchash::hash &hstate)
6912 const_tree tail;
6914 for (tail = list; tail; tail = TREE_CHAIN (tail))
6915 /* ??? Do we want to add in TREE_VALUE too? */
6916 hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (tail)));
6919 /* Given two lists of attributes, return true if list l2 is
6920 equivalent to l1. */
6923 attribute_list_equal (const_tree l1, const_tree l2)
6925 if (l1 == l2)
6926 return 1;
6928 return attribute_list_contained (l1, l2)
6929 && attribute_list_contained (l2, l1);
6932 /* Given two lists of attributes, return true if list L2 is
6933 completely contained within L1. */
6934 /* ??? This would be faster if attribute names were stored in a canonicalized
6935 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6936 must be used to show these elements are equivalent (which they are). */
6937 /* ??? It's not clear that attributes with arguments will always be handled
6938 correctly. */
6941 attribute_list_contained (const_tree l1, const_tree l2)
6943 const_tree t1, t2;
6945 /* First check the obvious, maybe the lists are identical. */
6946 if (l1 == l2)
6947 return 1;
6949 /* Maybe the lists are similar. */
6950 for (t1 = l1, t2 = l2;
6951 t1 != 0 && t2 != 0
6952 && get_attribute_name (t1) == get_attribute_name (t2)
6953 && TREE_VALUE (t1) == TREE_VALUE (t2);
6954 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6957 /* Maybe the lists are equal. */
6958 if (t1 == 0 && t2 == 0)
6959 return 1;
6961 for (; t2 != 0; t2 = TREE_CHAIN (t2))
6963 const_tree attr;
6964 /* This CONST_CAST is okay because lookup_attribute does not
6965 modify its argument and the return value is assigned to a
6966 const_tree. */
6967 for (attr = lookup_ident_attribute (get_attribute_name (t2),
6968 CONST_CAST_TREE (l1));
6969 attr != NULL_TREE && !attribute_value_equal (t2, attr);
6970 attr = lookup_ident_attribute (get_attribute_name (t2),
6971 TREE_CHAIN (attr)))
6974 if (attr == NULL_TREE)
6975 return 0;
6978 return 1;
6981 /* Given two lists of types
6982 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6983 return 1 if the lists contain the same types in the same order.
6984 Also, the TREE_PURPOSEs must match. */
6987 type_list_equal (const_tree l1, const_tree l2)
6989 const_tree t1, t2;
6991 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6992 if (TREE_VALUE (t1) != TREE_VALUE (t2)
6993 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6994 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6995 && (TREE_TYPE (TREE_PURPOSE (t1))
6996 == TREE_TYPE (TREE_PURPOSE (t2))))))
6997 return 0;
6999 return t1 == t2;
7002 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7003 given by TYPE. If the argument list accepts variable arguments,
7004 then this function counts only the ordinary arguments. */
7007 type_num_arguments (const_tree type)
7009 int i = 0;
7010 tree t;
7012 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7013 /* If the function does not take a variable number of arguments,
7014 the last element in the list will have type `void'. */
7015 if (VOID_TYPE_P (TREE_VALUE (t)))
7016 break;
7017 else
7018 ++i;
7020 return i;
7023 /* Nonzero if integer constants T1 and T2
7024 represent the same constant value. */
7027 tree_int_cst_equal (const_tree t1, const_tree t2)
7029 if (t1 == t2)
7030 return 1;
7032 if (t1 == 0 || t2 == 0)
7033 return 0;
7035 if (TREE_CODE (t1) == INTEGER_CST
7036 && TREE_CODE (t2) == INTEGER_CST
7037 && wi::to_widest (t1) == wi::to_widest (t2))
7038 return 1;
7040 return 0;
7043 /* Return true if T is an INTEGER_CST whose numerical value (extended
7044 according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */
7046 bool
7047 tree_fits_shwi_p (const_tree t)
7049 return (t != NULL_TREE
7050 && TREE_CODE (t) == INTEGER_CST
7051 && wi::fits_shwi_p (wi::to_widest (t)));
7054 /* Return true if T is an INTEGER_CST whose numerical value (extended
7055 according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */
7057 bool
7058 tree_fits_uhwi_p (const_tree t)
7060 return (t != NULL_TREE
7061 && TREE_CODE (t) == INTEGER_CST
7062 && wi::fits_uhwi_p (wi::to_widest (t)));
7065 /* T is an INTEGER_CST whose numerical value (extended according to
7066 TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
7067 HOST_WIDE_INT. */
7069 HOST_WIDE_INT
7070 tree_to_shwi (const_tree t)
7072 gcc_assert (tree_fits_shwi_p (t));
7073 return TREE_INT_CST_LOW (t);
7076 /* T is an INTEGER_CST whose numerical value (extended according to
7077 TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that
7078 HOST_WIDE_INT. */
7080 unsigned HOST_WIDE_INT
7081 tree_to_uhwi (const_tree t)
7083 gcc_assert (tree_fits_uhwi_p (t));
7084 return TREE_INT_CST_LOW (t);
7087 /* Return the most significant (sign) bit of T. */
7090 tree_int_cst_sign_bit (const_tree t)
7092 unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
7094 return wi::extract_uhwi (t, bitno, 1);
7097 /* Return an indication of the sign of the integer constant T.
7098 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7099 Note that -1 will never be returned if T's type is unsigned. */
7102 tree_int_cst_sgn (const_tree t)
7104 if (wi::eq_p (t, 0))
7105 return 0;
7106 else if (TYPE_UNSIGNED (TREE_TYPE (t)))
7107 return 1;
7108 else if (wi::neg_p (t))
7109 return -1;
7110 else
7111 return 1;
7114 /* Return the minimum number of bits needed to represent VALUE in a
7115 signed or unsigned type, UNSIGNEDP says which. */
7117 unsigned int
7118 tree_int_cst_min_precision (tree value, signop sgn)
7120 /* If the value is negative, compute its negative minus 1. The latter
7121 adjustment is because the absolute value of the largest negative value
7122 is one larger than the largest positive value. This is equivalent to
7123 a bit-wise negation, so use that operation instead. */
7125 if (tree_int_cst_sgn (value) < 0)
7126 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
7128 /* Return the number of bits needed, taking into account the fact
7129 that we need one more bit for a signed than unsigned type.
7130 If value is 0 or -1, the minimum precision is 1 no matter
7131 whether unsignedp is true or false. */
7133 if (integer_zerop (value))
7134 return 1;
7135 else
7136 return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
7139 /* Return truthvalue of whether T1 is the same tree structure as T2.
7140 Return 1 if they are the same.
7141 Return 0 if they are understandably different.
7142 Return -1 if either contains tree structure not understood by
7143 this function. */
7146 simple_cst_equal (const_tree t1, const_tree t2)
7148 enum tree_code code1, code2;
7149 int cmp;
7150 int i;
7152 if (t1 == t2)
7153 return 1;
7154 if (t1 == 0 || t2 == 0)
7155 return 0;
7157 code1 = TREE_CODE (t1);
7158 code2 = TREE_CODE (t2);
7160 if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
7162 if (CONVERT_EXPR_CODE_P (code2)
7163 || code2 == NON_LVALUE_EXPR)
7164 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7165 else
7166 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
7169 else if (CONVERT_EXPR_CODE_P (code2)
7170 || code2 == NON_LVALUE_EXPR)
7171 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
7173 if (code1 != code2)
7174 return 0;
7176 switch (code1)
7178 case INTEGER_CST:
7179 return wi::to_widest (t1) == wi::to_widest (t2);
7181 case REAL_CST:
7182 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
7184 case FIXED_CST:
7185 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
7187 case STRING_CST:
7188 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
7189 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
7190 TREE_STRING_LENGTH (t1)));
7192 case CONSTRUCTOR:
7194 unsigned HOST_WIDE_INT idx;
7195 vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
7196 vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
7198 if (vec_safe_length (v1) != vec_safe_length (v2))
7199 return false;
7201 for (idx = 0; idx < vec_safe_length (v1); ++idx)
7202 /* ??? Should we handle also fields here? */
7203 if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
7204 return false;
7205 return true;
7208 case SAVE_EXPR:
7209 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7211 case CALL_EXPR:
7212 cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
7213 if (cmp <= 0)
7214 return cmp;
7215 if (call_expr_nargs (t1) != call_expr_nargs (t2))
7216 return 0;
7218 const_tree arg1, arg2;
7219 const_call_expr_arg_iterator iter1, iter2;
7220 for (arg1 = first_const_call_expr_arg (t1, &iter1),
7221 arg2 = first_const_call_expr_arg (t2, &iter2);
7222 arg1 && arg2;
7223 arg1 = next_const_call_expr_arg (&iter1),
7224 arg2 = next_const_call_expr_arg (&iter2))
7226 cmp = simple_cst_equal (arg1, arg2);
7227 if (cmp <= 0)
7228 return cmp;
7230 return arg1 == arg2;
7233 case TARGET_EXPR:
7234 /* Special case: if either target is an unallocated VAR_DECL,
7235 it means that it's going to be unified with whatever the
7236 TARGET_EXPR is really supposed to initialize, so treat it
7237 as being equivalent to anything. */
7238 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
7239 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
7240 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
7241 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
7242 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
7243 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
7244 cmp = 1;
7245 else
7246 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7248 if (cmp <= 0)
7249 return cmp;
7251 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
7253 case WITH_CLEANUP_EXPR:
7254 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7255 if (cmp <= 0)
7256 return cmp;
7258 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
7260 case COMPONENT_REF:
7261 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
7262 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7264 return 0;
7266 case VAR_DECL:
7267 case PARM_DECL:
7268 case CONST_DECL:
7269 case FUNCTION_DECL:
7270 return 0;
7272 default:
7273 break;
7276 /* This general rule works for most tree codes. All exceptions should be
7277 handled above. If this is a language-specific tree code, we can't
7278 trust what might be in the operand, so say we don't know
7279 the situation. */
7280 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7281 return -1;
7283 switch (TREE_CODE_CLASS (code1))
7285 case tcc_unary:
7286 case tcc_binary:
7287 case tcc_comparison:
7288 case tcc_expression:
7289 case tcc_reference:
7290 case tcc_statement:
7291 cmp = 1;
7292 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7294 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7295 if (cmp <= 0)
7296 return cmp;
7299 return cmp;
7301 default:
7302 return -1;
7306 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7307 Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7308 than U, respectively. */
7311 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7313 if (tree_int_cst_sgn (t) < 0)
7314 return -1;
7315 else if (!tree_fits_uhwi_p (t))
7316 return 1;
7317 else if (TREE_INT_CST_LOW (t) == u)
7318 return 0;
7319 else if (TREE_INT_CST_LOW (t) < u)
7320 return -1;
7321 else
7322 return 1;
7325 /* Return true if SIZE represents a constant size that is in bounds of
7326 what the middle-end and the backend accepts (covering not more than
7327 half of the address-space). */
7329 bool
7330 valid_constant_size_p (const_tree size)
7332 if (! tree_fits_uhwi_p (size)
7333 || TREE_OVERFLOW (size)
7334 || tree_int_cst_sign_bit (size) != 0)
7335 return false;
7336 return true;
7339 /* Return the precision of the type, or for a complex or vector type the
7340 precision of the type of its elements. */
7342 unsigned int
7343 element_precision (const_tree type)
7345 enum tree_code code = TREE_CODE (type);
7346 if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7347 type = TREE_TYPE (type);
7349 return TYPE_PRECISION (type);
7352 /* Return true if CODE represents an associative tree code. Otherwise
7353 return false. */
7354 bool
7355 associative_tree_code (enum tree_code code)
7357 switch (code)
7359 case BIT_IOR_EXPR:
7360 case BIT_AND_EXPR:
7361 case BIT_XOR_EXPR:
7362 case PLUS_EXPR:
7363 case MULT_EXPR:
7364 case MIN_EXPR:
7365 case MAX_EXPR:
7366 return true;
7368 default:
7369 break;
7371 return false;
7374 /* Return true if CODE represents a commutative tree code. Otherwise
7375 return false. */
7376 bool
7377 commutative_tree_code (enum tree_code code)
7379 switch (code)
7381 case PLUS_EXPR:
7382 case MULT_EXPR:
7383 case MULT_HIGHPART_EXPR:
7384 case MIN_EXPR:
7385 case MAX_EXPR:
7386 case BIT_IOR_EXPR:
7387 case BIT_XOR_EXPR:
7388 case BIT_AND_EXPR:
7389 case NE_EXPR:
7390 case EQ_EXPR:
7391 case UNORDERED_EXPR:
7392 case ORDERED_EXPR:
7393 case UNEQ_EXPR:
7394 case LTGT_EXPR:
7395 case TRUTH_AND_EXPR:
7396 case TRUTH_XOR_EXPR:
7397 case TRUTH_OR_EXPR:
7398 case WIDEN_MULT_EXPR:
7399 case VEC_WIDEN_MULT_HI_EXPR:
7400 case VEC_WIDEN_MULT_LO_EXPR:
7401 case VEC_WIDEN_MULT_EVEN_EXPR:
7402 case VEC_WIDEN_MULT_ODD_EXPR:
7403 return true;
7405 default:
7406 break;
7408 return false;
7411 /* Return true if CODE represents a ternary tree code for which the
7412 first two operands are commutative. Otherwise return false. */
7413 bool
7414 commutative_ternary_tree_code (enum tree_code code)
7416 switch (code)
7418 case WIDEN_MULT_PLUS_EXPR:
7419 case WIDEN_MULT_MINUS_EXPR:
7420 case DOT_PROD_EXPR:
7421 case FMA_EXPR:
7422 return true;
7424 default:
7425 break;
7427 return false;
7430 namespace inchash
7433 /* Generate a hash value for an expression. This can be used iteratively
7434 by passing a previous result as the HSTATE argument.
7436 This function is intended to produce the same hash for expressions which
7437 would compare equal using operand_equal_p. */
7438 void
7439 add_expr (const_tree t, inchash::hash &hstate)
7441 int i;
7442 enum tree_code code;
7443 enum tree_code_class tclass;
7445 if (t == NULL_TREE)
7447 hstate.merge_hash (0);
7448 return;
7451 code = TREE_CODE (t);
7453 switch (code)
7455 /* Alas, constants aren't shared, so we can't rely on pointer
7456 identity. */
7457 case VOID_CST:
7458 hstate.merge_hash (0);
7459 return;
7460 case INTEGER_CST:
7461 for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
7462 hstate.add_wide_int (TREE_INT_CST_ELT (t, i));
7463 return;
7464 case REAL_CST:
7466 unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
7467 hstate.merge_hash (val2);
7468 return;
7470 case FIXED_CST:
7472 unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7473 hstate.merge_hash (val2);
7474 return;
7476 case STRING_CST:
7477 hstate.add ((const void *) TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
7478 return;
7479 case COMPLEX_CST:
7480 inchash::add_expr (TREE_REALPART (t), hstate);
7481 inchash::add_expr (TREE_IMAGPART (t), hstate);
7482 return;
7483 case VECTOR_CST:
7485 unsigned i;
7486 for (i = 0; i < VECTOR_CST_NELTS (t); ++i)
7487 inchash::add_expr (VECTOR_CST_ELT (t, i), hstate);
7488 return;
7490 case SSA_NAME:
7491 /* We can just compare by pointer. */
7492 hstate.add_wide_int (SSA_NAME_VERSION (t));
7493 return;
7494 case PLACEHOLDER_EXPR:
7495 /* The node itself doesn't matter. */
7496 return;
7497 case TREE_LIST:
7498 /* A list of expressions, for a CALL_EXPR or as the elements of a
7499 VECTOR_CST. */
7500 for (; t; t = TREE_CHAIN (t))
7501 inchash::add_expr (TREE_VALUE (t), hstate);
7502 return;
7503 case CONSTRUCTOR:
7505 unsigned HOST_WIDE_INT idx;
7506 tree field, value;
7507 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7509 inchash::add_expr (field, hstate);
7510 inchash::add_expr (value, hstate);
7512 return;
7514 case FUNCTION_DECL:
7515 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7516 Otherwise nodes that compare equal according to operand_equal_p might
7517 get different hash codes. However, don't do this for machine specific
7518 or front end builtins, since the function code is overloaded in those
7519 cases. */
7520 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7521 && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7523 t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7524 code = TREE_CODE (t);
7526 /* FALL THROUGH */
7527 default:
7528 tclass = TREE_CODE_CLASS (code);
7530 if (tclass == tcc_declaration)
7532 /* DECL's have a unique ID */
7533 hstate.add_wide_int (DECL_UID (t));
7535 else
7537 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
7539 hstate.add_object (code);
7541 /* Don't hash the type, that can lead to having nodes which
7542 compare equal according to operand_equal_p, but which
7543 have different hash codes. */
7544 if (CONVERT_EXPR_CODE_P (code)
7545 || code == NON_LVALUE_EXPR)
7547 /* Make sure to include signness in the hash computation. */
7548 hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7549 inchash::add_expr (TREE_OPERAND (t, 0), hstate);
7552 else if (commutative_tree_code (code))
7554 /* It's a commutative expression. We want to hash it the same
7555 however it appears. We do this by first hashing both operands
7556 and then rehashing based on the order of their independent
7557 hashes. */
7558 inchash::hash one, two;
7559 inchash::add_expr (TREE_OPERAND (t, 0), one);
7560 inchash::add_expr (TREE_OPERAND (t, 1), two);
7561 hstate.add_commutative (one, two);
7563 else
7564 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
7565 inchash::add_expr (TREE_OPERAND (t, i), hstate);
7567 return;
7573 /* Constructors for pointer, array and function types.
7574 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
7575 constructed by language-dependent code, not here.) */
7577 /* Construct, lay out and return the type of pointers to TO_TYPE with
7578 mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
7579 reference all of memory. If such a type has already been
7580 constructed, reuse it. */
7582 tree
7583 build_pointer_type_for_mode (tree to_type, machine_mode mode,
7584 bool can_alias_all)
7586 tree t;
7588 if (to_type == error_mark_node)
7589 return error_mark_node;
7591 /* If the pointed-to type has the may_alias attribute set, force
7592 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7593 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7594 can_alias_all = true;
7596 /* In some cases, languages will have things that aren't a POINTER_TYPE
7597 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
7598 In that case, return that type without regard to the rest of our
7599 operands.
7601 ??? This is a kludge, but consistent with the way this function has
7602 always operated and there doesn't seem to be a good way to avoid this
7603 at the moment. */
7604 if (TYPE_POINTER_TO (to_type) != 0
7605 && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
7606 return TYPE_POINTER_TO (to_type);
7608 /* First, if we already have a type for pointers to TO_TYPE and it's
7609 the proper mode, use it. */
7610 for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
7611 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7612 return t;
7614 t = make_node (POINTER_TYPE);
7616 TREE_TYPE (t) = to_type;
7617 SET_TYPE_MODE (t, mode);
7618 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7619 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
7620 TYPE_POINTER_TO (to_type) = t;
7622 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
7623 SET_TYPE_STRUCTURAL_EQUALITY (t);
7624 else if (TYPE_CANONICAL (to_type) != to_type)
7625 TYPE_CANONICAL (t)
7626 = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
7627 mode, can_alias_all);
7629 /* Lay out the type. This function has many callers that are concerned
7630 with expression-construction, and this simplifies them all. */
7631 layout_type (t);
7633 return t;
7636 /* By default build pointers in ptr_mode. */
7638 tree
7639 build_pointer_type (tree to_type)
7641 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7642 : TYPE_ADDR_SPACE (to_type);
7643 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7644 return build_pointer_type_for_mode (to_type, pointer_mode, false);
7647 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
7649 tree
7650 build_reference_type_for_mode (tree to_type, machine_mode mode,
7651 bool can_alias_all)
7653 tree t;
7655 if (to_type == error_mark_node)
7656 return error_mark_node;
7658 /* If the pointed-to type has the may_alias attribute set, force
7659 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
7660 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
7661 can_alias_all = true;
7663 /* In some cases, languages will have things that aren't a REFERENCE_TYPE
7664 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
7665 In that case, return that type without regard to the rest of our
7666 operands.
7668 ??? This is a kludge, but consistent with the way this function has
7669 always operated and there doesn't seem to be a good way to avoid this
7670 at the moment. */
7671 if (TYPE_REFERENCE_TO (to_type) != 0
7672 && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
7673 return TYPE_REFERENCE_TO (to_type);
7675 /* First, if we already have a type for pointers to TO_TYPE and it's
7676 the proper mode, use it. */
7677 for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
7678 if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
7679 return t;
7681 t = make_node (REFERENCE_TYPE);
7683 TREE_TYPE (t) = to_type;
7684 SET_TYPE_MODE (t, mode);
7685 TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
7686 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
7687 TYPE_REFERENCE_TO (to_type) = t;
7689 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
7690 SET_TYPE_STRUCTURAL_EQUALITY (t);
7691 else if (TYPE_CANONICAL (to_type) != to_type)
7692 TYPE_CANONICAL (t)
7693 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
7694 mode, can_alias_all);
7696 layout_type (t);
7698 return t;
7702 /* Build the node for the type of references-to-TO_TYPE by default
7703 in ptr_mode. */
7705 tree
7706 build_reference_type (tree to_type)
7708 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
7709 : TYPE_ADDR_SPACE (to_type);
7710 machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
7711 return build_reference_type_for_mode (to_type, pointer_mode, false);
7714 #define MAX_INT_CACHED_PREC \
7715 (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7716 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7718 /* Builds a signed or unsigned integer type of precision PRECISION.
7719 Used for C bitfields whose precision does not match that of
7720 built-in target types. */
7721 tree
7722 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7723 int unsignedp)
7725 tree itype, ret;
7727 if (unsignedp)
7728 unsignedp = MAX_INT_CACHED_PREC + 1;
7730 if (precision <= MAX_INT_CACHED_PREC)
7732 itype = nonstandard_integer_type_cache[precision + unsignedp];
7733 if (itype)
7734 return itype;
7737 itype = make_node (INTEGER_TYPE);
7738 TYPE_PRECISION (itype) = precision;
7740 if (unsignedp)
7741 fixup_unsigned_type (itype);
7742 else
7743 fixup_signed_type (itype);
7745 ret = itype;
7746 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype)))
7747 ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype);
7748 if (precision <= MAX_INT_CACHED_PREC)
7749 nonstandard_integer_type_cache[precision + unsignedp] = ret;
7751 return ret;
7754 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
7755 or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED
7756 is true, reuse such a type that has already been constructed. */
7758 static tree
7759 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
7761 tree itype = make_node (INTEGER_TYPE);
7762 inchash::hash hstate;
7764 TREE_TYPE (itype) = type;
7766 TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7767 TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7769 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7770 SET_TYPE_MODE (itype, TYPE_MODE (type));
7771 TYPE_SIZE (itype) = TYPE_SIZE (type);
7772 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7773 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
7774 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7776 if (!shared)
7777 return itype;
7779 if ((TYPE_MIN_VALUE (itype)
7780 && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
7781 || (TYPE_MAX_VALUE (itype)
7782 && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
7784 /* Since we cannot reliably merge this type, we need to compare it using
7785 structural equality checks. */
7786 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7787 return itype;
7790 inchash::add_expr (TYPE_MIN_VALUE (itype), hstate);
7791 inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);
7792 hstate.merge_hash (TYPE_HASH (type));
7793 itype = type_hash_canon (hstate.end (), itype);
7795 return itype;
7798 /* Wrapper around build_range_type_1 with SHARED set to true. */
7800 tree
7801 build_range_type (tree type, tree lowval, tree highval)
7803 return build_range_type_1 (type, lowval, highval, true);
7806 /* Wrapper around build_range_type_1 with SHARED set to false. */
7808 tree
7809 build_nonshared_range_type (tree type, tree lowval, tree highval)
7811 return build_range_type_1 (type, lowval, highval, false);
7814 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
7815 MAXVAL should be the maximum value in the domain
7816 (one less than the length of the array).
7818 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
7819 We don't enforce this limit, that is up to caller (e.g. language front end).
7820 The limit exists because the result is a signed type and we don't handle
7821 sizes that use more than one HOST_WIDE_INT. */
7823 tree
7824 build_index_type (tree maxval)
7826 return build_range_type (sizetype, size_zero_node, maxval);
7829 /* Return true if the debug information for TYPE, a subtype, should be emitted
7830 as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
7831 high bound, respectively. Sometimes doing so unnecessarily obfuscates the
7832 debug info and doesn't reflect the source code. */
7834 bool
7835 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7837 tree base_type = TREE_TYPE (type), low, high;
7839 /* Subrange types have a base type which is an integral type. */
7840 if (!INTEGRAL_TYPE_P (base_type))
7841 return false;
7843 /* Get the real bounds of the subtype. */
7844 if (lang_hooks.types.get_subrange_bounds)
7845 lang_hooks.types.get_subrange_bounds (type, &low, &high);
7846 else
7848 low = TYPE_MIN_VALUE (type);
7849 high = TYPE_MAX_VALUE (type);
7852 /* If the type and its base type have the same representation and the same
7853 name, then the type is not a subrange but a copy of the base type. */
7854 if ((TREE_CODE (base_type) == INTEGER_TYPE
7855 || TREE_CODE (base_type) == BOOLEAN_TYPE)
7856 && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7857 && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7858 && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))
7859 && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
7860 return false;
7862 if (lowval)
7863 *lowval = low;
7864 if (highval)
7865 *highval = high;
7866 return true;
7869 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7870 and number of elements specified by the range of values of INDEX_TYPE.
7871 If SHARED is true, reuse such a type that has already been constructed. */
7873 static tree
7874 build_array_type_1 (tree elt_type, tree index_type, bool shared)
7876 tree t;
7878 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7880 error ("arrays of functions are not meaningful");
7881 elt_type = integer_type_node;
7884 t = make_node (ARRAY_TYPE);
7885 TREE_TYPE (t) = elt_type;
7886 TYPE_DOMAIN (t) = index_type;
7887 TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7888 layout_type (t);
7890 /* If the element type is incomplete at this point we get marked for
7891 structural equality. Do not record these types in the canonical
7892 type hashtable. */
7893 if (TYPE_STRUCTURAL_EQUALITY_P (t))
7894 return t;
7896 if (shared)
7898 inchash::hash hstate;
7899 hstate.add_object (TYPE_HASH (elt_type));
7900 if (index_type)
7901 hstate.add_object (TYPE_HASH (index_type));
7902 t = type_hash_canon (hstate.end (), t);
7905 if (TYPE_CANONICAL (t) == t)
7907 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7908 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7909 SET_TYPE_STRUCTURAL_EQUALITY (t);
7910 else if (TYPE_CANONICAL (elt_type) != elt_type
7911 || (index_type && TYPE_CANONICAL (index_type) != index_type))
7912 TYPE_CANONICAL (t)
7913 = build_array_type_1 (TYPE_CANONICAL (elt_type),
7914 index_type
7915 ? TYPE_CANONICAL (index_type) : NULL_TREE,
7916 shared);
7919 return t;
7922 /* Wrapper around build_array_type_1 with SHARED set to true. */
7924 tree
7925 build_array_type (tree elt_type, tree index_type)
7927 return build_array_type_1 (elt_type, index_type, true);
7930 /* Wrapper around build_array_type_1 with SHARED set to false. */
7932 tree
7933 build_nonshared_array_type (tree elt_type, tree index_type)
7935 return build_array_type_1 (elt_type, index_type, false);
7938 /* Return a representation of ELT_TYPE[NELTS], using indices of type
7939 sizetype. */
7941 tree
7942 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts)
7944 return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
7947 /* Recursively examines the array elements of TYPE, until a non-array
7948 element type is found. */
7950 tree
7951 strip_array_types (tree type)
7953 while (TREE_CODE (type) == ARRAY_TYPE)
7954 type = TREE_TYPE (type);
7956 return type;
7959 /* Computes the canonical argument types from the argument type list
7960 ARGTYPES.
7962 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7963 on entry to this function, or if any of the ARGTYPES are
7964 structural.
7966 Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7967 true on entry to this function, or if any of the ARGTYPES are
7968 non-canonical.
7970 Returns a canonical argument list, which may be ARGTYPES when the
7971 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7972 true) or would not differ from ARGTYPES. */
7974 static tree
7975 maybe_canonicalize_argtypes (tree argtypes,
7976 bool *any_structural_p,
7977 bool *any_noncanonical_p)
7979 tree arg;
7980 bool any_noncanonical_argtypes_p = false;
7982 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7984 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7985 /* Fail gracefully by stating that the type is structural. */
7986 *any_structural_p = true;
7987 else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7988 *any_structural_p = true;
7989 else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7990 || TREE_PURPOSE (arg))
7991 /* If the argument has a default argument, we consider it
7992 non-canonical even though the type itself is canonical.
7993 That way, different variants of function and method types
7994 with default arguments will all point to the variant with
7995 no defaults as their canonical type. */
7996 any_noncanonical_argtypes_p = true;
7999 if (*any_structural_p)
8000 return argtypes;
8002 if (any_noncanonical_argtypes_p)
8004 /* Build the canonical list of argument types. */
8005 tree canon_argtypes = NULL_TREE;
8006 bool is_void = false;
8008 for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
8010 if (arg == void_list_node)
8011 is_void = true;
8012 else
8013 canon_argtypes = tree_cons (NULL_TREE,
8014 TYPE_CANONICAL (TREE_VALUE (arg)),
8015 canon_argtypes);
8018 canon_argtypes = nreverse (canon_argtypes);
8019 if (is_void)
8020 canon_argtypes = chainon (canon_argtypes, void_list_node);
8022 /* There is a non-canonical type. */
8023 *any_noncanonical_p = true;
8024 return canon_argtypes;
8027 /* The canonical argument types are the same as ARGTYPES. */
8028 return argtypes;
8031 /* Construct, lay out and return
8032 the type of functions returning type VALUE_TYPE
8033 given arguments of types ARG_TYPES.
8034 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8035 are data type nodes for the arguments of the function.
8036 If such a type has already been constructed, reuse it. */
8038 tree
8039 build_function_type (tree value_type, tree arg_types)
8041 tree t;
8042 inchash::hash hstate;
8043 bool any_structural_p, any_noncanonical_p;
8044 tree canon_argtypes;
8046 if (TREE_CODE (value_type) == FUNCTION_TYPE)
8048 error ("function return type cannot be function");
8049 value_type = integer_type_node;
8052 /* Make a node of the sort we want. */
8053 t = make_node (FUNCTION_TYPE);
8054 TREE_TYPE (t) = value_type;
8055 TYPE_ARG_TYPES (t) = arg_types;
8057 /* If we already have such a type, use the old one. */
8058 hstate.add_object (TYPE_HASH (value_type));
8059 type_hash_list (arg_types, hstate);
8060 t = type_hash_canon (hstate.end (), t);
8062 /* Set up the canonical type. */
8063 any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8064 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8065 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8066 &any_structural_p,
8067 &any_noncanonical_p);
8068 if (any_structural_p)
8069 SET_TYPE_STRUCTURAL_EQUALITY (t);
8070 else if (any_noncanonical_p)
8071 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8072 canon_argtypes);
8074 if (!COMPLETE_TYPE_P (t))
8075 layout_type (t);
8076 return t;
8079 /* Build a function type. The RETURN_TYPE is the type returned by the
8080 function. If VAARGS is set, no void_type_node is appended to the
8081 the list. ARGP must be always be terminated be a NULL_TREE. */
8083 static tree
8084 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8086 tree t, args, last;
8088 t = va_arg (argp, tree);
8089 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8090 args = tree_cons (NULL_TREE, t, args);
8092 if (vaargs)
8094 last = args;
8095 if (args != NULL_TREE)
8096 args = nreverse (args);
8097 gcc_assert (last != void_list_node);
8099 else if (args == NULL_TREE)
8100 args = void_list_node;
8101 else
8103 last = args;
8104 args = nreverse (args);
8105 TREE_CHAIN (last) = void_list_node;
8107 args = build_function_type (return_type, args);
8109 return args;
8112 /* Build a function type. The RETURN_TYPE is the type returned by the
8113 function. If additional arguments are provided, they are
8114 additional argument types. The list of argument types must always
8115 be terminated by NULL_TREE. */
8117 tree
8118 build_function_type_list (tree return_type, ...)
8120 tree args;
8121 va_list p;
8123 va_start (p, return_type);
8124 args = build_function_type_list_1 (false, return_type, p);
8125 va_end (p);
8126 return args;
8129 /* Build a variable argument function type. The RETURN_TYPE is the
8130 type returned by the function. If additional arguments are provided,
8131 they are additional argument types. The list of argument types must
8132 always be terminated by NULL_TREE. */
8134 tree
8135 build_varargs_function_type_list (tree return_type, ...)
8137 tree args;
8138 va_list p;
8140 va_start (p, return_type);
8141 args = build_function_type_list_1 (true, return_type, p);
8142 va_end (p);
8144 return args;
8147 /* Build a function type. RETURN_TYPE is the type returned by the
8148 function; VAARGS indicates whether the function takes varargs. The
8149 function takes N named arguments, the types of which are provided in
8150 ARG_TYPES. */
8152 static tree
8153 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8154 tree *arg_types)
8156 int i;
8157 tree t = vaargs ? NULL_TREE : void_list_node;
8159 for (i = n - 1; i >= 0; i--)
8160 t = tree_cons (NULL_TREE, arg_types[i], t);
8162 return build_function_type (return_type, t);
8165 /* Build a function type. RETURN_TYPE is the type returned by the
8166 function. The function takes N named arguments, the types of which
8167 are provided in ARG_TYPES. */
8169 tree
8170 build_function_type_array (tree return_type, int n, tree *arg_types)
8172 return build_function_type_array_1 (false, return_type, n, arg_types);
8175 /* Build a variable argument function type. RETURN_TYPE is the type
8176 returned by the function. The function takes N named arguments, the
8177 types of which are provided in ARG_TYPES. */
8179 tree
8180 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8182 return build_function_type_array_1 (true, return_type, n, arg_types);
8185 /* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
8186 and ARGTYPES (a TREE_LIST) are the return type and arguments types
8187 for the method. An implicit additional parameter (of type
8188 pointer-to-BASETYPE) is added to the ARGTYPES. */
8190 tree
8191 build_method_type_directly (tree basetype,
8192 tree rettype,
8193 tree argtypes)
8195 tree t;
8196 tree ptype;
8197 inchash::hash hstate;
8198 bool any_structural_p, any_noncanonical_p;
8199 tree canon_argtypes;
8201 /* Make a node of the sort we want. */
8202 t = make_node (METHOD_TYPE);
8204 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8205 TREE_TYPE (t) = rettype;
8206 ptype = build_pointer_type (basetype);
8208 /* The actual arglist for this function includes a "hidden" argument
8209 which is "this". Put it into the list of argument types. */
8210 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8211 TYPE_ARG_TYPES (t) = argtypes;
8213 /* If we already have such a type, use the old one. */
8214 hstate.add_object (TYPE_HASH (basetype));
8215 hstate.add_object (TYPE_HASH (rettype));
8216 type_hash_list (argtypes, hstate);
8217 t = type_hash_canon (hstate.end (), t);
8219 /* Set up the canonical type. */
8220 any_structural_p
8221 = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8222 || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8223 any_noncanonical_p
8224 = (TYPE_CANONICAL (basetype) != basetype
8225 || TYPE_CANONICAL (rettype) != rettype);
8226 canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8227 &any_structural_p,
8228 &any_noncanonical_p);
8229 if (any_structural_p)
8230 SET_TYPE_STRUCTURAL_EQUALITY (t);
8231 else if (any_noncanonical_p)
8232 TYPE_CANONICAL (t)
8233 = build_method_type_directly (TYPE_CANONICAL (basetype),
8234 TYPE_CANONICAL (rettype),
8235 canon_argtypes);
8236 if (!COMPLETE_TYPE_P (t))
8237 layout_type (t);
8239 return t;
8242 /* Construct, lay out and return the type of methods belonging to class
8243 BASETYPE and whose arguments and values are described by TYPE.
8244 If that type exists already, reuse it.
8245 TYPE must be a FUNCTION_TYPE node. */
8247 tree
8248 build_method_type (tree basetype, tree type)
8250 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8252 return build_method_type_directly (basetype,
8253 TREE_TYPE (type),
8254 TYPE_ARG_TYPES (type));
8257 /* Construct, lay out and return the type of offsets to a value
8258 of type TYPE, within an object of type BASETYPE.
8259 If a suitable offset type exists already, reuse it. */
8261 tree
8262 build_offset_type (tree basetype, tree type)
8264 tree t;
8265 inchash::hash hstate;
8267 /* Make a node of the sort we want. */
8268 t = make_node (OFFSET_TYPE);
8270 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8271 TREE_TYPE (t) = type;
8273 /* If we already have such a type, use the old one. */
8274 hstate.add_object (TYPE_HASH (basetype));
8275 hstate.add_object (TYPE_HASH (type));
8276 t = type_hash_canon (hstate.end (), t);
8278 if (!COMPLETE_TYPE_P (t))
8279 layout_type (t);
8281 if (TYPE_CANONICAL (t) == t)
8283 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8284 || TYPE_STRUCTURAL_EQUALITY_P (type))
8285 SET_TYPE_STRUCTURAL_EQUALITY (t);
8286 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8287 || TYPE_CANONICAL (type) != type)
8288 TYPE_CANONICAL (t)
8289 = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8290 TYPE_CANONICAL (type));
8293 return t;
8296 /* Create a complex type whose components are COMPONENT_TYPE. */
8298 tree
8299 build_complex_type (tree component_type)
8301 tree t;
8302 inchash::hash hstate;
8304 gcc_assert (INTEGRAL_TYPE_P (component_type)
8305 || SCALAR_FLOAT_TYPE_P (component_type)
8306 || FIXED_POINT_TYPE_P (component_type));
8308 /* Make a node of the sort we want. */
8309 t = make_node (COMPLEX_TYPE);
8311 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
8313 /* If we already have such a type, use the old one. */
8314 hstate.add_object (TYPE_HASH (component_type));
8315 t = type_hash_canon (hstate.end (), t);
8317 if (!COMPLETE_TYPE_P (t))
8318 layout_type (t);
8320 if (TYPE_CANONICAL (t) == t)
8322 if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
8323 SET_TYPE_STRUCTURAL_EQUALITY (t);
8324 else if (TYPE_CANONICAL (component_type) != component_type)
8325 TYPE_CANONICAL (t)
8326 = build_complex_type (TYPE_CANONICAL (component_type));
8329 /* We need to create a name, since complex is a fundamental type. */
8330 if (! TYPE_NAME (t))
8332 const char *name;
8333 if (component_type == char_type_node)
8334 name = "complex char";
8335 else if (component_type == signed_char_type_node)
8336 name = "complex signed char";
8337 else if (component_type == unsigned_char_type_node)
8338 name = "complex unsigned char";
8339 else if (component_type == short_integer_type_node)
8340 name = "complex short int";
8341 else if (component_type == short_unsigned_type_node)
8342 name = "complex short unsigned int";
8343 else if (component_type == integer_type_node)
8344 name = "complex int";
8345 else if (component_type == unsigned_type_node)
8346 name = "complex unsigned int";
8347 else if (component_type == long_integer_type_node)
8348 name = "complex long int";
8349 else if (component_type == long_unsigned_type_node)
8350 name = "complex long unsigned int";
8351 else if (component_type == long_long_integer_type_node)
8352 name = "complex long long int";
8353 else if (component_type == long_long_unsigned_type_node)
8354 name = "complex long long unsigned int";
8355 else
8356 name = 0;
8358 if (name != 0)
8359 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8360 get_identifier (name), t);
8363 return build_qualified_type (t, TYPE_QUALS (component_type));
8366 /* If TYPE is a real or complex floating-point type and the target
8367 does not directly support arithmetic on TYPE then return the wider
8368 type to be used for arithmetic on TYPE. Otherwise, return
8369 NULL_TREE. */
8371 tree
8372 excess_precision_type (tree type)
8374 if (flag_excess_precision != EXCESS_PRECISION_FAST)
8376 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
8377 switch (TREE_CODE (type))
8379 case REAL_TYPE:
8380 switch (flt_eval_method)
8382 case 1:
8383 if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
8384 return double_type_node;
8385 break;
8386 case 2:
8387 if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
8388 || TYPE_MODE (type) == TYPE_MODE (double_type_node))
8389 return long_double_type_node;
8390 break;
8391 default:
8392 gcc_unreachable ();
8394 break;
8395 case COMPLEX_TYPE:
8396 if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8397 return NULL_TREE;
8398 switch (flt_eval_method)
8400 case 1:
8401 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
8402 return complex_double_type_node;
8403 break;
8404 case 2:
8405 if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
8406 || (TYPE_MODE (TREE_TYPE (type))
8407 == TYPE_MODE (double_type_node)))
8408 return complex_long_double_type_node;
8409 break;
8410 default:
8411 gcc_unreachable ();
8413 break;
8414 default:
8415 break;
8418 return NULL_TREE;
8421 /* Return OP, stripped of any conversions to wider types as much as is safe.
8422 Converting the value back to OP's type makes a value equivalent to OP.
8424 If FOR_TYPE is nonzero, we return a value which, if converted to
8425 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8427 OP must have integer, real or enumeral type. Pointers are not allowed!
8429 There are some cases where the obvious value we could return
8430 would regenerate to OP if converted to OP's type,
8431 but would not extend like OP to wider types.
8432 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8433 For example, if OP is (unsigned short)(signed char)-1,
8434 we avoid returning (signed char)-1 if FOR_TYPE is int,
8435 even though extending that to an unsigned short would regenerate OP,
8436 since the result of extending (signed char)-1 to (int)
8437 is different from (int) OP. */
8439 tree
8440 get_unwidened (tree op, tree for_type)
8442 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
8443 tree type = TREE_TYPE (op);
8444 unsigned final_prec
8445 = TYPE_PRECISION (for_type != 0 ? for_type : type);
8446 int uns
8447 = (for_type != 0 && for_type != type
8448 && final_prec > TYPE_PRECISION (type)
8449 && TYPE_UNSIGNED (type));
8450 tree win = op;
8452 while (CONVERT_EXPR_P (op))
8454 int bitschange;
8456 /* TYPE_PRECISION on vector types has different meaning
8457 (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8458 so avoid them here. */
8459 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
8460 break;
8462 bitschange = TYPE_PRECISION (TREE_TYPE (op))
8463 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
8465 /* Truncations are many-one so cannot be removed.
8466 Unless we are later going to truncate down even farther. */
8467 if (bitschange < 0
8468 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
8469 break;
8471 /* See what's inside this conversion. If we decide to strip it,
8472 we will set WIN. */
8473 op = TREE_OPERAND (op, 0);
8475 /* If we have not stripped any zero-extensions (uns is 0),
8476 we can strip any kind of extension.
8477 If we have previously stripped a zero-extension,
8478 only zero-extensions can safely be stripped.
8479 Any extension can be stripped if the bits it would produce
8480 are all going to be discarded later by truncating to FOR_TYPE. */
8482 if (bitschange > 0)
8484 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
8485 win = op;
8486 /* TYPE_UNSIGNED says whether this is a zero-extension.
8487 Let's avoid computing it if it does not affect WIN
8488 and if UNS will not be needed again. */
8489 if ((uns
8490 || CONVERT_EXPR_P (op))
8491 && TYPE_UNSIGNED (TREE_TYPE (op)))
8493 uns = 1;
8494 win = op;
8499 /* If we finally reach a constant see if it fits in for_type and
8500 in that case convert it. */
8501 if (for_type
8502 && TREE_CODE (win) == INTEGER_CST
8503 && TREE_TYPE (win) != for_type
8504 && int_fits_type_p (win, for_type))
8505 win = fold_convert (for_type, win);
8507 return win;
8510 /* Return OP or a simpler expression for a narrower value
8511 which can be sign-extended or zero-extended to give back OP.
8512 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
8513 or 0 if the value should be sign-extended. */
8515 tree
8516 get_narrower (tree op, int *unsignedp_ptr)
8518 int uns = 0;
8519 int first = 1;
8520 tree win = op;
8521 bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
8523 while (TREE_CODE (op) == NOP_EXPR)
8525 int bitschange
8526 = (TYPE_PRECISION (TREE_TYPE (op))
8527 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
8529 /* Truncations are many-one so cannot be removed. */
8530 if (bitschange < 0)
8531 break;
8533 /* See what's inside this conversion. If we decide to strip it,
8534 we will set WIN. */
8536 if (bitschange > 0)
8538 op = TREE_OPERAND (op, 0);
8539 /* An extension: the outermost one can be stripped,
8540 but remember whether it is zero or sign extension. */
8541 if (first)
8542 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8543 /* Otherwise, if a sign extension has been stripped,
8544 only sign extensions can now be stripped;
8545 if a zero extension has been stripped, only zero-extensions. */
8546 else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
8547 break;
8548 first = 0;
8550 else /* bitschange == 0 */
8552 /* A change in nominal type can always be stripped, but we must
8553 preserve the unsignedness. */
8554 if (first)
8555 uns = TYPE_UNSIGNED (TREE_TYPE (op));
8556 first = 0;
8557 op = TREE_OPERAND (op, 0);
8558 /* Keep trying to narrow, but don't assign op to win if it
8559 would turn an integral type into something else. */
8560 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
8561 continue;
8564 win = op;
8567 if (TREE_CODE (op) == COMPONENT_REF
8568 /* Since type_for_size always gives an integer type. */
8569 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
8570 && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
8571 /* Ensure field is laid out already. */
8572 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
8573 && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
8575 unsigned HOST_WIDE_INT innerprec
8576 = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
8577 int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
8578 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
8579 tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
8581 /* We can get this structure field in a narrower type that fits it,
8582 but the resulting extension to its nominal type (a fullword type)
8583 must satisfy the same conditions as for other extensions.
8585 Do this only for fields that are aligned (not bit-fields),
8586 because when bit-field insns will be used there is no
8587 advantage in doing this. */
8589 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
8590 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
8591 && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
8592 && type != 0)
8594 if (first)
8595 uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
8596 win = fold_convert (type, op);
8600 *unsignedp_ptr = uns;
8601 return win;
8604 /* Returns true if integer constant C has a value that is permissible
8605 for type TYPE (an INTEGER_TYPE). */
8607 bool
8608 int_fits_type_p (const_tree c, const_tree type)
8610 tree type_low_bound, type_high_bound;
8611 bool ok_for_low_bound, ok_for_high_bound;
8612 signop sgn_c = TYPE_SIGN (TREE_TYPE (c));
8614 retry:
8615 type_low_bound = TYPE_MIN_VALUE (type);
8616 type_high_bound = TYPE_MAX_VALUE (type);
8618 /* If at least one bound of the type is a constant integer, we can check
8619 ourselves and maybe make a decision. If no such decision is possible, but
8620 this type is a subtype, try checking against that. Otherwise, use
8621 fits_to_tree_p, which checks against the precision.
8623 Compute the status for each possibly constant bound, and return if we see
8624 one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
8625 for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
8626 for "constant known to fit". */
8628 /* Check if c >= type_low_bound. */
8629 if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
8631 if (tree_int_cst_lt (c, type_low_bound))
8632 return false;
8633 ok_for_low_bound = true;
8635 else
8636 ok_for_low_bound = false;
8638 /* Check if c <= type_high_bound. */
8639 if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
8641 if (tree_int_cst_lt (type_high_bound, c))
8642 return false;
8643 ok_for_high_bound = true;
8645 else
8646 ok_for_high_bound = false;
8648 /* If the constant fits both bounds, the result is known. */
8649 if (ok_for_low_bound && ok_for_high_bound)
8650 return true;
8652 /* Perform some generic filtering which may allow making a decision
8653 even if the bounds are not constant. First, negative integers
8654 never fit in unsigned types, */
8655 if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (c))
8656 return false;
8658 /* Second, narrower types always fit in wider ones. */
8659 if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8660 return true;
8662 /* Third, unsigned integers with top bit set never fit signed types. */
8663 if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED)
8665 int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1;
8666 if (prec < TYPE_PRECISION (TREE_TYPE (c)))
8668 /* When a tree_cst is converted to a wide-int, the precision
8669 is taken from the type. However, if the precision of the
8670 mode underneath the type is smaller than that, it is
8671 possible that the value will not fit. The test below
8672 fails if any bit is set between the sign bit of the
8673 underlying mode and the top bit of the type. */
8674 if (wi::ne_p (wi::zext (c, prec - 1), c))
8675 return false;
8677 else if (wi::neg_p (c))
8678 return false;
8681 /* If we haven't been able to decide at this point, there nothing more we
8682 can check ourselves here. Look at the base type if we have one and it
8683 has the same precision. */
8684 if (TREE_CODE (type) == INTEGER_TYPE
8685 && TREE_TYPE (type) != 0
8686 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8688 type = TREE_TYPE (type);
8689 goto retry;
8692 /* Or to fits_to_tree_p, if nothing else. */
8693 return wi::fits_to_tree_p (c, type);
8696 /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant
8697 bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8698 represented (assuming two's-complement arithmetic) within the bit
8699 precision of the type are returned instead. */
8701 void
8702 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8704 if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8705 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8706 wi::to_mpz (TYPE_MIN_VALUE (type), min, TYPE_SIGN (type));
8707 else
8709 if (TYPE_UNSIGNED (type))
8710 mpz_set_ui (min, 0);
8711 else
8713 wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED);
8714 wi::to_mpz (mn, min, SIGNED);
8718 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8719 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8720 wi::to_mpz (TYPE_MAX_VALUE (type), max, TYPE_SIGN (type));
8721 else
8723 wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
8724 wi::to_mpz (mn, max, TYPE_SIGN (type));
8728 /* Return true if VAR is an automatic variable defined in function FN. */
8730 bool
8731 auto_var_in_fn_p (const_tree var, const_tree fn)
8733 return (DECL_P (var) && DECL_CONTEXT (var) == fn
8734 && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
8735 || TREE_CODE (var) == PARM_DECL)
8736 && ! TREE_STATIC (var))
8737 || TREE_CODE (var) == LABEL_DECL
8738 || TREE_CODE (var) == RESULT_DECL));
8741 /* Subprogram of following function. Called by walk_tree.
8743 Return *TP if it is an automatic variable or parameter of the
8744 function passed in as DATA. */
8746 static tree
8747 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8749 tree fn = (tree) data;
8751 if (TYPE_P (*tp))
8752 *walk_subtrees = 0;
8754 else if (DECL_P (*tp)
8755 && auto_var_in_fn_p (*tp, fn))
8756 return *tp;
8758 return NULL_TREE;
8761 /* Returns true if T is, contains, or refers to a type with variable
8762 size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8763 arguments, but not the return type. If FN is nonzero, only return
8764 true if a modifier of the type or position of FN is a variable or
8765 parameter inside FN.
8767 This concept is more general than that of C99 'variably modified types':
8768 in C99, a struct type is never variably modified because a VLA may not
8769 appear as a structure member. However, in GNU C code like:
8771 struct S { int i[f()]; };
8773 is valid, and other languages may define similar constructs. */
8775 bool
8776 variably_modified_type_p (tree type, tree fn)
8778 tree t;
8780 /* Test if T is either variable (if FN is zero) or an expression containing
8781 a variable in FN. If TYPE isn't gimplified, return true also if
8782 gimplify_one_sizepos would gimplify the expression into a local
8783 variable. */
8784 #define RETURN_TRUE_IF_VAR(T) \
8785 do { tree _t = (T); \
8786 if (_t != NULL_TREE \
8787 && _t != error_mark_node \
8788 && TREE_CODE (_t) != INTEGER_CST \
8789 && TREE_CODE (_t) != PLACEHOLDER_EXPR \
8790 && (!fn \
8791 || (!TYPE_SIZES_GIMPLIFIED (type) \
8792 && !is_gimple_sizepos (_t)) \
8793 || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
8794 return true; } while (0)
8796 if (type == error_mark_node)
8797 return false;
8799 /* If TYPE itself has variable size, it is variably modified. */
8800 RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8801 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8803 switch (TREE_CODE (type))
8805 case POINTER_TYPE:
8806 case REFERENCE_TYPE:
8807 case VECTOR_TYPE:
8808 if (variably_modified_type_p (TREE_TYPE (type), fn))
8809 return true;
8810 break;
8812 case FUNCTION_TYPE:
8813 case METHOD_TYPE:
8814 /* If TYPE is a function type, it is variably modified if the
8815 return type is variably modified. */
8816 if (variably_modified_type_p (TREE_TYPE (type), fn))
8817 return true;
8818 break;
8820 case INTEGER_TYPE:
8821 case REAL_TYPE:
8822 case FIXED_POINT_TYPE:
8823 case ENUMERAL_TYPE:
8824 case BOOLEAN_TYPE:
8825 /* Scalar types are variably modified if their end points
8826 aren't constant. */
8827 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8828 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8829 break;
8831 case RECORD_TYPE:
8832 case UNION_TYPE:
8833 case QUAL_UNION_TYPE:
8834 /* We can't see if any of the fields are variably-modified by the
8835 definition we normally use, since that would produce infinite
8836 recursion via pointers. */
8837 /* This is variably modified if some field's type is. */
8838 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
8839 if (TREE_CODE (t) == FIELD_DECL)
8841 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8842 RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8843 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8845 if (TREE_CODE (type) == QUAL_UNION_TYPE)
8846 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8848 break;
8850 case ARRAY_TYPE:
8851 /* Do not call ourselves to avoid infinite recursion. This is
8852 variably modified if the element type is. */
8853 RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8854 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8855 break;
8857 default:
8858 break;
8861 /* The current language may have other cases to check, but in general,
8862 all other types are not variably modified. */
8863 return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8865 #undef RETURN_TRUE_IF_VAR
8868 /* Given a DECL or TYPE, return the scope in which it was declared, or
8869 NULL_TREE if there is no containing scope. */
8871 tree
8872 get_containing_scope (const_tree t)
8874 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8877 /* Return the innermost context enclosing DECL that is
8878 a FUNCTION_DECL, or zero if none. */
8880 tree
8881 decl_function_context (const_tree decl)
8883 tree context;
8885 if (TREE_CODE (decl) == ERROR_MARK)
8886 return 0;
8888 /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8889 where we look up the function at runtime. Such functions always take
8890 a first argument of type 'pointer to real context'.
8892 C++ should really be fixed to use DECL_CONTEXT for the real context,
8893 and use something else for the "virtual context". */
8894 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8895 context
8896 = TYPE_MAIN_VARIANT
8897 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8898 else
8899 context = DECL_CONTEXT (decl);
8901 while (context && TREE_CODE (context) != FUNCTION_DECL)
8903 if (TREE_CODE (context) == BLOCK)
8904 context = BLOCK_SUPERCONTEXT (context);
8905 else
8906 context = get_containing_scope (context);
8909 return context;
8912 /* Return the innermost context enclosing DECL that is
8913 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8914 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
8916 tree
8917 decl_type_context (const_tree decl)
8919 tree context = DECL_CONTEXT (decl);
8921 while (context)
8922 switch (TREE_CODE (context))
8924 case NAMESPACE_DECL:
8925 case TRANSLATION_UNIT_DECL:
8926 return NULL_TREE;
8928 case RECORD_TYPE:
8929 case UNION_TYPE:
8930 case QUAL_UNION_TYPE:
8931 return context;
8933 case TYPE_DECL:
8934 case FUNCTION_DECL:
8935 context = DECL_CONTEXT (context);
8936 break;
8938 case BLOCK:
8939 context = BLOCK_SUPERCONTEXT (context);
8940 break;
8942 default:
8943 gcc_unreachable ();
8946 return NULL_TREE;
8949 /* CALL is a CALL_EXPR. Return the declaration for the function
8950 called, or NULL_TREE if the called function cannot be
8951 determined. */
8953 tree
8954 get_callee_fndecl (const_tree call)
8956 tree addr;
8958 if (call == error_mark_node)
8959 return error_mark_node;
8961 /* It's invalid to call this function with anything but a
8962 CALL_EXPR. */
8963 gcc_assert (TREE_CODE (call) == CALL_EXPR);
8965 /* The first operand to the CALL is the address of the function
8966 called. */
8967 addr = CALL_EXPR_FN (call);
8969 /* If there is no function, return early. */
8970 if (addr == NULL_TREE)
8971 return NULL_TREE;
8973 STRIP_NOPS (addr);
8975 /* If this is a readonly function pointer, extract its initial value. */
8976 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8977 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8978 && DECL_INITIAL (addr))
8979 addr = DECL_INITIAL (addr);
8981 /* If the address is just `&f' for some function `f', then we know
8982 that `f' is being called. */
8983 if (TREE_CODE (addr) == ADDR_EXPR
8984 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8985 return TREE_OPERAND (addr, 0);
8987 /* We couldn't figure out what was being called. */
8988 return NULL_TREE;
8991 /* Print debugging information about tree nodes generated during the compile,
8992 and any language-specific information. */
8994 void
8995 dump_tree_statistics (void)
8997 if (GATHER_STATISTICS)
8999 int i;
9000 int total_nodes, total_bytes;
9001 fprintf (stderr, "Kind Nodes Bytes\n");
9002 fprintf (stderr, "---------------------------------------\n");
9003 total_nodes = total_bytes = 0;
9004 for (i = 0; i < (int) all_kinds; i++)
9006 fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
9007 tree_node_counts[i], tree_node_sizes[i]);
9008 total_nodes += tree_node_counts[i];
9009 total_bytes += tree_node_sizes[i];
9011 fprintf (stderr, "---------------------------------------\n");
9012 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
9013 fprintf (stderr, "---------------------------------------\n");
9014 fprintf (stderr, "Code Nodes\n");
9015 fprintf (stderr, "----------------------------\n");
9016 for (i = 0; i < (int) MAX_TREE_CODES; i++)
9017 fprintf (stderr, "%-20s %7d\n", get_tree_code_name ((enum tree_code) i),
9018 tree_code_counts[i]);
9019 fprintf (stderr, "----------------------------\n");
9020 ssanames_print_statistics ();
9021 phinodes_print_statistics ();
9023 else
9024 fprintf (stderr, "(No per-node statistics)\n");
9026 print_type_hash_statistics ();
9027 print_debug_expr_statistics ();
9028 print_value_expr_statistics ();
9029 lang_hooks.print_statistics ();
9032 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9034 /* Generate a crc32 of a byte. */
9036 static unsigned
9037 crc32_unsigned_bits (unsigned chksum, unsigned value, unsigned bits)
9039 unsigned ix;
9041 for (ix = bits; ix--; value <<= 1)
9043 unsigned feedback;
9045 feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
9046 chksum <<= 1;
9047 chksum ^= feedback;
9049 return chksum;
9052 /* Generate a crc32 of a 32-bit unsigned. */
9054 unsigned
9055 crc32_unsigned (unsigned chksum, unsigned value)
9057 return crc32_unsigned_bits (chksum, value, 32);
9060 /* Generate a crc32 of a byte. */
9062 unsigned
9063 crc32_byte (unsigned chksum, char byte)
9065 return crc32_unsigned_bits (chksum, (unsigned) byte << 24, 8);
9068 /* Generate a crc32 of a string. */
9070 unsigned
9071 crc32_string (unsigned chksum, const char *string)
9075 chksum = crc32_byte (chksum, *string);
9077 while (*string++);
9078 return chksum;
9081 /* P is a string that will be used in a symbol. Mask out any characters
9082 that are not valid in that context. */
9084 void
9085 clean_symbol_name (char *p)
9087 for (; *p; p++)
9088 if (! (ISALNUM (*p)
9089 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
9090 || *p == '$'
9091 #endif
9092 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
9093 || *p == '.'
9094 #endif
9096 *p = '_';
9099 /* Generate a name for a special-purpose function.
9100 The generated name may need to be unique across the whole link.
9101 Changes to this function may also require corresponding changes to
9102 xstrdup_mask_random.
9103 TYPE is some string to identify the purpose of this function to the
9104 linker or collect2; it must start with an uppercase letter,
9105 one of:
9106 I - for constructors
9107 D - for destructors
9108 N - for C++ anonymous namespaces
9109 F - for DWARF unwind frame information. */
9111 tree
9112 get_file_function_name (const char *type)
9114 char *buf;
9115 const char *p;
9116 char *q;
9118 /* If we already have a name we know to be unique, just use that. */
9119 if (first_global_object_name)
9120 p = q = ASTRDUP (first_global_object_name);
9121 /* If the target is handling the constructors/destructors, they
9122 will be local to this file and the name is only necessary for
9123 debugging purposes.
9124 We also assign sub_I and sub_D sufixes to constructors called from
9125 the global static constructors. These are always local. */
9126 else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9127 || (strncmp (type, "sub_", 4) == 0
9128 && (type[4] == 'I' || type[4] == 'D')))
9130 const char *file = main_input_filename;
9131 if (! file)
9132 file = LOCATION_FILE (input_location);
9133 /* Just use the file's basename, because the full pathname
9134 might be quite long. */
9135 p = q = ASTRDUP (lbasename (file));
9137 else
9139 /* Otherwise, the name must be unique across the entire link.
9140 We don't have anything that we know to be unique to this translation
9141 unit, so use what we do have and throw in some randomness. */
9142 unsigned len;
9143 const char *name = weak_global_object_name;
9144 const char *file = main_input_filename;
9146 if (! name)
9147 name = "";
9148 if (! file)
9149 file = LOCATION_FILE (input_location);
9151 len = strlen (file);
9152 q = (char *) alloca (9 + 17 + len + 1);
9153 memcpy (q, file, len + 1);
9155 snprintf (q + len, 9 + 17 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9156 crc32_string (0, name), get_random_seed (false));
9158 p = q;
9161 clean_symbol_name (q);
9162 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9163 + strlen (type));
9165 /* Set up the name of the file-level functions we may need.
9166 Use a global object (which is already required to be unique over
9167 the program) rather than the file name (which imposes extra
9168 constraints). */
9169 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9171 return get_identifier (buf);
9174 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9176 /* Complain that the tree code of NODE does not match the expected 0
9177 terminated list of trailing codes. The trailing code list can be
9178 empty, for a more vague error message. FILE, LINE, and FUNCTION
9179 are of the caller. */
9181 void
9182 tree_check_failed (const_tree node, const char *file,
9183 int line, const char *function, ...)
9185 va_list args;
9186 const char *buffer;
9187 unsigned length = 0;
9188 enum tree_code code;
9190 va_start (args, function);
9191 while ((code = (enum tree_code) va_arg (args, int)))
9192 length += 4 + strlen (get_tree_code_name (code));
9193 va_end (args);
9194 if (length)
9196 char *tmp;
9197 va_start (args, function);
9198 length += strlen ("expected ");
9199 buffer = tmp = (char *) alloca (length);
9200 length = 0;
9201 while ((code = (enum tree_code) va_arg (args, int)))
9203 const char *prefix = length ? " or " : "expected ";
9205 strcpy (tmp + length, prefix);
9206 length += strlen (prefix);
9207 strcpy (tmp + length, get_tree_code_name (code));
9208 length += strlen (get_tree_code_name (code));
9210 va_end (args);
9212 else
9213 buffer = "unexpected node";
9215 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9216 buffer, get_tree_code_name (TREE_CODE (node)),
9217 function, trim_filename (file), line);
9220 /* Complain that the tree code of NODE does match the expected 0
9221 terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9222 the caller. */
9224 void
9225 tree_not_check_failed (const_tree node, const char *file,
9226 int line, const char *function, ...)
9228 va_list args;
9229 char *buffer;
9230 unsigned length = 0;
9231 enum tree_code code;
9233 va_start (args, function);
9234 while ((code = (enum tree_code) va_arg (args, int)))
9235 length += 4 + strlen (get_tree_code_name (code));
9236 va_end (args);
9237 va_start (args, function);
9238 buffer = (char *) alloca (length);
9239 length = 0;
9240 while ((code = (enum tree_code) va_arg (args, int)))
9242 if (length)
9244 strcpy (buffer + length, " or ");
9245 length += 4;
9247 strcpy (buffer + length, get_tree_code_name (code));
9248 length += strlen (get_tree_code_name (code));
9250 va_end (args);
9252 internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9253 buffer, get_tree_code_name (TREE_CODE (node)),
9254 function, trim_filename (file), line);
9257 /* Similar to tree_check_failed, except that we check for a class of tree
9258 code, given in CL. */
9260 void
9261 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9262 const char *file, int line, const char *function)
9264 internal_error
9265 ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9266 TREE_CODE_CLASS_STRING (cl),
9267 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9268 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9271 /* Similar to tree_check_failed, except that instead of specifying a
9272 dozen codes, use the knowledge that they're all sequential. */
9274 void
9275 tree_range_check_failed (const_tree node, const char *file, int line,
9276 const char *function, enum tree_code c1,
9277 enum tree_code c2)
9279 char *buffer;
9280 unsigned length = 0;
9281 unsigned int c;
9283 for (c = c1; c <= c2; ++c)
9284 length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9286 length += strlen ("expected ");
9287 buffer = (char *) alloca (length);
9288 length = 0;
9290 for (c = c1; c <= c2; ++c)
9292 const char *prefix = length ? " or " : "expected ";
9294 strcpy (buffer + length, prefix);
9295 length += strlen (prefix);
9296 strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9297 length += strlen (get_tree_code_name ((enum tree_code) c));
9300 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9301 buffer, get_tree_code_name (TREE_CODE (node)),
9302 function, trim_filename (file), line);
9306 /* Similar to tree_check_failed, except that we check that a tree does
9307 not have the specified code, given in CL. */
9309 void
9310 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9311 const char *file, int line, const char *function)
9313 internal_error
9314 ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9315 TREE_CODE_CLASS_STRING (cl),
9316 TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9317 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9321 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
9323 void
9324 omp_clause_check_failed (const_tree node, const char *file, int line,
9325 const char *function, enum omp_clause_code code)
9327 internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9328 omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9329 function, trim_filename (file), line);
9333 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
9335 void
9336 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9337 const char *function, enum omp_clause_code c1,
9338 enum omp_clause_code c2)
9340 char *buffer;
9341 unsigned length = 0;
9342 unsigned int c;
9344 for (c = c1; c <= c2; ++c)
9345 length += 4 + strlen (omp_clause_code_name[c]);
9347 length += strlen ("expected ");
9348 buffer = (char *) alloca (length);
9349 length = 0;
9351 for (c = c1; c <= c2; ++c)
9353 const char *prefix = length ? " or " : "expected ";
9355 strcpy (buffer + length, prefix);
9356 length += strlen (prefix);
9357 strcpy (buffer + length, omp_clause_code_name[c]);
9358 length += strlen (omp_clause_code_name[c]);
9361 internal_error ("tree check: %s, have %s in %s, at %s:%d",
9362 buffer, omp_clause_code_name[TREE_CODE (node)],
9363 function, trim_filename (file), line);
9367 #undef DEFTREESTRUCT
9368 #define DEFTREESTRUCT(VAL, NAME) NAME,
9370 static const char *ts_enum_names[] = {
9371 #include "treestruct.def"
9373 #undef DEFTREESTRUCT
9375 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9377 /* Similar to tree_class_check_failed, except that we check for
9378 whether CODE contains the tree structure identified by EN. */
9380 void
9381 tree_contains_struct_check_failed (const_tree node,
9382 const enum tree_node_structure_enum en,
9383 const char *file, int line,
9384 const char *function)
9386 internal_error
9387 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9388 TS_ENUM_NAME (en),
9389 get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9393 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9394 (dynamically sized) vector. */
9396 void
9397 tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line,
9398 const char *function)
9400 internal_error
9401 ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
9402 idx + 1, len, function, trim_filename (file), line);
9405 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9406 (dynamically sized) vector. */
9408 void
9409 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
9410 const char *function)
9412 internal_error
9413 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
9414 idx + 1, len, function, trim_filename (file), line);
9417 /* Similar to above, except that the check is for the bounds of the operand
9418 vector of an expression node EXP. */
9420 void
9421 tree_operand_check_failed (int idx, const_tree exp, const char *file,
9422 int line, const char *function)
9424 enum tree_code code = TREE_CODE (exp);
9425 internal_error
9426 ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
9427 idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
9428 function, trim_filename (file), line);
9431 /* Similar to above, except that the check is for the number of
9432 operands of an OMP_CLAUSE node. */
9434 void
9435 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
9436 int line, const char *function)
9438 internal_error
9439 ("tree check: accessed operand %d of omp_clause %s with %d operands "
9440 "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
9441 omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
9442 trim_filename (file), line);
9444 #endif /* ENABLE_TREE_CHECKING */
9446 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
9447 and mapped to the machine mode MODE. Initialize its fields and build
9448 the information necessary for debugging output. */
9450 static tree
9451 make_vector_type (tree innertype, int nunits, machine_mode mode)
9453 tree t;
9454 inchash::hash hstate;
9456 t = make_node (VECTOR_TYPE);
9457 TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
9458 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
9459 SET_TYPE_MODE (t, mode);
9461 if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
9462 SET_TYPE_STRUCTURAL_EQUALITY (t);
9463 else if (TYPE_CANONICAL (innertype) != innertype
9464 || mode != VOIDmode)
9465 TYPE_CANONICAL (t)
9466 = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
9468 layout_type (t);
9470 hstate.add_wide_int (VECTOR_TYPE);
9471 hstate.add_wide_int (nunits);
9472 hstate.add_wide_int (mode);
9473 hstate.add_object (TYPE_HASH (TREE_TYPE (t)));
9474 t = type_hash_canon (hstate.end (), t);
9476 /* We have built a main variant, based on the main variant of the
9477 inner type. Use it to build the variant we return. */
9478 if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
9479 && TREE_TYPE (t) != innertype)
9480 return build_type_attribute_qual_variant (t,
9481 TYPE_ATTRIBUTES (innertype),
9482 TYPE_QUALS (innertype));
9484 return t;
9487 static tree
9488 make_or_reuse_type (unsigned size, int unsignedp)
9490 int i;
9492 if (size == INT_TYPE_SIZE)
9493 return unsignedp ? unsigned_type_node : integer_type_node;
9494 if (size == CHAR_TYPE_SIZE)
9495 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
9496 if (size == SHORT_TYPE_SIZE)
9497 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
9498 if (size == LONG_TYPE_SIZE)
9499 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
9500 if (size == LONG_LONG_TYPE_SIZE)
9501 return (unsignedp ? long_long_unsigned_type_node
9502 : long_long_integer_type_node);
9504 for (i = 0; i < NUM_INT_N_ENTS; i ++)
9505 if (size == int_n_data[i].bitsize
9506 && int_n_enabled_p[i])
9507 return (unsignedp ? int_n_trees[i].unsigned_type
9508 : int_n_trees[i].signed_type);
9510 if (unsignedp)
9511 return make_unsigned_type (size);
9512 else
9513 return make_signed_type (size);
9516 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
9518 static tree
9519 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
9521 if (satp)
9523 if (size == SHORT_FRACT_TYPE_SIZE)
9524 return unsignedp ? sat_unsigned_short_fract_type_node
9525 : sat_short_fract_type_node;
9526 if (size == FRACT_TYPE_SIZE)
9527 return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
9528 if (size == LONG_FRACT_TYPE_SIZE)
9529 return unsignedp ? sat_unsigned_long_fract_type_node
9530 : sat_long_fract_type_node;
9531 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9532 return unsignedp ? sat_unsigned_long_long_fract_type_node
9533 : sat_long_long_fract_type_node;
9535 else
9537 if (size == SHORT_FRACT_TYPE_SIZE)
9538 return unsignedp ? unsigned_short_fract_type_node
9539 : short_fract_type_node;
9540 if (size == FRACT_TYPE_SIZE)
9541 return unsignedp ? unsigned_fract_type_node : fract_type_node;
9542 if (size == LONG_FRACT_TYPE_SIZE)
9543 return unsignedp ? unsigned_long_fract_type_node
9544 : long_fract_type_node;
9545 if (size == LONG_LONG_FRACT_TYPE_SIZE)
9546 return unsignedp ? unsigned_long_long_fract_type_node
9547 : long_long_fract_type_node;
9550 return make_fract_type (size, unsignedp, satp);
9553 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
9555 static tree
9556 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
9558 if (satp)
9560 if (size == SHORT_ACCUM_TYPE_SIZE)
9561 return unsignedp ? sat_unsigned_short_accum_type_node
9562 : sat_short_accum_type_node;
9563 if (size == ACCUM_TYPE_SIZE)
9564 return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
9565 if (size == LONG_ACCUM_TYPE_SIZE)
9566 return unsignedp ? sat_unsigned_long_accum_type_node
9567 : sat_long_accum_type_node;
9568 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9569 return unsignedp ? sat_unsigned_long_long_accum_type_node
9570 : sat_long_long_accum_type_node;
9572 else
9574 if (size == SHORT_ACCUM_TYPE_SIZE)
9575 return unsignedp ? unsigned_short_accum_type_node
9576 : short_accum_type_node;
9577 if (size == ACCUM_TYPE_SIZE)
9578 return unsignedp ? unsigned_accum_type_node : accum_type_node;
9579 if (size == LONG_ACCUM_TYPE_SIZE)
9580 return unsignedp ? unsigned_long_accum_type_node
9581 : long_accum_type_node;
9582 if (size == LONG_LONG_ACCUM_TYPE_SIZE)
9583 return unsignedp ? unsigned_long_long_accum_type_node
9584 : long_long_accum_type_node;
9587 return make_accum_type (size, unsignedp, satp);
9591 /* Create an atomic variant node for TYPE. This routine is called
9592 during initialization of data types to create the 5 basic atomic
9593 types. The generic build_variant_type function requires these to
9594 already be set up in order to function properly, so cannot be
9595 called from there. If ALIGN is non-zero, then ensure alignment is
9596 overridden to this value. */
9598 static tree
9599 build_atomic_base (tree type, unsigned int align)
9601 tree t;
9603 /* Make sure its not already registered. */
9604 if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
9605 return t;
9607 t = build_variant_type_copy (type);
9608 set_type_quals (t, TYPE_QUAL_ATOMIC);
9610 if (align)
9611 TYPE_ALIGN (t) = align;
9613 return t;
9616 /* Create nodes for all integer types (and error_mark_node) using the sizes
9617 of C datatypes. SIGNED_CHAR specifies whether char is signed,
9618 SHORT_DOUBLE specifies whether double should be of the same precision
9619 as float. */
9621 void
9622 build_common_tree_nodes (bool signed_char, bool short_double)
9624 int i;
9626 error_mark_node = make_node (ERROR_MARK);
9627 TREE_TYPE (error_mark_node) = error_mark_node;
9629 initialize_sizetypes ();
9631 /* Define both `signed char' and `unsigned char'. */
9632 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
9633 TYPE_STRING_FLAG (signed_char_type_node) = 1;
9634 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
9635 TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
9637 /* Define `char', which is like either `signed char' or `unsigned char'
9638 but not the same as either. */
9639 char_type_node
9640 = (signed_char
9641 ? make_signed_type (CHAR_TYPE_SIZE)
9642 : make_unsigned_type (CHAR_TYPE_SIZE));
9643 TYPE_STRING_FLAG (char_type_node) = 1;
9645 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
9646 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
9647 integer_type_node = make_signed_type (INT_TYPE_SIZE);
9648 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
9649 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
9650 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
9651 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
9652 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
9654 for (i = 0; i < NUM_INT_N_ENTS; i ++)
9656 int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize);
9657 int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize);
9658 TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize);
9659 TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize);
9661 if (int_n_data[i].bitsize > LONG_LONG_TYPE_SIZE
9662 && int_n_enabled_p[i])
9664 integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type;
9665 integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type;
9669 /* Define a boolean type. This type only represents boolean values but
9670 may be larger than char depending on the value of BOOL_TYPE_SIZE. */
9671 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
9672 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
9673 TYPE_PRECISION (boolean_type_node) = 1;
9674 TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
9676 /* Define what type to use for size_t. */
9677 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
9678 size_type_node = unsigned_type_node;
9679 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
9680 size_type_node = long_unsigned_type_node;
9681 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
9682 size_type_node = long_long_unsigned_type_node;
9683 else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
9684 size_type_node = short_unsigned_type_node;
9685 else
9687 int i;
9689 size_type_node = NULL_TREE;
9690 for (i = 0; i < NUM_INT_N_ENTS; i++)
9691 if (int_n_enabled_p[i])
9693 char name[50];
9694 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
9696 if (strcmp (name, SIZE_TYPE) == 0)
9698 size_type_node = int_n_trees[i].unsigned_type;
9701 if (size_type_node == NULL_TREE)
9702 gcc_unreachable ();
9705 /* Fill in the rest of the sized types. Reuse existing type nodes
9706 when possible. */
9707 intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
9708 intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
9709 intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
9710 intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
9711 intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
9713 unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
9714 unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
9715 unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
9716 unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
9717 unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
9719 /* Don't call build_qualified type for atomics. That routine does
9720 special processing for atomics, and until they are initialized
9721 it's better not to make that call.
9723 Check to see if there is a target override for atomic types. */
9725 atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
9726 targetm.atomic_align_for_mode (QImode));
9727 atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
9728 targetm.atomic_align_for_mode (HImode));
9729 atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
9730 targetm.atomic_align_for_mode (SImode));
9731 atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
9732 targetm.atomic_align_for_mode (DImode));
9733 atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
9734 targetm.atomic_align_for_mode (TImode));
9736 access_public_node = get_identifier ("public");
9737 access_protected_node = get_identifier ("protected");
9738 access_private_node = get_identifier ("private");
9740 /* Define these next since types below may used them. */
9741 integer_zero_node = build_int_cst (integer_type_node, 0);
9742 integer_one_node = build_int_cst (integer_type_node, 1);
9743 integer_three_node = build_int_cst (integer_type_node, 3);
9744 integer_minus_one_node = build_int_cst (integer_type_node, -1);
9746 size_zero_node = size_int (0);
9747 size_one_node = size_int (1);
9748 bitsize_zero_node = bitsize_int (0);
9749 bitsize_one_node = bitsize_int (1);
9750 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
9752 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
9753 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
9755 void_type_node = make_node (VOID_TYPE);
9756 layout_type (void_type_node);
9758 pointer_bounds_type_node = targetm.chkp_bound_type ();
9760 /* We are not going to have real types in C with less than byte alignment,
9761 so we might as well not have any types that claim to have it. */
9762 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
9763 TYPE_USER_ALIGN (void_type_node) = 0;
9765 void_node = make_node (VOID_CST);
9766 TREE_TYPE (void_node) = void_type_node;
9768 null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9769 layout_type (TREE_TYPE (null_pointer_node));
9771 ptr_type_node = build_pointer_type (void_type_node);
9772 const_ptr_type_node
9773 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9774 fileptr_type_node = ptr_type_node;
9776 pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
9778 float_type_node = make_node (REAL_TYPE);
9779 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9780 layout_type (float_type_node);
9782 double_type_node = make_node (REAL_TYPE);
9783 if (short_double)
9784 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
9785 else
9786 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9787 layout_type (double_type_node);
9789 long_double_type_node = make_node (REAL_TYPE);
9790 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9791 layout_type (long_double_type_node);
9793 float_ptr_type_node = build_pointer_type (float_type_node);
9794 double_ptr_type_node = build_pointer_type (double_type_node);
9795 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9796 integer_ptr_type_node = build_pointer_type (integer_type_node);
9798 /* Fixed size integer types. */
9799 uint16_type_node = make_or_reuse_type (16, 1);
9800 uint32_type_node = make_or_reuse_type (32, 1);
9801 uint64_type_node = make_or_reuse_type (64, 1);
9803 /* Decimal float types. */
9804 dfloat32_type_node = make_node (REAL_TYPE);
9805 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9806 layout_type (dfloat32_type_node);
9807 SET_TYPE_MODE (dfloat32_type_node, SDmode);
9808 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9810 dfloat64_type_node = make_node (REAL_TYPE);
9811 TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9812 layout_type (dfloat64_type_node);
9813 SET_TYPE_MODE (dfloat64_type_node, DDmode);
9814 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9816 dfloat128_type_node = make_node (REAL_TYPE);
9817 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9818 layout_type (dfloat128_type_node);
9819 SET_TYPE_MODE (dfloat128_type_node, TDmode);
9820 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
9822 complex_integer_type_node = build_complex_type (integer_type_node);
9823 complex_float_type_node = build_complex_type (float_type_node);
9824 complex_double_type_node = build_complex_type (double_type_node);
9825 complex_long_double_type_node = build_complex_type (long_double_type_node);
9827 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */
9828 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9829 sat_ ## KIND ## _type_node = \
9830 make_sat_signed_ ## KIND ## _type (SIZE); \
9831 sat_unsigned_ ## KIND ## _type_node = \
9832 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9833 KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9834 unsigned_ ## KIND ## _type_node = \
9835 make_unsigned_ ## KIND ## _type (SIZE);
9837 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9838 sat_ ## WIDTH ## KIND ## _type_node = \
9839 make_sat_signed_ ## KIND ## _type (SIZE); \
9840 sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9841 make_sat_unsigned_ ## KIND ## _type (SIZE); \
9842 WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9843 unsigned_ ## WIDTH ## KIND ## _type_node = \
9844 make_unsigned_ ## KIND ## _type (SIZE);
9846 /* Make fixed-point type nodes based on four different widths. */
9847 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9848 MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9849 MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9850 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9851 MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9853 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
9854 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9855 NAME ## _type_node = \
9856 make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9857 u ## NAME ## _type_node = \
9858 make_or_reuse_unsigned_ ## KIND ## _type \
9859 (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9860 sat_ ## NAME ## _type_node = \
9861 make_or_reuse_sat_signed_ ## KIND ## _type \
9862 (GET_MODE_BITSIZE (MODE ## mode)); \
9863 sat_u ## NAME ## _type_node = \
9864 make_or_reuse_sat_unsigned_ ## KIND ## _type \
9865 (GET_MODE_BITSIZE (U ## MODE ## mode));
9867 /* Fixed-point type and mode nodes. */
9868 MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
9869 MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
9870 MAKE_FIXED_MODE_NODE (fract, qq, QQ)
9871 MAKE_FIXED_MODE_NODE (fract, hq, HQ)
9872 MAKE_FIXED_MODE_NODE (fract, sq, SQ)
9873 MAKE_FIXED_MODE_NODE (fract, dq, DQ)
9874 MAKE_FIXED_MODE_NODE (fract, tq, TQ)
9875 MAKE_FIXED_MODE_NODE (accum, ha, HA)
9876 MAKE_FIXED_MODE_NODE (accum, sa, SA)
9877 MAKE_FIXED_MODE_NODE (accum, da, DA)
9878 MAKE_FIXED_MODE_NODE (accum, ta, TA)
9881 tree t = targetm.build_builtin_va_list ();
9883 /* Many back-ends define record types without setting TYPE_NAME.
9884 If we copied the record type here, we'd keep the original
9885 record type without a name. This breaks name mangling. So,
9886 don't copy record types and let c_common_nodes_and_builtins()
9887 declare the type to be __builtin_va_list. */
9888 if (TREE_CODE (t) != RECORD_TYPE)
9889 t = build_variant_type_copy (t);
9891 va_list_type_node = t;
9895 /* Modify DECL for given flags.
9896 TM_PURE attribute is set only on types, so the function will modify
9897 DECL's type when ECF_TM_PURE is used. */
9899 void
9900 set_call_expr_flags (tree decl, int flags)
9902 if (flags & ECF_NOTHROW)
9903 TREE_NOTHROW (decl) = 1;
9904 if (flags & ECF_CONST)
9905 TREE_READONLY (decl) = 1;
9906 if (flags & ECF_PURE)
9907 DECL_PURE_P (decl) = 1;
9908 if (flags & ECF_LOOPING_CONST_OR_PURE)
9909 DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9910 if (flags & ECF_NOVOPS)
9911 DECL_IS_NOVOPS (decl) = 1;
9912 if (flags & ECF_NORETURN)
9913 TREE_THIS_VOLATILE (decl) = 1;
9914 if (flags & ECF_MALLOC)
9915 DECL_IS_MALLOC (decl) = 1;
9916 if (flags & ECF_RETURNS_TWICE)
9917 DECL_IS_RETURNS_TWICE (decl) = 1;
9918 if (flags & ECF_LEAF)
9919 DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
9920 NULL, DECL_ATTRIBUTES (decl));
9921 if ((flags & ECF_TM_PURE) && flag_tm)
9922 apply_tm_attr (decl, get_identifier ("transaction_pure"));
9923 /* Looping const or pure is implied by noreturn.
9924 There is currently no way to declare looping const or looping pure alone. */
9925 gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
9926 || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
9930 /* A subroutine of build_common_builtin_nodes. Define a builtin function. */
9932 static void
9933 local_define_builtin (const char *name, tree type, enum built_in_function code,
9934 const char *library_name, int ecf_flags)
9936 tree decl;
9938 decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9939 library_name, NULL_TREE);
9940 set_call_expr_flags (decl, ecf_flags);
9942 set_builtin_decl (code, decl, true);
9945 /* Call this function after instantiating all builtins that the language
9946 front end cares about. This will build the rest of the builtins
9947 and internal functions that are relied upon by the tree optimizers and
9948 the middle-end. */
9950 void
9951 build_common_builtin_nodes (void)
9953 tree tmp, ftype;
9954 int ecf_flags;
9956 if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
9958 ftype = build_function_type (void_type_node, void_list_node);
9959 local_define_builtin ("__builtin_unreachable", ftype, BUILT_IN_UNREACHABLE,
9960 "__builtin_unreachable",
9961 ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
9962 | ECF_CONST | ECF_LEAF);
9965 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
9966 || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
9968 ftype = build_function_type_list (ptr_type_node,
9969 ptr_type_node, const_ptr_type_node,
9970 size_type_node, NULL_TREE);
9972 if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
9973 local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9974 "memcpy", ECF_NOTHROW | ECF_LEAF);
9975 if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
9976 local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9977 "memmove", ECF_NOTHROW | ECF_LEAF);
9980 if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
9982 ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
9983 const_ptr_type_node, size_type_node,
9984 NULL_TREE);
9985 local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9986 "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
9989 if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
9991 ftype = build_function_type_list (ptr_type_node,
9992 ptr_type_node, integer_type_node,
9993 size_type_node, NULL_TREE);
9994 local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9995 "memset", ECF_NOTHROW | ECF_LEAF);
9998 if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
10000 ftype = build_function_type_list (ptr_type_node,
10001 size_type_node, NULL_TREE);
10002 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
10003 "alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
10006 ftype = build_function_type_list (ptr_type_node, size_type_node,
10007 size_type_node, NULL_TREE);
10008 local_define_builtin ("__builtin_alloca_with_align", ftype,
10009 BUILT_IN_ALLOCA_WITH_ALIGN, "alloca",
10010 ECF_MALLOC | ECF_NOTHROW | ECF_LEAF);
10012 /* If we're checking the stack, `alloca' can throw. */
10013 if (flag_stack_check)
10015 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA)) = 0;
10016 TREE_NOTHROW (builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN)) = 0;
10019 ftype = build_function_type_list (void_type_node,
10020 ptr_type_node, ptr_type_node,
10021 ptr_type_node, NULL_TREE);
10022 local_define_builtin ("__builtin_init_trampoline", ftype,
10023 BUILT_IN_INIT_TRAMPOLINE,
10024 "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
10025 local_define_builtin ("__builtin_init_heap_trampoline", ftype,
10026 BUILT_IN_INIT_HEAP_TRAMPOLINE,
10027 "__builtin_init_heap_trampoline",
10028 ECF_NOTHROW | ECF_LEAF);
10030 ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
10031 local_define_builtin ("__builtin_adjust_trampoline", ftype,
10032 BUILT_IN_ADJUST_TRAMPOLINE,
10033 "__builtin_adjust_trampoline",
10034 ECF_CONST | ECF_NOTHROW);
10036 ftype = build_function_type_list (void_type_node,
10037 ptr_type_node, ptr_type_node, NULL_TREE);
10038 local_define_builtin ("__builtin_nonlocal_goto", ftype,
10039 BUILT_IN_NONLOCAL_GOTO,
10040 "__builtin_nonlocal_goto",
10041 ECF_NORETURN | ECF_NOTHROW);
10043 ftype = build_function_type_list (void_type_node,
10044 ptr_type_node, ptr_type_node, NULL_TREE);
10045 local_define_builtin ("__builtin_setjmp_setup", ftype,
10046 BUILT_IN_SETJMP_SETUP,
10047 "__builtin_setjmp_setup", ECF_NOTHROW);
10049 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10050 local_define_builtin ("__builtin_setjmp_receiver", ftype,
10051 BUILT_IN_SETJMP_RECEIVER,
10052 "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
10054 ftype = build_function_type_list (ptr_type_node, NULL_TREE);
10055 local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
10056 "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
10058 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10059 local_define_builtin ("__builtin_stack_restore", ftype,
10060 BUILT_IN_STACK_RESTORE,
10061 "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
10063 /* If there's a possibility that we might use the ARM EABI, build the
10064 alternate __cxa_end_cleanup node used to resume from C++ and Java. */
10065 if (targetm.arm_eabi_unwinder)
10067 ftype = build_function_type_list (void_type_node, NULL_TREE);
10068 local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10069 BUILT_IN_CXA_END_CLEANUP,
10070 "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10073 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10074 local_define_builtin ("__builtin_unwind_resume", ftype,
10075 BUILT_IN_UNWIND_RESUME,
10076 ((targetm_common.except_unwind_info (&global_options)
10077 == UI_SJLJ)
10078 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10079 ECF_NORETURN);
10081 if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10083 ftype = build_function_type_list (ptr_type_node, integer_type_node,
10084 NULL_TREE);
10085 local_define_builtin ("__builtin_return_address", ftype,
10086 BUILT_IN_RETURN_ADDRESS,
10087 "__builtin_return_address",
10088 ECF_NOTHROW);
10091 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10092 || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10094 ftype = build_function_type_list (void_type_node, ptr_type_node,
10095 ptr_type_node, NULL_TREE);
10096 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10097 local_define_builtin ("__cyg_profile_func_enter", ftype,
10098 BUILT_IN_PROFILE_FUNC_ENTER,
10099 "__cyg_profile_func_enter", 0);
10100 if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10101 local_define_builtin ("__cyg_profile_func_exit", ftype,
10102 BUILT_IN_PROFILE_FUNC_EXIT,
10103 "__cyg_profile_func_exit", 0);
10106 /* The exception object and filter values from the runtime. The argument
10107 must be zero before exception lowering, i.e. from the front end. After
10108 exception lowering, it will be the region number for the exception
10109 landing pad. These functions are PURE instead of CONST to prevent
10110 them from being hoisted past the exception edge that will initialize
10111 its value in the landing pad. */
10112 ftype = build_function_type_list (ptr_type_node,
10113 integer_type_node, NULL_TREE);
10114 ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10115 /* Only use TM_PURE if we we have TM language support. */
10116 if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10117 ecf_flags |= ECF_TM_PURE;
10118 local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10119 "__builtin_eh_pointer", ecf_flags);
10121 tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10122 ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10123 local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10124 "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10126 ftype = build_function_type_list (void_type_node,
10127 integer_type_node, integer_type_node,
10128 NULL_TREE);
10129 local_define_builtin ("__builtin_eh_copy_values", ftype,
10130 BUILT_IN_EH_COPY_VALUES,
10131 "__builtin_eh_copy_values", ECF_NOTHROW);
10133 /* Complex multiplication and division. These are handled as builtins
10134 rather than optabs because emit_library_call_value doesn't support
10135 complex. Further, we can do slightly better with folding these
10136 beasties if the real and complex parts of the arguments are separate. */
10138 int mode;
10140 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10142 char mode_name_buf[4], *q;
10143 const char *p;
10144 enum built_in_function mcode, dcode;
10145 tree type, inner_type;
10146 const char *prefix = "__";
10148 if (targetm.libfunc_gnu_prefix)
10149 prefix = "__gnu_";
10151 type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0);
10152 if (type == NULL)
10153 continue;
10154 inner_type = TREE_TYPE (type);
10156 ftype = build_function_type_list (type, inner_type, inner_type,
10157 inner_type, inner_type, NULL_TREE);
10159 mcode = ((enum built_in_function)
10160 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10161 dcode = ((enum built_in_function)
10162 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10164 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10165 *q = TOLOWER (*p);
10166 *q = '\0';
10168 built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10169 NULL);
10170 local_define_builtin (built_in_names[mcode], ftype, mcode,
10171 built_in_names[mcode],
10172 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10174 built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10175 NULL);
10176 local_define_builtin (built_in_names[dcode], ftype, dcode,
10177 built_in_names[dcode],
10178 ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10182 init_internal_fns ();
10185 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
10186 better way.
10188 If we requested a pointer to a vector, build up the pointers that
10189 we stripped off while looking for the inner type. Similarly for
10190 return values from functions.
10192 The argument TYPE is the top of the chain, and BOTTOM is the
10193 new type which we will point to. */
10195 tree
10196 reconstruct_complex_type (tree type, tree bottom)
10198 tree inner, outer;
10200 if (TREE_CODE (type) == POINTER_TYPE)
10202 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10203 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10204 TYPE_REF_CAN_ALIAS_ALL (type));
10206 else if (TREE_CODE (type) == REFERENCE_TYPE)
10208 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10209 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10210 TYPE_REF_CAN_ALIAS_ALL (type));
10212 else if (TREE_CODE (type) == ARRAY_TYPE)
10214 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10215 outer = build_array_type (inner, TYPE_DOMAIN (type));
10217 else if (TREE_CODE (type) == FUNCTION_TYPE)
10219 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10220 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10222 else if (TREE_CODE (type) == METHOD_TYPE)
10224 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10225 /* The build_method_type_directly() routine prepends 'this' to argument list,
10226 so we must compensate by getting rid of it. */
10227 outer
10228 = build_method_type_directly
10229 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10230 inner,
10231 TREE_CHAIN (TYPE_ARG_TYPES (type)));
10233 else if (TREE_CODE (type) == OFFSET_TYPE)
10235 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10236 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10238 else
10239 return bottom;
10241 return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10242 TYPE_QUALS (type));
10245 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10246 the inner type. */
10247 tree
10248 build_vector_type_for_mode (tree innertype, machine_mode mode)
10250 int nunits;
10252 switch (GET_MODE_CLASS (mode))
10254 case MODE_VECTOR_INT:
10255 case MODE_VECTOR_FLOAT:
10256 case MODE_VECTOR_FRACT:
10257 case MODE_VECTOR_UFRACT:
10258 case MODE_VECTOR_ACCUM:
10259 case MODE_VECTOR_UACCUM:
10260 nunits = GET_MODE_NUNITS (mode);
10261 break;
10263 case MODE_INT:
10264 /* Check that there are no leftover bits. */
10265 gcc_assert (GET_MODE_BITSIZE (mode)
10266 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10268 nunits = GET_MODE_BITSIZE (mode)
10269 / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
10270 break;
10272 default:
10273 gcc_unreachable ();
10276 return make_vector_type (innertype, nunits, mode);
10279 /* Similarly, but takes the inner type and number of units, which must be
10280 a power of two. */
10282 tree
10283 build_vector_type (tree innertype, int nunits)
10285 return make_vector_type (innertype, nunits, VOIDmode);
10288 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */
10290 tree
10291 build_opaque_vector_type (tree innertype, int nunits)
10293 tree t = make_vector_type (innertype, nunits, VOIDmode);
10294 tree cand;
10295 /* We always build the non-opaque variant before the opaque one,
10296 so if it already exists, it is TYPE_NEXT_VARIANT of this one. */
10297 cand = TYPE_NEXT_VARIANT (t);
10298 if (cand
10299 && TYPE_VECTOR_OPAQUE (cand)
10300 && check_qualified_type (cand, t, TYPE_QUALS (t)))
10301 return cand;
10302 /* Othewise build a variant type and make sure to queue it after
10303 the non-opaque type. */
10304 cand = build_distinct_type_copy (t);
10305 TYPE_VECTOR_OPAQUE (cand) = true;
10306 TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
10307 TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
10308 TYPE_NEXT_VARIANT (t) = cand;
10309 TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
10310 return cand;
10314 /* Given an initializer INIT, return TRUE if INIT is zero or some
10315 aggregate of zeros. Otherwise return FALSE. */
10316 bool
10317 initializer_zerop (const_tree init)
10319 tree elt;
10321 STRIP_NOPS (init);
10323 switch (TREE_CODE (init))
10325 case INTEGER_CST:
10326 return integer_zerop (init);
10328 case REAL_CST:
10329 /* ??? Note that this is not correct for C4X float formats. There,
10330 a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
10331 negative exponent. */
10332 return real_zerop (init)
10333 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
10335 case FIXED_CST:
10336 return fixed_zerop (init);
10338 case COMPLEX_CST:
10339 return integer_zerop (init)
10340 || (real_zerop (init)
10341 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
10342 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
10344 case VECTOR_CST:
10346 unsigned i;
10347 for (i = 0; i < VECTOR_CST_NELTS (init); ++i)
10348 if (!initializer_zerop (VECTOR_CST_ELT (init, i)))
10349 return false;
10350 return true;
10353 case CONSTRUCTOR:
10355 unsigned HOST_WIDE_INT idx;
10357 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
10358 if (!initializer_zerop (elt))
10359 return false;
10360 return true;
10363 case STRING_CST:
10365 int i;
10367 /* We need to loop through all elements to handle cases like
10368 "\0" and "\0foobar". */
10369 for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
10370 if (TREE_STRING_POINTER (init)[i] != '\0')
10371 return false;
10373 return true;
10376 default:
10377 return false;
10381 /* Check if vector VEC consists of all the equal elements and
10382 that the number of elements corresponds to the type of VEC.
10383 The function returns first element of the vector
10384 or NULL_TREE if the vector is not uniform. */
10385 tree
10386 uniform_vector_p (const_tree vec)
10388 tree first, t;
10389 unsigned i;
10391 if (vec == NULL_TREE)
10392 return NULL_TREE;
10394 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
10396 if (TREE_CODE (vec) == VECTOR_CST)
10398 first = VECTOR_CST_ELT (vec, 0);
10399 for (i = 1; i < VECTOR_CST_NELTS (vec); ++i)
10400 if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0))
10401 return NULL_TREE;
10403 return first;
10406 else if (TREE_CODE (vec) == CONSTRUCTOR)
10408 first = error_mark_node;
10410 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
10412 if (i == 0)
10414 first = t;
10415 continue;
10417 if (!operand_equal_p (first, t, 0))
10418 return NULL_TREE;
10420 if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)))
10421 return NULL_TREE;
10423 return first;
10426 return NULL_TREE;
10429 /* Build an empty statement at location LOC. */
10431 tree
10432 build_empty_stmt (location_t loc)
10434 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
10435 SET_EXPR_LOCATION (t, loc);
10436 return t;
10440 /* Build an OpenMP clause with code CODE. LOC is the location of the
10441 clause. */
10443 tree
10444 build_omp_clause (location_t loc, enum omp_clause_code code)
10446 tree t;
10447 int size, length;
10449 length = omp_clause_num_ops[code];
10450 size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
10452 record_node_allocation_statistics (OMP_CLAUSE, size);
10454 t = (tree) ggc_internal_alloc (size);
10455 memset (t, 0, size);
10456 TREE_SET_CODE (t, OMP_CLAUSE);
10457 OMP_CLAUSE_SET_CODE (t, code);
10458 OMP_CLAUSE_LOCATION (t) = loc;
10460 return t;
10463 /* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
10464 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
10465 Except for the CODE and operand count field, other storage for the
10466 object is initialized to zeros. */
10468 tree
10469 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
10471 tree t;
10472 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
10474 gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
10475 gcc_assert (len >= 1);
10477 record_node_allocation_statistics (code, length);
10479 t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
10481 TREE_SET_CODE (t, code);
10483 /* Can't use TREE_OPERAND to store the length because if checking is
10484 enabled, it will try to check the length before we store it. :-P */
10485 t->exp.operands[0] = build_int_cst (sizetype, len);
10487 return t;
10490 /* Helper function for build_call_* functions; build a CALL_EXPR with
10491 indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
10492 the argument slots. */
10494 static tree
10495 build_call_1 (tree return_type, tree fn, int nargs)
10497 tree t;
10499 t = build_vl_exp (CALL_EXPR, nargs + 3);
10500 TREE_TYPE (t) = return_type;
10501 CALL_EXPR_FN (t) = fn;
10502 CALL_EXPR_STATIC_CHAIN (t) = NULL;
10504 return t;
10507 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10508 FN and a null static chain slot. NARGS is the number of call arguments
10509 which are specified as "..." arguments. */
10511 tree
10512 build_call_nary (tree return_type, tree fn, int nargs, ...)
10514 tree ret;
10515 va_list args;
10516 va_start (args, nargs);
10517 ret = build_call_valist (return_type, fn, nargs, args);
10518 va_end (args);
10519 return ret;
10522 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10523 FN and a null static chain slot. NARGS is the number of call arguments
10524 which are specified as a va_list ARGS. */
10526 tree
10527 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
10529 tree t;
10530 int i;
10532 t = build_call_1 (return_type, fn, nargs);
10533 for (i = 0; i < nargs; i++)
10534 CALL_EXPR_ARG (t, i) = va_arg (args, tree);
10535 process_call_operands (t);
10536 return t;
10539 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
10540 FN and a null static chain slot. NARGS is the number of call arguments
10541 which are specified as a tree array ARGS. */
10543 tree
10544 build_call_array_loc (location_t loc, tree return_type, tree fn,
10545 int nargs, const tree *args)
10547 tree t;
10548 int i;
10550 t = build_call_1 (return_type, fn, nargs);
10551 for (i = 0; i < nargs; i++)
10552 CALL_EXPR_ARG (t, i) = args[i];
10553 process_call_operands (t);
10554 SET_EXPR_LOCATION (t, loc);
10555 return t;
10558 /* Like build_call_array, but takes a vec. */
10560 tree
10561 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
10563 tree ret, t;
10564 unsigned int ix;
10566 ret = build_call_1 (return_type, fn, vec_safe_length (args));
10567 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
10568 CALL_EXPR_ARG (ret, ix) = t;
10569 process_call_operands (ret);
10570 return ret;
10573 /* Conveniently construct a function call expression. FNDECL names the
10574 function to be called and N arguments are passed in the array
10575 ARGARRAY. */
10577 tree
10578 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10580 tree fntype = TREE_TYPE (fndecl);
10581 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10583 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10586 /* Conveniently construct a function call expression. FNDECL names the
10587 function to be called and the arguments are passed in the vector
10588 VEC. */
10590 tree
10591 build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec)
10593 return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec),
10594 vec_safe_address (vec));
10598 /* Conveniently construct a function call expression. FNDECL names the
10599 function to be called, N is the number of arguments, and the "..."
10600 parameters are the argument expressions. */
10602 tree
10603 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10605 va_list ap;
10606 tree *argarray = XALLOCAVEC (tree, n);
10607 int i;
10609 va_start (ap, n);
10610 for (i = 0; i < n; i++)
10611 argarray[i] = va_arg (ap, tree);
10612 va_end (ap);
10613 return build_call_expr_loc_array (loc, fndecl, n, argarray);
10616 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10617 varargs macros aren't supported by all bootstrap compilers. */
10619 tree
10620 build_call_expr (tree fndecl, int n, ...)
10622 va_list ap;
10623 tree *argarray = XALLOCAVEC (tree, n);
10624 int i;
10626 va_start (ap, n);
10627 for (i = 0; i < n; i++)
10628 argarray[i] = va_arg (ap, tree);
10629 va_end (ap);
10630 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10633 /* Build internal call expression. This is just like CALL_EXPR, except
10634 its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary
10635 internal function. */
10637 tree
10638 build_call_expr_internal_loc (location_t loc, enum internal_fn ifn,
10639 tree type, int n, ...)
10641 va_list ap;
10642 int i;
10644 tree fn = build_call_1 (type, NULL_TREE, n);
10645 va_start (ap, n);
10646 for (i = 0; i < n; i++)
10647 CALL_EXPR_ARG (fn, i) = va_arg (ap, tree);
10648 va_end (ap);
10649 SET_EXPR_LOCATION (fn, loc);
10650 CALL_EXPR_IFN (fn) = ifn;
10651 return fn;
10654 /* Create a new constant string literal and return a char* pointer to it.
10655 The STRING_CST value is the LEN characters at STR. */
10656 tree
10657 build_string_literal (int len, const char *str)
10659 tree t, elem, index, type;
10661 t = build_string (len, str);
10662 elem = build_type_variant (char_type_node, 1, 0);
10663 index = build_index_type (size_int (len - 1));
10664 type = build_array_type (elem, index);
10665 TREE_TYPE (t) = type;
10666 TREE_CONSTANT (t) = 1;
10667 TREE_READONLY (t) = 1;
10668 TREE_STATIC (t) = 1;
10670 type = build_pointer_type (elem);
10671 t = build1 (ADDR_EXPR, type,
10672 build4 (ARRAY_REF, elem,
10673 t, integer_zero_node, NULL_TREE, NULL_TREE));
10674 return t;
10679 /* Return true if T (assumed to be a DECL) must be assigned a memory
10680 location. */
10682 bool
10683 needs_to_live_in_memory (const_tree t)
10685 return (TREE_ADDRESSABLE (t)
10686 || is_global_var (t)
10687 || (TREE_CODE (t) == RESULT_DECL
10688 && !DECL_BY_REFERENCE (t)
10689 && aggregate_value_p (t, current_function_decl)));
10692 /* Return value of a constant X and sign-extend it. */
10694 HOST_WIDE_INT
10695 int_cst_value (const_tree x)
10697 unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
10698 unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
10700 /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */
10701 gcc_assert (cst_and_fits_in_hwi (x));
10703 if (bits < HOST_BITS_PER_WIDE_INT)
10705 bool negative = ((val >> (bits - 1)) & 1) != 0;
10706 if (negative)
10707 val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
10708 else
10709 val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
10712 return val;
10715 /* If TYPE is an integral or pointer type, return an integer type with
10716 the same precision which is unsigned iff UNSIGNEDP is true, or itself
10717 if TYPE is already an integer type of signedness UNSIGNEDP. */
10719 tree
10720 signed_or_unsigned_type_for (int unsignedp, tree type)
10722 if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
10723 return type;
10725 if (TREE_CODE (type) == VECTOR_TYPE)
10727 tree inner = TREE_TYPE (type);
10728 tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
10729 if (!inner2)
10730 return NULL_TREE;
10731 if (inner == inner2)
10732 return type;
10733 return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
10736 if (!INTEGRAL_TYPE_P (type)
10737 && !POINTER_TYPE_P (type)
10738 && TREE_CODE (type) != OFFSET_TYPE)
10739 return NULL_TREE;
10741 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
10744 /* If TYPE is an integral or pointer type, return an integer type with
10745 the same precision which is unsigned, or itself if TYPE is already an
10746 unsigned integer type. */
10748 tree
10749 unsigned_type_for (tree type)
10751 return signed_or_unsigned_type_for (1, type);
10754 /* If TYPE is an integral or pointer type, return an integer type with
10755 the same precision which is signed, or itself if TYPE is already a
10756 signed integer type. */
10758 tree
10759 signed_type_for (tree type)
10761 return signed_or_unsigned_type_for (0, type);
10764 /* If TYPE is a vector type, return a signed integer vector type with the
10765 same width and number of subparts. Otherwise return boolean_type_node. */
10767 tree
10768 truth_type_for (tree type)
10770 if (TREE_CODE (type) == VECTOR_TYPE)
10772 tree elem = lang_hooks.types.type_for_size
10773 (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))), 0);
10774 return build_opaque_vector_type (elem, TYPE_VECTOR_SUBPARTS (type));
10776 else
10777 return boolean_type_node;
10780 /* Returns the largest value obtainable by casting something in INNER type to
10781 OUTER type. */
10783 tree
10784 upper_bound_in_type (tree outer, tree inner)
10786 unsigned int det = 0;
10787 unsigned oprec = TYPE_PRECISION (outer);
10788 unsigned iprec = TYPE_PRECISION (inner);
10789 unsigned prec;
10791 /* Compute a unique number for every combination. */
10792 det |= (oprec > iprec) ? 4 : 0;
10793 det |= TYPE_UNSIGNED (outer) ? 2 : 0;
10794 det |= TYPE_UNSIGNED (inner) ? 1 : 0;
10796 /* Determine the exponent to use. */
10797 switch (det)
10799 case 0:
10800 case 1:
10801 /* oprec <= iprec, outer: signed, inner: don't care. */
10802 prec = oprec - 1;
10803 break;
10804 case 2:
10805 case 3:
10806 /* oprec <= iprec, outer: unsigned, inner: don't care. */
10807 prec = oprec;
10808 break;
10809 case 4:
10810 /* oprec > iprec, outer: signed, inner: signed. */
10811 prec = iprec - 1;
10812 break;
10813 case 5:
10814 /* oprec > iprec, outer: signed, inner: unsigned. */
10815 prec = iprec;
10816 break;
10817 case 6:
10818 /* oprec > iprec, outer: unsigned, inner: signed. */
10819 prec = oprec;
10820 break;
10821 case 7:
10822 /* oprec > iprec, outer: unsigned, inner: unsigned. */
10823 prec = iprec;
10824 break;
10825 default:
10826 gcc_unreachable ();
10829 return wide_int_to_tree (outer,
10830 wi::mask (prec, false, TYPE_PRECISION (outer)));
10833 /* Returns the smallest value obtainable by casting something in INNER type to
10834 OUTER type. */
10836 tree
10837 lower_bound_in_type (tree outer, tree inner)
10839 unsigned oprec = TYPE_PRECISION (outer);
10840 unsigned iprec = TYPE_PRECISION (inner);
10842 /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
10843 and obtain 0. */
10844 if (TYPE_UNSIGNED (outer)
10845 /* If we are widening something of an unsigned type, OUTER type
10846 contains all values of INNER type. In particular, both INNER
10847 and OUTER types have zero in common. */
10848 || (oprec > iprec && TYPE_UNSIGNED (inner)))
10849 return build_int_cst (outer, 0);
10850 else
10852 /* If we are widening a signed type to another signed type, we
10853 want to obtain -2^^(iprec-1). If we are keeping the
10854 precision or narrowing to a signed type, we want to obtain
10855 -2^(oprec-1). */
10856 unsigned prec = oprec > iprec ? iprec : oprec;
10857 return wide_int_to_tree (outer,
10858 wi::mask (prec - 1, true,
10859 TYPE_PRECISION (outer)));
10863 /* Return nonzero if two operands that are suitable for PHI nodes are
10864 necessarily equal. Specifically, both ARG0 and ARG1 must be either
10865 SSA_NAME or invariant. Note that this is strictly an optimization.
10866 That is, callers of this function can directly call operand_equal_p
10867 and get the same result, only slower. */
10870 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
10872 if (arg0 == arg1)
10873 return 1;
10874 if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
10875 return 0;
10876 return operand_equal_p (arg0, arg1, 0);
10879 /* Returns number of zeros at the end of binary representation of X. */
10881 tree
10882 num_ending_zeros (const_tree x)
10884 return build_int_cst (TREE_TYPE (x), wi::ctz (x));
10888 #define WALK_SUBTREE(NODE) \
10889 do \
10891 result = walk_tree_1 (&(NODE), func, data, pset, lh); \
10892 if (result) \
10893 return result; \
10895 while (0)
10897 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10898 be walked whenever a type is seen in the tree. Rest of operands and return
10899 value are as for walk_tree. */
10901 static tree
10902 walk_type_fields (tree type, walk_tree_fn func, void *data,
10903 hash_set<tree> *pset, walk_tree_lh lh)
10905 tree result = NULL_TREE;
10907 switch (TREE_CODE (type))
10909 case POINTER_TYPE:
10910 case REFERENCE_TYPE:
10911 case VECTOR_TYPE:
10912 /* We have to worry about mutually recursive pointers. These can't
10913 be written in C. They can in Ada. It's pathological, but
10914 there's an ACATS test (c38102a) that checks it. Deal with this
10915 by checking if we're pointing to another pointer, that one
10916 points to another pointer, that one does too, and we have no htab.
10917 If so, get a hash table. We check three levels deep to avoid
10918 the cost of the hash table if we don't need one. */
10919 if (POINTER_TYPE_P (TREE_TYPE (type))
10920 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10921 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10922 && !pset)
10924 result = walk_tree_without_duplicates (&TREE_TYPE (type),
10925 func, data);
10926 if (result)
10927 return result;
10929 break;
10932 /* ... fall through ... */
10934 case COMPLEX_TYPE:
10935 WALK_SUBTREE (TREE_TYPE (type));
10936 break;
10938 case METHOD_TYPE:
10939 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10941 /* Fall through. */
10943 case FUNCTION_TYPE:
10944 WALK_SUBTREE (TREE_TYPE (type));
10946 tree arg;
10948 /* We never want to walk into default arguments. */
10949 for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10950 WALK_SUBTREE (TREE_VALUE (arg));
10952 break;
10954 case ARRAY_TYPE:
10955 /* Don't follow this nodes's type if a pointer for fear that
10956 we'll have infinite recursion. If we have a PSET, then we
10957 need not fear. */
10958 if (pset
10959 || (!POINTER_TYPE_P (TREE_TYPE (type))
10960 && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10961 WALK_SUBTREE (TREE_TYPE (type));
10962 WALK_SUBTREE (TYPE_DOMAIN (type));
10963 break;
10965 case OFFSET_TYPE:
10966 WALK_SUBTREE (TREE_TYPE (type));
10967 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10968 break;
10970 default:
10971 break;
10974 return NULL_TREE;
10977 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
10978 called with the DATA and the address of each sub-tree. If FUNC returns a
10979 non-NULL value, the traversal is stopped, and the value returned by FUNC
10980 is returned. If PSET is non-NULL it is used to record the nodes visited,
10981 and to avoid visiting a node more than once. */
10983 tree
10984 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10985 hash_set<tree> *pset, walk_tree_lh lh)
10987 enum tree_code code;
10988 int walk_subtrees;
10989 tree result;
10991 #define WALK_SUBTREE_TAIL(NODE) \
10992 do \
10994 tp = & (NODE); \
10995 goto tail_recurse; \
10997 while (0)
10999 tail_recurse:
11000 /* Skip empty subtrees. */
11001 if (!*tp)
11002 return NULL_TREE;
11004 /* Don't walk the same tree twice, if the user has requested
11005 that we avoid doing so. */
11006 if (pset && pset->add (*tp))
11007 return NULL_TREE;
11009 /* Call the function. */
11010 walk_subtrees = 1;
11011 result = (*func) (tp, &walk_subtrees, data);
11013 /* If we found something, return it. */
11014 if (result)
11015 return result;
11017 code = TREE_CODE (*tp);
11019 /* Even if we didn't, FUNC may have decided that there was nothing
11020 interesting below this point in the tree. */
11021 if (!walk_subtrees)
11023 /* But we still need to check our siblings. */
11024 if (code == TREE_LIST)
11025 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11026 else if (code == OMP_CLAUSE)
11027 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11028 else
11029 return NULL_TREE;
11032 if (lh)
11034 result = (*lh) (tp, &walk_subtrees, func, data, pset);
11035 if (result || !walk_subtrees)
11036 return result;
11039 switch (code)
11041 case ERROR_MARK:
11042 case IDENTIFIER_NODE:
11043 case INTEGER_CST:
11044 case REAL_CST:
11045 case FIXED_CST:
11046 case VECTOR_CST:
11047 case STRING_CST:
11048 case BLOCK:
11049 case PLACEHOLDER_EXPR:
11050 case SSA_NAME:
11051 case FIELD_DECL:
11052 case RESULT_DECL:
11053 /* None of these have subtrees other than those already walked
11054 above. */
11055 break;
11057 case TREE_LIST:
11058 WALK_SUBTREE (TREE_VALUE (*tp));
11059 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11060 break;
11062 case TREE_VEC:
11064 int len = TREE_VEC_LENGTH (*tp);
11066 if (len == 0)
11067 break;
11069 /* Walk all elements but the first. */
11070 while (--len)
11071 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
11073 /* Now walk the first one as a tail call. */
11074 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
11077 case COMPLEX_CST:
11078 WALK_SUBTREE (TREE_REALPART (*tp));
11079 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
11081 case CONSTRUCTOR:
11083 unsigned HOST_WIDE_INT idx;
11084 constructor_elt *ce;
11086 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11087 idx++)
11088 WALK_SUBTREE (ce->value);
11090 break;
11092 case SAVE_EXPR:
11093 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11095 case BIND_EXPR:
11097 tree decl;
11098 for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11100 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
11101 into declarations that are just mentioned, rather than
11102 declared; they don't really belong to this part of the tree.
11103 And, we can see cycles: the initializer for a declaration
11104 can refer to the declaration itself. */
11105 WALK_SUBTREE (DECL_INITIAL (decl));
11106 WALK_SUBTREE (DECL_SIZE (decl));
11107 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11109 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11112 case STATEMENT_LIST:
11114 tree_stmt_iterator i;
11115 for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11116 WALK_SUBTREE (*tsi_stmt_ptr (i));
11118 break;
11120 case OMP_CLAUSE:
11121 switch (OMP_CLAUSE_CODE (*tp))
11123 case OMP_CLAUSE_DEVICE_RESIDENT:
11124 case OMP_CLAUSE_USE_DEVICE:
11125 case OMP_CLAUSE_GANG:
11126 case OMP_CLAUSE_ASYNC:
11127 case OMP_CLAUSE_WAIT:
11128 case OMP_CLAUSE_WORKER:
11129 case OMP_CLAUSE_VECTOR:
11130 case OMP_CLAUSE_NUM_GANGS:
11131 case OMP_CLAUSE_NUM_WORKERS:
11132 case OMP_CLAUSE_VECTOR_LENGTH:
11133 case OMP_CLAUSE_PRIVATE:
11134 case OMP_CLAUSE_SHARED:
11135 case OMP_CLAUSE_FIRSTPRIVATE:
11136 case OMP_CLAUSE_COPYIN:
11137 case OMP_CLAUSE_COPYPRIVATE:
11138 case OMP_CLAUSE_FINAL:
11139 case OMP_CLAUSE_IF:
11140 case OMP_CLAUSE_NUM_THREADS:
11141 case OMP_CLAUSE_SCHEDULE:
11142 case OMP_CLAUSE_UNIFORM:
11143 case OMP_CLAUSE_DEPEND:
11144 case OMP_CLAUSE_NUM_TEAMS:
11145 case OMP_CLAUSE_THREAD_LIMIT:
11146 case OMP_CLAUSE_DEVICE:
11147 case OMP_CLAUSE_DIST_SCHEDULE:
11148 case OMP_CLAUSE_SAFELEN:
11149 case OMP_CLAUSE_SIMDLEN:
11150 case OMP_CLAUSE__LOOPTEMP_:
11151 case OMP_CLAUSE__SIMDUID_:
11152 case OMP_CLAUSE__CILK_FOR_COUNT_:
11153 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11154 /* FALLTHRU */
11156 case OMP_CLAUSE_INDEPENDENT:
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 case OMP_CLAUSE__CACHE_:
11195 WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11196 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11197 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11199 case OMP_CLAUSE_REDUCTION:
11201 int i;
11202 for (i = 0; i < 4; i++)
11203 WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11204 WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11207 default:
11208 gcc_unreachable ();
11210 break;
11212 case TARGET_EXPR:
11214 int i, len;
11216 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
11217 But, we only want to walk once. */
11218 len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
11219 for (i = 0; i < len; ++i)
11220 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11221 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
11224 case DECL_EXPR:
11225 /* If this is a TYPE_DECL, walk into the fields of the type that it's
11226 defining. We only want to walk into these fields of a type in this
11227 case and not in the general case of a mere reference to the type.
11229 The criterion is as follows: if the field can be an expression, it
11230 must be walked only here. This should be in keeping with the fields
11231 that are directly gimplified in gimplify_type_sizes in order for the
11232 mark/copy-if-shared/unmark machinery of the gimplifier to work with
11233 variable-sized types.
11235 Note that DECLs get walked as part of processing the BIND_EXPR. */
11236 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
11238 tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
11239 if (TREE_CODE (*type_p) == ERROR_MARK)
11240 return NULL_TREE;
11242 /* Call the function for the type. See if it returns anything or
11243 doesn't want us to continue. If we are to continue, walk both
11244 the normal fields and those for the declaration case. */
11245 result = (*func) (type_p, &walk_subtrees, data);
11246 if (result || !walk_subtrees)
11247 return result;
11249 /* But do not walk a pointed-to type since it may itself need to
11250 be walked in the declaration case if it isn't anonymous. */
11251 if (!POINTER_TYPE_P (*type_p))
11253 result = walk_type_fields (*type_p, func, data, pset, lh);
11254 if (result)
11255 return result;
11258 /* If this is a record type, also walk the fields. */
11259 if (RECORD_OR_UNION_TYPE_P (*type_p))
11261 tree field;
11263 for (field = TYPE_FIELDS (*type_p); field;
11264 field = DECL_CHAIN (field))
11266 /* We'd like to look at the type of the field, but we can
11267 easily get infinite recursion. So assume it's pointed
11268 to elsewhere in the tree. Also, ignore things that
11269 aren't fields. */
11270 if (TREE_CODE (field) != FIELD_DECL)
11271 continue;
11273 WALK_SUBTREE (DECL_FIELD_OFFSET (field));
11274 WALK_SUBTREE (DECL_SIZE (field));
11275 WALK_SUBTREE (DECL_SIZE_UNIT (field));
11276 if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
11277 WALK_SUBTREE (DECL_QUALIFIER (field));
11281 /* Same for scalar types. */
11282 else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
11283 || TREE_CODE (*type_p) == ENUMERAL_TYPE
11284 || TREE_CODE (*type_p) == INTEGER_TYPE
11285 || TREE_CODE (*type_p) == FIXED_POINT_TYPE
11286 || TREE_CODE (*type_p) == REAL_TYPE)
11288 WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
11289 WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
11292 WALK_SUBTREE (TYPE_SIZE (*type_p));
11293 WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
11295 /* FALLTHRU */
11297 default:
11298 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
11300 int i, len;
11302 /* Walk over all the sub-trees of this operand. */
11303 len = TREE_OPERAND_LENGTH (*tp);
11305 /* Go through the subtrees. We need to do this in forward order so
11306 that the scope of a FOR_EXPR is handled properly. */
11307 if (len)
11309 for (i = 0; i < len - 1; ++i)
11310 WALK_SUBTREE (TREE_OPERAND (*tp, i));
11311 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
11314 /* If this is a type, walk the needed fields in the type. */
11315 else if (TYPE_P (*tp))
11316 return walk_type_fields (*tp, func, data, pset, lh);
11317 break;
11320 /* We didn't find what we were looking for. */
11321 return NULL_TREE;
11323 #undef WALK_SUBTREE_TAIL
11325 #undef WALK_SUBTREE
11327 /* Like walk_tree, but does not walk duplicate nodes more than once. */
11329 tree
11330 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
11331 walk_tree_lh lh)
11333 tree result;
11335 hash_set<tree> pset;
11336 result = walk_tree_1 (tp, func, data, &pset, lh);
11337 return result;
11341 tree
11342 tree_block (tree t)
11344 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
11346 if (IS_EXPR_CODE_CLASS (c))
11347 return LOCATION_BLOCK (t->exp.locus);
11348 gcc_unreachable ();
11349 return NULL;
11352 void
11353 tree_set_block (tree t, tree b)
11355 const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
11357 if (IS_EXPR_CODE_CLASS (c))
11359 if (b)
11360 t->exp.locus = COMBINE_LOCATION_DATA (line_table, t->exp.locus, b);
11361 else
11362 t->exp.locus = LOCATION_LOCUS (t->exp.locus);
11364 else
11365 gcc_unreachable ();
11368 /* Create a nameless artificial label and put it in the current
11369 function context. The label has a location of LOC. Returns the
11370 newly created label. */
11372 tree
11373 create_artificial_label (location_t loc)
11375 tree lab = build_decl (loc,
11376 LABEL_DECL, NULL_TREE, void_type_node);
11378 DECL_ARTIFICIAL (lab) = 1;
11379 DECL_IGNORED_P (lab) = 1;
11380 DECL_CONTEXT (lab) = current_function_decl;
11381 return lab;
11384 /* Given a tree, try to return a useful variable name that we can use
11385 to prefix a temporary that is being assigned the value of the tree.
11386 I.E. given <temp> = &A, return A. */
11388 const char *
11389 get_name (tree t)
11391 tree stripped_decl;
11393 stripped_decl = t;
11394 STRIP_NOPS (stripped_decl);
11395 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
11396 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
11397 else if (TREE_CODE (stripped_decl) == SSA_NAME)
11399 tree name = SSA_NAME_IDENTIFIER (stripped_decl);
11400 if (!name)
11401 return NULL;
11402 return IDENTIFIER_POINTER (name);
11404 else
11406 switch (TREE_CODE (stripped_decl))
11408 case ADDR_EXPR:
11409 return get_name (TREE_OPERAND (stripped_decl, 0));
11410 default:
11411 return NULL;
11416 /* Return true if TYPE has a variable argument list. */
11418 bool
11419 stdarg_p (const_tree fntype)
11421 function_args_iterator args_iter;
11422 tree n = NULL_TREE, t;
11424 if (!fntype)
11425 return false;
11427 FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
11429 n = t;
11432 return n != NULL_TREE && n != void_type_node;
11435 /* Return true if TYPE has a prototype. */
11437 bool
11438 prototype_p (tree fntype)
11440 tree t;
11442 gcc_assert (fntype != NULL_TREE);
11444 t = TYPE_ARG_TYPES (fntype);
11445 return (t != NULL_TREE);
11448 /* If BLOCK is inlined from an __attribute__((__artificial__))
11449 routine, return pointer to location from where it has been
11450 called. */
11451 location_t *
11452 block_nonartificial_location (tree block)
11454 location_t *ret = NULL;
11456 while (block && TREE_CODE (block) == BLOCK
11457 && BLOCK_ABSTRACT_ORIGIN (block))
11459 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
11461 while (TREE_CODE (ao) == BLOCK
11462 && BLOCK_ABSTRACT_ORIGIN (ao)
11463 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
11464 ao = BLOCK_ABSTRACT_ORIGIN (ao);
11466 if (TREE_CODE (ao) == FUNCTION_DECL)
11468 /* If AO is an artificial inline, point RET to the
11469 call site locus at which it has been inlined and continue
11470 the loop, in case AO's caller is also an artificial
11471 inline. */
11472 if (DECL_DECLARED_INLINE_P (ao)
11473 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
11474 ret = &BLOCK_SOURCE_LOCATION (block);
11475 else
11476 break;
11478 else if (TREE_CODE (ao) != BLOCK)
11479 break;
11481 block = BLOCK_SUPERCONTEXT (block);
11483 return ret;
11487 /* If EXP is inlined from an __attribute__((__artificial__))
11488 function, return the location of the original call expression. */
11490 location_t
11491 tree_nonartificial_location (tree exp)
11493 location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
11495 if (loc)
11496 return *loc;
11497 else
11498 return EXPR_LOCATION (exp);
11502 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
11503 nodes. */
11505 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */
11507 static hashval_t
11508 cl_option_hash_hash (const void *x)
11510 const_tree const t = (const_tree) x;
11511 const char *p;
11512 size_t i;
11513 size_t len = 0;
11514 hashval_t hash = 0;
11516 if (TREE_CODE (t) == OPTIMIZATION_NODE)
11518 p = (const char *)TREE_OPTIMIZATION (t);
11519 len = sizeof (struct cl_optimization);
11522 else if (TREE_CODE (t) == TARGET_OPTION_NODE)
11524 p = (const char *)TREE_TARGET_OPTION (t);
11525 len = sizeof (struct cl_target_option);
11528 else
11529 gcc_unreachable ();
11531 /* assume most opt flags are just 0/1, some are 2-3, and a few might be
11532 something else. */
11533 for (i = 0; i < len; i++)
11534 if (p[i])
11535 hash = (hash << 4) ^ ((i << 2) | p[i]);
11537 return hash;
11540 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
11541 TARGET_OPTION tree node) is the same as that given by *Y, which is the
11542 same. */
11544 static int
11545 cl_option_hash_eq (const void *x, const void *y)
11547 const_tree const xt = (const_tree) x;
11548 const_tree const yt = (const_tree) y;
11549 const char *xp;
11550 const char *yp;
11551 size_t len;
11553 if (TREE_CODE (xt) != TREE_CODE (yt))
11554 return 0;
11556 if (TREE_CODE (xt) == OPTIMIZATION_NODE)
11558 xp = (const char *)TREE_OPTIMIZATION (xt);
11559 yp = (const char *)TREE_OPTIMIZATION (yt);
11560 len = sizeof (struct cl_optimization);
11563 else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
11565 xp = (const char *)TREE_TARGET_OPTION (xt);
11566 yp = (const char *)TREE_TARGET_OPTION (yt);
11567 len = sizeof (struct cl_target_option);
11570 else
11571 gcc_unreachable ();
11573 return (memcmp (xp, yp, len) == 0);
11576 /* Build an OPTIMIZATION_NODE based on the options in OPTS. */
11578 tree
11579 build_optimization_node (struct gcc_options *opts)
11581 tree t;
11582 void **slot;
11584 /* Use the cache of optimization nodes. */
11586 cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
11587 opts);
11589 slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
11590 t = (tree) *slot;
11591 if (!t)
11593 /* Insert this one into the hash table. */
11594 t = cl_optimization_node;
11595 *slot = t;
11597 /* Make a new node for next time round. */
11598 cl_optimization_node = make_node (OPTIMIZATION_NODE);
11601 return t;
11604 /* Build a TARGET_OPTION_NODE based on the options in OPTS. */
11606 tree
11607 build_target_option_node (struct gcc_options *opts)
11609 tree t;
11610 void **slot;
11612 /* Use the cache of optimization nodes. */
11614 cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
11615 opts);
11617 slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
11618 t = (tree) *slot;
11619 if (!t)
11621 /* Insert this one into the hash table. */
11622 t = cl_target_option_node;
11623 *slot = t;
11625 /* Make a new node for next time round. */
11626 cl_target_option_node = make_node (TARGET_OPTION_NODE);
11629 return t;
11632 /* Reset TREE_TARGET_GLOBALS cache for TARGET_OPTION_NODE.
11633 Called through htab_traverse. */
11635 static int
11636 prepare_target_option_node_for_pch (void **slot, void *)
11638 tree node = (tree) *slot;
11639 if (TREE_CODE (node) == TARGET_OPTION_NODE)
11640 TREE_TARGET_GLOBALS (node) = NULL;
11641 return 1;
11644 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
11645 so that they aren't saved during PCH writing. */
11647 void
11648 prepare_target_option_nodes_for_pch (void)
11650 htab_traverse (cl_option_hash_table, prepare_target_option_node_for_pch,
11651 NULL);
11654 /* Determine the "ultimate origin" of a block. The block may be an inlined
11655 instance of an inlined instance of a block which is local to an inline
11656 function, so we have to trace all of the way back through the origin chain
11657 to find out what sort of node actually served as the original seed for the
11658 given block. */
11660 tree
11661 block_ultimate_origin (const_tree block)
11663 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
11665 /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
11666 we're trying to output the abstract instance of this function. */
11667 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
11668 return NULL_TREE;
11670 if (immediate_origin == NULL_TREE)
11671 return NULL_TREE;
11672 else
11674 tree ret_val;
11675 tree lookahead = immediate_origin;
11679 ret_val = lookahead;
11680 lookahead = (TREE_CODE (ret_val) == BLOCK
11681 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
11683 while (lookahead != NULL && lookahead != ret_val);
11685 /* The block's abstract origin chain may not be the *ultimate* origin of
11686 the block. It could lead to a DECL that has an abstract origin set.
11687 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
11688 will give us if it has one). Note that DECL's abstract origins are
11689 supposed to be the most distant ancestor (or so decl_ultimate_origin
11690 claims), so we don't need to loop following the DECL origins. */
11691 if (DECL_P (ret_val))
11692 return DECL_ORIGIN (ret_val);
11694 return ret_val;
11698 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
11699 no instruction. */
11701 bool
11702 tree_nop_conversion_p (const_tree outer_type, const_tree inner_type)
11704 /* Use precision rather then machine mode when we can, which gives
11705 the correct answer even for submode (bit-field) types. */
11706 if ((INTEGRAL_TYPE_P (outer_type)
11707 || POINTER_TYPE_P (outer_type)
11708 || TREE_CODE (outer_type) == OFFSET_TYPE)
11709 && (INTEGRAL_TYPE_P (inner_type)
11710 || POINTER_TYPE_P (inner_type)
11711 || TREE_CODE (inner_type) == OFFSET_TYPE))
11712 return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
11714 /* Otherwise fall back on comparing machine modes (e.g. for
11715 aggregate types, floats). */
11716 return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
11719 /* Return true iff conversion in EXP generates no instruction. Mark
11720 it inline so that we fully inline into the stripping functions even
11721 though we have two uses of this function. */
11723 static inline bool
11724 tree_nop_conversion (const_tree exp)
11726 tree outer_type, inner_type;
11728 if (!CONVERT_EXPR_P (exp)
11729 && TREE_CODE (exp) != NON_LVALUE_EXPR)
11730 return false;
11731 if (TREE_OPERAND (exp, 0) == error_mark_node)
11732 return false;
11734 outer_type = TREE_TYPE (exp);
11735 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
11737 if (!inner_type)
11738 return false;
11740 return tree_nop_conversion_p (outer_type, inner_type);
11743 /* Return true iff conversion in EXP generates no instruction. Don't
11744 consider conversions changing the signedness. */
11746 static bool
11747 tree_sign_nop_conversion (const_tree exp)
11749 tree outer_type, inner_type;
11751 if (!tree_nop_conversion (exp))
11752 return false;
11754 outer_type = TREE_TYPE (exp);
11755 inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
11757 return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
11758 && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
11761 /* Strip conversions from EXP according to tree_nop_conversion and
11762 return the resulting expression. */
11764 tree
11765 tree_strip_nop_conversions (tree exp)
11767 while (tree_nop_conversion (exp))
11768 exp = TREE_OPERAND (exp, 0);
11769 return exp;
11772 /* Strip conversions from EXP according to tree_sign_nop_conversion
11773 and return the resulting expression. */
11775 tree
11776 tree_strip_sign_nop_conversions (tree exp)
11778 while (tree_sign_nop_conversion (exp))
11779 exp = TREE_OPERAND (exp, 0);
11780 return exp;
11783 /* Avoid any floating point extensions from EXP. */
11784 tree
11785 strip_float_extensions (tree exp)
11787 tree sub, expt, subt;
11789 /* For floating point constant look up the narrowest type that can hold
11790 it properly and handle it like (type)(narrowest_type)constant.
11791 This way we can optimize for instance a=a*2.0 where "a" is float
11792 but 2.0 is double constant. */
11793 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
11795 REAL_VALUE_TYPE orig;
11796 tree type = NULL;
11798 orig = TREE_REAL_CST (exp);
11799 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
11800 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
11801 type = float_type_node;
11802 else if (TYPE_PRECISION (TREE_TYPE (exp))
11803 > TYPE_PRECISION (double_type_node)
11804 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
11805 type = double_type_node;
11806 if (type)
11807 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
11810 if (!CONVERT_EXPR_P (exp))
11811 return exp;
11813 sub = TREE_OPERAND (exp, 0);
11814 subt = TREE_TYPE (sub);
11815 expt = TREE_TYPE (exp);
11817 if (!FLOAT_TYPE_P (subt))
11818 return exp;
11820 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
11821 return exp;
11823 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
11824 return exp;
11826 return strip_float_extensions (sub);
11829 /* Strip out all handled components that produce invariant
11830 offsets. */
11832 const_tree
11833 strip_invariant_refs (const_tree op)
11835 while (handled_component_p (op))
11837 switch (TREE_CODE (op))
11839 case ARRAY_REF:
11840 case ARRAY_RANGE_REF:
11841 if (!is_gimple_constant (TREE_OPERAND (op, 1))
11842 || TREE_OPERAND (op, 2) != NULL_TREE
11843 || TREE_OPERAND (op, 3) != NULL_TREE)
11844 return NULL;
11845 break;
11847 case COMPONENT_REF:
11848 if (TREE_OPERAND (op, 2) != NULL_TREE)
11849 return NULL;
11850 break;
11852 default:;
11854 op = TREE_OPERAND (op, 0);
11857 return op;
11860 static GTY(()) tree gcc_eh_personality_decl;
11862 /* Return the GCC personality function decl. */
11864 tree
11865 lhd_gcc_personality (void)
11867 if (!gcc_eh_personality_decl)
11868 gcc_eh_personality_decl = build_personality_function ("gcc");
11869 return gcc_eh_personality_decl;
11872 /* TARGET is a call target of GIMPLE call statement
11873 (obtained by gimple_call_fn). Return true if it is
11874 OBJ_TYPE_REF representing an virtual call of C++ method.
11875 (As opposed to OBJ_TYPE_REF representing objc calls
11876 through a cast where middle-end devirtualization machinery
11877 can't apply.) */
11879 bool
11880 virtual_method_call_p (tree target)
11882 if (TREE_CODE (target) != OBJ_TYPE_REF)
11883 return false;
11884 target = TREE_TYPE (target);
11885 gcc_checking_assert (TREE_CODE (target) == POINTER_TYPE);
11886 target = TREE_TYPE (target);
11887 if (TREE_CODE (target) == FUNCTION_TYPE)
11888 return false;
11889 gcc_checking_assert (TREE_CODE (target) == METHOD_TYPE);
11890 return true;
11893 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */
11895 tree
11896 obj_type_ref_class (tree ref)
11898 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
11899 ref = TREE_TYPE (ref);
11900 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
11901 ref = TREE_TYPE (ref);
11902 /* We look for type THIS points to. ObjC also builds
11903 OBJ_TYPE_REF with non-method calls, Their first parameter
11904 ID however also corresponds to class type. */
11905 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
11906 || TREE_CODE (ref) == FUNCTION_TYPE);
11907 ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
11908 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
11909 return TREE_TYPE (ref);
11912 /* Return true if T is in anonymous namespace. */
11914 bool
11915 type_in_anonymous_namespace_p (const_tree t)
11917 /* TREE_PUBLIC of TYPE_STUB_DECL may not be properly set for
11918 bulitin types; those have CONTEXT NULL. */
11919 if (!TYPE_CONTEXT (t))
11920 return false;
11921 return (TYPE_STUB_DECL (t) && !TREE_PUBLIC (TYPE_STUB_DECL (t)));
11924 /* Try to find a base info of BINFO that would have its field decl at offset
11925 OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be
11926 found, return, otherwise return NULL_TREE. */
11928 tree
11929 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
11931 tree type = BINFO_TYPE (binfo);
11933 while (true)
11935 HOST_WIDE_INT pos, size;
11936 tree fld;
11937 int i;
11939 if (types_same_for_odr (type, expected_type))
11940 return binfo;
11941 if (offset < 0)
11942 return NULL_TREE;
11944 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
11946 if (TREE_CODE (fld) != FIELD_DECL)
11947 continue;
11949 pos = int_bit_position (fld);
11950 size = tree_to_uhwi (DECL_SIZE (fld));
11951 if (pos <= offset && (pos + size) > offset)
11952 break;
11954 if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
11955 return NULL_TREE;
11957 if (!DECL_ARTIFICIAL (fld))
11959 binfo = TYPE_BINFO (TREE_TYPE (fld));
11960 if (!binfo)
11961 return NULL_TREE;
11963 /* Offset 0 indicates the primary base, whose vtable contents are
11964 represented in the binfo for the derived class. */
11965 else if (offset != 0)
11967 tree base_binfo, binfo2 = binfo;
11969 /* Find BINFO corresponding to FLD. This is bit harder
11970 by a fact that in virtual inheritance we may need to walk down
11971 the non-virtual inheritance chain. */
11972 while (true)
11974 tree containing_binfo = NULL, found_binfo = NULL;
11975 for (i = 0; BINFO_BASE_ITERATE (binfo2, i, base_binfo); i++)
11976 if (types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
11978 found_binfo = base_binfo;
11979 break;
11981 else
11982 if ((tree_to_shwi (BINFO_OFFSET (base_binfo))
11983 - tree_to_shwi (BINFO_OFFSET (binfo)))
11984 * BITS_PER_UNIT < pos
11985 /* Rule out types with no virtual methods or we can get confused
11986 here by zero sized bases. */
11987 && BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (base_binfo)))
11988 && (!containing_binfo
11989 || (tree_to_shwi (BINFO_OFFSET (containing_binfo))
11990 < tree_to_shwi (BINFO_OFFSET (base_binfo)))))
11991 containing_binfo = base_binfo;
11992 if (found_binfo)
11994 binfo = found_binfo;
11995 break;
11997 if (!containing_binfo)
11998 return NULL_TREE;
11999 binfo2 = containing_binfo;
12003 type = TREE_TYPE (fld);
12004 offset -= pos;
12008 /* Returns true if X is a typedef decl. */
12010 bool
12011 is_typedef_decl (tree x)
12013 return (x && TREE_CODE (x) == TYPE_DECL
12014 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
12017 /* Returns true iff TYPE is a type variant created for a typedef. */
12019 bool
12020 typedef_variant_p (tree type)
12022 return is_typedef_decl (TYPE_NAME (type));
12025 /* Warn about a use of an identifier which was marked deprecated. */
12026 void
12027 warn_deprecated_use (tree node, tree attr)
12029 const char *msg;
12031 if (node == 0 || !warn_deprecated_decl)
12032 return;
12034 if (!attr)
12036 if (DECL_P (node))
12037 attr = DECL_ATTRIBUTES (node);
12038 else if (TYPE_P (node))
12040 tree decl = TYPE_STUB_DECL (node);
12041 if (decl)
12042 attr = lookup_attribute ("deprecated",
12043 TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12047 if (attr)
12048 attr = lookup_attribute ("deprecated", attr);
12050 if (attr)
12051 msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12052 else
12053 msg = NULL;
12055 if (DECL_P (node))
12057 expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
12058 if (msg)
12059 warning (OPT_Wdeprecated_declarations,
12060 "%qD is deprecated (declared at %r%s:%d%R): %s",
12061 node, "locus", xloc.file, xloc.line, msg);
12062 else
12063 warning (OPT_Wdeprecated_declarations,
12064 "%qD is deprecated (declared at %r%s:%d%R)",
12065 node, "locus", xloc.file, xloc.line);
12067 else if (TYPE_P (node))
12069 tree what = NULL_TREE;
12070 tree decl = TYPE_STUB_DECL (node);
12072 if (TYPE_NAME (node))
12074 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12075 what = TYPE_NAME (node);
12076 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12077 && DECL_NAME (TYPE_NAME (node)))
12078 what = DECL_NAME (TYPE_NAME (node));
12081 if (decl)
12083 expanded_location xloc
12084 = expand_location (DECL_SOURCE_LOCATION (decl));
12085 if (what)
12087 if (msg)
12088 warning (OPT_Wdeprecated_declarations,
12089 "%qE is deprecated (declared at %r%s:%d%R): %s",
12090 what, "locus", xloc.file, xloc.line, msg);
12091 else
12092 warning (OPT_Wdeprecated_declarations,
12093 "%qE is deprecated (declared at %r%s:%d%R)",
12094 what, "locus", xloc.file, xloc.line);
12096 else
12098 if (msg)
12099 warning (OPT_Wdeprecated_declarations,
12100 "type is deprecated (declared at %r%s:%d%R): %s",
12101 "locus", xloc.file, xloc.line, msg);
12102 else
12103 warning (OPT_Wdeprecated_declarations,
12104 "type is deprecated (declared at %r%s:%d%R)",
12105 "locus", xloc.file, xloc.line);
12108 else
12110 if (what)
12112 if (msg)
12113 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12114 what, msg);
12115 else
12116 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12118 else
12120 if (msg)
12121 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12122 msg);
12123 else
12124 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12130 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12131 somewhere in it. */
12133 bool
12134 contains_bitfld_component_ref_p (const_tree ref)
12136 while (handled_component_p (ref))
12138 if (TREE_CODE (ref) == COMPONENT_REF
12139 && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12140 return true;
12141 ref = TREE_OPERAND (ref, 0);
12144 return false;
12147 /* Try to determine whether a TRY_CATCH expression can fall through.
12148 This is a subroutine of block_may_fallthru. */
12150 static bool
12151 try_catch_may_fallthru (const_tree stmt)
12153 tree_stmt_iterator i;
12155 /* If the TRY block can fall through, the whole TRY_CATCH can
12156 fall through. */
12157 if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12158 return true;
12160 i = tsi_start (TREE_OPERAND (stmt, 1));
12161 switch (TREE_CODE (tsi_stmt (i)))
12163 case CATCH_EXPR:
12164 /* We expect to see a sequence of CATCH_EXPR trees, each with a
12165 catch expression and a body. The whole TRY_CATCH may fall
12166 through iff any of the catch bodies falls through. */
12167 for (; !tsi_end_p (i); tsi_next (&i))
12169 if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12170 return true;
12172 return false;
12174 case EH_FILTER_EXPR:
12175 /* The exception filter expression only matters if there is an
12176 exception. If the exception does not match EH_FILTER_TYPES,
12177 we will execute EH_FILTER_FAILURE, and we will fall through
12178 if that falls through. If the exception does match
12179 EH_FILTER_TYPES, the stack unwinder will continue up the
12180 stack, so we will not fall through. We don't know whether we
12181 will throw an exception which matches EH_FILTER_TYPES or not,
12182 so we just ignore EH_FILTER_TYPES and assume that we might
12183 throw an exception which doesn't match. */
12184 return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
12186 default:
12187 /* This case represents statements to be executed when an
12188 exception occurs. Those statements are implicitly followed
12189 by a RESX statement to resume execution after the exception.
12190 So in this case the TRY_CATCH never falls through. */
12191 return false;
12195 /* Try to determine if we can fall out of the bottom of BLOCK. This guess
12196 need not be 100% accurate; simply be conservative and return true if we
12197 don't know. This is used only to avoid stupidly generating extra code.
12198 If we're wrong, we'll just delete the extra code later. */
12200 bool
12201 block_may_fallthru (const_tree block)
12203 /* This CONST_CAST is okay because expr_last returns its argument
12204 unmodified and we assign it to a const_tree. */
12205 const_tree stmt = expr_last (CONST_CAST_TREE (block));
12207 switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
12209 case GOTO_EXPR:
12210 case RETURN_EXPR:
12211 /* Easy cases. If the last statement of the block implies
12212 control transfer, then we can't fall through. */
12213 return false;
12215 case SWITCH_EXPR:
12216 /* If SWITCH_LABELS is set, this is lowered, and represents a
12217 branch to a selected label and hence can not fall through.
12218 Otherwise SWITCH_BODY is set, and the switch can fall
12219 through. */
12220 return SWITCH_LABELS (stmt) == NULL_TREE;
12222 case COND_EXPR:
12223 if (block_may_fallthru (COND_EXPR_THEN (stmt)))
12224 return true;
12225 return block_may_fallthru (COND_EXPR_ELSE (stmt));
12227 case BIND_EXPR:
12228 return block_may_fallthru (BIND_EXPR_BODY (stmt));
12230 case TRY_CATCH_EXPR:
12231 return try_catch_may_fallthru (stmt);
12233 case TRY_FINALLY_EXPR:
12234 /* The finally clause is always executed after the try clause,
12235 so if it does not fall through, then the try-finally will not
12236 fall through. Otherwise, if the try clause does not fall
12237 through, then when the finally clause falls through it will
12238 resume execution wherever the try clause was going. So the
12239 whole try-finally will only fall through if both the try
12240 clause and the finally clause fall through. */
12241 return (block_may_fallthru (TREE_OPERAND (stmt, 0))
12242 && block_may_fallthru (TREE_OPERAND (stmt, 1)));
12244 case MODIFY_EXPR:
12245 if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
12246 stmt = TREE_OPERAND (stmt, 1);
12247 else
12248 return true;
12249 /* FALLTHRU */
12251 case CALL_EXPR:
12252 /* Functions that do not return do not fall through. */
12253 return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
12255 case CLEANUP_POINT_EXPR:
12256 return block_may_fallthru (TREE_OPERAND (stmt, 0));
12258 case TARGET_EXPR:
12259 return block_may_fallthru (TREE_OPERAND (stmt, 1));
12261 case ERROR_MARK:
12262 return true;
12264 default:
12265 return lang_hooks.block_may_fallthru (stmt);
12269 /* True if we are using EH to handle cleanups. */
12270 static bool using_eh_for_cleanups_flag = false;
12272 /* This routine is called from front ends to indicate eh should be used for
12273 cleanups. */
12274 void
12275 using_eh_for_cleanups (void)
12277 using_eh_for_cleanups_flag = true;
12280 /* Query whether EH is used for cleanups. */
12281 bool
12282 using_eh_for_cleanups_p (void)
12284 return using_eh_for_cleanups_flag;
12287 /* Wrapper for tree_code_name to ensure that tree code is valid */
12288 const char *
12289 get_tree_code_name (enum tree_code code)
12291 const char *invalid = "<invalid tree code>";
12293 if (code >= MAX_TREE_CODES)
12294 return invalid;
12296 return tree_code_name[code];
12299 /* Drops the TREE_OVERFLOW flag from T. */
12301 tree
12302 drop_tree_overflow (tree t)
12304 gcc_checking_assert (TREE_OVERFLOW (t));
12306 /* For tree codes with a sharing machinery re-build the result. */
12307 if (TREE_CODE (t) == INTEGER_CST)
12308 return wide_int_to_tree (TREE_TYPE (t), t);
12310 /* Otherwise, as all tcc_constants are possibly shared, copy the node
12311 and drop the flag. */
12312 t = copy_node (t);
12313 TREE_OVERFLOW (t) = 0;
12314 return t;
12317 /* Given a memory reference expression T, return its base address.
12318 The base address of a memory reference expression is the main
12319 object being referenced. For instance, the base address for
12320 'array[i].fld[j]' is 'array'. You can think of this as stripping
12321 away the offset part from a memory address.
12323 This function calls handled_component_p to strip away all the inner
12324 parts of the memory reference until it reaches the base object. */
12326 tree
12327 get_base_address (tree t)
12329 while (handled_component_p (t))
12330 t = TREE_OPERAND (t, 0);
12332 if ((TREE_CODE (t) == MEM_REF
12333 || TREE_CODE (t) == TARGET_MEM_REF)
12334 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
12335 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
12337 /* ??? Either the alias oracle or all callers need to properly deal
12338 with WITH_SIZE_EXPRs before we can look through those. */
12339 if (TREE_CODE (t) == WITH_SIZE_EXPR)
12340 return NULL_TREE;
12342 return t;
12345 #include "gt-tree.h"